WIP: implement borrowck

Author: frank-king

compiler/rustc_borrowck/src/borrow_set.rs

@@ -121,19 +121,6 @@ impl<'tcx> BorrowData<'tcx> {
     pub fn assigned_place(&self) -> mir::Place<'tcx> {
         self.assigned_place
     }
-
-    pub(crate) fn is_pinned(&self) -> bool {
-        matches!(self.pinnedness, Pinnedness::Pinned { .. })
-    }
-
-    /// Returns the Pin result place if this borrow is pinned.
-    #[allow(dead_code)]
-    pub(crate) fn pin_target_local(&self) -> Option<mir::Local> {
-        match self.pinnedness {
-            Pinnedness::Pinned { to, .. } => Some(to.local),
-            Pinnedness::Not => None,
-        }
-    }
 }
 
 impl<'tcx> fmt::Display for BorrowData<'tcx> {

compiler/rustc_borrowck/src/borrowck_errors.rs

@@ -479,6 +479,38 @@ impl<'infcx, 'tcx> crate::MirBorrowckCtxt<'_, 'infcx, 'tcx> {
     pub(crate) fn temporary_value_borrowed_for_too_long(&self, span: Span) -> Diag<'infcx> {
         struct_span_code_err!(self.dcx(), span, E0716, "temporary value dropped while borrowed")
     }
+
+    pub(crate) fn cannot_move_out_while_pinned(
+        &self,
+        span: Span,
+        pin_span: Span,
+        place: &str,
+        pin_place: &str,
+        value_place: &str,
+    ) -> Diag<'infcx> {
+        self.dcx().create_err(crate::session_diagnostics::MovePin {
+            place,
+            pin_place,
+            value_place,
+            span,
+            pin_span,
+        })
+    }
+
+    pub(crate) fn cannot_mutably_borrow_pinned(
+        &self,
+        span: Span,
+        pin_span: Span,
+        place: &str,
+        pin_place: &str,
+    ) -> Diag<'infcx> {
+        self.dcx().create_err(crate::session_diagnostics::MutablyBorrowPin {
+            place,
+            span,
+            pin_place,
+            pin_span,
+        })
+    }
 }
 
 pub(crate) fn borrowed_data_escapes_closure<'tcx>(

compiler/rustc_borrowck/src/dataflow.rs

@@ -36,7 +36,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
     fn bottom_value(&self, body: &mir::Body<'tcx>) -> Self::Domain {
         BorrowckDomain {
             borrows: self.borrows.bottom_value(body),
-            pins: self.pins.bottom_value(body),
+            pinned_borrows: self.pins.bottom_value(body),
             uninits: self.uninits.bottom_value(body),
             ever_inits: self.ever_inits.bottom_value(body),
         }
@@ -54,7 +54,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
         loc: Location,
     ) {
         self.borrows.apply_early_statement_effect(&mut state.borrows, stmt, loc);
-        self.pins.apply_early_statement_effect(&mut state.pins, stmt, loc);
+        self.pins.apply_early_statement_effect(&mut state.pinned_borrows, stmt, loc);
         self.uninits.apply_early_statement_effect(&mut state.uninits, stmt, loc);
         self.ever_inits.apply_early_statement_effect(&mut state.ever_inits, stmt, loc);
     }
@@ -66,7 +66,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
         loc: Location,
     ) {
         self.borrows.apply_primary_statement_effect(&mut state.borrows, stmt, loc);
-        self.pins.apply_primary_statement_effect(&mut state.pins, stmt, loc);
+        self.pins.apply_primary_statement_effect(&mut state.pinned_borrows, stmt, loc);
         self.uninits.apply_primary_statement_effect(&mut state.uninits, stmt, loc);
         self.ever_inits.apply_primary_statement_effect(&mut state.ever_inits, stmt, loc);
     }
@@ -78,7 +78,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
         loc: Location,
     ) {
         self.borrows.apply_early_terminator_effect(&mut state.borrows, term, loc);
-        self.pins.apply_early_terminator_effect(&mut state.pins, term, loc);
+        self.pins.apply_early_terminator_effect(&mut state.pinned_borrows, term, loc);
         self.uninits.apply_early_terminator_effect(&mut state.uninits, term, loc);
         self.ever_inits.apply_early_terminator_effect(&mut state.ever_inits, term, loc);
     }
