Implement pinned borrows, part of pin_ergonomics

frank-king · frank-king · commit 7010181c07f2 · 2025-03-07T22:19:10.000+08:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -877,6 +877,10 @@ pub enum BorrowKind {
     /// The resulting type is either `*const T` or `*mut T`
     /// where `T = typeof($expr)`.
     Raw,
+    /// A pinned borrow, `&pin const $expr` or `&pin mut $expr`.
+    /// The resulting type is either `Pin<&'a T>` or `Pin<&'a mut T>`
+    /// where `T = typeof($expr)` and `'a` is some lifetime.
+    Pin,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -339,6 +339,10 @@ impl<'a> State<'a> {
                 self.word_nbsp("raw");
                 self.print_mutability(mutability, true);
             }
+            ast::BorrowKind::Pin => {
+                self.word_nbsp("pin");
+                self.print_mutability(mutability, true);
+            }
         }
         self.print_expr_cond_paren(
             expr,
diff --git a/compiler/rustc_const_eval/src/check_consts/ops.rs b/compiler/rustc_const_eval/src/check_consts/ops.rs
@@ -619,11 +619,13 @@ impl<'tcx> NonConstOp<'tcx> for EscapingMutBorrow {
                 kind: ccx.const_kind(),
                 teach: ccx.tcx.sess.teach(E0764),
             }),
-            hir::BorrowKind::Ref => ccx.dcx().create_err(errors::MutableRefEscaping {
-                span,
-                kind: ccx.const_kind(),
-                teach: ccx.tcx.sess.teach(E0764),
-            }),
+            hir::BorrowKind::Ref | hir::BorrowKind::Pin => {
+                ccx.dcx().create_err(errors::MutableRefEscaping {
+                    span,
+                    kind: ccx.const_kind(),
+                    teach: ccx.tcx.sess.teach(E0764),
+                })
+            }
         }
     }
 }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1417,6 +1417,10 @@ impl<'a> State<'a> {
                 self.word_nbsp("raw");
                 self.print_mutability(mutability, true);
             }
+            hir::BorrowKind::Pin => {
+                self.word_nbsp("pin");
+                self.print_mutability(mutability, true);
+            }
         }
         self.print_expr_cond_paren(expr, expr.precedence() < ExprPrecedence::Prefix);
     }
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
@@ -688,6 +688,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 let region = self.next_region_var(infer::BorrowRegion(expr.span));
                 Ty::new_ref(self.tcx, region, ty, mutbl)
             }
+            hir::BorrowKind::Pin => {
+                // See comments in the `hir::BorrowKind::Ref` arm above.
+                let region = self.next_region_var(infer::BorrowRegion(expr.span));
+                Ty::new_pinned_ref(self.tcx, region, ty, mutbl)
+            }
         }
     }
 
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -472,6 +472,31 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 ExprKind::RawBorrow { mutability, arg: self.mirror_expr(arg) }
             }
 
