Fix issues Jasper identified

src/borrow_pcg/state/mod.rs

@@ -9,8 +9,13 @@ use super::{
     latest::Latest,
     path_condition::{PathCondition, PathConditions},
 };
-use crate::borrow_pcg::edge::borrow::{BorrowEdge, LocalBorrow};
-use crate::{borrow_pcg::action::executed_actions::ExecutedActions, combined_pcs::PcgError};
+use crate::{
+    borrow_pcg::action::executed_actions::ExecutedActions,
+    combined_pcs::PcgError,
+};
+use crate::{
+    borrow_pcg::edge::borrow::{BorrowEdge, LocalBorrow},
+};
 use crate::{
     borrow_pcg::edge::kind::BorrowPCGEdgeKind, utils::place::maybe_remote::MaybeRemotePlace,
 };
@@ -94,7 +99,9 @@ impl<'tcx> BorrowsState<'tcx> {
         if removed {
             for node in edge.blocked_by_nodes(repacker) {
                 if !self.graph.contains(node, repacker) {
-                    let _ = self.remove_capability(node.place().into());
+                    if let PCGNode::Place(MaybeOldPlace::Current { place }) = node {
+                        let _ = self.remove_capability(place.into());
+                    }
                 }
             }
         }
@@ -191,6 +198,7 @@ impl<'tcx> BorrowsState<'tcx> {
         changed
     }
 
+    #[tracing::instrument(skip(self, edge, location, repacker))]
     pub(super) fn remove_edge_and_set_latest(
         &mut self,
         edge: impl BorrowPCGEdgeLike<'tcx>,

src/borrow_pcg/state/obtain.rs

@@ -90,7 +90,8 @@ impl<'tcx> BorrowsState<'tcx> {
         if !place.is_owned(repacker) {
             pcg_validity_assert!(
                 self.get_capability(place.into()).is_some(),
-                "Place {:?} does not have a capability after obtain {:?}",
+                "{:?}: Place {:?} does not have a capability after obtain {:?}",
+                location,
                 place,
                 obtain_reason
             );

src/free_pcs/impl/triple.rs

@@ -6,12 +6,12 @@
 
 use crate::pcg_validity_assert;
 use crate::rustc_interface::middle::mir::{
-    visit::Visitor, BorrowKind, Local, Location, Operand, ProjectionElem, Rvalue, Statement,
-    StatementKind, Terminator, TerminatorKind, RETURN_PLACE,
+    visit::Visitor, BorrowKind, Local, Location, MutBorrowKind, Operand, ProjectionElem, Rvalue,
+    Statement, StatementKind, Terminator, TerminatorKind, RETURN_PLACE,
 };
 
 use crate::{
-    combined_pcs::{PcgError, PCGUnsupportedError},
+    combined_pcs::{PCGUnsupportedError, PcgError},
     free_pcs::CapabilityKind,
     utils::{display::DisplayWithRepacker, Place, PlaceRepacker},
 };
@@ -230,10 +230,17 @@ impl<'tcx> Visitor<'tcx> for TripleWalker<'_, 'tcx> {
                     post: Some(Condition::read(*place)),
                 },
                 BorrowKind::Fake(..) => return,
-                BorrowKind::Mut { .. } => Triple {
-                    pre: Condition::exclusive(*place, self.repacker),
-                    post: Some(Condition::RemoveCapability((*place).into())),
-                },
+                BorrowKind::Mut { kind } => {
+                    let post = if matches!(kind, MutBorrowKind::TwoPhaseBorrow) {
+                        Some(Condition::read(*place))
+                    } else {
+                        Some(Condition::RemoveCapability((*place).into()))
+                    };
+                    Triple {
+                        pre: Condition::exclusive(*place, self.repacker),
+                        post,
+                    }
+                }
             };
             self.main_triples.push(triple);
         }

test-files/126_hashbrown_occupied_error.rs

@@ -0,0 +1,56 @@
+#![feature(allocator_api)]
+
+pub type DefaultHashBuilder = ();
+
+pub struct Bucket<T> {
+    // Actually it is pointer to next element than element itself
+    // this is needed to maintain pointer arithmetic invariants
+    // keeping direct pointer to element introduces difficulty.
+    // Using `NonNull` for variance and niche layout
+    ptr: NonNull<T>,
+}
+
+use std::ptr::NonNull;
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::alloc::{Allocator, Global};
+use std::fmt;
+pub struct OccupiedEntry<'a, K, V, S = DefaultHashBuilder, A: Allocator = Global> {
+    hash: u64,
+    elem: Bucket<(K, V)>,
+    table: &'a mut (),
+    phantom: std::marker::PhantomData<(S, A)>,
+}
+
+impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
+    pub fn key(&self) -> &K {
+        unimplemented!()
+    }
+
+    pub fn get(&self) -> &V {
+        unimplemented!()
+    }
+}
+
+pub struct OccupiedError<'a, K, V, S, A: Allocator = Global> {
+    /// The entry in the map that was already occupied.
+    pub entry: OccupiedEntry<'a, K, V, S, A>,
+    /// The value which was not inserted, because the entry was already occupied.
+    pub value: V,
+}
+
+impl<K: Debug, V: Debug, S, A: Allocator> fmt::Display for OccupiedError<'_, K, V, S, A> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "failed to insert {:?}, key {:?} already exists with value {:?}",
+            self.value,
+            self.entry.key(),
+            self.entry.get(),
+        )
+    }
+}
+
+fn main(){
+
+}

test-files/127_syn_tokenbuffer.rs

@@ -0,0 +1,29 @@
+pub struct TokenStream {
+    inner: (),
+    _marker: (),
+}
+
+enum Entry {
+    End(isize, isize),
+}
+
+pub struct TokenBuffer {
+    // NOTE: Do not implement clone on this - while the current design could be
+    // cloned, other designs which could be desirable may not be cloneable.
+    entries: Box<[Entry]>,
+}
+
+impl TokenBuffer {
+    fn recursive_new(entries: &mut Vec<Entry>, stream: TokenStream) {
+    }
+    pub fn new2(stream: TokenStream) -> Self {
+        let mut entries = Vec::new();
+        Self::recursive_new(&mut entries, stream);
+        entries.push(Entry::End(-(entries.len() as isize), 0));
+        Self {
+            entries: entries.into_boxed_slice(),
+        }
+    }
+}
+
+fn main(){}

tests/selected_crates.rs

@@ -11,6 +11,15 @@ fn test_selected_crates() {
     // common::run_on_crate("cookie", "0.18.1", Some("2025-03-13"), false, true);
     // common::run_on_crate("futures-util", "0.3.31", false);
     // common::run_on_crate("gimli", "0.31.1", false);
+    common::run_on_crate(
+        "hashbrown",
+        "0.15.2",
+        Some("2025-03-13"),
+        common::RunOnCrateOptions::RunPCG {
+            target: common::Target::Release,
+            validity_checks: true,
+        },
+    );
     // common::run_on_crate("http", "1.2.0", true);
     // common::run_on_crate("miniz_oxide", "0.8.5", true);
     // common::run_on_crate("num-conv", "0.1.0", true);
@@ -33,6 +42,16 @@ fn test_selected_crates() {
     //     },
     // );
 
+    common::run_on_crate(
+        "syn",
+        "2.0.100",
+        Some("2025-03-13"),
+        common::RunOnCrateOptions::RunPCG {
+            target: common::Target::Release,
+            validity_checks: true,
+        },
+    );
+
     // common::run_on_crate(
     //     "cfg-if",
     //     "1.0.0",