rename MemoryKind::Heap to ConstHeap; bless test

Author: vn-ki

compiler/rustc_mir/src/interpret/intern.rs

@@ -104,7 +104,10 @@ fn intern_shallow<'rt, 'mir, 'tcx, M: CompileTimeMachine<'mir, 'tcx>>(
     // This match is just a canary for future changes to `MemoryKind`, which most likely need
     // changes in this function.
     match kind {
-        MemoryKind::Stack | MemoryKind::Heap | MemoryKind::Vtable | MemoryKind::CallerLocation => {}
+        MemoryKind::Stack
+        | MemoryKind::ConstHeap
+        | MemoryKind::Vtable
+        | MemoryKind::CallerLocation => {}
     }
     // Set allocation mutability as appropriate. This is used by LLVM to put things into
     // read-only memory, and also by Miri when evaluating other globals that

compiler/rustc_mir/src/interpret/intrinsics.rs

@@ -347,8 +347,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                     Err(err) => throw_ub_format!("align has to be a power of 2, {}", err),
                 };
 
-                let ptr =
-                    self.memory.allocate(Size::from_bytes(size as u64), align, MemoryKind::Heap);
+                let ptr = self.memory.allocate(
+                    Size::from_bytes(size as u64),
+                    align,
+                    MemoryKind::ConstHeap,
+                );
                 self.write_scalar(Scalar::Ptr(ptr), dest)?;
             }
             sym::offset => {

compiler/rustc_mir/src/interpret/memory.rs

@@ -28,7 +28,7 @@ pub enum MemoryKind<T> {
     /// Stack memory. Error if deallocated except during a stack pop.
     Stack,
     /// Heap memory.
-    Heap,
+    ConstHeap,
     /// Memory backing vtables. Error if ever deallocated.
     Vtable,
     /// Memory allocated by `caller_location` intrinsic. Error if ever deallocated.
@@ -42,7 +42,7 @@ impl<T: MayLeak> MayLeak for MemoryKind<T> {
     fn may_leak(self) -> bool {
         match self {
             MemoryKind::Stack => false,
-            MemoryKind::Heap => false,
+            MemoryKind::ConstHeap => false,
             MemoryKind::Vtable => true,
             MemoryKind::CallerLocation => true,
             MemoryKind::Machine(k) => k.may_leak(),
@@ -54,7 +54,7 @@ impl<T: fmt::Display> fmt::Display for MemoryKind<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             MemoryKind::Stack => write!(f, "stack variable"),
-            MemoryKind::Heap => write!(f, "heap allocation"),
+            MemoryKind::ConstHeap => write!(f, "heap allocation"),
             MemoryKind::Vtable => write!(f, "vtable"),
             MemoryKind::CallerLocation => write!(f, "caller location"),
             MemoryKind::Machine(m) => write!(f, "{}", m),

src/test/ui/consts/const-eval/erroneous-const.rs

@@ -9,11 +9,11 @@ impl<T> PrintName<T> {
 
 const fn no_codegen<T>() {
     if false {
-        let _ = PrintName::<T>::VOID; //~ERROR evaluation of constant value failed
+        let _ = PrintName::<T>::VOID; //~ERROR could not evaluate static initializer
     }
 }
 
-pub static FOO: () = no_codegen::<i32>(); //~ERROR could not evaluate static initializer
+pub static FOO: () = no_codegen::<i32>();
 
 fn main() {
     FOO

src/test/ui/consts/const-eval/heap/alloc_intrinsic_nontransient_fail.rs

@@ -1,11 +1,11 @@
-// run-pass
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 #![feature(const_raw_ptr_deref)]
 #![feature(const_mut_refs)]
 use std::intrinsics;
 
-const FOO: &i32 = foo();
+const FOO: *const i32 = foo();
+//~^ ERROR untyped pointers are not allowed in constant
 
 const fn foo() -> &'static i32 {
     let t = unsafe {
@@ -16,5 +16,4 @@ const fn foo() -> &'static i32 {
     unsafe { &*t }
 }
 fn main() {
-    assert_eq!(*FOO, 20)
 }

src/test/ui/consts/const-eval/heap/alloc_intrinsic_nontransient_fail.stderr

@@ -0,0 +1,8 @@
+error: untyped pointers are not allowed in constant
+  --> $DIR/alloc_intrinsic_nontransient_fail.rs:7:1
+   |
+LL | const FOO: *const i32 = foo();
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+

src/test/ui/consts/const-eval/unwind-abort.rs

@@ -2,7 +2,7 @@
 
 #[unwind(aborts)]
 const fn foo() {
-    panic!() //~ 5:13: any use of this value will cause an error [const_err]
+    panic!() //~ ERROR any use of this value will cause an error [const_err]
 }
 
 const _: () = foo();

src/test/ui/consts/uninhabited-const-issue-61744.rs

@@ -1,7 +1,7 @@
 // build-fail
 
 pub const unsafe fn fake_type<T>() -> T {
-    hint_unreachable() //~ 4:23: any use of this value will cause an error [const_err]
+    hint_unreachable() //~ ERROR any use of this value will cause an error [const_err]
 }
 
 pub const unsafe fn hint_unreachable() -> ! {

src/test/ui/infinite/infinite-recursion-const-fn.rs

@@ -1,7 +1,7 @@
 //https://github.com/rust-lang/rust/issues/31364
 
 const fn a() -> usize {
-    b() //~ 4:8: evaluation of constant value failed [E0080]
+    b() //~ ERROR evaluation of constant value failed [E0080]
 }
 const fn b() -> usize {
     a()