implement k# raw_handle and place handles

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

Author: ShaddyDC

compiler/rustc_ast/src/ast.rs

@@ -1612,6 +1612,7 @@ impl Expr {
             | ExprKind::Match(..)
             | ExprKind::MethodCall(..)
             | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
             | ExprKind::Paren(..)
             | ExprKind::Path(..)
             | ExprKind::Repeat(..)
@@ -1871,6 +1872,9 @@ pub enum ExprKind {
     /// indirectly via the macro `core::mem::offset_of!(...)`.
     OffsetOf(Box<Ty>, ThinVec<Ident>),
 
+    /// A `raw_handle` expression (e.g., `k#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

@@ -1101,6 +1101,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/diagnostics.rs

@@ -112,6 +112,14 @@ pub(crate) struct UnderscoreExprLhsAssign {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("cannot take address of a temporary", code = E0745)]
+pub(crate) struct AddressOfTemporaryTaken {
+    #[primary_span]
+    #[label("temporary value")]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("`await` is only allowed inside `async` functions and blocks", code = E0728)]
 pub(crate) struct AwaitOnlyInAsyncFnAndBlocks {

compiler/rustc_ast_lowering/src/expr.rs

@@ -14,13 +14,14 @@ use rustc_hir::def::{DefKind, Res};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::diagnostics::report_lit_error;
 use rustc_span::{
-    ByteSymbol, DUMMY_SP, DesugaringKind, Ident, Span, Spanned, Symbol, respan, span_bug, sym,
+    ByteSymbol, DUMMY_SP, DesugaringKind, ErrorGuaranteed, Ident, Span, Spanned, Symbol, respan,
+    span_bug, sym,
 };
 use thin_vec::ThinVec;
 mod closure;
 
 use crate::diagnostics::{
-    AsyncCoroutinesNotSupported, AwaitOnlyInAsyncFnAndBlocks,
+    AddressOfTemporaryTaken, AsyncCoroutinesNotSupported, AwaitOnlyInAsyncFnAndBlocks,
     FunctionalRecordUpdateDestructuringAssignment, InclusiveRangeWithNoEnd,
     InvalidLegacyConstGenericArg, MatchArmWithNoBody, MoveExprOnlyInSupportedContexts,
     NestedMoveExprWithoutEnclosingContext, NeverPatternWithBody, NeverPatternWithGuard,
@@ -500,6 +501,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 ),
                 self.arena.alloc_from_iter(fields.iter().map(|&ident| self.lower_ident(ident))),
             ),
+            ExprKind::RawHandle(place) => match self.lower_field_project(place) {
+                Ok(fp) => hir::ExprKind::RawHandle(fp),
+                Err(guar) => hir::ExprKind::Err(guar),
+            },
             ExprKind::Struct(se) => {
                 let rest = match se.rest {
                     StructRest::Base(ref e) => hir::StructTailExpr::Base(self.lower_expr(e)),
@@ -553,6 +558,35 @@ impl<'hir> LoweringContext<'_, 'hir> {
         hir::Expr { hir_id: expr_hir_id, kind, span }
     }
 
+    fn lower_field_project(
+        &mut self,
+        e: &Expr,
+    ) -> Result<&'hir hir::FieldProject<'hir>, ErrorGuaranteed> {
+        let kind = match &e.kind {
+            ExprKind::Paren(inner) => return self.lower_field_project(inner),
+            ExprKind::Path(qself, path) => hir::FieldProjectKind::Path(self.lower_qpath(
+                e.id,
+                qself,
+                path,
+                ParamMode::Optional,
+                AllowReturnTypeNotation::No,
+                ImplTraitContext::Disallowed(ImplTraitPosition::Path),
+                None,
+            )),
+            ExprKind::Field(base, ident) => {
+                let base = self.lower_field_project(base)?;
+                hir::FieldProjectKind::Field(base, self.lower_ident(*ident))
+            }
+            ExprKind::Unary(UnOp::Deref, base) => {
+                hir::FieldProjectKind::Deref(self.lower_field_project(base)?)
+            }
+            ExprKind::Err(guar) => return Err(*guar),
+            _ => return Err(self.dcx().emit_err(AddressOfTemporaryTaken { span: e.span })),
+        };
+        let hir_id = self.lower_node_id(e.id);
+        Ok(self.arena.alloc(hir::FieldProject { hir_id, kind, span: self.lower_span(e.span) }))
+    }
+
     pub(crate) fn lower_const_block(&mut self, c: &AnonConst) -> hir::ConstBlock {
         self.with_new_scopes(c.value.span, |this| {
             let def_id = this.local_def_id(c.id);

compiler/rustc_ast_lowering/src/index.rs

@@ -286,6 +286,13 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> {
         });
     }
 
+    fn visit_field_project(&mut self, fp: &'hir FieldProject<'hir>) {
+        self.insert(fp.span, fp.hir_id, Node::FieldProject(fp));
+        self.with_parent(fp.hir_id, |this| {
+            intravisit::walk_field_project(this, fp);
+        });
+    }
+
     fn visit_const_arg_expr_field(&mut self, field: &'hir ConstArgExprField<'hir>) {
         self.insert(field.span, field.hir_id, Node::ConstArgExprField(field));
         self.with_parent(field.hir_id, |this| {

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("k#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

@@ -466,6 +466,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

@@ -310,6 +310,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

@@ -2266,6 +2266,7 @@ impl Expr<'_> {
             | ExprKind::Match(..)
             | ExprKind::MethodCall(..)
             | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
             | ExprKind::Path(..)
             | ExprKind::Repeat(..)
             | ExprKind::Struct(..)
@@ -2338,6 +2339,7 @@ impl Expr<'_> {
             | ExprKind::Assign(..)
             | ExprKind::InlineAsm(..)
             | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
             | ExprKind::AssignOp(..)
             | ExprKind::Lit(_)
             | ExprKind::ConstBlock(..)
@@ -2429,6 +2431,7 @@ impl Expr<'_> {
             | ExprKind::Become(_)
             | ExprKind::InlineAsm(_)
             | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
             | ExprKind::Struct(..)
             | ExprKind::Repeat(..)
             | ExprKind::Yield(..)
@@ -2486,9 +2489,11 @@ impl Expr<'_> {
 
     pub fn can_have_side_effects(&self) -> bool {
         match self.peel_drop_temps().kind {
-            ExprKind::Path(_) | ExprKind::Lit(_) | ExprKind::OffsetOf(..) | ExprKind::Use(..) => {
-                false
-            }
+            ExprKind::Path(_)
+            | ExprKind::Lit(_)
+            | ExprKind::OffsetOf(..)
+            | ExprKind::RawHandle(..)
+            | ExprKind::Use(..) => false,
             ExprKind::Type(base, _)
             | ExprKind::Unary(_, base)
             | ExprKind::Field(base, _)
@@ -2654,6 +2659,21 @@ pub fn expr_needs_parens(expr: &Expr<'_>) -> bool {
     }
 }
 
+#[derive(Debug, Clone, Copy, StableHash)]
+pub struct FieldProject<'hir> {
+    #[stable_hash(ignore)]
+    pub hir_id: HirId,
+    pub kind: FieldProjectKind<'hir>,
+    pub span: Span,
+}
+
+#[derive(Debug, Clone, Copy, StableHash)]
+pub enum FieldProjectKind<'hir> {
+    Path(QPath<'hir>),
+    Field(&'hir FieldProject<'hir>, Ident),
+    Deref(&'hir FieldProject<'hir>),
+}
+
 #[derive(Debug, Clone, Copy, StableHash)]
 pub enum ExprKind<'hir> {
     /// Allow anonymous constants from an inline `const` block
@@ -2770,6 +2790,9 @@ pub enum ExprKind<'hir> {
     /// Field offset (`offset_of!`)
     OffsetOf(&'hir Ty<'hir>, &'hir [Ident]),
 
+    /// Raw place handle (`raw_handle!`)
+    RawHandle(&'hir FieldProject<'hir>),
+
     /// A struct or struct-like variant literal expression.
     ///
     /// E.g., `Foo {x: 1, y: 2}`, or `Foo {x: 1, .. base}`,
@@ -5050,6 +5073,7 @@ pub enum Node<'hir> {
     ConstBlock(&'hir ConstBlock),
     ConstArg(&'hir ConstArg<'hir>),
     Expr(&'hir Expr<'hir>),
+    FieldProject(&'hir FieldProject<'hir>),
     ExprField(&'hir ExprField<'hir>),
     ConstArgExprField(&'hir ConstArgExprField<'hir>),
     Stmt(&'hir Stmt<'hir>),
@@ -5122,6 +5146,7 @@ impl<'hir> Node<'hir> {
             | Node::ConstBlock(..)
             | Node::ConstArg(..)
             | Node::Expr(..)
+            | Node::FieldProject(..)
             | Node::Stmt(..)
             | Node::Block(..)
             | Node::Ctor(..)
@@ -5322,6 +5347,7 @@ impl<'hir> Node<'hir> {
         match self {
             Node::Ty(Ty { kind: TyKind::Path(path), .. })
             | Node::Expr(Expr { kind: ExprKind::Path(path), .. })
+            | Node::FieldProject(FieldProject { kind: FieldProjectKind::Path(path), .. })
             | Node::PatExpr(PatExpr { kind: PatExprKind::Path(path), .. }) => Some(path),
             _ => None,
         }
@@ -5338,6 +5364,7 @@ impl<'hir> Node<'hir> {
         expect_anon_const,    &'hir AnonConst,          Node::AnonConst(n),    n;
         expect_inline_const,  &'hir ConstBlock,         Node::ConstBlock(n),   n;
         expect_expr,          &'hir Expr<'hir>,         Node::Expr(n),         n;
+        expect_field_project, &'hir FieldProject<'hir>, Node::FieldProject(n), n;
         expect_expr_field,    &'hir ExprField<'hir>,    Node::ExprField(n),    n;
         expect_stmt,          &'hir Stmt<'hir>,         Node::Stmt(n),         n;
         expect_path_segment,  &'hir PathSegment<'hir>,  Node::PathSegment(n),  n;
@@ -5370,6 +5397,8 @@ mod size_asserts {
     static_assert_size!(Body<'_>, 24);
     static_assert_size!(Expr<'_>, 64);
     static_assert_size!(ExprKind<'_>, 48);
+    static_assert_size!(FieldProject<'_>, 48);
+    static_assert_size!(FieldProjectKind<'_>, 32);
     static_assert_size!(FnDecl<'_>, 40);
     static_assert_size!(ForeignItem<'_>, 88);
     static_assert_size!(ForeignItemKind<'_>, 56);