WIP

Author: zgrannan

Diff for: src/borrows/borrow_edge.rs

@@ -7,14 +7,14 @@ use super::{
     has_pcs_elem::HasPcsElems,
     region_projection::RegionProjection,
 };
-use crate::rustc_interface::{
+use crate::{rustc_interface::{
     ast::Mutability,
     data_structures::fx::FxHashSet,
     middle::{
         mir::Location,
         ty::{self},
     },
-};
+}, utils::display::DisplayWithRepacker};
 use crate::utils::PlaceRepacker;
 
 #[derive(PartialEq, Eq, Clone, Debug, Hash)]
@@ -31,6 +31,17 @@ pub struct BorrowEdge<'tcx> {
     pub region: ty::Region<'tcx>,
 }
 
+impl<'tcx> DisplayWithRepacker<'tcx> for BorrowEdge<'tcx> {
+    fn to_short_string(&self, repacker: PlaceRepacker<'_, 'tcx>) -> String {
+        format!(
+            "borrow: {} = &{} {}",
+            self.assigned_ref.to_short_string(repacker),
+            if self.mutability == Mutability::Mut { "mut " } else { "" },
+            self.blocked_place.to_short_string(repacker)
+        )
+    }
+}
+
 impl<'tcx, T> HasPcsElems<RegionProjection<'tcx, T>> for BorrowEdge<'tcx> {
     fn pcs_elems(&mut self) -> Vec<&mut RegionProjection<'tcx, T>> {
         vec![]

Diff for: src/borrows/borrow_pcg_action.rs

@@ -2,7 +2,9 @@ use tracing::instrument;
 
 use crate::free_pcs::CapabilityKind;
 use crate::rustc_interface::{ast::Mutability, middle::mir::Location};
+use crate::utils::display::DisplayWithRepacker;
 use crate::utils::{Place, PlaceRepacker, SnapshotLocation};
+use crate::{RestoreCapability, Weaken};
 
 use super::borrow_pcg_edge::{BorrowPCGEdge, LocalNode, ToBorrowsEdge};
 use super::borrow_pcg_expansion::BorrowPCGExpansion;
@@ -22,11 +24,67 @@ use super::region_projection_member::RegionProjectionMember;
 /// in the `BorrowsVisitor`?
 #[derive(Clone, Debug)]
 pub struct BorrowPCGAction<'tcx> {
