(c2rust-analyze) Replace AnalysisCtxt::const_ref_{tys: HashMap<ConstantKind, LTy> => locs: Vec<Location> that indexes into rvalue_tys, which actually stores the LTys.

Author: kkysen

c2rust-analyze/src/context.rs

@@ -10,8 +10,8 @@ use bitflags::bitflags;
 use rustc_hir::def_id::DefId;
 use rustc_index::vec::IndexVec;
 use rustc_middle::mir::{
-    Body, CastKind, ConstantKind, Field, HasLocalDecls, Local, LocalDecls, Location, Operand,
-    Place, PlaceElem, PlaceRef, Rvalue,
+    Body, CastKind, Field, HasLocalDecls, Local, LocalDecls, Location, Operand, Place, PlaceElem,
+    PlaceRef, Rvalue,
 };
 use rustc_middle::ty::adjustment::PointerCast;
 use rustc_middle::ty::{self, AdtDef, FieldDef, Ty, TyCtxt, TyKind};
@@ -66,10 +66,6 @@ impl PermissionSet {
             panic!("expected an array, str, or primitive type: {ty:?}");
         }
     }
-
-    pub fn for_const_ref(constant: ConstantKind) -> Self {
-        Self::for_const_ref_ty(constant.ty())
-    }
 }
 
 bitflags! {
@@ -118,15 +114,18 @@ pub struct AnalysisCtxt<'a, 'tcx> {
     /// those `PointerId`s consistent, the `Rvalue`'s type must be stored rather than recomputed on
     /// the fly.
     pub rvalue_tys: HashMap<Location, LTy<'tcx>>,
-    pub const_ref_tys: HashMap<ConstantKind<'tcx>, LTy<'tcx>>,
+
+    /// [`Location`]s of const ref [`rvalue_tys`](Self::rvalue_tys).
+    pub const_ref_locs: Vec<Location>,
+
     next_ptr_id: NextLocalPointerId,
 }
 
 pub struct AnalysisCtxtData<'tcx> {
     local_tys: IndexVec<Local, LTy<'tcx>>,
     addr_of_local: IndexVec<Local, PointerId>,
     rvalue_tys: HashMap<Location, LTy<'tcx>>,
-    const_ref_tys: HashMap<ConstantKind<'tcx>, LTy<'tcx>>,
+    const_ref_locs: Vec<Location>,
     next_ptr_id: NextLocalPointerId,
 }
 
@@ -219,7 +218,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
             c_void_casts: CVoidCasts::new(mir, tcx),
             addr_of_local: IndexVec::new(),
             rvalue_tys: HashMap::new(),
-            const_ref_tys: HashMap::new(),
+            const_ref_locs: Default::default(),
             next_ptr_id: NextLocalPointerId::new(),
         }
     }
@@ -233,7 +232,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
             local_tys,
             addr_of_local,
             rvalue_tys,
-            const_ref_tys,
+            const_ref_locs,
             next_ptr_id,
         } = data;
         AnalysisCtxt {
@@ -243,7 +242,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
             c_void_casts: CVoidCasts::default(),
             addr_of_local,
             rvalue_tys,
-            const_ref_tys,
+            const_ref_locs,
             next_ptr_id,
         }
     }
@@ -253,7 +252,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
             local_tys: self.local_tys,
             addr_of_local: self.addr_of_local,
             rvalue_tys: self.rvalue_tys,
-            const_ref_tys: self.const_ref_tys,
+            const_ref_locs: self.const_ref_locs,
             next_ptr_id: self.next_ptr_id,
         }
     }
