WIP: implement borrowck

Author: frank-king

compiler/rustc_borrowck/src/borrow_set.rs

@@ -126,7 +126,8 @@ impl<'tcx> BorrowData<'tcx> {
         matches!(self.pinnedness, Pinnedness::Pinned { .. })
     }
 
-    /// Returns the Pin result local if this borrow is 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),

compiler/rustc_borrowck/src/dataflow.rs

@@ -240,12 +240,6 @@ impl<'tcx> OutOfScopePrecomputer<'_, 'tcx> {
             borrows_out_of_scope_at_location: FxIndexMap::default(),
         };
         for (borrow_index, borrow_data) in borrow_set.iter_enumerated() {
-            // Skip pinned borrows: their lifetime is extended beyond NLL scope.
-            // They are killed by StorageDead of the Pin result local or by
-            // reassignment of the borrowed place.
-            if borrow_data.is_pinned() {
-                continue;
-            }
             let borrow_region = borrow_data.region;
             let location = borrow_data.reserve_location;
             prec.precompute_borrows_out_of_scope(borrow_index, borrow_region, location);
@@ -362,10 +356,6 @@ impl<'tcx> PoloniusOutOfScopePrecomputer<'_, 'tcx> {
             loans_out_of_scope_at_location: FxIndexMap::default(),
         };
         for (loan_idx, loan_data) in borrow_set.iter_enumerated() {
-            // Skip pinned borrows: their lifetime is extended beyond NLL scope.
-            if loan_data.is_pinned() {
-                continue;
-            }
             let loan_issued_at = loan_data.reserve_location;
             prec.precompute_loans_out_of_scope(loan_idx, loan_issued_at);
         }
@@ -556,91 +546,6 @@ impl<'a, 'tcx> Borrows<'a, 'tcx> {
 
         state.kill_all(definitely_conflicting_borrows);
     }
