Better support for arrays

zgrannan · zgrannan · commit 0662535c0b72 · 2025-02-19T07:12:37.000-08:00
diff --git a/src/borrows/borrow_pcg_expansion.rs b/src/borrows/borrow_pcg_expansion.rs
@@ -140,10 +140,11 @@ impl<'tcx> BorrowExpansion<'tcx> {
             BorrowExpansion::Fields(fields) => {
                 assert!(fields.len() <= 1024, "Too many fields: {:?}", fields);
                 fields
-                .iter()
-                .sorted_by_key(|(idx, _)| *idx)
-                .map(|(idx, ty)| PlaceElem::Field(*idx, *ty))
-                .collect()},
+                    .iter()
+                    .sorted_by_key(|(idx, _)| *idx)
+                    .map(|(idx, ty)| PlaceElem::Field(*idx, *ty))
+                    .collect()
+            }
             BorrowExpansion::Deref => vec![PlaceElem::Deref],
             BorrowExpansion::Downcast(symbol, variant_idx) => {
                 vec![PlaceElem::Downcast(*symbol, *variant_idx)]
diff --git a/src/borrows/borrows_graph/aliases.rs b/src/borrows/borrows_graph/aliases.rs
@@ -79,7 +79,7 @@ impl<'tcx> BorrowsGraph<'tcx> {
                     for blocked in blocked_nodes {
                         if seen.insert(blocked) {
                             let blocked_node = egraph.add(get_node(blocked, place_ids));
-                            add_to_egraph(blocked_node, blocking_node, edge, egraph);
+                            add_to_egraph(blocked_node, blocking_node, edge, egraph, repacker);
                             collect_nodes_up(graph, blocked, egraph, seen, place_ids, repacker);
                         }
                     }
@@ -109,22 +109,36 @@ impl<'tcx> BorrowsGraph<'tcx> {
             RPRelType::Unknown
         }
 
-        fn add_to_egraph(
+        fn add_to_egraph<'mir, 'tcx>(
             blocked_node: Id,
             blocking_node: Id,
-            edge: BorrowPCGEdgeRef<'_, '_>,
+            edge: BorrowPCGEdgeRef<'tcx, '_>,
             egraph: &mut EGraph<EggPcgNode, ()>,
+            repacker: PlaceRepacker<'mir, 'tcx>,
         ) {
             match edge.kind() {
+                BorrowPCGEdgeKind::RegionProjectionMember(member)
+                    if member.is_toplevel(repacker) =>
+                {
+                    match member.kind {
+                        RegionProjectionMemberKind::BorrowOutlives => {
+                            record_deref(blocked_node, blocking_node, egraph);
+                        }
+                        RegionProjectionMemberKind::DerefBorrowOutlives => {
+                            record_deref(blocking_node, blocked_node, egraph);
+                        }
+                        _ => unreachable!(),
+                    }
+                }
                 BorrowPCGEdgeKind::BorrowPCGExpansion(expansion) => match expansion {
                     BorrowPCGExpansion::FromOwned(_) => {
-                        record_deref(blocked_node, blocking_node, egraph)
+                        // record_deref(blocked_node, blocking_node, egraph)
                     }
                     BorrowPCGExpansion::FromBorrow(e) => {
                         if e.expansion.is_deref() {
-                            record_deref(blocked_node, blocking_node, egraph);
+                            // record_deref(blocked_node, blocking_node, egraph);
                         } else {
-                            egraph.union(blocked_node, blocking_node);
+                            // egraph.union(blocked_node, blocking_node);
                         }
                     }
                 },
@@ -149,7 +163,7 @@ impl<'tcx> BorrowsGraph<'tcx> {
                     let node: PCGNode<'tcx> = blocking.into();
                     if seen.insert(node) {
                         let blocking_id = egraph.add(get_node(node, place_ids));
-                        add_to_egraph(blocking_id, blocked_id, edge, egraph);
+                        add_to_egraph(blocking_id, blocked_id, edge, egraph, repacker);
                         collect_nodes_down(graph, node, egraph, seen, place_ids, repacker);
                     }
                 }
@@ -256,15 +270,15 @@ fn main() {
         let temp: mir::Place<'_> = mir::Local::from(4 as usize).into();
         let star_temp = temp.project_deeper(&[mir::ProjectionElem::Deref], tcx);
         let repacker = PlaceRepacker::new(&body.body, tcx);
-        // check_all_statements(&body.body, &mut pcg, |location, stmt| {
-        //     assert!(
-        //         !stmt
-        //             .aliases(star_temp.into(), repacker)
-        //             .contains(&temp.into()),
-        //         "Bad alias for {:?}",
-        //         location
-        //     );
-        // });
+        check_all_statements(&body.body, &mut pcg, |location, stmt| {
+            assert!(
+                !stmt
+                    .aliases(star_temp.into(), repacker)
+                    .contains(&temp.into()),
+                "Bad alias for {:?}",
+                location
+            );
+        });
     });
 
     let input = r#"
diff --git a/src/borrows/borrows_visitor.rs b/src/borrows/borrows_visitor.rs
@@ -323,6 +323,11 @@ impl<'tcx, 'mir, 'state> BorrowsVisitor<'tcx, 'mir, 'state> {
         location: Location,
         kind: impl Fn(usize) -> RegionProjectionMemberKind,
     ) {
+        tracing::info!(
+            "Connect outliving projections {:?} -> {:?}",
+            source_proj,
+            target
+        );
         for (idx, target_proj) in target
             .region_projections(self.repacker)
             .into_iter()
@@ -332,6 +337,11 @@ impl<'tcx, 'mir, 'state> BorrowsVisitor<'tcx, 'mir, 'state> {
                 source_proj.region(self.repacker),
                 target_proj.region(self.repacker),
             ) {
+                tracing::info!(
+                    "Adding region projection member {:?} -> {:?}",
+                    source_proj,
+                    target_proj
+                );
                 self.apply_action(BorrowPCGAction::add_region_projection_member(
                     RegionProjectionMember::new(
                         smallvec![source_proj.into()],
@@ -362,11 +372,12 @@ impl<'tcx, 'mir, 'state> BorrowsVisitor<'tcx, 'mir, 'state> {
                 }
                 match rvalue {
                     Rvalue::Aggregate(
-                        box (AggregateKind::Adt(..) | AggregateKind::Tuple),
+                        box (AggregateKind::Adt(..) | AggregateKind::Tuple | AggregateKind::Array(..)),
                         fields,
                     ) => {
                         let target: utils::Place<'tcx> = (*target).into();
                         for field in fields.iter() {
+                            tracing::info!("Field {:?}", field);
                             let operand_place: utils::Place<'tcx> =
                                 if let Some(place) = field.place() {
                                     place.into()
diff --git a/src/borrows/region_projection_member.rs b/src/borrows/region_projection_member.rs
@@ -11,7 +11,9 @@ use crate::utils::PlaceRepacker;
 
 use super::borrow_pcg_edge::{BlockedNode, LocalNode};
 use super::edge_data::EdgeData;
+use super::region_projection::MaybeRemoteRegionProjectionBase;
 use super::{has_pcs_elem::HasPcsElems, region_projection::RegionProjection};
+use crate::rustc_interface::middle::ty;
 use crate::utils::json::ToJsonWithRepacker;
 
 pub(crate) type RegionProjectionMemberInputs<'tcx> = SmallVec<[PCGNode<'tcx>; 8]>;
@@ -144,6 +146,33 @@ impl<'tcx> HasPcsElems<MaybeOldPlace<'tcx>> for RegionProjectionMember<'tcx> {
 }
 
 impl<'tcx> RegionProjectionMember<'tcx> {
+    pub(crate) fn is_toplevel(&self, repacker: PlaceRepacker<'_, 'tcx>) -> bool {
+        match self.kind {
+            RegionProjectionMemberKind::BorrowOutlives
+            | RegionProjectionMemberKind::DerefBorrowOutlives => {
+                match (self.inputs[0], self.outputs[0]) {
+                    (PCGNode::RegionProjection(rp1), PCGNode::RegionProjection(rp2)) => {
+                        match (rp1.place(), rp2.place()) {
+                            (
+                                MaybeRemoteRegionProjectionBase::Place(p1),
+                                MaybeOldPlace::Current { place: p2 },
+                            ) => match (p1.ty(repacker).ty.kind(), p2.ty(repacker).ty.kind()) {
+                                (ty::TyKind::Ref(r1, ..), ty::TyKind::Ref(r2, ..)) => {
+                                    rp1.region(repacker) == (*r1).into()
+                                        && rp2.region(repacker) == (*r2).into()
+                                }
+                                _ => false,
+                            },
+                            _ => false,
+                        }
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            _ => false,
+        }
+    }
+
     /// Returns `true` iff the lifetime projections are mutable
     pub(crate) fn mutability(&self, repacker: PlaceRepacker<'_, 'tcx>) -> Mutability {
         let mut_values = self
diff --git a/src/visualization/graph_constructor.rs b/src/visualization/graph_constructor.rs
@@ -19,7 +19,7 @@ use crate::{
 use super::{dot_graph::DotSubgraph, Graph, GraphEdge, GraphNode, NodeId, NodeType};
 use crate::borrows::edge::abstraction::AbstractionType;
 use crate::borrows::edge::kind::BorrowPCGEdgeKind;
-use crate::rustc_interface::middle::ty::{self, TyCtxt};
+use crate::rustc_interface::middle::ty::TyCtxt;
 use crate::utils::place::maybe_old::MaybeOldPlace;
 use crate::utils::place::maybe_remote::MaybeRemotePlace;
 use crate::utils::place::remote::RemotePlace;
diff --git a/test-files/50_flowistry_pointer_deep.rs b/test-files/50_flowistry_pointer_deep.rs
@@ -0,0 +1,9 @@
+fn foo() {
+    let x = 1;
+    let y = &&&x;
+    let a = ***y;
+}
+
+fn main(){
+
+}
diff --git a/test-files/57_slice_ptr_elem_write.rs b/test-files/57_slice_ptr_elem_write.rs
@@ -0,0 +1,6 @@
+fn main() {
+    let mut x = 1;
+    let y = [&mut x];
+    *y[0] = 0;
+    x;
+}