@@ -442,13 +441,13 @@ impl<'tcx> AnalysisCtxtData<'tcx> {
         map: PointerTable<PointerId>,
         counter: NextLocalPointerId,
     ) {
-        let AnalysisCtxtData {
-            ref mut local_tys,
-            ref mut addr_of_local,
-            ref mut rvalue_tys,
-            ref mut const_ref_tys,
-            ref mut next_ptr_id,
-        } = *self;
+        let Self {
+            local_tys,
+            addr_of_local,
+            rvalue_tys,
+            const_ref_locs: _,
+            next_ptr_id,
+        } = self;
 
         for lty in local_tys {
             *lty = remap_lty_pointers(lcx, &map, lty);
@@ -464,10 +463,6 @@ impl<'tcx> AnalysisCtxtData<'tcx> {
             *lty = remap_lty_pointers(lcx, &map, lty);
         }
 
-        for lty in const_ref_tys.values_mut() {
-            *lty = remap_lty_pointers(lcx, &map, lty);
-        }
-
         *next_ptr_id = counter;
     }
 
@@ -533,13 +528,7 @@ impl<'tcx> TypeOf<'tcx> for Operand<'tcx> {
     fn type_of(&self, acx: &AnalysisCtxt<'_, 'tcx>) -> LTy<'tcx> {
         match *self {
             Operand::Move(pl) | Operand::Copy(pl) => acx.type_of(pl),
-            Operand::Constant(ref c) => {
-                let c = &**c;
-                match acx.const_ref_tys.get(&c.literal) {
-                    Some(lty) => lty,
-                    None => label_no_pointers(acx, c.ty()),
-                }
-            }
+            Operand::Constant(ref c) => label_no_pointers(acx, c.ty()),
         }
     }
 }

c2rust-analyze/src/dataflow/type_check.rs

@@ -465,9 +465,12 @@ pub fn visit<'tcx>(
         equiv_constraints: Vec::new(),
     };
 
-    for (&constant, const_lty) in &acx.const_ref_tys {
-        tc.constraints
-            .add_all_perms(const_lty.label, PermissionSet::for_const_ref(constant));
+    for loc in &acx.const_ref_locs {
+        let const_ref_lty = acx.rvalue_tys[loc];
+        tc.constraints.add_all_perms(
+            const_ref_lty.label,
+            PermissionSet::for_const_ref_ty(const_ref_lty.ty),
+        );
     }
 
     for (bb, bb_data) in mir.basic_blocks().iter_enumerated() {

c2rust-analyze/src/main.rs

@@ -454,7 +454,6 @@ fn run(tcx: TyCtxt) {
             assert_eq!(local, l);
         }
 
-        let mut const_ref_tys = HashMap::new();
         for (bb, bb_data) in mir.basic_blocks().iter_enumerated() {
             for (i, stmt) in bb_data.statements.iter().enumerate() {
                 let (_, rv) = match &stmt.kind {
@@ -496,13 +495,11 @@ fn run(tcx: TyCtxt) {
                             // The [`Constant`] is an inline value and thus local to this function,
                             // as opposed to a global, named `const`s, for example.
                             // This might miss local, named `const`s,
-                            const_ref_tys
-                                .entry(c.literal)
-                                .or_insert_with(|| acx.assign_pointer_ids(ty));
+                            acx.assign_pointer_ids(ty)
                         } else {
                             // TODO: Handle global, named `const`s.
+                            continue;
                         }
-                        continue;
                     }
                     _ => continue,
                 };
@@ -513,8 +510,6 @@ fn run(tcx: TyCtxt) {
                 acx.rvalue_tys.insert(loc, lty);
             }
         }
-        assert!(acx.const_ref_tys.is_empty());
-        acx.const_ref_tys = const_ref_tys;
 
         // Compute local equivalence classes and dataflow constraints.
         let (dataflow, equiv_constraints) = dataflow::generate_constraints(&acx, &mir);
@@ -625,9 +620,10 @@ fn run(tcx: TyCtxt) {
         let mut asn = gasn.and(&mut info.lasn);
         info.dataflow.propagate_cell(&mut asn);
 
-        for (&constant, const_lty) in &acx.const_ref_tys {
-            let ptr_id = const_lty.label;
-            let expected_perms = PermissionSet::for_const_ref(constant);
+        for loc in &acx.const_ref_locs {
+            let const_ref_lty = acx.rvalue_tys[loc];
+            let ptr_id = const_ref_lty.label;
+            let expected_perms = PermissionSet::for_const_ref_ty(const_ref_lty.ty);
             let mut actual_perms = asn.perms()[ptr_id];
             // Ignore `UNIQUE` as it gets automatically added to all permissions
             // and then removed later if it can't apply.