(c2rust-analyze) Restrict const_tys => const_ref_tys to just ty::Ref, as non-refs work fine on their own.

Author: kkysen

c2rust-analyze/src/context.rs

@@ -98,15 +98,15 @@ 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_tys: HashMap<ConstantKind<'tcx>, LTy<'tcx>>,
+    pub const_ref_tys: HashMap<ConstantKind<'tcx>, LTy<'tcx>>,
     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_tys: HashMap<ConstantKind<'tcx>, LTy<'tcx>>,
+    const_ref_tys: HashMap<ConstantKind<'tcx>, LTy<'tcx>>,
     next_ptr_id: NextLocalPointerId,
 }
 
@@ -199,7 +199,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
             c_void_casts: CVoidCasts::new(mir, tcx),
             addr_of_local: IndexVec::new(),
             rvalue_tys: HashMap::new(),
-            const_tys: HashMap::new(),
+            const_ref_tys: HashMap::new(),
             next_ptr_id: NextLocalPointerId::new(),
         }
     }
@@ -213,7 +213,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
             local_tys,
             addr_of_local,
             rvalue_tys,
-            const_tys,
+            const_ref_tys,
             next_ptr_id,
         } = data;
         AnalysisCtxt {
@@ -223,7 +223,7 @@ impl<'a, 'tcx> AnalysisCtxt<'a, 'tcx> {
             c_void_casts: CVoidCasts::default(),
             addr_of_local,
             rvalue_tys,
-            const_tys,
+            const_ref_tys,
             next_ptr_id,
         }
     }
@@ -233,7 +233,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_tys: self.const_tys,
+            const_ref_tys: self.const_ref_tys,
             next_ptr_id: self.next_ptr_id,
         }
     }
@@ -426,7 +426,7 @@ impl<'tcx> AnalysisCtxtData<'tcx> {
             ref mut local_tys,
             ref mut addr_of_local,
             ref mut rvalue_tys,
-            ref mut const_tys,
+            ref mut const_ref_tys,
             ref mut next_ptr_id,
         } = *self;
 
@@ -444,7 +444,7 @@ impl<'tcx> AnalysisCtxtData<'tcx> {
             *lty = remap_lty_pointers(lcx, &map, lty);
         }
 
-        for lty in const_tys.values_mut() {
+        for lty in const_ref_tys.values_mut() {
             *lty = remap_lty_pointers(lcx, &map, lty);
         }
 
@@ -515,7 +515,7 @@ impl<'tcx> TypeOf<'tcx> for Operand<'tcx> {
             Operand::Move(pl) | Operand::Copy(pl) => acx.type_of(pl),
             Operand::Constant(ref c) => {
                 let c = &**c;
-                match acx.const_tys.get(&c.literal) {
+                match acx.const_ref_tys.get(&c.literal) {
                     Some(lty) => lty,
                     None => label_no_pointers(acx, c.ty()),
                 }

c2rust-analyze/src/main.rs

@@ -454,7 +454,7 @@ fn run(tcx: TyCtxt) {
             assert_eq!(local, l);
         }
 
-        let mut const_tys = HashMap::new();
+        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 {
@@ -492,11 +492,11 @@ fn run(tcx: TyCtxt) {
                     }
                     Rvalue::Use(Operand::Constant(c)) => {
                         // Constants can include, for example, `""` and `b""` string literals.
-                        if let ConstantKind::Val(_, ty) = c.literal {
+                        if let ConstantKind::Val(_, ty) = c.literal && ty.is_ref() {
                             // 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_tys
+                            const_ref_tys
                                 .entry(c.literal)
                                 .or_insert_with(|| acx.assign_pointer_ids(ty));
                         } else {
@@ -513,8 +513,8 @@ fn run(tcx: TyCtxt) {
                 acx.rvalue_tys.insert(loc, lty);
             }
         }
-        assert!(acx.const_tys.is_empty());
-        acx.const_tys = const_tys;
+        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);