Rollup of 4 pull requests

compiler/rustc_ast/src/ast.rs

@@ -789,14 +789,14 @@ pub struct PatField {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[derive(Encodable, Decodable, HashStable_Generic, Walkable)]
 pub enum ByRef {
- Yes(Mutability),
+ Yes(Pinnedness, Mutability),
  No,
 }
 
 impl ByRef {
  #[must_use]
  pub fn cap_ref_mutability(mut self, mutbl: Mutability) -> Self {
- if let ByRef::Yes(old_mutbl) = &mut self {
+ if let ByRef::Yes(_, old_mutbl) = &mut self {
  *old_mutbl = cmp::min(*old_mutbl, mutbl);
  }
  self
@@ -814,20 +814,33 @@ pub struct BindingMode(pub ByRef, pub Mutability);
 
 impl BindingMode {
  pub const NONE: Self = Self(ByRef::No, Mutability::Not);
- pub const REF: Self = Self(ByRef::Yes(Mutability::Not), Mutability::Not);
+ pub const REF: Self = Self(ByRef::Yes(Pinnedness::Not, Mutability::Not), Mutability::Not);
+ pub const REF_PIN: Self =
+ Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Not), Mutability::Not);
  pub const MUT: Self = Self(ByRef::No, Mutability::Mut);
- pub const REF_MUT: Self = Self(ByRef::Yes(Mutability::Mut), Mutability::Not);
- pub const MUT_REF: Self = Self(ByRef::Yes(Mutability::Not), Mutability::Mut);
- pub const MUT_REF_MUT: Self = Self(ByRef::Yes(Mutability::Mut), Mutability::Mut);
+ pub const REF_MUT: Self = Self(ByRef::Yes(Pinnedness::Not, Mutability::Mut), Mutability::Not);
+ pub const REF_PIN_MUT: Self =
+ Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Mut), Mutability::Not);
+ pub const MUT_REF: Self = Self(ByRef::Yes(Pinnedness::Not, Mutability::Not), Mutability::Mut);
+ pub const MUT_REF_PIN: Self =
+ Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Not), Mutability::Mut);
+ pub const MUT_REF_MUT: Self =
+ Self(ByRef::Yes(Pinnedness::Not, Mutability::Mut), Mutability::Mut);
+ pub const MUT_REF_PIN_MUT: Self =
+ Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Mut), Mutability::Mut);
 
  pub fn prefix_str(self) -> &'static str {
  match self {
  Self::NONE => "",
  Self::REF => "ref ",
+ Self::REF_PIN => "ref pin const ",
  Self::MUT => "mut ",
  Self::REF_MUT => "ref mut ",
+ Self::REF_PIN_MUT => "ref pin mut ",
  Self::MUT_REF => "mut ref ",
+ Self::MUT_REF_PIN => "mut ref pin ",
  Self::MUT_REF_MUT => "mut ref mut ",
+ Self::MUT_REF_PIN_MUT => "mut ref pin mut ",
  }
  }
 }

compiler/rustc_ast/src/visit.rs

