Support for havocing of nested references in fn calls

src/borrow_pcg/action/actions.rs

@@ -1,6 +1,7 @@
+use derive_more::Deref;
+
 use crate::borrow_pcg::action::BorrowPCGAction;
 use crate::borrow_pcg::borrow_pcg_edge::BorrowPCGEdge;
-use crate::borrow_pcg::borrow_pcg_expansion::BorrowPCGExpansion;
 use crate::borrow_pcg::edge::kind::BorrowPCGEdgeKind;
 use crate::borrow_pcg::edge::outlives::OutlivesEdge;
 use crate::borrow_pcg::graph::Conditioned;
@@ -12,7 +13,7 @@ use crate::{validity_checks_enabled, Weaken};
 
 use super::BorrowPCGActionKind;
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Deref, Debug, Default)]
 pub struct BorrowPCGActions<'tcx>(pub(crate) Vec<BorrowPCGAction<'tcx>>);
 
 impl<'tcx> ToJsonWithRepacker<'tcx> for BorrowPCGActions<'tcx> {
@@ -68,22 +69,6 @@ impl<'tcx> BorrowPCGActions<'tcx> {
             })
             .collect()
     }
-
-    pub fn expands(&self) -> FxHashSet<Conditioned<BorrowPCGExpansion<'tcx>>> {
-        self.0
-            .iter()
-            .filter_map(|action| match action.kind() {
-                BorrowPCGActionKind::AddEdge { edge, .. } => match edge.kind() {
-                    BorrowPCGEdgeKind::BorrowPCGExpansion(expansion) => Some(Conditioned::new(
-                        expansion.clone(),
-                        edge.conditions().clone(),
-                    )),
-                    _ => None,
-                },
-                _ => None,
-            })
-            .collect()
-    }
 }
 
 impl<'tcx> BorrowPCGActions<'tcx> {

src/borrow_pcg/action/mod.rs

@@ -214,9 +214,7 @@ impl<'tcx> BorrowsState<'tcx> {
                 true
             }
             BorrowPCGActionKind::MakePlaceOld(place) => self.make_place_old(place, repacker),
-            BorrowPCGActionKind::SetLatest(place, location) => {
-                self.set_latest(place, location, repacker)
-            }
+            BorrowPCGActionKind::SetLatest(place, location) => self.set_latest(place, location),
             BorrowPCGActionKind::RemoveEdge(edge) => self.remove(&edge, repacker),
             BorrowPCGActionKind::AddEdge {
                 edge,
@@ -235,7 +233,6 @@ impl<'tcx> BorrowsState<'tcx> {
     ) -> Result<bool, PcgError> {
         let mut changed = self.insert(edge.clone());
         Ok(match edge.kind {
-            BorrowPCGEdgeKind::Borrow(_) => changed,
             BorrowPCGEdgeKind::BorrowPCGExpansion(expansion) => {
                 if changed {
                     let base = expansion.base;
@@ -277,20 +274,13 @@ impl<'tcx> BorrowsState<'tcx> {
                 }
                 changed
             }
-            BorrowPCGEdgeKind::Abstraction(_) => changed,
-            BorrowPCGEdgeKind::Outlives(_) => changed,
-            BorrowPCGEdgeKind::RegionProjectionMember(_) => changed,
+            _ => changed,
         })
     }
 
     #[must_use]
-    fn set_latest<T: Into<SnapshotLocation>>(
-        &mut self,
-        place: Place<'tcx>,
-        location: T,
-        repacker: PlaceRepacker<'_, 'tcx>,
-    ) -> bool {
+    fn set_latest<T: Into<SnapshotLocation>>(&mut self, place: Place<'tcx>, location: T) -> bool {
         let location = location.into();
-        self.latest.insert(place, location, repacker)
+        self.latest.insert(place, location)
     }
 }

src/borrow_pcg/borrow_pcg_edge.rs

@@ -7,8 +7,7 @@ use super::{
     borrow_pcg_expansion::BorrowPCGExpansion,
     coupling_graph_constructor::CGNode,
     edge::{
-        borrow::RemoteBorrow, outlives::OutlivesEdge,
-        region_projection_member::RegionProjectionMember,
+        borrow::RemoteBorrow, coupling::FunctionCallRegionCoupling, outlives::OutlivesEdge, region_projection_member::RegionProjectionMember
     },
     edge_data::EdgeData,
     graph::Conditioned,
@@ -329,7 +328,7 @@ impl<'tcx> PCGNode<'tcx> {
             PCGNode::Place(MaybeRemotePlace::Remote(_)) => None,
             PCGNode::RegionProjection(rp) => {
                 let place = rp.place().as_local_place()?;
-                Some(LocalNode::RegionProjection(rp.set_base(place, repacker)))
+                Some(LocalNode::RegionProjection(rp.with_base(place, repacker)))
             }
         }
     }
@@ -437,6 +436,7 @@ edgedata_enum!(
     Abstraction(AbstractionType<'tcx>),
     Outlives(OutlivesEdge<'tcx>),
     RegionProjectionMember(RegionProjectionMember<'tcx>),
+    FunctionCallRegionCoupling(FunctionCallRegionCoupling<'tcx>),
 );
 
 pub(crate) trait ToBorrowsEdge<'tcx> {

src/borrow_pcg/borrow_pcg_expansion.rs

@@ -209,7 +209,7 @@ impl<'tcx> EdgeData<'tcx> for BorrowPCGExpansion<'tcx> {
         {
             base.insert(
                 base_projection
-                    .set_base(base_projection.base.into(), repacker)
+                    .with_base(base_projection.base.into(), repacker)
                     .into(),
             );
         }

src/borrow_pcg/coupling_graph_constructor.rs

@@ -155,6 +155,10 @@ pub trait BorrowCheckerInterface<'mir, 'tcx: 'mir> {
     fn is_live(&self, node: PCGNode<'tcx>, location: Location) -> bool;
     fn outlives(&self, sup: PCGRegion, sub: PCGRegion) -> bool;
 
+    fn same_region(&self, reg1: PCGRegion, reg2: PCGRegion) -> bool {
+        self.outlives(reg1, reg2) && self.outlives(reg2, reg1)
+    }
+
     /// Returns the set of two-phase borrows that activate at `location`.
     /// Each borrow in the returned set is represented by the MIR location
     /// that it was created at.
@@ -278,13 +282,6 @@ impl<'mir, 'tcx> RegionProjectionAbstractionConstructor<'mir, 'tcx> {
                         },
                     ) && !n.is_old()
                 });
-            tracing::info!(
-                "connect {} to {} ? (is_root: {:?}): {}",
-                bottom_connect.to_short_string(self.repacker),
-                coupled.to_short_string(self.repacker),
-                is_root,
-                should_include
-            );
             if !should_include {
                 self.add_edges_from(
                     bg,

src/borrow_pcg/domain.rs

@@ -172,7 +172,7 @@ impl<'mir, 'tcx: 'mir> BorrowsDomain<'mir, 'tcx> {
                                     );
                                 }),
                                 region_projection,
-                                OutlivesEdgeKind::Todo,
+                                OutlivesEdgeKind::InitialBorrows,
                                 self.repacker,
                             )
                             .into(),

src/borrow_pcg/edge/coupling.rs

@@ -0,0 +1,109 @@
+use crate::borrow_pcg::borrow_pcg_edge::LocalNode;
+use crate::borrow_pcg::edge_data::EdgeData;
+use crate::borrow_pcg::has_pcs_elem::{default_make_place_old, HasPcgElems, MakePlaceOld};
+use crate::borrow_pcg::latest::Latest;
+use crate::borrow_pcg::region_projection::LocalRegionProjection;
+use crate::combined_pcs::{LocalNodeLike, PCGNode, PCGNodeLike};
+use crate::pcg_validity_assert;
+use crate::rustc_interface::data_structures::fx::FxHashSet;
+use crate::utils::display::DisplayWithRepacker;
+use crate::utils::maybe_old::MaybeOldPlace;
+use crate::utils::validity::HasValidityCheck;
+use crate::utils::{Place, PlaceRepacker};
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct FunctionCallRegionCoupling<'tcx> {
+    pub(crate) inputs: Vec<LocalRegionProjection<'tcx>>,
+    pub(crate) outputs: Vec<LocalRegionProjection<'tcx>>,
+}
+
+impl <'tcx> FunctionCallRegionCoupling<'tcx> {
+    pub fn inputs(&self) -> &[LocalRegionProjection<'tcx>] {
+        &self.inputs
+    }
+    pub fn outputs(&self) -> &[LocalRegionProjection<'tcx>] {
+        &self.outputs
+    }
+
+    pub fn num_coupled_nodes(&self) -> usize {
+        self.inputs.len()
+    }
+}
+
+impl<'tcx> HasValidityCheck<'tcx> for FunctionCallRegionCoupling<'tcx> {
+    fn check_validity(&self, repacker: PlaceRepacker<'_, 'tcx>) -> Result<(), String> {
+        for input in self.inputs.iter() {
+            input.check_validity(repacker)?;
+        }
+        for output in self.outputs.iter() {
+            output.check_validity(repacker)?;
+        }
+        Ok(())
+    }
+}
+
+impl<'tcx> MakePlaceOld<'tcx> for FunctionCallRegionCoupling<'tcx> {
+    fn make_place_old(
+        &mut self,
+        place: Place<'tcx>,
+        latest: &Latest<'tcx>,
+        repacker: PlaceRepacker<'_, 'tcx>,
+    ) -> bool {
+        default_make_place_old(self, place, latest, repacker)
+    }
+}
+
+impl<'tcx> HasPcgElems<MaybeOldPlace<'tcx>> for FunctionCallRegionCoupling<'tcx> {
+    fn pcg_elems(&mut self) -> Vec<&mut MaybeOldPlace<'tcx>> {
+        self.inputs
+            .iter_mut()
+            .flat_map(|rp| rp.pcg_elems())
+            .collect::<Vec<_>>()
+            .into_iter()
+            .chain(
+                self.outputs
+                    .iter_mut()
+                    .flat_map(|rp| rp.pcg_elems())
+                    .collect::<Vec<_>>(),
+            )
+            .collect()
+    }
+}
+
+impl<'tcx> DisplayWithRepacker<'tcx> for FunctionCallRegionCoupling<'tcx> {
+    fn to_short_string(&self, _repacker: PlaceRepacker<'_, 'tcx>) -> String {
+        format!(
+            "FunctionCallRegionCoupling({:?}, {:?})",
+            self.inputs, self.outputs
+        )
+    }
+}
+
+impl<'tcx> FunctionCallRegionCoupling<'tcx> {
+    pub(crate) fn new(
+        inputs: FxHashSet<LocalRegionProjection<'tcx>>,
+        outputs: FxHashSet<LocalRegionProjection<'tcx>>,
+    ) -> Self {
+        pcg_validity_assert!(inputs.len() == outputs.len());
+        Self {
+            inputs: inputs.into_iter().collect(),
+            outputs: outputs.into_iter().collect(),
+        }
+    }
+}
+
+impl<'tcx> EdgeData<'tcx> for FunctionCallRegionCoupling<'tcx> {
+    fn blocked_nodes(&self, repacker: PlaceRepacker<'_, 'tcx>) -> FxHashSet<PCGNode<'tcx>> {
+        self.inputs
+            .iter()
+            .map(|rp| rp.to_pcg_node(repacker))
+            .collect()
+    }
+
+    fn blocked_by_nodes(&self, repacker: PlaceRepacker<'_, 'tcx>) -> FxHashSet<LocalNode<'tcx>> {
+        self.outputs
+            .iter()
+            .map(|rp| rp.to_local_node(repacker))
+            .collect()
+    }
+}