-    kind: BorrowPCGActionKind<'tcx>,
+    pub(crate) kind: BorrowPCGActionKind<'tcx>,
     debug_context: Option<String>,
 }
 
 impl<'tcx> BorrowPCGAction<'tcx> {
+    pub(crate) fn debug_line(&self, repacker: PlaceRepacker<'_, 'tcx>) -> String {
+        match &self.kind {
+            BorrowPCGActionKind::Weaken(weaken) => weaken.debug_line(repacker),
+            BorrowPCGActionKind::Restore(restore_capability) => {
+                restore_capability.debug_line(repacker)
+            }
+            BorrowPCGActionKind::MakePlaceOld(place) => {
+                format!("Make {} an old place", place.to_short_string(repacker))
+            }
+            BorrowPCGActionKind::SetLatest(place, location) => format!(
+                "Set Latest of {} to {:?}",
+                place.to_short_string(repacker),
+                location
+            ),
+            BorrowPCGActionKind::RemoveEdge(borrow_pcgedge) => {
+                format!("Remove Edge {}", borrow_pcgedge.to_short_string(repacker))
+            }
+            BorrowPCGActionKind::AddRegionProjectionMember(
+                region_projection_member,
+                path_conditions,
+            ) => format!(
+                "Add Region Projection Member: {}; path conditions: {}",
+                region_projection_member.to_short_string(repacker),
+                path_conditions
+            ),
+            BorrowPCGActionKind::InsertBorrowPCGExpansion(borrow_pcgexpansion, location) => {
+                format!(
+                    "Insert Expansion {} at {:?}",
+                    borrow_pcgexpansion.to_short_string(repacker),
+                    location
+                )
+            }
+            BorrowPCGActionKind::RenamePlace { old, new } => {
+                format!("Rename {:?} to {:?}", old, new)
+            }
+        }
+    }
+
+    pub fn kind(&self) -> &BorrowPCGActionKind<'tcx> {
+        &self.kind
+    }
+
+    pub(super) fn restore_capability(node: LocalNode<'tcx>, capability: CapabilityKind) -> Self {
+        BorrowPCGAction {
+            kind: BorrowPCGActionKind::Restore(RestoreCapability::new(node, capability)),
+            debug_context: None,
+        }
+    }
+
+    pub(super) fn weaken(place: Place<'tcx>, from: CapabilityKind, to: CapabilityKind) -> Self {
+        BorrowPCGAction {
+            kind: BorrowPCGActionKind::Weaken(Weaken::new(place, from, to)),
+            debug_context: None,
+        }
+    }
+
     pub(super) fn rename_place(old: MaybeOldPlace<'tcx>, new: MaybeOldPlace<'tcx>) -> Self {
         BorrowPCGAction {
             kind: BorrowPCGActionKind::RenamePlace { old, new },
@@ -91,7 +149,9 @@ impl<'tcx> From<BorrowPCGActionKind<'tcx>> for BorrowPCGAction<'tcx> {
 }
 
 #[derive(Clone, Debug)]
-pub(crate) enum BorrowPCGActionKind<'tcx> {
+pub enum BorrowPCGActionKind<'tcx> {
+    Weaken(Weaken<'tcx>),
+    Restore(RestoreCapability<'tcx>),
     MakePlaceOld(Place<'tcx>),
     SetLatest(Place<'tcx>, Location),
     RemoveEdge(BorrowPCGEdge<'tcx>),
@@ -121,6 +181,16 @@ impl<'tcx> BorrowsState<'tcx> {
         repacker: PlaceRepacker<'_, 'tcx>,
     ) -> bool {
         let result = match action.kind {
+            BorrowPCGActionKind::Restore(restore) => {
+                assert!(self.get_capability(restore.node()).unwrap() < restore.capability());
+                assert!(self.set_capability(restore.node(), restore.capability()));
+                true
+            }
+            BorrowPCGActionKind::Weaken(weaken) => {
+                assert_eq!(self.get_capability(weaken.place()), Some(weaken.from));
+                assert!(self.set_capability(weaken.place(), weaken.to));
+                true
+            }
             BorrowPCGActionKind::MakePlaceOld(place) => self.make_place_old(place, repacker, None),
             BorrowPCGActionKind::SetLatest(place, location) => {
                 self.set_latest(place, location, repacker)
@@ -130,34 +200,45 @@ impl<'tcx> BorrowsState<'tcx> {
                 self.add_region_projection_member(member, pc, repacker)
             }
             BorrowPCGActionKind::InsertBorrowPCGExpansion(de, location) => {
-                let inserted = self.insert(
+                let updated = self.insert(
                     de.clone()
                         .to_borrow_pcg_edge(PathConditions::new(location.block)),
                 );
-                if inserted {
+                if updated {
                     let base = de.base();
-                    let capability = match self.get_capability(base) {
-                        Some(c) => c,
-                        None => {
-                            // The expansion presumably already exists under
-                            // different path conditions. TODO: Maybe this is
-                            // worth checking?
-                            return inserted;
+                    let capability = match &de {
+                        BorrowPCGExpansion::FromOwned(expansion_of_owned) => {
+                            match expansion_of_owned.base().ty(repacker).ty.ref_mutability() {
+                                Some(Mutability::Mut) => CapabilityKind::Exclusive,
+                                Some(Mutability::Not) => CapabilityKind::Read,
+                                None => unreachable!(),
+                            }
+                        }
+                        BorrowPCGExpansion::FromBorrow(expansion_of_borrowed) => {
+                            if let Some(capability) =
+                                self.get_capability(expansion_of_borrowed.base)
+                            {
+                                capability
+                            } else {
+                                // Presumably already expanded in another branch
+                                // TODO: Check expansion capability exists
+                                return true;
+                            }
                         }
                     };
                     match capability {
                         CapabilityKind::Read => {
-                            self.set_capability(base, CapabilityKind::Read);
+                            _ = self.set_capability(base, CapabilityKind::Read);
                         }
                         _ => {
-                            self.remove_capability(base);
+                            _ = self.remove_capability(base);
                         }
                     }
                     for p in de.expansion(repacker).iter() {
-                        self.set_capability(*p, capability);
+                        _ = self.set_capability(*p, capability);
                     }
                 }
-                inserted
+                updated
             }
             BorrowPCGActionKind::RenamePlace { old, new } => self.change_pcs_elem(old, new),
         };

Diff for: src/borrows/borrow_pcg_capabilities.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::{free_pcs::CapabilityKind, utils::Place};
+use crate::free_pcs::CapabilityKind;
 
 use super::borrow_pcg_edge::PCGNode;
 
@@ -41,14 +41,6 @@ impl<'tcx> BorrowPCGCapabilities<'tcx> {
         self.0.iter().map(|(k, v)| (k.clone(), v.clone()))
     }
 
-    pub(crate) fn place_capabilities(
-        &self,
-    ) -> impl Iterator<Item = (Place<'tcx>, CapabilityKind)> + '_ {
-        self.0
-            .iter()
-            .flat_map(|(k, v)| k.as_current_place().map(|p| (p, v.clone())))
-    }
-
     pub(crate) fn get<T: Into<PCGNode<'tcx>>>(&self, node: T) -> Option<CapabilityKind> {
         self.0.get(&node.into()).cloned()
     }

Diff for: src/borrows/borrow_pcg_edge.rs

@@ -6,7 +6,7 @@ use rustc_interface::{
 
 use crate::{
     edgedata_enum, rustc_interface,
-    utils::{HasPlace, Place, PlaceRepacker},
+    utils::{display::DisplayWithRepacker, HasPlace, Place, PlaceRepacker},
 };
 
 use super::{
@@ -29,6 +29,16 @@ pub struct BorrowPCGEdge<'tcx> {
     pub(crate) kind: BorrowPCGEdgeKind<'tcx>,
 }
 
+impl<'tcx> DisplayWithRepacker<'tcx> for BorrowPCGEdge<'tcx> {
+    fn to_short_string(&self, repacker: PlaceRepacker<'_, 'tcx>) -> String {
+        format!(
+            "{} under conditions {:?}",
+            self.kind.to_short_string(repacker),
+            self.conditions
+        )
+    }
+}
+
 /// Any node in the PCG that is "local" in the sense that it can be named
 /// (include nodes that potentially refer to a past program point), i.e. any
 /// node other than a [`super::domain::RemotePlace`]
@@ -102,12 +112,12 @@ impl<'tcx> HasPlace<'tcx> for LocalNode<'tcx> {
 }
 
 impl<'tcx> LocalNode<'tcx> {
-    pub(crate) fn is_current(&self) -> bool {
-        match self {
-            LocalNode::Place(p) => p.is_current(),
-            LocalNode::RegionProjection(rp) => rp.place.is_current(),
-        }
-    }
+    // pub(crate) fn is_current(&self) -> bool {
+    //     match self {
+    //         LocalNode::Place(p) => p.is_current(),
+    //         LocalNode::RegionProjection(rp) => rp.place.is_current(),
+    //     }
+    // }
 
     pub fn as_cg_node(&self) -> Option<CGNode<'tcx>> {
         match self {
@@ -131,6 +141,15 @@ pub enum PCGNode<'tcx, T = MaybeRemotePlace<'tcx>> {
     RegionProjection(RegionProjection<'tcx, T>),
 }
 
+impl<'tcx, T: DisplayWithRepacker<'tcx>> DisplayWithRepacker<'tcx> for PCGNode<'tcx, T> {
+    fn to_short_string(&self, repacker: PlaceRepacker<'_, 'tcx>) -> String {
+        match self {
+            PCGNode::Place(p) => p.to_short_string(repacker),
+            PCGNode::RegionProjection(rp) => rp.to_short_string(repacker),
+        }
+    }
+}
+
 impl<'tcx, T: std::fmt::Display> std::fmt::Display for PCGNode<'tcx, T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -370,6 +389,17 @@ pub enum BorrowPCGEdgeKind<'tcx> {
     RegionProjectionMember(RegionProjectionMember<'tcx>),
 }
 
+impl<'tcx> DisplayWithRepacker<'tcx> for BorrowPCGEdgeKind<'tcx> {
+    fn to_short_string(&self, repacker: PlaceRepacker<'_, 'tcx>) -> String {
+        match self {
+            BorrowPCGEdgeKind::Borrow(borrow) => borrow.to_short_string(repacker),
+            BorrowPCGEdgeKind::BorrowPCGExpansion(expansion) => expansion.to_short_string(repacker),
+            BorrowPCGEdgeKind::Abstraction(abstraction) => abstraction.to_short_string(repacker),
+            BorrowPCGEdgeKind::RegionProjectionMember(member) => member.to_short_string(repacker),
+        }
+    }
+}
+
 edgedata_enum!(
     BorrowPCGEdgeKind<'tcx>,
     Borrow(BorrowEdge<'tcx>),

Diff for: src/borrows/borrow_pcg_expansion.rs

@@ -14,7 +14,9 @@ use crate::{
         span::Symbol,
         target::abi::{FieldIdx, VariantIdx},
     },
-    utils::{ConstantIndex, CorrectedPlace, HasPlace, Place, PlaceRepacker},
+    utils::{
+        display::DisplayWithRepacker, ConstantIndex, CorrectedPlace, HasPlace, Place, PlaceRepacker,
+    },
 };
 
 use super::{
@@ -264,6 +266,30 @@ pub enum BorrowPCGExpansion<'tcx, P = LocalNode<'tcx>> {
     FromBorrow(ExpansionOfBorrowed<'tcx, P>),
 }
 
+impl<
+        'tcx,
+        T: std::hash::Hash
+            + PartialEq
+            + Eq
+            + Copy
+            + HasPlace<'tcx>
+            + DisplayWithRepacker<'tcx>
+            + From<MaybeOldPlace<'tcx>>,
+    > DisplayWithRepacker<'tcx> for BorrowPCGExpansion<'tcx, T>
+{
+    fn to_short_string(&self, repacker: PlaceRepacker<'_, 'tcx>) -> String {
+        format!(
+            "{{{}}} -> {{{}}}",
+            self.base().to_short_string(repacker),
+            self.expansion(repacker)
+                .iter()
+                .map(|p| p.to_short_string(repacker))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    }
+}
+
 impl<'tcx> TryFrom<BorrowPCGExpansion<'tcx, LocalNode<'tcx>>>
     for BorrowPCGExpansion<'tcx, MaybeOldPlace<'tcx>>
 {