Make some diagnostics behave consistently

Author: oli-obk

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -608,14 +608,8 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
                 if place.layout.is_unsized() {
                     self.check_wide_ptr_meta(place.meta(), place.layout)?;
                 }
-                if self.ref_tracking.is_some()
-                    && let Some(alloc_id) = place.ptr().provenance.and_then(|p| p.get_alloc_id())
-                    && let AllocKind::Dead = self.ecx.get_alloc_info(alloc_id).2
-                {
-                    throw_validation_failure!(
-                        self.path,
-                        DanglingPtrUseAfterFree { ptr_kind: PointerKind::Ref(Mutability::Not) }
-                    )
+                if let Some(ref_tracking) = &mut self.ref_tracking {
+                    self.ecx.track_relocation(place.ptr(), ref_tracking, &self.path, None)
                 }
                 Ok(true)
             }
@@ -993,6 +987,17 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // Construct a visitor
         let mut visitor = ValidityVisitor { path, ref_tracking, ctfe_mode, ecx: self };
 
+        if visitor.ref_tracking.is_some()
+            && let Left(place) = op.as_mplace_or_imm()
+            && let Some(alloc_id) = place.ptr().provenance.and_then(|p| p.get_alloc_id())
+            && let AllocKind::Dead = self.get_alloc_info(alloc_id).2
+        {
+            throw_validation_failure!(
+                visitor.path,
+                DanglingPtrUseAfterFree { ptr_kind: PointerKind::Ref(Mutability::Not) }
+            )
+        }
+
         // Run it.
         match self.run_for_validation(|| visitor.visit_value(op)) {
             Ok(()) => Ok(visitor.path),
@@ -1050,33 +1055,40 @@ impl<'mir, 'tcx> InterpCx<'mir, 'tcx, crate::const_eval::CompileTimeInterpreter<
             && let Some((_, alloc)) = self.memory.alloc_map().get(&prov.alloc_id())
         {
             for &(offset, prov) in alloc.provenance().ptrs().iter() {
-                if let AllocKind::Dead = self.get_alloc_info(prov.alloc_id()).2 {
-                    throw_validation_failure!(
-                        path,
-                        DanglingPtrUseAfterFree { ptr_kind: PointerKind::Ref(Mutability::Not) }
-                    )
-                } else {
-                    let ptr = Pointer::new(Some(prov), Size::ZERO);
-                    let ty = self.tcx.types.unit;
-                    let layout = self.layout_of(ty).unwrap();
-                    let op = self.ptr_to_mplace(ptr, layout);
-                    ref_tracking.track(op, || {
-                        // We need to clone the path anyway, make sure it gets created
-                        // with enough space for the additional `Deref`.
-                        let mut new_path = Vec::with_capacity(path.len() + 1);
-                        new_path.extend(path.iter().copied());
-                        new_path.push(PathElem::Offset(offset));
-                        new_path.push(PathElem::Deref);
-                        new_path
-                    })
-                }
+                let ptr = Pointer::new(Some(prov), Size::ZERO);
+                self.track_relocation(ptr, ref_tracking, &path, Some(offset));
             }
         }
         Ok(())
     }
 }
 
 impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
+    fn track_relocation(
+        &self,
+        ptr: Pointer<Option<M::Provenance>>,
+        ref_tracking: &mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Vec<PathElem>>,
+        path: &Vec<PathElem>,
+        offset: Option<Size>,
+    ) {
+        let ty = self.tcx.types.unit;
+        let layout = self.layout_of(ty).unwrap();
+        let op = self.ptr_to_mplace(ptr, layout);
+        ref_tracking.track(op, || {
+            // We need to clone the path anyway, make sure it gets created
+            // with enough space for the additional `Deref`.
+            let mut new_path = Vec::with_capacity(path.len() + 1);
+            new_path.extend(path.iter().copied());
+            if let Some(offset) = offset
+                && offset != Size::ZERO
+            {
+                new_path.push(PathElem::Offset(offset));
+            }
+            new_path.push(PathElem::Deref);
+            new_path
+        })
+    }
+
     /// This function checks the data at `op` to be runtime-valid.
     /// `op` is assumed to cover valid memory if it is an indirect operand.
     /// It will error if the bits at the destination do not match the ones described by the layout.

tests/ui/consts/const-mut-refs/mut_ref_in_final_dynamic_check.stderr

@@ -35,7 +35,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/mut_ref_in_final_dynamic_check.rs:36:1
    |
 LL | const DANGLING: Option<&mut i32> = helper_dangling();
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-tag>: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -46,7 +46,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/mut_ref_in_final_dynamic_check.rs:37:1
    |
 LL | static DANGLING_STATIC: Option<&mut i32> = helper_dangling();
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-tag>: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-variant(Some)>.0: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {

tests/ui/consts/dangling_raw_ptr.stderr

@@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/dangling_raw_ptr.rs:6:1
    |
 LL | const FOO: *const u32 = {
-   | ^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -13,7 +13,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/dangling_raw_ptr.rs:15:1
    |
 LL | const BAR: Union = {
-   | ^^^^^^^^^^^^^^^^ constructing invalid value: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^ constructing invalid value at .<offset(0)>.<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -24,7 +24,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/dangling_raw_ptr.rs:20:1
    |
 LL | const BAZ: Union = {
-   | ^^^^^^^^^^^^^^^^ constructing invalid value at .<offset(0)>.<deref>: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^ constructing invalid value at .<offset(0)>.<deref>.<offset(0)>.<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -35,7 +35,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/dangling_raw_ptr.rs:25:1
    |
 LL | const FOOMP: *const u32 = {
-   | ^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<offset(0)>.<deref>: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>.<offset(0)>.<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {

tests/ui/consts/std/cell.stderr

@@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/cell.rs:11:1
    |
 LL | static FOO: Wrap<*mut u32> = Wrap(Cell::new(42).as_ptr());
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0.<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -13,7 +13,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/cell.rs:13:1
    |
 LL | const FOO_CONST: Wrap<*mut u32> = Wrap(Cell::new(42).as_ptr());
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0.<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -24,7 +24,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/cell.rs:27:1
    |
 LL | const FOO4_CONST: Wrap<*mut u32> = Wrap(FOO3_CONST.0.as_ptr());
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .0.<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
@@ -35,7 +35,7 @@ error[E0080]: it is undefined behavior to use this value
   --> $DIR/cell.rs:32:1
    |
 LL | const FOO2: *mut u32 = Cell::new(42).as_ptr();
-   | ^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered a dangling reference (use-after-free)
+   | ^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>: encountered a dangling reference (use-after-free)
    |
    = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
    = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {