implement builtin # raw_handle and place handles

Co-authored-by: Xiangfei Ding <dingxiangfei2009protonmail.ch>
Signed-off-by: Rasmus Piorr <piorr@google.com>

Author: ShaddyDC

compiler/rustc_ast/src/ast.rs

@@ -1616,6 +1616,7 @@ impl Expr {
             | ExprKind::Match(..)
             | ExprKind::MethodCall(..)
             | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
             | ExprKind::Paren(..)
             | ExprKind::Path(..)
             | ExprKind::Repeat(..)
@@ -1875,6 +1876,9 @@ pub enum ExprKind {
     /// indirectly via the macro `core::mem::offset_of!(...)`.
     OffsetOf(Box<Ty>, ThinVec<Ident>),
 
+    /// A `raw_handle` expression (e.g. `builtin # raw_handle(expr)`).
+    RawHandle(Box<Expr>),
+
     /// A macro invocation; pre-expansion.
     MacCall(Box<MacCall>),
 

compiler/rustc_ast/src/util/classify.rs

@@ -144,6 +144,7 @@ pub fn leading_labeled_expr(mut expr: &ast::Expr) -> bool {
             | MacCall(..)
             | Match(_, _, MatchKind::Prefix)
             | OffsetOf(..)
+            | RawHandle(..)
             | Paren(..)
             | Path(..)
             | Range(None, _, _)
@@ -218,7 +219,7 @@ pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
                 break (mac.args.delim == Delimiter::Brace).then_some(TrailingBrace::MacCall(mac));
             }
 
-            InlineAsm(_) | OffsetOf(_, _) | IncludedBytes(_) | FormatArgs(_) => {
+            InlineAsm(_) | OffsetOf(_, _) | RawHandle(_) | IncludedBytes(_) | FormatArgs(_) => {
                 // These should have been denied pre-expansion.
                 break None;
             }

compiler/rustc_ast/src/visit.rs

@@ -1099,6 +1099,8 @@ macro_rules! common_visitor_and_walkers {
                     visit_visitable!(vis, f),
                 ExprKind::OffsetOf(container, fields) =>
                     visit_visitable!(vis, container, fields),
+                ExprKind::RawHandle(subexpression) =>
+                    visit_visitable!(vis, subexpression),
                 ExprKind::Yield(kind) =>
                     visit_visitable!(vis, kind),
                 ExprKind::Try(subexpression) =>

compiler/rustc_ast_lowering/src/expr.rs

@@ -500,6 +500,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ),
                 self.arena.alloc_from_iter(fields.iter().map(|&ident| self.lower_ident(ident))),
             ),
+            ExprKind::RawHandle(expr) => hir::ExprKind::RawHandle(self.lower_expr(expr)),
             ExprKind::Struct(se) => {
                 let rest = match se.rest {
                     StructRest::Base(ref e) => hir::StructTailExpr::Base(self.lower_expr(e)),

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -813,6 +813,14 @@ impl<'a> State<'a> {
                 self.end(ib);
                 self.pclose();
             }
+            ast::ExprKind::RawHandle(expr) => {
+                self.word("builtin # raw_handle");
+                self.popen();
+                let ib = self.ibox(0);
+                self.print_expr(expr, FixupContext::default());
+                self.end(ib);
+                self.pclose();
+            }
             ast::ExprKind::MacCall(m) => self.print_mac(m),
             ast::ExprKind::Paren(e) => {
                 self.popen();

compiler/rustc_attr_ir/src/lang_items.rs

@@ -464,6 +464,15 @@ language_item_table! {
     FieldType,               sym::field_type,              field_type,                 Target::AssocTy(AssocCtxt::Trait),        GenericRequirement::Exact(0);
     FieldOffset,             sym::field_offset,            field_offset,               Target::AssocConst(AssocCtxt::Trait),     GenericRequirement::Exact(0);
 
+    // Place handles.
+    LocalHandle, sym::local_handle, local_handle, Target::Struct, GenericRequirement::Exact(1);
+    DerefPlace,              sym::deref_place,         deref_place_trait,          Target::Trait,          GenericRequirement::Exact(0);
+    DerefPlacePointeeHandle, sym::deref_place_pointee_handle, deref_place_pointee_handle, Target::AssocTy(AssocCtxt::Trait),                 GenericRequirement::None;
+    DerefPlaceDerefPlace,    sym::deref_place_deref_place, deref_place_deref_place, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
+    ProjectPlace,            sym::project_place,       project_place_trait,        Target::Trait,          GenericRequirement::Exact(1);
+    ProjectPlaceProjected,   sym::project_place_projected, project_place_projected, Target::AssocTy(AssocCtxt::Trait),                 GenericRequirement::None;
+    ProjectPlaceProjectPlace, sym::project_place_project_place, project_place_project_place, Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;
+
     // Used to fallback `{float}` to `f32` when `f32: From<{float}>`
     From,                    sym::From,                from_trait,                 Target::Trait,          GenericRequirement::Exact(1);
     FromFn,                  sym::from,                from_fn,                    Target::Method(MethodKind::Trait { body: false }), GenericRequirement::None;

compiler/rustc_builtin_macros/src/assert/context.rs

@@ -311,6 +311,7 @@ impl<'cx, 'a> Context<'cx, 'a> {
             | ExprKind::Loop(_, _, _)
             | ExprKind::MacCall(_)
             | ExprKind::OffsetOf(_, _)
+            | ExprKind::RawHandle(..)
             | ExprKind::Path(_, _)
             | ExprKind::Ret(_)
             | ExprKind::Try(_)

compiler/rustc_hir/src/hir.rs

@@ -2273,6 +2273,7 @@ impl Expr<'_> {
             | ExprKind::Match(..)
             | ExprKind::MethodCall(..)
             | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
             | ExprKind::Path(..)
             | ExprKind::Repeat(..)
             | ExprKind::Struct(..)
@@ -2345,6 +2346,7 @@ impl Expr<'_> {
             | ExprKind::Assign(..)
             | ExprKind::InlineAsm(..)
             | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
             | ExprKind::AssignOp(..)
             | ExprKind::Lit(_)
             | ExprKind::ConstBlock(..)
@@ -2415,6 +2417,7 @@ impl Expr<'_> {
             | ExprKind::Index(base, _, _)
             | ExprKind::AddrOf(.., base)
             | ExprKind::Cast(base, _)
+            | ExprKind::RawHandle(base)
             | ExprKind::UnsafeBinderCast(_, base, _) => {
                 // This isn't exactly true for `Index` and all `Unary`, but we are using this
                 // method exclusively for diagnostics and there's a *cultural* pressure against
@@ -2690,6 +2693,9 @@ pub enum ExprKind<'hir> {
     /// Field offset (`offset_of!`)
     OffsetOf(&'hir Ty<'hir>, &'hir [Ident]),
 
+    /// Raw place handle (`raw_handle!`)
+    RawHandle(&'hir Expr<'hir>),
+
     /// A struct or struct-like variant literal expression.
     ///
     /// E.g., `Foo {x: 1, y: 2}`, or `Foo {x: 1, .. base}`,

compiler/rustc_hir/src/intravisit.rs

@@ -958,6 +958,9 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr<'v>)
             try_visit!(visitor.visit_ty_unambig(container));
             walk_list!(visitor, visit_ident, fields.iter().copied());
         }
+        ExprKind::RawHandle(ref subexpression) => {
+            try_visit!(visitor.visit_expr(subexpression));
+        }
         ExprKind::Yield(ref subexpression, _) => {
             try_visit!(visitor.visit_expr(subexpression));
         }

compiler/rustc_hir_pretty/src/lib.rs

@@ -1783,6 +1783,11 @@ impl<'a> State<'a> {
 
                 self.word(")");
             }
+            hir::ExprKind::RawHandle(expr) => {
+                self.word("raw_handle!(");
+                self.print_expr(expr);
+                self.word(")");
+            }
             hir::ExprKind::UnsafeBinderCast(kind, expr, ty) => {
                 match kind {
                     ast::UnsafeBinderCastKind::Wrap => self.word("wrap_binder!("),