@@ -368,6 +368,7 @@ macro_rules! common_visitor_and_walkers {
  crate::tokenstream::TokenStream,
  Movability,
  Mutability,
+ Pinnedness,
  Result<(), rustc_span::ErrorGuaranteed>,
  rustc_data_structures::fx::FxHashMap<Symbol, usize>,
  rustc_span::ErrorGuaranteed,

compiler/rustc_ast_ir/src/lib.rs

@@ -311,3 +311,10 @@ pub enum Pinnedness {
  Not,
  Pinned,
 }
+
+impl Pinnedness {
+ /// Return `true` if self is pinned
+ pub fn is_pinned(self) -> bool {
+ matches!(self, Self::Pinned)
+ }
+}

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1712,10 +1712,15 @@ impl<'a> State<'a> {
  if mutbl.is_mut() {
  self.word_nbsp("mut");
  }
- if let ByRef::Yes(rmutbl) = by_ref {
+ if let ByRef::Yes(pinnedness, rmutbl) = by_ref {
  self.word_nbsp("ref");
+ if pinnedness.is_pinned() {
+ self.word_nbsp("pin");
+ }
  if rmutbl.is_mut() {
  self.word_nbsp("mut");
+ } else if pinnedness.is_pinned() {
+ self.word_nbsp("const");
  }
  }
  self.print_ident(*ident);

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -48,6 +48,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_v2;
 pub(crate) mod proc_macro_attrs;
 pub(crate) mod prototype;
 pub(crate) mod repr;

compiler/rustc_attr_parsing/src/attributes/pin_v2.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 PinV2Parser;
+
+impl<S: Stage> NoArgsAttributeParser<S> for PinV2Parser {
+ const PATH: &[Symbol] = &[sym::pin_v2];
+ 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::PinV2;
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -47,6 +47,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_v2::PinV2Parser;
 use crate::attributes::proc_macro_attrs::{
  ProcMacroAttributeParser, ProcMacroDeriveParser, ProcMacroParser, RustcBuiltinMacroParser,
 };
@@ -233,6 +234,7 @@ attribute_parsers!(
  Single<WithoutArgs<NonExhaustiveParser>>,
  Single<WithoutArgs<ParenSugarParser>>,
  Single<WithoutArgs<PassByValueParser>>,
+ Single<WithoutArgs<PinV2Parser>>,
  Single<WithoutArgs<PointeeParser>>,
  Single<WithoutArgs<ProcMacroAttributeParser>>,
  Single<WithoutArgs<ProcMacroParser>>,

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -1188,7 +1188,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
  }
 
  LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm {
- binding_mode: BindingMode(ByRef::Yes(_), _),
+ binding_mode: BindingMode(ByRef::Yes(..), _),
  ..
  })) => {
  let pattern_span: Span = local_decl.source_info.span;

compiler/rustc_borrowck/src/lib.rs

@@ -2584,6 +2584,16 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
  _ => bug!("Deref of unexpected type: {:?}", base_ty),
  }
  }
+ // Check as the inner reference type if it is a field projection
+ // from the `&pin` pattern
+ ProjectionElem::Field(FieldIdx::ZERO, _)
+ if let Some(adt) =
+ place_base.ty(self.body(), self.infcx.tcx).ty.ty_adt_def()
+ && adt.is_pin()
+ && self.infcx.tcx.features().pin_ergonomics() =>
+ {
+ self.is_mutable(place_base, is_local_mutation_allowed)
+ }
  // All other projections are owned by their base path, so mutable if
  // base path is mutable
  ProjectionElem::Field(..)

compiler/rustc_feature/src/builtin_attrs.rs

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

compiler/rustc_hir/src/attrs/data_structures.rs

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

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

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

compiler/rustc_hir/src/hir.rs

@@ -13,7 +13,7 @@ use rustc_ast::{
 pub use rustc_ast::{
  AssignOp, AssignOpKind, AttrId, AttrStyle, BinOp, BinOpKind, BindingMode, BorrowKind,
  BoundConstness, BoundPolarity, ByRef, CaptureBy, DelimArgs, ImplPolarity, IsAuto,
- MetaItemInner, MetaItemLit, Movability, Mutability, UnOp,
+ MetaItemInner, MetaItemLit, Movability, Mutability, Pinnedness, UnOp,
 };
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::sorted_map::SortedMap;

compiler/rustc_hir_analysis/src/check/region.rs

@@ -575,7 +575,7 @@ fn resolve_local<'tcx>(
  // & expression, and its lifetime would be extended to the end of the block (due
  // to a different rule, not the below code).
  match pat.kind {
- PatKind::Binding(hir::BindingMode(hir::ByRef::Yes(_), _), ..) => true,
+ PatKind::Binding(hir::BindingMode(hir::ByRef::Yes(..), _), ..) => true,
 
  PatKind::Struct(_, field_pats, _) => field_pats.iter().any(|fp| is_binding_pat(fp.pat)),
 

compiler/rustc_hir_pretty/src/lib.rs

@@ -1923,10 +1923,15 @@ impl<'a> State<'a> {
  if mutbl.is_mut() {
  self.word_nbsp("mut");
  }
- if let ByRef::Yes(rmutbl) = by_ref {
+ if let ByRef::Yes(pinnedness, rmutbl) = by_ref {
  self.word_nbsp("ref");
+ if pinnedness.is_pinned() {
+ self.word_nbsp("pin");
+ }
  if rmutbl.is_mut() {
  self.word_nbsp("mut");
+ } else if pinnedness.is_pinned() {
+ self.word_nbsp("const");
  }
  }
  self.print_ident(ident);

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_v2]`
+ .note = type defined here
+ .suggestion = add `#[pin_v2]` 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_v2]\n", applicability = "machine-applicable")]
+ pub sugg_span: Option<Span>,
+}

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -986,7 +986,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
  // of the pattern, as this just looks confusing, instead use the span
  // of the discriminant.
  match bm.0 {
- hir::ByRef::Yes(m) => {
+ hir::ByRef::Yes(_, m) => {
  let bk = ty::BorrowKind::from_mutbl(m);
  self.delegate.borrow_mut().borrow(place, discr_place.hir_id, bk);
  }
@@ -1004,7 +1004,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
  // Deref patterns on boxes don't borrow, so we ignore them here.
  // HACK: this could be a fake pattern corresponding to a deref inserted by match
  // ergonomics, in which case `pat.hir_id` will be the id of the subpattern.
- if let hir::ByRef::Yes(mutability) =
+ if let hir::ByRef::Yes(_, mutability) =
  self.cx.typeck_results().deref_pat_borrow_mode(place.place.ty(), subpattern)
  {
  let bk = ty::BorrowKind::from_mutbl(mutability);
@@ -1256,15 +1256,23 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
  .get(pat.hir_id)
  .expect("missing binding mode");
 
- if matches!(bm.0, hir::ByRef::Yes(_)) {
+ if let hir::ByRef::Yes(pinnedness, _) = bm.0 {
+ let base_ty = if pinnedness.is_pinned() {
+ base_ty.pinned_ty().ok_or_else(|| {
+ debug!("By-pin-ref binding of non-`Pin` type: {base_ty:?}");
+ self.cx.report_bug(pat.span, "by-pin-ref binding of non-`Pin` type")
+ })?
+ } else {
+ base_ty
+ };
  // a bind-by-ref means that the base_ty will be the type of the ident itself,
  // but what we want here is the type of the underlying value being borrowed.
  // So peel off one-level, turning the &T into T.
  match self.cx.structurally_resolve_type(pat.span, base_ty).builtin_deref(false)
  {
  Some(ty) => Ok(ty),
  None => {
- debug!("By-ref binding of non-derefable type");
+ debug!("By-ref binding of non-derefable type: {base_ty:?}");
  Err(self
  .cx
  .report_bug(pat.span, "by-ref binding of non-derefable type"))
@@ -1706,6 +1714,18 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
  };
  self.pat_deref_place(pat.hir_id, place_with_id, pat, target_ty)?
  }
+ adjustment::PatAdjust::PinDeref => {
+ debug!("`PinDeref` of non-pinned-reference type: {:?}", adjust.source);
+ let target_ty = adjust.source.pinned_ty().ok_or_else(|| {
+ self.cx.report_bug(
+ self.cx.tcx().hir_span(pat.hir_id),
+ "`PinDeref` of non-pinned-reference type",
+ )
+ })?;
+ let kind = ProjectionKind::Field(FieldIdx::ZERO, FIRST_VARIANT);
+ place_with_id = self.cat_projection(pat.hir_id, place_with_id, target_ty, kind);
+ self.cat_deref(pat.hir_id, place_with_id)?
+ }
  };
  }
  drop(typeck_results); // explicitly release borrow of typeck results, just in case.
@@ -1877,7 +1897,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
  // Deref patterns on boxes are lowered using a built-in deref.
  hir::ByRef::No => self.cat_deref(hir_id, base_place),
  // For other types, we create a temporary to match on.
- hir::ByRef::Yes(mutability) => {
+ hir::ByRef::Yes(_, mutability) => {
  let re_erased = self.cx.tcx().lifetimes.re_erased;
  let ty = Ty::new_ref(self.cx.tcx(), re_erased, target_ty, mutability);
  // A deref pattern stores the result of `Deref::deref` or `DerefMut::deref_mut` ...