src/borrow_pcg/edge/kind.rs

@@ -4,6 +4,7 @@ use crate::borrow_pcg::edge::borrow::BorrowEdge;
 use crate::utils::PlaceRepacker;
 
 use super::borrow::RemoteBorrow;
+use super::coupling::FunctionCallRegionCoupling;
 use super::outlives::OutlivesEdge;
 use super::region_projection_member::RegionProjectionMember;
 
@@ -14,6 +15,7 @@ pub enum BorrowPCGEdgeKind<'tcx> {
     Abstraction(AbstractionType<'tcx>),
     Outlives(OutlivesEdge<'tcx>),
     RegionProjectionMember(RegionProjectionMember<'tcx>),
+    FunctionCallRegionCoupling(FunctionCallRegionCoupling<'tcx>),
 }
 
 impl<'tcx> From<RemoteBorrow<'tcx>> for BorrowPCGEdgeKind<'tcx> {

src/borrow_pcg/edge/mod.rs

@@ -1,5 +1,6 @@
 pub mod abstraction;
 pub mod borrow;
+pub mod coupling;
 pub mod kind;
 pub mod outlives;
 pub mod region_projection_member;

src/borrow_pcg/edge/outlives.rs

@@ -114,31 +114,37 @@ pub enum OutlivesEdgeKind {
     /// for `{y|'a} -> {x|'b}` of this kind is created if 'a outlives 'b.
     ///
     /// `toplevel` is true for edges to x↓'x, false otherwise.
-    BorrowOutlives { toplevel: bool },
+    BorrowOutlives {
+        toplevel: bool,
+    },
     /// If e.g {x|'a} -> {y|'b} is a BorrowsOutlives, then {*x|'a} -> {*y|'b} is a DerefBorrowsOutlives
     /// (it's introduced if e.g. *y is expanded in the PCG)
     DerefBorrowOutlives,
-    /// TODO: Provide more useful kinds, this enum variant should be removed
-    Todo,
+    /// Initial borrows edge
+    InitialBorrows,
+    CopySharedRef,
+    HavocRegion
 }
 
 impl std::fmt::Display for OutlivesEdgeKind {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             OutlivesEdgeKind::Aggregate {
-                field_idx,
-                target_rp_index,
-            } => write!(f, "Aggregate({field_idx}, {target_rp_index})"),
+                        field_idx,
+                        target_rp_index,
+                    } => write!(f, "Aggregate({field_idx}, {target_rp_index})"),
             OutlivesEdgeKind::Borrow => write!(f, "Borrow"),
             OutlivesEdgeKind::DerefRegionProjection => write!(f, "DerefRegionProjection"),
             OutlivesEdgeKind::Ref => write!(f, "Ref"),
             OutlivesEdgeKind::ContractRef => write!(f, "ContractRef"),
             OutlivesEdgeKind::ConstRef => write!(f, "ConstRef"),
             OutlivesEdgeKind::BorrowOutlives { toplevel } => {
-                write!(f, "BorrowOutlives({toplevel})")
-            }
-            OutlivesEdgeKind::Todo => write!(f, "Todo"),
+                        write!(f, "BorrowOutlives({toplevel})")
+                    }
             OutlivesEdgeKind::DerefBorrowOutlives => write!(f, "DerefBorrowOutlives"),
+            OutlivesEdgeKind::InitialBorrows => write!(f, "InitialBorrows"),
+            OutlivesEdgeKind::CopySharedRef => write!(f, "CopySharedRef"),
+            OutlivesEdgeKind::HavocRegion => write!(f, "HavocRegion"),
         }
     }
 }