-
-    /// Kill pinned borrows whose borrowed place's local matches `local`.
-    /// This is called in the early phase when the borrowed place's storage dies,
-    /// to prevent spurious E0716 errors.
-    fn kill_pinned_borrows_on_borrowed_local(
-        &self,
-        state: &mut <Self as Analysis<'tcx>>::Domain,
-        local: mir::Local,
-    ) {
-        debug!("kill_pinned_borrows_on_borrowed_local: local={:?}", local);
-
-        let to_kill: Vec<_> = self
-            .borrow_set
-            .iter_enumerated()
-            .filter_map(|(idx, data)| {
-                if data.is_pinned() && data.borrowed_place.local == local {
-                    Some(idx)
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        state.kill_all(to_kill.into_iter());
-    }
-
-    /// Kill pinned borrows whose Pin result local matches `local`.
-    /// This is called when the Pin value goes out of scope (StorageDead).
-    fn kill_pinned_borrows_on_local(
-        &self,
-        state: &mut <Self as Analysis<'tcx>>::Domain,
-        local: mir::Local,
-    ) {
-        debug!("kill_pinned_borrows_on_local: local={:?}", local);
-
-        let to_kill: Vec<_> = self
-            .borrow_set
-            .iter_enumerated()
-            .filter_map(
-                |(idx, data)| {
-                    if data.pin_target_local() == Some(local) { Some(idx) } else { None }
-                },
-            )
-            .collect();
-
-        state.kill_all(to_kill.into_iter());
-    }
-
-    /// Kill pinned borrows whose borrowed place conflicts with `place`.
-    /// Called in the early phase so reassignment of a pinned place is allowed.
-    fn kill_pinned_borrows_on_reassignment(
-        &self,
-        state: &mut <Self as Analysis<'tcx>>::Domain,
-        place: Place<'tcx>,
-    ) {
-        debug!("kill_pinned_borrows_on_reassignment: place={:?}", place);
-
-        let other_borrows_of_local = self
-            .borrow_set
-            .local_map
-            .get(&place.local)
-            .into_iter()
-            .flat_map(|bs| bs.iter())
-            .copied();
-
-        if place.projection.is_empty() {
-            // Only kill pinned borrows, not regular ones
-            let pinned_borrows = other_borrows_of_local.filter(|&i| self.borrow_set[i].is_pinned());
-            state.kill_all(pinned_borrows);
-            return;
-        }
-
-        let conflicting_pinned_borrows = other_borrows_of_local.filter(|&i| {
-            self.borrow_set[i].is_pinned()
-                && places_conflict(
-                    self.tcx,
-                    self.body,
-                    self.borrow_set[i].borrowed_place,
-                    place,
-                    PlaceConflictBias::NoOverlap,
-                )
-        });
-
-        state.kill_all(conflicting_pinned_borrows);
-    }
 }
 
 type BorrowsDomain = MixedBitSet<BorrowIndex>;
@@ -670,29 +575,10 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
     fn apply_early_statement_effect(
         &self,
         state: &mut Self::Domain,
-        statement: &mir::Statement<'tcx>,
+        _statement: &mir::Statement<'tcx>,
         location: Location,
     ) {
         self.kill_loans_out_of_scope_at_location(state, location);
-
-        match &statement.kind {
-            // For pinned borrows whose lifetime is extended beyond NLL scope,
-            // kill them early when the pinned place is reassigned. This allows
-            // the reassignment to proceed without conflicting with the borrow.
-            mir::StatementKind::Assign(box (lhs, _)) => {
-                self.kill_pinned_borrows_on_reassignment(state, *lhs);
-            }
-            // Kill pinned borrows in the early phase when the borrowed place's
-            // local has StorageDead. This must happen before the visitor's
-            // StorageDead check (which runs after early effects) to avoid
-            // spurious E0716 errors for temporaries whose storage dies before
-            // the Pin result local.
-            mir::StatementKind::StorageDead(local) => {
-                self.kill_pinned_borrows_on_local(state, *local);
-                self.kill_pinned_borrows_on_borrowed_local(state, *local);
-            }
-            _ => {}
-        }
     }
 
     fn apply_primary_statement_effect(
@@ -727,8 +613,6 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
                 // Make sure there are no remaining borrows for locals that
                 // are gone out of scope.
                 self.kill_borrows_on_place(state, Place::from(*local));
-                // Kill pinned borrows whose Pin result local is going out of scope.
-                self.kill_pinned_borrows_on_local(state, *local);
             }
 
             mir::StatementKind::FakeRead(..)
@@ -848,11 +732,22 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Pins<'_, 'tcx> {
 
     fn apply_early_statement_effect(
         &self,
-        _state: &mut Self::Domain,
-        _statement: &mir::Statement<'tcx>,
+        state: &mut Self::Domain,
+        statement: &mir::Statement<'tcx>,
         _location: Location,
     ) {
-        // Pins don't go out of scope based on regions like borrows do
+        // Kill pins early on reassignment/StorageDead so that the visitor
+        // (which runs after the early phase) sees the updated pin state.
+        match &statement.kind {
+            mir::StatementKind::Assign(box (lhs, _)) => {
+                self.kill_pins_on_place(state, *lhs);
+            }
+            mir::StatementKind::StorageDead(local) => {
+                self.kill_pins_on_place(state, Place::from(*local));
+                self.kill_pins_by_pin_local(state, *local);
+            }
+            _ => {}
+        }
     }
 
     fn apply_primary_statement_effect(

compiler/rustc_borrowck/src/lib.rs

@@ -1037,15 +1037,6 @@ impl<'a, 'tcx> ResultsVisitor<'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<'a,
                         // so this "extra check" serves as a kind of backup.
                         for i in state.borrows.iter() {
                             let borrow = &self.borrow_set[i];
-                            // Skip pinned borrows: their lifetime is managed by
-                            // StorageDead of the Pin result local and reassignment,
-                            // not by NLL regions. On unwind paths, StorageDead may
-                            // not have been emitted, so these borrows can appear
-                            // spuriously alive. The normal dataflow-based conflict
-                            // detection already catches pin violations.
-                            if borrow.is_pinned() {
-                                continue;
-                            }
                             self.check_for_invalidation_at_exit(loc, borrow, span);
                         }
                     }
@@ -1275,7 +1266,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
         location: Location,
         state: &'s BorrowckDomain,
     ) -> Cow<'s, MixedBitSet<BorrowIndex>> {
-        if let Some(polonius) = &self.polonius_output {
+        let mut borrows = if let Some(polonius) = &self.polonius_output {
             // Use polonius output if it has been enabled.
             let location = self.location_table.start_index(location);
             let mut polonius_output = MixedBitSet::new_empty(self.borrow_set.len());
@@ -1285,7 +1276,22 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
             Cow::Owned(polonius_output)
         } else {
             Cow::Borrowed(&state.borrows)
+        };
+
+        // For pinned borrows, the Pins dataflow determines their liveness
+        // independently of NLL regions. If a pin is active, its corresponding
+        // borrow should be treated as in scope even if NLL killed it.
+        for (borrow_idx, borrow_data) in self.borrow_set.iter_enumerated() {
+            if let crate::borrow_set::Pinnedness::Pinned { at, .. } = borrow_data.pinnedness {
+                if let Some(pin_idx) = self.pin_set.get_index_of(&at) {
+                    if state.pins.contains(pin_idx) && !borrows.contains(borrow_idx) {
+                        borrows.to_mut().insert(borrow_idx);
+                    }
+                }
+            }
         }
+
+        borrows
     }
 
     #[instrument(level = "debug", skip(self, state))]