WIP: implement pin-project for &pin mut|const T

Author: frank-king

compiler/rustc_feature/src/builtin_attrs.rs

@@ -583,6 +583,12 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         EncodeCrossCrate::Yes, min_generic_const_args, experimental!(type_const),
     ),
 
+    // Pinned fields `#[pin]`
+    gated!(
+        pin, Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::Yes, pin_ergonomics,
+        experimental!(pin),
+    ),
+
     // ==========================================================================
     // Internal attributes: Stability, deprecation, and unsafe:
     // ==========================================================================

compiler/rustc_hir_analysis/src/collect.rs

@@ -20,7 +20,7 @@ use std::iter;
 use std::ops::Bound;
 
 use rustc_abi::ExternAbi;
-use rustc_ast::Recovered;
+use rustc_ast::{Pinnedness, Recovered};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_data_structures::unord::UnordMap;
 use rustc_errors::{
@@ -1061,6 +1061,11 @@ fn lower_variant<'tcx>(
             vis: tcx.visibility(f.def_id),
             safety: f.safety,
             value: f.default.map(|v| v.def_id.to_def_id()),
+            pinnedness: if tcx.has_attr(f.def_id, sym::pin) {
+                Pinnedness::Pinned
+            } else {
+                Pinnedness::Not
+            },
         })
         .collect();
     let recovered = match def {

compiler/rustc_hir_typeck/src/pat.rs

@@ -88,6 +88,7 @@ struct TopInfo<'tcx> {
 
 #[derive(Copy, Clone)]
 struct PatInfo<'tcx> {
+    pinnedness: ast::Pinnedness,
     binding_mode: ByRef,
     max_ref_mutbl: MutblCap,
     top_info: TopInfo<'tcx>,
@@ -302,6 +303,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) {
         let top_info = TopInfo { expected, origin_expr, span, hir_id: pat.hir_id };
         let pat_info = PatInfo {
+            pinnedness: ast::Pinnedness::Not,
             binding_mode: ByRef::No,
             max_ref_mutbl: MutblCap::Mut,
             top_info,
@@ -400,11 +402,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let pat_info = PatInfo { current_depth: old_pat_info.current_depth + 1, ..old_pat_info };
 
         match pat.kind {
-            // Peel off a `&` or `&mut` from the scrutinee type. See the examples in
-            // `tests/ui/rfcs/rfc-2005-default-binding-mode`.
+            // Peel off a `&`, `&mut`, `&pin const` or `&pin mut` from the scrutinee type.
+            // See the examples in `tests/ui/rfcs/rfc-2005-default-binding-mode`
+            // and `tests/ui/async-await/pin-ergonomics/project-pattern-match`.
             _ if let AdjustMode::Peel = adjust_mode
                 && pat.default_binding_modes
-                && let ty::Ref(_, inner_ty, inner_mutability) = *expected.kind() =>
+                && let Some((_, pinnedness, inner_ty, inner_mutability)) =
+                    expected.is_ref_or_pin_ref(self.tcx) =>
             {
                 debug!("inspecting {:?}", expected);
 
@@ -428,6 +432,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     ByRef::Yes(Mutability::Not) => Mutability::Not,
                 });
 
+                let pinnedness = pinnedness.max(pat_info.pinnedness);
+
                 let mut max_ref_mutbl = pat_info.max_ref_mutbl;
                 if self.downgrade_mut_inside_shared() {
                     binding_mode = binding_mode.cap_ref_mutability(max_ref_mutbl.as_mutbl());
@@ -438,7 +444,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 debug!("default binding mode is now {:?}", binding_mode);
 
                 // Use the old pat info to keep `current_depth` to its old value.
-                let new_pat_info = PatInfo { binding_mode, max_ref_mutbl, ..old_pat_info };
+                let new_pat_info =
+                    PatInfo { pinnedness, binding_mode, max_ref_mutbl, ..old_pat_info };
                 // Recurse with the new expected type.
                 self.check_pat_inner(pat, opt_path_res, adjust_mode, inner_ty, new_pat_info)
             }
@@ -790,7 +797,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expected: Ty<'tcx>,
         pat_info: PatInfo<'tcx>,
     ) -> Ty<'tcx> {
-        let PatInfo { binding_mode: def_br, top_info: ti, .. } = pat_info;
+        let PatInfo { pinnedness, binding_mode: def_br, top_info: ti, .. } = pat_info;
 
         // Determine the binding mode...
         let bm = match user_bind_annot {
@@ -883,6 +890,17 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             ByRef::No => expected, // As above, `T <: typeof(x)` is required, but we use equality, see (note_1).
         };
 
+        // Wrapping the type into `Pin` if the pattern is pinned
+        let eq_ty = if pinnedness == ast::Pinnedness::Pinned {
+            Ty::new_adt(
+                self.tcx,
+                self.tcx.adt_def(self.tcx.require_lang_item(hir::LangItem::Pin, Some(pat.span))),
+                self.tcx.mk_args(&[eq_ty.into()]),
+            )
+        } else {
+            eq_ty
+        };
+
         // We have a concrete type for the local, so we do not need to taint it and hide follow up errors *using* the local.
         let _ = self.demand_eqtype_pat(pat.span, eq_ty, local_ty, &ti);
 
@@ -1386,6 +1404,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             for (i, subpat) in subpats.iter().enumerate_and_adjust(variant.fields.len(), ddpos) {
                 let field = &variant.fields[FieldIdx::from_usize(i)];
                 let field_ty = self.field_ty(subpat.span, field, args);
+                // If the field is not marked as `#[pin]`, then remove the
+                // pinnedness in `pat_info`.
+                let pinnedness = pat_info.pinnedness.min(field.pinnedness);
+                let pat_info = PatInfo { pinnedness, ..pat_info };
                 self.check_pat(subpat, field_ty, pat_info);
 
                 self.tcx.check_stability(
@@ -1642,11 +1664,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         for field in fields {
             let span = field.span;
             let ident = tcx.adjust_ident(field.ident, variant.def_id);
-            let field_ty = match used_fields.entry(ident) {
+            let (field_ty, pinnedness) = match used_fields.entry(ident) {
                 Occupied(occupied) => {
                     let guar = self.error_field_already_bound(span, field.ident, *occupied.get());
                     result = Err(guar);
-                    Ty::new_error(tcx, guar)
+                    (Ty::new_error(tcx, guar), ast::Pinnedness::Not)
                 }
                 Vacant(vacant) => {
                     vacant.insert(span);
@@ -1655,15 +1677,19 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         .map(|(i, f)| {
                             self.write_field_index(field.hir_id, *i);
                             self.tcx.check_stability(f.did, Some(field.hir_id), span, None);
-                            self.field_ty(span, f, args)
+                            (self.field_ty(span, f, args), f.pinnedness)
                         })
                         .unwrap_or_else(|| {
                             inexistent_fields.push(field);
-                            Ty::new_misc_error(tcx)
+                            (Ty::new_misc_error(tcx), ast::Pinnedness::Not)
                         })
                 }
             };
 
+            // If the field is not marked as `#[pin]`, then remove the
+            // pinnedness in `pat_info`.
+            let pinnedness = pat_info.pinnedness.min(pinnedness);
+            let pat_info = PatInfo { pinnedness, ..pat_info };
             self.check_pat(field.pat, field_ty, pat_info);
         }
 

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -32,7 +32,7 @@ use rustc_session::Session;
 use rustc_session::config::TargetModifier;
 use rustc_session::cstore::{CrateSource, ExternCrate};
 use rustc_span::hygiene::HygieneDecodeContext;
-use rustc_span::{BytePos, DUMMY_SP, Pos, SpanData, SpanDecoder, SyntaxContext, kw};
+use rustc_span::{BytePos, DUMMY_SP, Pos, SpanData, SpanDecoder, SyntaxContext, kw, sym};
 use tracing::debug;
 
 use crate::creader::CStore;
@@ -1084,6 +1084,7 @@ impl<'a> CrateMetadataRef<'a> {
         kind: DefKind,
         index: DefIndex,
         parent_did: DefId,
+        sess: &'a Session,
     ) -> (VariantIdx, ty::VariantDef) {
         let adt_kind = match kind {
             DefKind::Variant => ty::AdtKind::Enum,
@@ -1112,6 +1113,15 @@ impl<'a> CrateMetadataRef<'a> {
                         vis: self.get_visibility(did.index),
                         safety: self.get_safety(did.index),
                         value: self.get_default_field(did.index),
+                        pinnedness: if self
+                            .get_item_attrs(did.index, sess)
+                            .find(|attr| attr.has_name(sym::pin))
+                            .is_some()
+                        {
+                            ast::Pinnedness::Pinned
+                        } else {
+                            ast::Pinnedness::Not
+                        },
                     })
                     .collect(),
                 parent_did,
@@ -1144,12 +1154,12 @@ impl<'a> CrateMetadataRef<'a> {
                     let kind = self.def_kind(index);
                     match kind {
                         DefKind::Ctor(..) => None,
-                        _ => Some(self.get_variant(kind, index, did)),
+                        _ => Some(self.get_variant(kind, index, did, tcx.sess)),
                     }
                 })
                 .collect()
         } else {
-            std::iter::once(self.get_variant(kind, item_id, did)).collect()
+            std::iter::once(self.get_variant(kind, item_id, did, tcx.sess)).collect()
         };
 
         variants.sort_by_key(|(idx, _)| *idx);

compiler/rustc_middle/src/ty/mod.rs

@@ -1379,6 +1379,7 @@ pub struct FieldDef {
     pub vis: Visibility<DefId>,
     pub safety: hir::Safety,
     pub value: Option<DefId>,
+    pub pinnedness: ast::Pinnedness,
 }
 
 impl PartialEq for FieldDef {
@@ -1391,9 +1392,9 @@ impl PartialEq for FieldDef {
         // of `FieldDef` changes, a compile-error will be produced, reminding
         // us to revisit this assumption.
 
-        let Self { did: lhs_did, name: _, vis: _, safety: _, value: _ } = &self;
+        let Self { did: lhs_did, name: _, vis: _, safety: _, value: _, pinnedness: _ } = &self;
 
-        let Self { did: rhs_did, name: _, vis: _, safety: _, value: _ } = other;
+        let Self { did: rhs_did, name: _, vis: _, safety: _, value: _, pinnedness: _ } = other;
 
         let res = lhs_did == rhs_did;
 
@@ -1420,7 +1421,7 @@ impl Hash for FieldDef {
         // of `FieldDef` changes, a compile-error will be produced, reminding
         // us to revisit this assumption.
 
-        let Self { did, name: _, vis: _, safety: _, value: _ } = &self;
+        let Self { did, name: _, vis: _, safety: _, value: _, pinnedness: _ } = &self;
 
         did.hash(s)
     }

compiler/rustc_middle/src/ty/util.rs

@@ -1545,6 +1545,27 @@ impl<'tcx> Ty<'tcx> {
         ty
     }
 
+    /// Destructs a reference type `&'a [mut] T` or a pinned reference type
+    /// `&'a pin const|mut T` into `'a` the region, `[pin]` the pinnedness,
+    /// `T` the inner type, and `mut|const` the mutability.
+    pub fn is_ref_or_pin_ref(
+        self,
+        tcx: TyCtxt<'tcx>,
+    ) -> Option<(ty::Region<'tcx>, ty::Pinnedness, Ty<'tcx>, ty::Mutability)> {
+        match self.kind() {
+            &ty::Ref(region, inner_ty, mutbl) => {
+                Some((region, ty::Pinnedness::Not, inner_ty, mutbl))
+            }
+            ty::Adt(adt, args)
+                if tcx.is_lang_item(adt.did(), hir::LangItem::Pin)
+                    && let &ty::Ref(region, inner_ty, mutbl) = args.type_at(0).kind() =>
+            {
+                Some((region, ty::Pinnedness::Pinned, inner_ty, mutbl))
+            }
+            _ => None,
+        }
+    }
+
     // FIXME(compiler-errors): Think about removing this.
     #[inline]
     pub fn outer_exclusive_binder(self) -> ty::DebruijnIndex {

compiler/rustc_mir_build/src/thir/pattern/mod.rs

@@ -348,8 +348,8 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 // x's type, which is &T, where we want T (the type being matched).
                 let var_ty = ty;
                 if let hir::ByRef::Yes(_) = mode.0 {
-                    if let ty::Ref(_, rty, _) = ty.kind() {
-                        ty = *rty;
+                    if let Some((_, _, rty, _)) = ty.is_ref_or_pin_ref(self.tcx) {
+                        ty = rty;
                     } else {
                         bug!("`ref {}` has wrong type {}", ident, ty);
                     }

compiler/rustc_passes/messages.ftl

@@ -618,6 +618,10 @@ passes_pass_by_value =
     `pass_by_value` attribute should be applied to a struct, enum or type alias
     .label = is not a struct, enum or type alias
 
+passes_pin_bad_location =
+    `pin` attribute should be applied to a field
+    .label = expect field, but apllied to this {$target}
+
 passes_proc_macro_bad_sig = {$kind} has incorrect signature
 
 passes_remove_fields =

compiler/rustc_passes/src/check_attr.rs

@@ -263,6 +263,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         }
                         [sym::linkage, ..] => self.check_linkage(attr, span, target),
                         [sym::rustc_pub_transparent, ..] => self.check_rustc_pub_transparent(attr.span(), span, attrs),
+                        [sym::pin, ..] => self.check_pin(attr.span(), span, target),
                         [
                             // ok
                             sym::allow
@@ -2644,6 +2645,20 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
         }
     }
+
+    /// Checkes if `#[pin]` is applied to a field definition.
+    fn check_pin(&self, attr_span: Span, span: Span, target: Target) {
+        match target {
+            Target::Field => {}
+            _ => {
+                self.dcx().emit_err(errors::PinBadLocation {
+                    attr_span,
+                    span,
+                    target: target.name(),
+                });
+            }
+        }
+    }
 }
 
 impl<'tcx> Visitor<'tcx> for CheckAttrVisitor<'tcx> {

compiler/rustc_passes/src/errors.rs

@@ -1928,3 +1928,13 @@ pub(crate) struct UnsupportedAttributesInWhere {
     #[primary_span]
     pub span: MultiSpan,
 }
+
+#[derive(Diagnostic)]
+#[diag(passes_pin_bad_location)]
+pub(crate) struct PinBadLocation {
+    #[primary_span]
+    pub attr_span: Span,
+    #[label]
+    pub span: Span,
+    pub target: &'static str,
+}

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -4,8 +4,8 @@ use std::ops::ControlFlow;
 
 use rustc_abi::{FIRST_VARIANT, FieldIdx, Integer, VariantIdx};
 use rustc_arena::DroplessArena;
-use rustc_hir::HirId;
 use rustc_hir::def_id::DefId;
+use rustc_hir::{HirId, LangItem};
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::middle::stability::EvalResult;
 use rustc_middle::mir::{self, Const};
@@ -484,6 +484,8 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 ctor = match ty.kind() {
                     // This is a box pattern.
                     ty::Adt(adt, ..) if adt.is_box() => Struct,
+                    // This is a pin ref pattern.
+                    ty::Adt(adt, ..) if self.tcx.is_lang_item(adt.did(), LangItem::Pin) => Ref,
                     ty::Ref(..) => Ref,
                     _ => span_bug!(
                         pat.span,