Update MIRI comment and fix test in stage2

Author: Centri3

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -531,11 +531,10 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                     )?;
                 }
             }
-            // The name of this intrinsic is actually misleading. It actually
-            // represents whether the value is known to the optimizer (LLVM).
-            // The value of `arg`, while known to the machine, should be
-            // considered unknown to the optimizer as we haven't gotten to the
-            // codegen stage or ran any sort of optimizations yet.
+            // The intrinsic represents whether the value is known to the optimizer (LLVM).
+            // We're not doing any optimizations here, so there is no optimizer that could know the value.
+            // (We know the value here in the machine of course, but this is the runtime of that code,
+            // not the optimization stage.)
             sym::is_val_statically_known => ecx.write_scalar(Scalar::from_bool(false), dest)?,
             _ => {
                 throw_unsup_format!(

compiler/rustc_hir_analysis/messages.ftl

@@ -178,8 +178,6 @@ hir_analysis_invalid_union_field =
 hir_analysis_invalid_union_field_sugg =
     wrap the field type in `ManuallyDrop<...>`
 
-hir_analysis_is_constant_zst = parameter for `is_constant` cannot be zero-sized
-
 hir_analysis_late_bound_const_in_apit = `impl Trait` can only mention const parameters from an fn or impl
     .label = const parameter declared here
 

tests/codegen/is_val_statically_known.rs

@@ -9,39 +9,39 @@ pub enum B {
 }
 
 #[inline]
-pub fn tuple_struct(a: A) -> i32 {
+pub fn _u32(a: u32) -> i32 {
     if unsafe { is_val_statically_known(a) } { 1 } else { 0 }
 }
 
-// CHECK-LABEL: @tuple_struct_true(
+// CHECK-LABEL: @_u32_true(
 #[no_mangle]
-pub fn tuple_struct_true() -> i32 {
+pub fn _u32_true() -> i32 {
     // CHECK: ret i32 1
-    tuple_struct(A(1))
+    _u32(1)
 }
 
-// CHECK-LABEL: @tuple_struct_false(
+// CHECK-LABEL: @_u32_false(
 #[no_mangle]
-pub fn tuple_struct_false(a: A) -> i32 {
+pub fn _u32_false(a: u32) -> i32 {
     // CHECK: ret i32 0
-    tuple_struct(a)
+    _u32(a)
 }
 
 #[inline]
-pub fn r#enum(b: B) -> i32 {
+pub fn _bool(b: bool) -> i32 {
     if unsafe { is_val_statically_known(b) } { 3 } else { 2 }
 }
 
-// CHECK-LABEL: @enum_true(
+// CHECK-LABEL: @_bool_true(
 #[no_mangle]
-pub fn enum_true() -> i32 {
+pub fn _bool_true() -> i32 {
     // CHECK: ret i32 3
-    r#enum(B::Ye(2))
+    _bool(true)
 }
 
-// CHECK-LABEL: @enum_false(
+// CHECK-LABEL: @_bool_false(
 #[no_mangle]
-pub fn enum_false(b: B) -> i32 {
+pub fn _bool_false(b: bool) -> i32 {
     // CHECK: ret i32 2
-    r#enum(b)
+    _bool(b)
 }

tests/codegen/pow_of_two.rs

@@ -1,6 +1,5 @@
 // compile-flags: --crate-type=lib
 
-// CHECK: @b = unnamed_addr alias i64 (i32), ptr @a
 // CHECK-LABEL: @a(
 #[no_mangle]
 pub fn a(exp: u32) -> u64 {
@@ -11,6 +10,7 @@ pub fn a(exp: u32) -> u64 {
     2u64.pow(exp)
 }
 
+// This is sometimes an alias to `a`, but this isn't guaranteed
 #[no_mangle]
 pub fn b(exp: u32) -> i64 {
     2i64.pow(exp)