Implement &pin patterns and ref pin bindings

Author: frank-king

compiler/rustc_ast/src/ast.rs

@@ -648,9 +648,10 @@ impl Pat {
 PatKind::Path(qself, path) => TyKind::Path(qself.clone(), path.clone()),
 PatKind::MacCall(mac) => TyKind::MacCall(mac.clone()),
 // `&mut? P` can be reinterpreted as `&mut? T` where `T` is `P` reparsed as a type.
-PatKind::Ref(pat, mutbl) => {
- pat.to_ty().map(|ty| TyKind::Ref(None,MutTy{ ty,mutbl:*mutbl }))?
-}
+PatKind::Ref(pat, pinned, mutbl) => pat.to_ty().map(|ty| match pinned {
+Pinnedness::Not => TyKind::Ref(None,MutTy{ ty,mutbl:*mutbl }),
+Pinnedness::Pinned => TyKind::PinnedRef(None,MutTy{ ty,mutbl:*mutbl }),
+})?,
 // A slice/array pattern `[P]` can be reparsed as `[T]`, an unsized array,
 // when `P` can be reparsed as a type `T`.
 PatKind::Slice(pats)iflet[pat] = pats.as_slice() => {
@@ -696,7 +697,7 @@ impl Pat {
 // Trivial wrappers over inner patterns.
 PatKind::Box(s)
  | PatKind::Deref(s)
- | PatKind::Ref(s, _)
+ | PatKind::Ref(s, _, _)
  | PatKind::Paren(s)
  | PatKind::Guard(s, _) => s.walk(it),
 
@@ -717,7 +718,7 @@ impl Pat {
 /// Strip off all reference patterns (`&`, `&mut`) and return the inner pattern.
 pubfnpeel_refs(&self) -> &Pat{
 letmut current = self;
-whileletPatKind::Ref(inner, _) = &current.kind{
+whileletPatKind::Ref(inner, _, _) = &current.kind{
  current = inner;
 }
  current
@@ -765,7 +766,9 @@ impl Pat {
 PatKind::Missing => unreachable!(),
 PatKind::Wild => Some("_".to_string()),
 PatKind::Ident(BindingMode::NONE, ident,None) => Some(format!("{ident}")),
-PatKind::Ref(pat, mutbl) => pat.descr().map(|d| format!("&{}{d}", mutbl.prefix_str())),
+PatKind::Ref(pat, pinned, mutbl) => {
+ pat.descr().map(|d| format!("&{}{d}", pinned.prefix_str(*mutbl)))
+}
  _ => None,
 }
 }
@@ -913,7 +916,7 @@ pub enum PatKind {
 Deref(Box<Pat>),
 
 /// A reference pattern (e.g., `&mut (a, b)`).
-Ref(Box<Pat>,Mutability),
+Ref(Box<Pat>,Pinnedness,Mutability),
 
 /// A literal, const block or path.
 Expr(Box<Expr>),

compiler/rustc_ast_ir/src/lib.rs

@@ -317,4 +317,15 @@ impl Pinnedness {
 pubfnis_pinned(self) -> bool{
 matches!(self,Self::Pinned)
 }
+
+/// Returns `""` (empty string), "mut", `"pin mut "` or `"pin const "` depending
+/// on the pinnedness and mutability.
+pubfnprefix_str(self,mutbl:Mutability) -> &'staticstr{
+match(self, mutbl){
+(Pinnedness::Pinned,Mutability::Mut) => "pin mut ",
+(Pinnedness::Pinned,Mutability::Not) => "pin const ",
+(Pinnedness::Not,Mutability::Mut) => "mut ",
+(Pinnedness::Not,Mutability::Not) => "",
+}
+}
 }

compiler/rustc_ast_lowering/src/pat.rs

@@ -124,8 +124,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 PatKind::Deref(inner) => {
 break hir::PatKind::Deref(self.lower_pat(inner));
 }
-PatKind::Ref(inner, mutbl) => {
-break hir::PatKind::Ref(self.lower_pat(inner),*mutbl);
+PatKind::Ref(inner,pinned,mutbl) => {
+break hir::PatKind::Ref(self.lower_pat(inner),*pinned,*mutbl);
 }
 PatKind::Range(e1, e2,Spanned{node: end, .. }) => {
 break hir::PatKind::Range(

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -1807,8 +1807,14 @@ impl<'a> State<'a> {
 self.print_pat(inner);
 self.pclose();
 }
-PatKind::Ref(inner, mutbl) => {
+PatKind::Ref(inner,pinned,mutbl) => {
 self.word("&");
+if pinned.is_pinned(){
+self.word("pin ");
+if mutbl.is_not(){
+self.word("const ");
+}
+}
 if mutbl.is_mut(){
 self.word("mut ");
 }

compiler/rustc_borrowck/src/diagnostics/move_errors.rs

@@ -867,11 +867,12 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
 for(binding_span, opt_ref_pat)in finder.ref_pat_for_binding{
 ifletSome(ref_pat) = opt_ref_pat
  && !finder.cannot_remove.contains(&ref_pat.hir_id)
- && let hir::PatKind::Ref(subpat, mutbl) = ref_pat.kind
+ && let hir::PatKind::Ref(subpat,pinned,mutbl) = ref_pat.kind
  && letSome(ref_span) = ref_pat.span.trim_end(subpat.span)
 {
+let pinned_str = if pinned.is_pinned(){"pinned "}else{""};
 let mutable_str = if mutbl.is_mut(){"mutable "}else{""};
-let msg = format!("consider removing the {mutable_str}borrow");
+let msg = format!("consider removing the {pinned_str}{mutable_str}borrow");
  suggestions.push((ref_span, msg,"".to_string()));
 }else{
 let msg = "consider borrowing the pattern binding".to_string();

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -772,11 +772,11 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
  && letSome(hir_id) = (BindingFinder{span: pat_span }).visit_body(&body).break_value()
  && let node = self.infcx.tcx.hir_node(hir_id)
  && let hir::Node::LetStmt(hir::LetStmt{
-pat: hir::Pat{kind: hir::PatKind::Ref(_, _), .. },
+pat: hir::Pat{kind: hir::PatKind::Ref(_, _, _), .. },
  ..
 })
  | hir::Node::Param(Param{
-pat: hir::Pat{kind: hir::PatKind::Ref(_, _), .. },
+pat: hir::Pat{kind: hir::PatKind::Ref(_, _, _), .. },
  ..
 }) = node
 {
@@ -1494,7 +1494,7 @@ impl<'tcx> Visitor<'tcx> for BindingFinder {
 }
 
 fnvisit_param(&mutself,param:&'tcx hir::Param<'tcx>) -> Self::Result{
-iflet hir::Pat{kind: hir::PatKind::Ref(_, _), span, .. } = param.pat
+iflet hir::Pat{kind: hir::PatKind::Ref(_, _, _), span, .. } = param.pat
  && *span == self.span
 {
 ControlFlow::Break(param.hir_id)

compiler/rustc_hir/src/hir.rs

@@ -1722,7 +1722,9 @@ impl<'hir> Pat<'hir> {
 matchself.kind{
 Missing => unreachable!(),
 Wild | Never | Expr(_) | Range(..) | Binding(..,None) | Err(_) => true,
-Box(s) | Deref(s) | Ref(s, _) | Binding(..,Some(s)) | Guard(s, _) => s.walk_short_(it),
+Box(s) | Deref(s) | Ref(s, _, _) | Binding(..,Some(s)) | Guard(s, _) => {
+ s.walk_short_(it)
+}
 Struct(_, fields, _) => fields.iter().all(|field| field.pat.walk_short_(it)),
 TupleStruct(_, s, _) | Tuple(s, _) | Or(s) => s.iter().all(|p| p.walk_short_(it)),
 Slice(before, slice, after) => {
@@ -1749,7 +1751,7 @@ impl<'hir> Pat<'hir> {
 usePatKind::*;
 matchself.kind{
 Missing | Wild | Never | Expr(_) | Range(..) | Binding(..,None) | Err(_) => {}
-Box(s) | Deref(s) | Ref(s, _) | Binding(..,Some(s)) | Guard(s, _) => s.walk_(it),
+Box(s) | Deref(s) | Ref(s, _, _) | Binding(..,Some(s)) | Guard(s, _) => s.walk_(it),
 Struct(_, fields, _) => fields.iter().for_each(|field| field.pat.walk_(it)),
 TupleStruct(_, s, _) | Tuple(s, _) | Or(s) => s.iter().for_each(|p| p.walk_(it)),
 Slice(before, slice, after) => {
@@ -1938,7 +1940,7 @@ pub enum PatKind<'hir> {
 Deref(&'hirPat<'hir>),
 
 /// A reference pattern (e.g., `&mut (a, b)`).
-Ref(&'hirPat<'hir>,Mutability),
+Ref(&'hirPat<'hir>,Pinnedness,Mutability),
 
 /// A literal, const block or path.
 Expr(&'hirPatExpr<'hir>),

compiler/rustc_hir/src/intravisit.rs

@@ -752,7 +752,7 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat<'v>) -> V:
 }
 PatKind::Box(ref subpattern)
  | PatKind::Deref(ref subpattern)
- | PatKind::Ref(ref subpattern, _) => {
+ | PatKind::Ref(ref subpattern, _, _) => {
 try_visit!(visitor.visit_pat(subpattern));
 }
 PatKind::Binding(_, _hir_id, ident,ref optional_subpattern) => {

compiler/rustc_hir_analysis/src/check/region.rs

@@ -593,7 +593,7 @@ fn resolve_local<'tcx>(
 is_binding_pat(subpat)
 }
 
-PatKind::Ref(_, _)
+PatKind::Ref(_, _, _)
  | PatKind::Binding(hir::BindingMode(hir::ByRef::No, _), ..)
  | PatKind::Missing
  | PatKind::Wild

compiler/rustc_hir_pretty/src/lib.rs

@@ -2028,9 +2028,15 @@ impl<'a> State<'a> {
 self.print_pat(inner);
 self.pclose();
 }
-PatKind::Ref(inner, mutbl) => {
+PatKind::Ref(inner,pinned,mutbl) => {
 let is_range_inner = matches!(inner.kind,PatKind::Range(..));
 self.word("&");
+if pinned.is_pinned(){
+self.word("pin ");
+if mutbl.is_not(){
+self.word("const ");
+}
+}
 self.word(mutbl.prefix_str());
 if is_range_inner {
 self.popen();