Add #[pin_project] attribute for structually pinning

Author: frank-king

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -47,6 +47,7 @@ pub(crate) mod must_use;
 pub(crate) mod no_implicit_prelude;
 pub(crate) mod non_exhaustive;
 pub(crate) mod path;
+pub(crate) mod pin_project;
 pub(crate) mod proc_macro_attrs;
 pub(crate) mod prototype;
 pub(crate) mod repr;

compiler/rustc_attr_parsing/src/attributes/pin_project.rs

@@ -0,0 +1,21 @@
+use rustc_hir::Target;
+use rustc_hir::attrs::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use crate::attributes::{NoArgsAttributeParser, OnDuplicate};
+use crate::context::Stage;
+use crate::target_checking::AllowedTargets;
+use crate::target_checking::Policy::Allow;
+
+pub(crate) struct PinProjectParser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for PinProjectParser {
+    const PATH: &[Symbol] = &[sym::pin_project];
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+        Allow(Target::Enum),
+        Allow(Target::Struct),
+        Allow(Target::Union),
+    ]);
+    const CREATE: fn(Span) -> AttributeKind = AttributeKind::PinProject;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -46,6 +46,7 @@ use crate::attributes::must_use::MustUseParser;
 use crate::attributes::no_implicit_prelude::NoImplicitPreludeParser;
 use crate::attributes::non_exhaustive::NonExhaustiveParser;
 use crate::attributes::path::PathParser as PathAttributeParser;
+use crate::attributes::pin_project::PinProjectParser;
 use crate::attributes::proc_macro_attrs::{
     ProcMacroAttributeParser, ProcMacroDeriveParser, ProcMacroParser, RustcBuiltinMacroParser,
 };
@@ -231,6 +232,7 @@ attribute_parsers!(
         Single<WithoutArgs<NonExhaustiveParser>>,
         Single<WithoutArgs<ParenSugarParser>>,
         Single<WithoutArgs<PassByValueParser>>,
+        Single<WithoutArgs<PinProjectParser>>,
         Single<WithoutArgs<PointeeParser>>,
         Single<WithoutArgs<ProcMacroAttributeParser>>,
         Single<WithoutArgs<ProcMacroParser>>,

compiler/rustc_feature/src/builtin_attrs.rs

@@ -888,6 +888,15 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         EncodeCrossCrate::No, loop_match, experimental!(loop_match)
     ),
 
+    // The `#[pin_project]` attribute is part of the `pin_ergonomics` experiment
+    // that allows structually pinning, tracked in:
+    //
+    // - https://github.com/rust-lang/rust/issues/130494
+    gated!(
+        pin_project, Normal, template!(Word), ErrorFollowing,
+        EncodeCrossCrate::Yes, pin_ergonomics, experimental!(pin_project),
+    ),
+
     // ==========================================================================
     // Internal attributes: Stability, deprecation, and unsafe:
     // ==========================================================================

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -615,6 +615,9 @@ pub enum AttributeKind {
     /// Represents `#[pattern_complexity_limit]`
     PatternComplexityLimit { attr_span: Span, limit_span: Span, limit: Limit },
 
+    /// Represents `#[pin_project]`
+    PinProject(Span),
+
     /// Represents `#[pointee]`
     Pointee(Span),
 

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -76,6 +76,7 @@ impl AttributeKind {
             PassByValue(..) => Yes,
             Path(..) => No,
             PatternComplexityLimit { .. } => No,
+            PinProject(..) => Yes,
             Pointee(..) => No,
             ProcMacro(..) => No,
             ProcMacroAttribute(..) => No,

compiler/rustc_hir_typeck/messages.ftl

@@ -227,6 +227,10 @@ hir_typeck_pass_to_variadic_function = can't pass `{$ty}` to variadic function
     .suggestion = cast the value to `{$cast_ty}`
     .teach_help = certain types, like `{$ty}`, must be cast before passing them to a variadic function to match the implicit cast that a C compiler would perform as part of C's numeric promotion rules
 
+hir_typeck_project_on_non_pin_project_type = cannot project on type that is not `#[pin_project]`
+    .note = type defined here
+    .suggestion = add `#[pin_project]` here
+
 hir_typeck_ptr_cast_add_auto_to_object = cannot add {$traits_len ->
     [1] auto trait {$traits}
     *[other] auto traits {$traits}

compiler/rustc_hir_typeck/src/errors.rs

@@ -1156,3 +1156,14 @@ pub(crate) struct ConstContinueBadLabel {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(hir_typeck_project_on_non_pin_project_type)]
+pub(crate) struct ProjectOnNonPinProjectType {
+    #[primary_span]
+    pub span: Span,
+    #[note]
+    pub def_span: Option<Span>,
+    #[suggestion(code = "#[pin_project]\n", applicability = "machine-applicable")]
+    pub sugg_span: Option<Span>,
+}

compiler/rustc_hir_typeck/src/pat.rs

@@ -554,6 +554,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             {
                 debug!("scrutinee ty {expected:?} is a pinned reference, inserting pin deref");
 
+                // if the inner_ty is an ADT, make sure that it can be structually pinned
+                // (i.e., it is `#[pin_project]`).
+                if let Some(adt) = inner_ty.ty_adt_def()
+                    && !adt.is_pin_project()
+                    && !adt.is_pin()
+                {
+                    let def_span: Option<Span> = self.tcx.hir_span_if_local(adt.did());
+                    let sugg_span = def_span.map(|span| span.shrink_to_lo());
+                    self.dcx().emit_err(crate::errors::ProjectOnNonPinProjectType {
+                        span: pat.span,
+                        def_span,
+                        sugg_span,
+                    });
+                }
+
                 let binding_mode = adjust_binding_mode(Pinnedness::Pinned, inner_mutability);
                 // If the pinnedness is `Not`, it means the pattern is unpinned
                 // and thus requires an `Unpin` bound.

compiler/rustc_middle/src/ty/adt.rs

@@ -57,6 +57,8 @@ bitflags::bitflags! {
         const IS_UNSAFE_PINNED              = 1 << 10;
         /// Indicates whether the type is `Pin`.
         const IS_PIN                        = 1 << 11;
+        /// Indicates whether the type is `#[pin_project]`.
+        const IS_PIN_PROJECT                = 1 << 12;
     }
 }
 rustc_data_structures::external_bitflags_debug! { AdtFlags }
@@ -286,6 +288,10 @@ impl AdtDefData {
             debug!("found non-exhaustive variant list for {:?}", did);
             flags = flags | AdtFlags::IS_VARIANT_LIST_NON_EXHAUSTIVE;
         }
+        if find_attr!(tcx.get_all_attrs(did), AttributeKind::PinProject(..)) {
+            debug!("found pin-project type {:?}", did);
+            flags |= AdtFlags::IS_PIN_PROJECT;
+        }
 
         flags |= match kind {
             AdtKind::Enum => AdtFlags::IS_ENUM,
@@ -439,6 +445,13 @@ impl<'tcx> AdtDef<'tcx> {
         self.flags().contains(AdtFlags::IS_PIN)
     }
 
+    /// Returns `true` is this is `#[pin_project]` for the purposes
+    /// of structual pinning.
+    #[inline]
+    pub fn is_pin_project(self) -> bool {
+        self.flags().contains(AdtFlags::IS_PIN_PROJECT)
+    }
+
     /// Returns `true` if this type has a destructor.
     pub fn has_dtor(self, tcx: TyCtxt<'tcx>) -> bool {
         self.destructor(tcx).is_some()