@@ -90,7 +90,7 @@ impl<'a, 'tcx> Analysis<'tcx> for Borrowck<'a, 'tcx> {
         loc: Location,
     ) -> TerminatorEdges<'mir, 'tcx> {
         self.borrows.apply_primary_terminator_effect(&mut state.borrows, term, loc);
-        self.pins.apply_primary_terminator_effect(&mut state.pins, term, loc);
+        self.pins.apply_primary_terminator_effect(&mut state.pinned_borrows, term, loc);
         self.uninits.apply_primary_terminator_effect(&mut state.uninits, term, loc);
         self.ever_inits.apply_primary_terminator_effect(&mut state.ever_inits, term, loc);
 
@@ -124,8 +124,8 @@ where
     fn fmt_with(&self, ctxt: &C, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("borrows: ")?;
         self.borrows.fmt_with(ctxt, f)?;
-        f.write_str(" pins: ")?;
-        self.pins.fmt_with(ctxt, f)?;
+        f.write_str(" pinned_borrows: ")?;
+        self.pinned_borrows.fmt_with(ctxt, f)?;
         f.write_str(" uninits: ")?;
         self.uninits.fmt_with(ctxt, f)?;
         f.write_str(" ever_inits: ")?;
@@ -144,9 +144,9 @@ where
             f.write_str("\n")?;
         }
 
-        if self.pins != old.pins {
-            f.write_str("pins: ")?;
-            self.pins.fmt_diff_with(&old.pins, ctxt, f)?;
+        if self.pinned_borrows != old.pinned_borrows {
+            f.write_str("pinned_borrows: ")?;
+            self.pinned_borrows.fmt_diff_with(&old.pinned_borrows, ctxt, f)?;
             f.write_str("\n")?;
         }
 
@@ -170,7 +170,7 @@ where
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub(crate) struct BorrowckDomain {
     pub(crate) borrows: BorrowsDomain,
-    pub(crate) pins: PinsDomain,
+    pub(crate) pinned_borrows: BorrowsDomain,
     pub(crate) uninits: MaybeUninitializedPlacesDomain,
     pub(crate) ever_inits: EverInitializedPlacesDomain,
 }
@@ -183,14 +183,6 @@ rustc_index::newtype_index! {
 
 impl<C> DebugWithContext<C> for BorrowIndex {}
 
-rustc_index::newtype_index! {
-    #[orderable]
-    #[debug_format = "pi{}"]
-    pub struct PinIndex {}
-}
-
-impl<C> DebugWithContext<C> for PinIndex {}
-
 /// `Borrows` stores the data used in the analyses that track the flow
 /// of borrows.
 ///
@@ -215,7 +207,8 @@ pub struct Borrows<'a, 'tcx> {
 pub(crate) struct Pins<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     body: &'a Body<'tcx>,
-    pin_set: &'a PinSet<'tcx>,
+    borrow_set: &'a BorrowSet<'tcx>,
+    pin_set: &'a PinSet,
 }
 
 struct OutOfScopePrecomputer<'a, 'tcx> {
@@ -658,16 +651,26 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
 }
 
 impl<'a, 'tcx> Pins<'a, 'tcx> {
-    pub(crate) fn new(tcx: TyCtxt<'tcx>, body: &'a Body<'tcx>, pin_set: &'a PinSet<'tcx>) -> Self {
-        Pins { tcx, body, pin_set }
+    pub(crate) fn new(
+        tcx: TyCtxt<'tcx>,
+        body: &'a Body<'tcx>,
+        borrow_set: &'a BorrowSet<'tcx>,
+        pin_set: &'a PinSet,
+    ) -> Self {
+        Pins { tcx, body, borrow_set, pin_set }
     }
 
     /// Kill any pins whose original pinned place conflicts with `place`.
     fn kill_pins_on_place(&self, state: &mut <Self as Analysis<'tcx>>::Domain, place: Place<'tcx>) {
         debug!("kill_pins_on_place: place={:?}", place);
 
-        let other_pins_of_local =
-            self.pin_set.local_map.get(&place.local).into_iter().flat_map(|ps| ps.iter()).copied();
+        let other_pins_of_local = self
+            .borrow_set
+            .local_map
+            .get(&place.local)
+            .into_iter()
+            .flat_map(|bs| bs.iter())
+            .copied();
 
         // If the place is a local with no projections, all pins of this
         // local must be killed. This is purely an optimization so we don't have to call
@@ -685,7 +688,7 @@ impl<'a, 'tcx> Pins<'a, 'tcx> {
             places_conflict(
                 self.tcx,
                 self.body,
-                self.pin_set[i].pinned_place,
+                self.borrow_set[i].borrowed_place,
                 place,
                 PlaceConflictBias::NoOverlap,
             )
@@ -704,26 +707,24 @@ impl<'a, 'tcx> Pins<'a, 'tcx> {
         debug!("kill_pins_by_pin_local: local={:?}", local);
 
         let pins_of_local =
-            self.pin_set.pin_local_map.get(&local).into_iter().flat_map(|ps| ps.iter()).copied();
+            self.pin_set.pin_local_map.get(&local).into_iter().flat_map(|bs| bs.iter()).copied();
 
         state.kill_all(pins_of_local);
     }
 }
 
-type PinsDomain = MixedBitSet<PinIndex>;
-
 /// Forward dataflow computation of the set of pins that are in scope at a particular location.
 /// - we gen the introduced pins
 /// - we kill pins on locals going out of scope
 /// - we kill pins when the pinned place is moved or overwritten
 impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Pins<'_, 'tcx> {
-    type Domain = PinsDomain;
+    type Domain = BorrowsDomain;
 
     const NAME: &'static str = "pins";
 
     fn bottom_value(&self, _: &mir::Body<'tcx>) -> Self::Domain {
         // bottom = nothing is pinned yet
-        MixedBitSet::new_empty(self.pin_set.len())
+        MixedBitSet::new_empty(self.borrow_set.len())
     }
 
     fn initialize_start_block(&self, _: &mir::Body<'tcx>, _: &mut Self::Domain) {
@@ -758,20 +759,26 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Pins<'_, 'tcx> {
     ) {
         match &stmt.kind {
             mir::StatementKind::Assign(box (lhs, rhs)) => {
+                self.kill_pins_on_place(state, *lhs);
+
                 // Check if this is a Pin aggregate creation
                 if let mir::Rvalue::Aggregate(box agg_kind, _) = rhs
                     && let mir::AggregateKind::Adt(adt_did, _, args, _, _) = agg_kind
                     && self.tcx.adt_def(*adt_did).is_pin()
                     && args.type_at(0).is_ref()
                 {
                     // Generate the pin
-                    if let Some(index) = self.pin_set.get_index_of(&location) {
+                    for index in self
+                        .pin_set
+                        .pin_location_map
+                        .get(&location)
+                        .into_iter()
+                        .flat_map(|bs| bs.iter())
+                        .copied()
+                    {
                         state.gen_(index);
                     }
                 }
-
-                // Kill any pins on the place being assigned to
-                self.kill_pins_on_place(state, *lhs);
             }
 
             mir::StatementKind::StorageDead(local) => {

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -1979,6 +1979,60 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         err
     }
 
+    pub(crate) fn report_move_after_pinned(
+        &mut self,
+        location: Location,
+        (place, span): (Place<'tcx>, Span),
+        borrow: &BorrowData<'tcx>,
+    ) {
+        debug!(
+            "report_move_after_pinned: location={:?} place={:?} span={:?} borrow={:?}",
+            location, place, span, borrow
+        );
+
+        let value_msg = self.describe_any_place(place.as_ref());
+        let borrow_msg = self.describe_any_place(borrow.borrowed_place.as_ref());
+
+        let borrow_spans = self.retrieve_borrow_spans(borrow);
+        let borrow_span = borrow_spans.args_or_use();
+
+        let move_spans = self.move_spans(place.as_ref(), location);
+        let span = move_spans.args_or_use();
+
+        let err = self.cannot_move_out_while_pinned(
+            span,
+            borrow_span,
+            &self.describe_any_place(place.as_ref()),
+            &borrow_msg,
+            &value_msg,
+        );
+        self.buffer_error(err);
+    }
+
+    pub(crate) fn report_mutably_borrow_after_pinned(
+        &mut self,
+        location: Location,
+        (place, span): (Place<'tcx>, Span),
+        borrow: &BorrowData<'tcx>,
+    ) {
+        debug!(
+            "report_mutably_borrow_after_pinned: location={:?} place={:?} span={:?} borrow={:?}",
+            location, place, span, borrow
+        );
+
+        let borrow_spans = self.borrow_spans(span, location);
+        let span = borrow_spans.args_or_use();
+
+        let pin_spans = self.retrieve_borrow_spans(borrow);
+        let pin_span = pin_spans.args_or_use();
+
+        let value_msg = self.describe_any_place(place.as_ref());
+        let pin_msg = self.describe_any_place(borrow.borrowed_place.as_ref());
+
+        let err = self.cannot_mutably_borrow_pinned(span, pin_span, &value_msg, &pin_msg);
+        self.buffer_error(err);
+    }
+
     fn suggest_copy_for_type_in_cloned_ref(&self, err: &mut Diag<'infcx>, place: Place<'tcx>) {
         let tcx = self.infcx.tcx;
         let Some(body_id) = tcx.hir_node(self.mir_hir_id()).body_id() else { return };

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -612,13 +612,6 @@ impl<'tcx> MirBorrowckCtxt<'_, '_, 'tcx> {
         borrow: &BorrowData<'tcx>,
         kind_place: Option<(WriteKind, Place<'tcx>)>,
     ) -> BorrowExplanation<'tcx> {
-        // For pinned borrows, the borrow lifetime is extended beyond the NLL region.
-        // The region inference can't explain why the borrow is still active,
-        // so return Unexplained and let the caller provide context.
-        if borrow.is_pinned() {
-            return BorrowExplanation::Unexplained;
-        }
-
         let regioncx = &self.regioncx;
         let body: &Body<'_> = self.body;
         let tcx = self.infcx.tcx;