src/borrow_pcg/graph/aliases.rs

@@ -4,7 +4,7 @@ use crate::{
         edge::{kind::BorrowPCGEdgeKind, outlives::OutlivesEdgeKind},
         region_projection::RegionIdx,
     },
-    combined_pcs::{PCGNode, PCGNodeLike},
+    combined_pcs::{LocalNodeLike, PCGNode, PCGNodeLike},
     rustc_interface::data_structures::fx::FxHashSet,
     utils::{display::DisplayWithRepacker, HasPlace, PlaceRepacker},
 };
@@ -80,15 +80,15 @@ impl<'tcx> BorrowsGraph<'tcx> {
                     &mut FxHashSet::default(),
                     true,
                 ));
-                if let PCGNode::Place(p) = local_node {
-                    if let Some(rp) = p.deref_to_rp(repacker) {
-                        results.extend(self.direct_aliases(
-                            rp.try_to_local_node(repacker).unwrap(),
-                            repacker,
-                            &mut FxHashSet::default(),
-                            true,
-                        ));
-                    }
+                if let PCGNode::Place(p) = local_node
+                    && let Some(rp) = p.deref_to_rp(repacker)
+                {
+                    results.extend(self.direct_aliases(
+                        rp.to_local_node(repacker),
+                        repacker,
+                        &mut FxHashSet::default(),
+                        true,
+                    ));
                 }
             }
         }
@@ -166,6 +166,11 @@ impl<'tcx> BorrowsGraph<'tcx> {
                         );
                     }
                 },
+                BorrowPCGEdgeKind::FunctionCallRegionCoupling(edge) => {
+                    for input in edge.inputs.iter() {
+                        extend(input.to_pcg_node(repacker), seen, &mut result, false);
+                    }
+                }
                 _ => todo!(),
             }
         }
@@ -232,6 +237,7 @@ fn test_aliases() {
             &body.body,
             tcx,
         );
+        // *_2 aliases _4 at bb3[1]
         assert!(aliases.contains(&temp4));
         assert!(aliases.contains(&x));
     });