Skip to content

Commit 235c3f6

Browse files
frank-kingfrank-king
committed
Implement pinned borrows, part of pin_ergonomics 
1 parent 49e5e4e commit 235c3f6

File tree

18 files changed

+471
-18
lines changed

18 files changed

+471
-18
lines changed

‎compiler/rustc_ast/src/ast.rs

+4
Original file line numberDiff line numberDiff line change
@@ -886,6 +886,10 @@ pub enum BorrowKind {
886886
/// The resulting type is either `*const T` or `*mut T`
887887
/// where `T = typeof($expr)`.
888888
Raw,
889+
/// A pinned borrow, `&pin const $expr` or `&pin mut $expr`.
890+
/// The resulting type is either `Pin<&'a T>` or `Pin<&'a mut T>`
891+
/// where `T = typeof($expr)` and `'a` is some lifetime.
892+
Pin,
889893
}
890894

891895
#[derive(Clone, Copy, Debug, PartialEq, Encodable, Decodable, HashStable_Generic)]

‎compiler/rustc_ast_pretty/src/pprust/state/expr.rs

+4
Original file line numberDiff line numberDiff line change
@@ -339,6 +339,10 @@ impl<'a> State<'a> {
339339
self.word_nbsp("raw");
340340
self.print_mutability(mutability, true);
341341
}
342+
ast::BorrowKind::Pin => {
343+
self.word_nbsp("pin");
344+
self.print_mutability(mutability, true);
345+
}
342346
}
343347
self.print_expr_cond_paren(
344348
expr,

‎compiler/rustc_const_eval/src/check_consts/ops.rs

+7-5
Original file line numberDiff line numberDiff line change
@@ -619,11 +619,13 @@ impl<'tcx> NonConstOp<'tcx> for EscapingMutBorrow {
619619
kind: ccx.const_kind(),
620620
teach: ccx.tcx.sess.teach(E0764),
621621
}),
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+
}
627629
}
628630
}
629631
}

‎compiler/rustc_hir_pretty/src/lib.rs

+4
Original file line numberDiff line numberDiff line change
@@ -1325,6 +1325,10 @@ impl<'a> State<'a> {
13251325
self.word_nbsp("raw");
13261326
self.print_mutability(mutability, true);
13271327
}
1328+
hir::BorrowKind::Pin => {
1329+
self.word_nbsp("pin");
1330+
self.print_mutability(mutability, true);
1331+
}
13281332
}
13291333
self.print_expr_cond_paren(expr, expr.precedence() < ExprPrecedence::Prefix);
13301334
}

‎compiler/rustc_hir_typeck/src/expr.rs

+6-2
Original file line numberDiff line numberDiff line change
@@ -673,7 +673,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
673673
self.check_named_place_expr(oprnd);
674674
Ty::new_ptr(self.tcx, ty, mutbl)
675675
}
676-
hir::BorrowKind::Ref => {
676+
hir::BorrowKind::Ref | hir::BorrowKind::Pin => {
677677
// Note: at this point, we cannot say what the best lifetime
678678
// is to use for resulting pointer. We want to use the
679679
// shortest lifetime possible so as to avoid spurious borrowck
@@ -689,7 +689,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
689689
// whose address was taken can actually be made to live as long
690690
// as it needs to live.
691691
let region = self.next_region_var(infer::BorrowRegion(expr.span));
692-
Ty::new_ref(self.tcx, region, ty, mutbl)
692+
match kind {
693+
hir::BorrowKind::Ref => Ty::new_ref(self.tcx, region, ty, mutbl),
694+
hir::BorrowKind::Pin => Ty::new_pinned_ref(self.tcx, region, ty, mutbl),
695+
_ => unreachable!(),
696+
}
693697
}
694698
}
695699
}

‎compiler/rustc_mir_build/src/thir/cx/expr.rs

+25
Original file line numberDiff line numberDiff line change
@@ -476,6 +476,31 @@ impl<'tcx> ThirBuildCx<'tcx> {
476476
ExprKind::RawBorrow { mutability, arg: self.mirror_expr(arg) }
477477
}
478478

479+
// Make `&pin mut $expr` and `&pin const $expr` into
480+
// `Pin { __pointer: &mut $expr }` and `Pin { __pointer: &$expr }`.
481+
hir::ExprKind::AddrOf(hir::BorrowKind::Pin, mutbl, arg) => match expr_ty.kind() {
482+
&ty::Adt(adt_def, args)
483+
if tcx.is_lang_item(adt_def.did(), rustc_hir::LangItem::Pin) =>
484+
{
485+
let arg = self.mirror_expr(arg);
486+
let expr = self.thir.exprs.push(Expr {
487+
temp_lifetime: TempLifetime { temp_lifetime, backwards_incompatible },
488+
ty: args.type_at(0),
489+
span: expr.span,
490+
kind: ExprKind::Borrow { borrow_kind: mutbl.to_borrow_kind(), arg },
491+
});
492+
ExprKind::Adt(Box::new(AdtExpr {
493+
adt_def,
494+
variant_index: FIRST_VARIANT,
495+
args,
496+
fields: Box::new([FieldExpr { name: FieldIdx::from(0u32), expr }]),
497+
user_ty: None,
498+
base: AdtExprBase::None,
499+
}))
500+
}
501+
_ => span_bug!(expr.span, "unexpected type for pinned borrow: {:?}", expr_ty),
502+
},
503+
479504
hir::ExprKind::Block(blk, _) => ExprKind::Block { block: self.mirror_block(blk) },
480505

