WIP: implelment borrowck

Author: frank-king

compiler/rustc_borrowck/src/borrow_set.rs

@@ -121,6 +121,18 @@ 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 local if this borrow is pinned.
+    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> {
@@ -335,7 +347,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
             if let mir::StatementKind::Assign(box (pinned_place, ref rvalue)) = stmt.kind
                 && let mir::Rvalue::Aggregate(box agg_kind, operands) = rvalue
                 && let mir::AggregateKind::Adt(adt_did, _, args, _, _) = agg_kind
-                && tcx.adt_def(adt_did).is_pin()
+                && tcx.adt_def(*adt_did).is_pin()
                 && args.type_at(0).is_ref()
                 && let mir::Operand::Move(place) = operands[FieldIdx::ZERO]
                 && place == assigned_place

compiler/rustc_borrowck/src/dataflow.rs

@@ -240,6 +240,12 @@ 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);
@@ -356,6 +362,10 @@ 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);
         }
@@ -546,6 +556,65 @@ impl<'a, 'tcx> Borrows<'a, 'tcx> {
 
         state.kill_all(definitely_conflicting_borrows);
     }
+
+    /// 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>;
@@ -575,10 +644,17 @@ 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);
+
+        // 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.
+        if let mir::StatementKind::Assign(box (lhs, _)) = &statement.kind {
+            self.kill_pinned_borrows_on_reassignment(state, *lhs);
+        }
     }
 
     fn apply_primary_statement_effect(
@@ -613,6 +689,8 @@ 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(..)
@@ -666,7 +744,7 @@ impl<'a, 'tcx> Pins<'a, 'tcx> {
         Pins { tcx, body, pin_set }
     }
 
-    /// Kill any pins on `place`.
+    /// Kill any pins whose original pinned place conflicts with `place`.
     fn kill_pins_on_place(
         &self,
         state: &mut <Self as Analysis<'tcx>>::Domain,
@@ -706,6 +784,26 @@ impl<'a, 'tcx> Pins<'a, 'tcx> {
 
         state.kill_all(definitely_conflicting_pins);
     }
+
+    /// Kill any pins whose Pin result local is `local`.
+    /// This is used when the Pin value goes out of scope (StorageDead).
+    fn kill_pins_by_pin_local(
+        &self,
+        state: &mut <Self as Analysis<'tcx>>::Domain,
+        local: mir::Local,
+    ) {
+        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();
+
+        state.kill_all(pins_of_local);
+    }
 }
 
 type PinsDomain = MixedBitSet<PinIndex>;
@@ -748,7 +846,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Pins<'_, 'tcx> {
                 // 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()
+                    && self.tcx.adt_def(*adt_did).is_pin()
                     && args.type_at(0).is_ref()
                 {
                     // Generate the pin
@@ -764,6 +862,8 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Pins<'_, 'tcx> {
             mir::StatementKind::StorageDead(local) => {
                 // Kill all pins on locals that are going out of scope
                 self.kill_pins_on_place(state, Place::from(*local));
+                // Also kill pins whose Pin result local is going out of scope
+                self.kill_pins_by_pin_local(state, *local);
             }
 
             mir::StatementKind::FakeRead(..)

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -44,9 +44,8 @@ use super::{DescribePlaceOpt, RegionName, RegionNameSource, UseSpans};
 use crate::borrow_set::{BorrowData, TwoPhaseActivation};
 use crate::diagnostics::conflict_errors::StorageDeadOrDrop::LocalStorageDead;
 use crate::diagnostics::{CapturedMessageOpt, call_kind, find_all_local_uses};
-use crate::pin_set::PinData;
 use crate::prefixes::IsPrefixOf;
-use crate::{InitializationRequiringAction, MirBorrowckCtxt, ReadOrWrite, WriteKind, borrowck_errors};
+use crate::{InitializationRequiringAction, MirBorrowckCtxt, WriteKind, borrowck_errors};
 
 #[derive(Debug)]
 struct MoveSite {
@@ -1684,45 +1683,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         err
     }
 
-    pub(crate) fn report_pin_violation(
-        &mut self,
-        _location: Location,
-        place_span: (Place<'tcx>, Span),
-        pin_data: &PinData<'tcx>,
-        access_kind: ReadOrWrite,
-    ) {
-        use ReadOrWrite::Write;
-        use WriteKind::{Move, MutableBorrow};
-
-        let (place, span) = place_span;
-
-        let violation_kind = match access_kind {
-            Write(Move) => "move",
-            Write(MutableBorrow(_)) => "mutably borrow",
-            _ => unreachable!(),
-        };
-
-        let place_desc = self
-            .describe_place(place.as_ref())
-            .unwrap_or_else(|| "value".to_string());
-
-        let mut err = self.root_cx.tcx.dcx().struct_span_err(
-            span,
-            format!("cannot {} `{}` because it is pinned", violation_kind, place_desc),
-        );
-
-        // Show where the pin was created
-        let pin_span = self.body.source_info(pin_data.location).span;
-        err.span_note(pin_span, "pin created here");
-
-        err.help(
-            "pinned values cannot be moved or mutably borrowed, \
-             as this would invalidate the pin guarantee",
-        );
-
-        self.buffer_error(err);
-    }
-
     pub(crate) fn report_conflicting_borrow(
         &self,
         location: Location,

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -612,6 +612,13 @@ 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;

compiler/rustc_borrowck/src/lib.rs

@@ -48,13 +48,12 @@ use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_mir_dataflow::{Analysis, EntryStates, Results, ResultsVisitor, visit_results};
 use rustc_session::lint::builtin::{TAIL_EXPR_DROP_ORDER, UNUSED_MUT};
 use rustc_span::{ErrorGuaranteed, Span, Symbol};
-use rustc_trait_selection::infer::InferCtxtExt;
 use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
 use crate::borrow_set::{BorrowData, BorrowSet};
 use crate::consumers::{BodyWithBorrowckFacts, RustcFacts};
-use crate::dataflow::{BorrowIndex, Borrowck, BorrowckDomain, Borrows, PinIndex, Pins};
+use crate::dataflow::{BorrowIndex, Borrowck, BorrowckDomain, Borrows, Pins};
 use crate::diagnostics::{
     AccessKind, BorrowckDiagnosticsBuffer, IllegalMoveOriginKind, MoveError, RegionName,
 };
@@ -775,6 +774,7 @@ pub(crate) struct MirBorrowckCtxt<'a, 'infcx, 'tcx> {
     borrow_set: &'a BorrowSet<'tcx>,
 
     /// The set of pins extracted from the MIR
+    #[allow(dead_code)]
     pin_set: &'a PinSet<'tcx>,
 
     /// Information about upvars not necessarily preserved in types or MIR
@@ -1032,6 +1032,15 @@ 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);
                         }
                     }
@@ -1249,10 +1258,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
             location,
         );
         let conflict_error = self.check_access_for_conflict(location, place_span, sd, rw, state);
-        let pin_conflict_error =
-            self.check_access_for_pin_conflict(location, place_span, sd, rw, state);
 
-        if conflict_error || mutability_error || pin_conflict_error {
+        if conflict_error || mutability_error {
             debug!("access_place: logging error place_span=`{:?}` kind=`{:?}`", place_span, kind);
             self.access_place_error_reported.insert((place_span.0, place_span.1));
         }
@@ -1276,77 +1283,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
         }
     }
 
-    fn pins_in_scope<'s>(
-        &self,
-        _location: Location,
-        state: &'s BorrowckDomain,
-    ) -> &'s MixedBitSet<PinIndex> {
-        &state.pins
-    }
-
-    #[instrument(level = "debug", skip(self, state))]
-    fn check_access_for_pin_conflict(
-        &mut self,
-        location: Location,
-        place_span: (Place<'tcx>, Span),
-        sd: AccessDepth,
-        rw: ReadOrWrite,
-        state: &BorrowckDomain,
-    ) -> bool {
-        use ReadOrWrite::Write;
-        use WriteKind::{Move, MutableBorrow};
-
-        // Early return: only check Move and MutableBorrow operations
-        let is_violating_access = matches!(rw, Write(Move) | Write(MutableBorrow(_)));
-        if !is_violating_access {
-            return false;
-        }
-
-        let mut error_reported = false;
-        let pins_in_scope = self.pins_in_scope(location, state);
-
-        // Check each active pin for conflicts
-        for pin_index in pins_in_scope.iter() {
-            let pin_data = &self.pin_set[pin_index];
-
-            // Check if accessed place conflicts with pinned place
-            if places_conflict(
-                self.infcx.tcx,
-                self.body,
-                pin_data.pinned_place,
-                place_span.0,
-                PlaceConflictBias::Overlap,
-            ) {
-                // Get the type of the pinned place (Pin<Ptr>)
-                let pinned_ty = pin_data.pinned_place.ty(self.body, self.infcx.tcx).ty;
-
-                // Extract the pointee type from Pin<&[mut] T> to get T
-                if let Some(pointee_ty) = pinned_ty.builtin_deref(true) {
-                    // Check if the pointee type implements Unpin
-                    let unpin_trait = self.infcx.tcx.lang_items().unpin_trait();
-                    if let Some(unpin_trait) = unpin_trait {
-                        let param_env = self.infcx.tcx.param_env(
-                            self.body.source.def_id()
-                        );
-                        let ty_is_unpin = self.infcx.type_implements_trait(
-                            unpin_trait,
-                            [pointee_ty],
-                            param_env,
-                        ).must_apply_modulo_regions();
-
-                        // Only report violation if the type does NOT implement Unpin
-                        if !ty_is_unpin {
-                            error_reported = true;
-                            self.report_pin_violation(location, place_span, pin_data, rw);
-                        }
-                    }
-                }
-            }
-        }
-
-        error_reported
-    }
-
     #[instrument(level = "debug", skip(self, state))]
     fn check_access_for_conflict(
         &mut self,