+            // make `&pin mut $expr` and `&pin const $expr` into `Pin { __pointer: &mut $expr }`
+            // and `Pin { __pointer: &$expr }`
+            hir::ExprKind::AddrOf(hir::BorrowKind::Pin, mutbl, arg) => match expr_ty.kind() {
+                &ty::Adt(adt_def, args)
+                    if tcx.is_lang_item(adt_def.did(), rustc_hir::LangItem::Pin) =>
+                {
+                    let arg = self.mirror_expr(arg);
+                    let expr = self.thir.exprs.push(Expr {
+                        temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
+                        ty: args.type_at(0),
+                        span: expr.span,
+                        kind: ExprKind::Borrow { borrow_kind: mutbl.to_borrow_kind(), arg },
+                    });
+                    ExprKind::Adt(Box::new(AdtExpr {
+                        adt_def,
+                        variant_index: FIRST_VARIANT,
+                        args,
+                        fields: Box::new([FieldExpr { name: FieldIdx::from(0u32), expr }]),
+                        user_ty: None,
+                        base: AdtExprBase::None,
+                    }))
+                }
+                _ => span_bug!(expr.span, "unexpected type for pinned borrow: {:?}", expr_ty),
+            },
+
             hir::ExprKind::Block(blk, _) => ExprKind::Block { block: self.mirror_block(blk) },
 
             hir::ExprKind::Assign(lhs, rhs, _) => {
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
@@ -836,6 +836,10 @@ impl<'a> Parser<'a> {
             assert!(found_raw);
             let mutability = self.parse_const_or_mut().unwrap();
             (ast::BorrowKind::Raw, mutability)
+        } else if let Some((ast::Pinnedness::Pinned, mutbl)) = self.parse_pin_and_mut() {
+            // `pin [ const | mut ]`.
+            // `pin` has been gated in `self.parse_pin_and_mut()` so we don't need to gate it here.
+            (ast::BorrowKind::Pin, mutbl)
         } else {
             // `mut?`
             (ast::BorrowKind::Ref, self.parse_mutability())
diff --git a/src/tools/rustfmt/src/expr.rs b/src/tools/rustfmt/src/expr.rs
@@ -2285,8 +2285,10 @@ fn rewrite_expr_addrof(
     let operator_str = match (mutability, borrow_kind) {
         (ast::Mutability::Not, ast::BorrowKind::Ref) => "&",
         (ast::Mutability::Not, ast::BorrowKind::Raw) => "&raw const ",
+        (ast::Mutability::Not, ast::BorrowKind::Pin) => "&pin const ",
         (ast::Mutability::Mut, ast::BorrowKind::Ref) => "&mut ",
         (ast::Mutability::Mut, ast::BorrowKind::Raw) => "&raw mut ",
+        (ast::Mutability::Mut, ast::BorrowKind::Pin) => "&pin mut ",
     };
     rewrite_unary_prefix(context, operator_str, expr, shape)
 }
diff --git a/src/tools/rustfmt/tests/source/pin_sugar.rs b/src/tools/rustfmt/tests/source/pin_sugar.rs
@@ -18,3 +18,13 @@ impl Foo {
 mut self) {}
     fn i(&pin      mut   self) {}
 }
+
+fn borrows() {
+    let mut foo = 0_i32;
+    let x: Pin<&mut _> = & pin 
+    mut    foo;
+
+    let x: Pin<&_> = &
+    pin                const 
+    foo;
+}
diff --git a/src/tools/rustfmt/tests/target/pin_sugar.rs b/src/tools/rustfmt/tests/target/pin_sugar.rs
@@ -16,3 +16,10 @@ impl Foo {
     fn h<'a>(&'a pin mut self) {}
     fn i(&pin mut self) {}
 }