481506
hir::ExprKind::Assign(lhs, rhs, _) => {

‎compiler/rustc_parse/src/parser/expr.rs

+6-1
Original file line numberDiff line numberDiff line change
@@ -846,14 +846,19 @@ impl<'a> Parser<'a> {
846846
self.dcx().emit_err(errors::LifetimeInBorrowExpression { span, lifetime_span: lt_span });
847847
}
848848

849-
/// Parse `mut?` or `raw [ const | mut ]`.
849+
/// Parse `mut?` or `[ raw | pin ] [ const | mut ]`.
850850
fn parse_borrow_modifiers(&mut self) -> (ast::BorrowKind, ast::Mutability) {
851851
if self.check_keyword(exp!(Raw)) && self.look_ahead(1, Token::is_mutability) {
852852
// `raw [ const | mut ]`.
853853
let found_raw = self.eat_keyword(exp!(Raw));
854854
assert!(found_raw);
855855
let mutability = self.parse_const_or_mut().unwrap();
856856
(ast::BorrowKind::Raw, mutability)
857+
} else if let Some((ast::Pinnedness::Pinned, mutbl)) = self.parse_pin_and_mut() {
858+
// `pin [ const | mut ]`.
859+
// `pin` has been gated in `self.parse_pin_and_mut()` so we don't
860+
// need to gate it here.
861+
(ast::BorrowKind::Pin, mutbl)
857862
} else {
858863
// `mut?`
859864
(ast::BorrowKind::Ref, self.parse_mutability())

‎src/tools/rustfmt/src/expr.rs

+2
Original file line numberDiff line numberDiff line change
@@ -2289,8 +2289,10 @@ fn rewrite_expr_addrof(
22892289
) -> RewriteResult {
22902290
let operator_str = match (mutability, borrow_kind) {
22912291
(ast::Mutability::Not, ast::BorrowKind::Ref) => "&",
2292+
(ast::Mutability::Not, ast::BorrowKind::Pin) => "&pin const ",
22922293
(ast::Mutability::Not, ast::BorrowKind::Raw) => "&raw const ",
22932294
(ast::Mutability::Mut, ast::BorrowKind::Ref) => "&mut ",
2295+
(ast::Mutability::Mut, ast::BorrowKind::Pin) => "&pin mut ",
22942296
(ast::Mutability::Mut, ast::BorrowKind::Raw) => "&raw mut ",
22952297
};
22962298
rewrite_unary_prefix(context, operator_str, expr, shape)

‎src/tools/rustfmt/tests/source/pin_sugar.rs

+10
Original file line numberDiff line numberDiff line change
@@ -18,3 +18,13 @@ impl Foo {
1818
mut self) {}
1919
fn i(&pin mut self) {}
2020
}
21+
22+
fn borrows() {
23+
let mut foo = 0_i32;
24+
let x: Pin<&mut _> = & pin
25+
mut foo;
26+
27+
let x: Pin<&_> = &
28+
pin const
29+
foo;
30+
}

‎src/tools/rustfmt/tests/target/pin_sugar.rs

+7
Original file line numberDiff line numberDiff line change
@@ -16,3 +16,10 @@ impl Foo {
1616
fn h<'a>(&'a pin mut self) {}
1717
fn i(&pin mut self) {}
1818
}
19+
20+
fn borrows() {
21+
let mut foo = 0_i32;
22+
let x: Pin<&mut _> = &pin mut foo;
23+
24+
let x: Pin<&_> = &pin const foo;
25+
}

‎tests/pretty/pin-ergonomics-hir.pp

+43
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,43 @@
1+
//@ pretty-compare-only
2+
//@ pretty-mode:hir
3+
//@ pp-exact:pin-ergonomics-hir.pp
4+
5+
#![feature(pin_ergonomics)]#![allow(dead_code, incomplete_features)]
6+
#[prelude_import]
7+
use ::std::prelude::rust_2015::*;
8+
#[macro_use]
9+
extern crate std;
10+
11+
use std::pin::Pin;
12+
13+
struct Foo;
14+
15+
impl Foo {
16+
fn baz(&mut self) { }
17+
18+
fn baz_const(&self) { }
19+
20+
fn baz_lt<'a>(&mut self) { }
21+
22+
fn baz_const_lt(&self) { }
23+
}
24+
25+
fn foo(_: Pin<&'_ mut Foo>) { }
26+
fn foo_lt<'a>(_: Pin<&'a mut Foo>) { }
27+
28+
fn foo_const(_: Pin<&'_ Foo>) { }
29+
fn foo_const_lt(_: Pin<&'_ Foo>) { }
30+
31+
fn bar() {
32+
let mut x: Pin<&mut _> = &pin mut Foo;
33+
foo(x.as_mut());
34+
foo(x.as_mut());
35+
foo_const(x);
36+
37+
let x: Pin<&_> = &pin const Foo;
38+
39+
foo_const(x);
40+
foo_const(x);
41+
}
42+
43+
fn main() { }

‎tests/pretty/pin-ergonomics-hir.rs

+40
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,40 @@
1+
//@ pretty-compare-only
2+
//@ pretty-mode:hir
3+
//@ pp-exact:pin-ergonomics-hir.pp
4+
5+
#![feature(pin_ergonomics)]
6+
#![allow(dead_code, incomplete_features)]
7+
8+
use std::pin::Pin;
9+
10+
struct Foo;
11+
12+
impl Foo {
13+
fn baz(&mut self) { }
14+
15+
fn baz_const(&self) { }
16+
17+
fn baz_lt<'a>(&mut self) { }
18+
19+
fn baz_const_lt(&self) { }
20+
}
21+
22+
fn foo(_: Pin<&'_ mut Foo>) { }
23+
fn foo_lt<'a>(_: Pin<&'a mut Foo>) { }
24+
25+
fn foo_const(_: Pin<&'_ Foo>) { }
26+
fn foo_const_lt(_: Pin<&'_ Foo>) { }
27+
28+
fn bar() {
29+
let mut x: Pin<&mut _> = &pin mut Foo;
30+
foo(x.as_mut());
31+
foo(x.as_mut());
32+
foo_const(x);
33+
34+
let x: Pin<&_> = &pin const Foo;
35+
36+
foo_const(x);
37+
foo_const(x);
38+
}
39+
40+
fn main() { }

‎tests/pretty/pin-ergonomics.rs

+14
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,8 @@
33
#![feature(pin_ergonomics)]
44
#![allow(dead_code, incomplete_features)]
55

6+
use std::pin::Pin;
7+
68
struct Foo;
79

810
impl Foo {
@@ -21,4 +23,16 @@ fn foo_lt<'a>(_: &'a pin mut Foo) {}
2123
fn foo_const(_: &pin const Foo) {}
2224
fn foo_const_lt(_: &'_ pin const Foo) {}
2325

26+
fn bar() {
27+
let mut x: Pin<&mut _> = &pin mut Foo;
28+
foo(x.as_mut());
29+
foo(x.as_mut());
30+
foo_const(x);
31+
32+
let x: Pin<&_> = &pin const Foo;
33+
34+
foo_const(x);
35+
foo_const(x);
36+
}
37+
2438
fn main() {}

‎tests/ui/async-await/pin-ergonomics/borrow-mut-xor-share.rs

+59
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
#![feature(pin_ergonomics)]
2+
#![allow(dead_code, incomplete_features)]
3+
4+
// Makes sure `&pin mut place` and `&pin const place` cannot violate the mut-xor-share rules.
5+
6+
use std::pin::Pin;
7+
8+
struct Foo;
9+
10+
fn foo_mut(_: &mut Foo) {
11+
}
12+
13+
fn foo_ref(_: &Foo) {
14+
}
15+
16+
fn foo_pin_mut(_: Pin<&mut Foo>) {
17+
}
18+
19+
fn foo_pin_ref(_: Pin<&Foo>) {
20+
}
21+
22+
fn bar() {
23+
let foo = Foo;
24+
foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable, as it is not declared as mutable
25+
26+
let mut foo = Foo;
27+
let x = &pin mut foo;
28+
foo_pin_ref(&pin const foo); //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
29+
foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable more than once at a time
30+
foo_ref(&foo); //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
31+
foo_mut(&mut foo); //~ ERROR cannot borrow `foo` as mutable more than once at a time
32+
33+
foo_pin_mut(x);
34+
35+
let mut foo = Foo;
36+
let x = &pin const foo;
37+
foo_pin_ref(&pin const foo); // ok
38+
foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable because it is also borrowed as immutable
39+
foo_ref(&foo); // ok
40+
foo_mut(&mut foo); //~ ERROR cannot borrow `foo` as mutable because it is also borrowed as immutable
41+
42+
foo_pin_ref(x);
43+
44+
let mut foo = Foo;
45+
let x = &mut foo;
46+
foo_pin_ref(&pin const foo); //~ ERROR cannot borrow `foo` as immutable because it is also borrowed as mutable
47+
foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable more than once at a time
48+
49+
foo_mut(x);
50+
51+
let mut foo = Foo;
52+
let x = &foo;
53+
foo_pin_ref(&pin const foo); // ok
54+
foo_pin_mut(&pin mut foo); //~ ERROR cannot borrow `foo` as mutable because it is also borrowed as immutable
55+
56+
foo_ref(x);
57+
}
58+
59+
fn main() {}

0 commit comments

Comments
 (0)