WIP: implelment borrowck

Author: frank-king

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -44,8 +44,9 @@ 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, WriteKind, borrowck_errors};
+use crate::{InitializationRequiringAction, MirBorrowckCtxt, ReadOrWrite, WriteKind, borrowck_errors};
 
 #[derive(Debug)]
 struct MoveSite {
@@ -1683,6 +1684,45 @@ 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/lib.rs

@@ -48,6 +48,7 @@ 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};
 
@@ -486,6 +487,7 @@ fn borrowck_check_region_constraints<'tcx>(
             used_mut: Default::default(),
             used_mut_upvars: SmallVec::new(),
             borrow_set: &borrow_set,
+            pin_set: &pin_set,
             upvars: &[],
             local_names: OnceCell::from(IndexVec::from_elem(None, &promoted_body.local_decls)),
             region_names: RefCell::default(),
@@ -525,6 +527,7 @@ fn borrowck_check_region_constraints<'tcx>(
         used_mut: Default::default(),
         used_mut_upvars: SmallVec::new(),
         borrow_set: &borrow_set,
+        pin_set: &pin_set,
         upvars: tcx.closure_captures(def),
         local_names: OnceCell::new(),
         region_names: RefCell::default(),
@@ -771,6 +774,9 @@ pub(crate) struct MirBorrowckCtxt<'a, 'infcx, 'tcx> {
     /// The set of borrows extracted from the MIR
     borrow_set: &'a BorrowSet<'tcx>,
 
+    /// The set of pins extracted from the MIR
+    pin_set: &'a PinSet<'tcx>,
+
     /// Information about upvars not necessarily preserved in types or MIR
     upvars: &'tcx [&'tcx ty::CapturedPlace<'tcx>],
 
@@ -1243,8 +1249,10 @@ 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 {
+        if conflict_error || mutability_error || pin_conflict_error {
             debug!("access_place: logging error place_span=`{:?}` kind=`{:?}`", place_span, kind);
             self.access_place_error_reported.insert((place_span.0, place_span.1));
         }
@@ -1268,6 +1276,77 @@ 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,

tests/ui/borrowck/pin-violations.rs

@@ -0,0 +1,24 @@
+//@ check-pass
+// Test for pin violation detection - currently a placeholder
+// The pin violation detection is implemented but may not trigger
+// for all pin patterns yet. This test documents expected behavior.
+
+#![feature(pin_ergonomics)]
+#![allow(incomplete_features, dead_code)]
+
+use std::marker::PhantomPinned;
+
+#[derive(Default)]
+struct Foo {
+    _pinned: PhantomPinned,
+}
+
+// Test basic pin borrow patterns
+fn test_pin_borrows() {
+    let mut foo = Foo::default();
+    let _pinned = &pin mut foo;
+    // Currently, &pin mut creates a special borrow, not a Pin aggregate
+    // So our violation detection may not trigger here
+}
+
+fn main() {}