+
+fn borrows() {
+    let mut foo = 0_i32;
+    let x: Pin<&mut _> = &pin mut foo;
+
+    let x: Pin<&_> = &pin const foo;
+}
diff --git a/tests/ui/async-await/pin-ergonomics/borrow-mut-xor-share.rs b/tests/ui/async-await/pin-ergonomics/borrow-mut-xor-share.rs
@@ -0,0 +1,59 @@
+#![feature(pin_ergonomics)]
+#![allow(dead_code, incomplete_features)]
+
+// Makes sure `&pin mut place` and `&pin const place` cannot violate the mut-xor-share rules.
+
+use std::pin::Pin;
+
+struct Foo;
+
+fn foo_mut(_: &mut Foo) {
+}
+
+fn foo_ref(_: &Foo) {
+}
+
+fn foo_pin_mut(_: Pin<&mut Foo>) {
+}
+
+fn foo_pin_ref(_: Pin<&Foo>) {
+}
+
+fn bar() {
+    let foo = Foo;
+    foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable, as it is not declared as mutable
+
+    let mut foo = Foo;
+    let x = &pin mut foo;
+    foo_pin_ref(&pin const foo); //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
+    foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable more than once at a time
+    foo_ref(&foo); //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
+    foo_mut(&mut foo); //~ ERROR cannot borrow `foo` as mutable more than once at a time
+
+    foo_pin_mut(x);
+
+    let mut foo = Foo;
+    let x = &pin const foo;
+    foo_pin_ref(&pin const foo); // ok
+    foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable because it is also borrowed as immutable
+    foo_ref(&foo); // ok
+    foo_mut(&mut foo); //~ ERROR cannot borrow `foo` as mutable because it is also borrowed as immutable
+
+    foo_pin_ref(x);
+
+    let mut foo = Foo;
+    let x = &mut foo;
+    foo_pin_ref(&pin const foo); //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
+    foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable more than once at a time
+
+    foo_mut(x);
+
+    let mut foo = Foo;
+    let x = &foo;
+    foo_pin_ref(&pin const foo); // ok
+    foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable because it is also borrowed as immutable
+
+    foo_ref(x);
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/pin-ergonomics/borrow-mut-xor-share.stderr b/tests/ui/async-await/pin-ergonomics/borrow-mut-xor-share.stderr
@@ -0,0 +1,121 @@
+error[E0596]: cannot borrow `foo` as mutable, as it is not declared as mutable
+  --> $DIR/borrow-mut-xor-share.rs:24:17
+   |
+LL |     foo_pin_mut(&pin mut foo);
+   |                 ^^^^^^^^^^^^ cannot borrow as mutable
+   |
+help: consider changing this to be mutable
+   |
+LL |     let mut foo = Foo;
+   |         +++
+
+error[E0502]: cannot borrow `foo` as immutable because it is also borrowed as mutable
+  --> $DIR/borrow-mut-xor-share.rs:28:17
+   |
+LL |     let x = &pin mut foo;
+   |             ------------ mutable borrow occurs here
+LL |     foo_pin_ref(&pin const foo);
+   |                 ^^^^^^^^^^^^^^ immutable borrow occurs here
+...
+LL |     foo_pin_mut(x);
+   |                 - mutable borrow later used here
+
+error[E0499]: cannot borrow `foo` as mutable more than once at a time
+  --> $DIR/borrow-mut-xor-share.rs:29:17
+   |
+LL |     let x = &pin mut foo;
+   |             ------------ first mutable borrow occurs here
+LL |     foo_pin_ref(&pin const foo);
+LL |     foo_pin_mut(&pin mut foo);
+   |                 ^^^^^^^^^^^^ second mutable borrow occurs here
+...
+LL |     foo_pin_mut(x);
+   |                 - first borrow later used here
+
+error[E0502]: cannot borrow `foo` as immutable because it is also borrowed as mutable
+  --> $DIR/borrow-mut-xor-share.rs:30:13
+   |
+LL |     let x = &pin mut foo;
+   |             ------------ mutable borrow occurs here
+...
+LL |     foo_ref(&foo);
+   |             ^^^^ immutable borrow occurs here
+...
+LL |     foo_pin_mut(x);
+   |                 - mutable borrow later used here
+
+error[E0499]: cannot borrow `foo` as mutable more than once at a time
+  --> $DIR/borrow-mut-xor-share.rs:31:13
+   |
+LL |     let x = &pin mut foo;
+   |             ------------ first mutable borrow occurs here
+...
+LL |     foo_mut(&mut foo);
+   |             ^^^^^^^^ second mutable borrow occurs here
+LL |
+LL |     foo_pin_mut(x);
+   |                 - first borrow later used here
+
+error[E0502]: cannot borrow `foo` as mutable because it is also borrowed as immutable
+  --> $DIR/borrow-mut-xor-share.rs:38:17
+   |
+LL |     let x = &pin const foo;
+   |             -------------- immutable borrow occurs here
+LL |     foo_pin_ref(&pin const foo); // ok
+LL |     foo_pin_mut(&pin mut foo);
+   |                 ^^^^^^^^^^^^ mutable borrow occurs here
+...
+LL |     foo_pin_ref(x);
+   |                 - immutable borrow later used here
+
+error[E0502]: cannot borrow `foo` as mutable because it is also borrowed as immutable
+  --> $DIR/borrow-mut-xor-share.rs:40:13
+   |
+LL |     let x = &pin const foo;
+   |             -------------- immutable borrow occurs here
+...
+LL |     foo_mut(&mut foo);
+   |             ^^^^^^^^ mutable borrow occurs here
+LL |
+LL |     foo_pin_ref(x);
+   |                 - immutable borrow later used here
+
+error[E0502]: cannot borrow `foo` as immutable because it is also borrowed as mutable
+  --> $DIR/borrow-mut-xor-share.rs:46:17
+   |
+LL |     let x = &mut foo;
+   |             -------- mutable borrow occurs here
+LL |     foo_pin_ref(&pin const foo);
+   |                 ^^^^^^^^^^^^^^ immutable borrow occurs here
+...
+LL |     foo_mut(x);
+   |             - mutable borrow later used here
+
+error[E0499]: cannot borrow `foo` as mutable more than once at a time
+  --> $DIR/borrow-mut-xor-share.rs:47:17
+   |
+LL |     let x = &mut foo;
+   |             -------- first mutable borrow occurs here
+LL |     foo_pin_ref(&pin const foo);
+LL |     foo_pin_mut(&pin mut foo);
+   |                 ^^^^^^^^^^^^ second mutable borrow occurs here
+LL |
+LL |     foo_mut(x);
+   |             - first borrow later used here
+
+error[E0502]: cannot borrow `foo` as mutable because it is also borrowed as immutable
+  --> $DIR/borrow-mut-xor-share.rs:54:17
+   |
+LL |     let x = &foo;
+   |             ---- immutable borrow occurs here
+LL |     foo_pin_ref(&pin const foo); // ok
+LL |     foo_pin_mut(&pin mut foo);
+   |                 ^^^^^^^^^^^^ mutable borrow occurs here
+LL |
+LL |     foo_ref(x);
+   |             - immutable borrow later used here
+
+error: aborting due to 10 previous errors
+
+Some errors have detailed explanations: E0499, E0502, E0596.
+For more information about an error, try `rustc --explain E0499`.
diff --git a/tests/ui/async-await/pin-ergonomics/borrow.rs b/tests/ui/async-await/pin-ergonomics/borrow.rs
@@ -0,0 +1,31 @@
+//@ check-pass
+
+#![feature(pin_ergonomics)]
+#![allow(dead_code, incomplete_features)]
+
+// Makes sure we can handle `&pin mut place` and `&pin const place` as sugar for
+// `unsafe { Pin::new_unchecked(&mut place) }` and `Pin::new(&place)`.
+
+use std::pin::Pin;
+
+struct Foo;
+
+fn foo(_: Pin<&mut Foo>) {
+}
+
+fn foo_const(_: Pin<&Foo>) {
+}
+
+fn bar() {
+    let mut x: Pin<&mut _> = &pin mut Foo;
+    foo(x.as_mut());
+    foo(x.as_mut());
+    foo_const(x);
+
+    let x: Pin<&_> = &pin const Foo;
+
+    foo_const(x);
+    foo_const(x);
+}
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-pin_ergonomics.rs b/tests/ui/feature-gates/feature-gate-pin_ergonomics.rs
diff --git a/tests/ui/feature-gates/feature-gate-pin_ergonomics.stderr b/tests/ui/feature-gates/feature-gate-pin_ergonomics.stderr

Original file line number	Diff line number	Diff line change
`@@ -339,6 +339,10 @@ impl<'a> State<'a> {`
`339`	`339`	`self.word_nbsp("raw");`
`340`	`340`	`self.print_mutability(mutability, true);`
`341`	`341`	`}`
	`342`	`+ ast::BorrowKind::Pin => {`
	`343`	`+ self.word_nbsp("pin");`
	`344`	`+ self.print_mutability(mutability, true);`
	`345`	`+ }`
`342`	`346`	`}`
`343`	`347`	`self.print_expr_cond_paren(`
`344`	`348`	`expr,`
Original file line number	Diff line number	Diff line change
`@@ -619,11 +619,13 @@ impl<'tcx> NonConstOp<'tcx> for EscapingMutBorrow {`
`619`	`619`	`kind: ccx.const_kind(),`
`620`	`620`	`teach: ccx.tcx.sess.teach(E0764),`
`621`	`621`	`}),`
`622`		`- hir::BorrowKind::Ref => ccx.dcx().create_err(errors::MutableRefEscaping {`
`623`		`- span,`
`624`		`- kind: ccx.const_kind(),`
`625`		`- teach: ccx.tcx.sess.teach(E0764),`
`626`		`- }),`
	`622`	`+ hir::BorrowKind::Ref \| hir::BorrowKind::Pin => {`
	`623`	`+ ccx.dcx().create_err(errors::MutableRefEscaping {`
	`624`	`+ span,`
	`625`	`+ kind: ccx.const_kind(),`
	`626`	`+ teach: ccx.tcx.sess.teach(E0764),`
	`627`	`+ })`
	`628`	`+ }`
`627`	`629`	`}`
`628`	`630`	`}`
`629`	`631`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1417,6 +1417,10 @@ impl<'a> State<'a> {`
`1417`	`1417`	`self.word_nbsp("raw");`
`1418`	`1418`	`self.print_mutability(mutability, true);`
`1419`	`1419`	`}`
	`1420`	`+ hir::BorrowKind::Pin => {`
	`1421`	`+ self.word_nbsp("pin");`
	`1422`	`+ self.print_mutability(mutability, true);`
	`1423`	`+ }`
`1420`	`1424`	`}`
`1421`	`1425`	`self.print_expr_cond_paren(expr, expr.precedence() < ExprPrecedence::Prefix);`
`1422`	`1426`	`}`
Original file line number	Diff line number	Diff line change
`@@ -688,6 +688,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`688`	`688`	`let region = self.next_region_var(infer::BorrowRegion(expr.span));`
`689`	`689`	`Ty::new_ref(self.tcx, region, ty, mutbl)`
`690`	`690`	`}`
	`691`	`+ hir::BorrowKind::Pin => {`
	`692`	+ // See comments in the `hir::BorrowKind::Ref` arm above.
	`693`	`+ let region = self.next_region_var(infer::BorrowRegion(expr.span));`
	`694`	`+ Ty::new_pinned_ref(self.tcx, region, ty, mutbl)`
	`695`	`+ }`
`691`	`696`	`}`
`692`	`697`	`}`
`693`	`698`