Better pretty printing for const raw pointers

src/librustc/ty/print/pretty.rs

@@ -864,6 +864,49 @@ pub trait PrettyPrinter<'tcx>:
 
         let u8 = self.tcx().types.u8;
 
+        if let ty::Ref(_, ref_ty, _) = ct.ty.kind {
+            let byte_str = match (ct.val, &ref_ty.kind) {
+                (ConstValue::Scalar(Scalar::Ptr(ptr)), ty::Array(t, n)) if *t == u8 => {
+                    let n = n.eval_usize(self.tcx(), ty::ParamEnv::empty());
+                    Some(self.tcx()
+                        .alloc_map.lock()
+                        .unwrap_memory(ptr.alloc_id)
+                        .get_bytes(&self.tcx(), ptr, Size::from_bytes(n)).unwrap())
+                },
+                (ConstValue::Slice { data, start, end }, ty::Slice(t)) if *t == u8 => {
+                    // The `inspect` here is okay since we checked the bounds, and there are
+                    // no relocations (we have an active slice reference here). We don't use
+                    // this result to affect interpreter execution.
+                    Some(data.inspect_with_undef_and_ptr_outside_interpreter(start..end))
+                },
+                _ => None,
+            };
+
+            if let Some(byte_str) = byte_str {
+                p!(write("b\""));
+                for &c in byte_str {
+                    for e in std::ascii::escape_default(c) {
+                        self.write_char(e as char)?;
+                    }
+                }
+                p!(write("\""));
+                return Ok(self);
+            }
+
+            if let (ConstValue::Slice { data, start, end }, ty::Str) =
+                (ct.val, &ref_ty.kind)
+            {
+                // The `inspect` here is okay since we checked the bounds, and there are no
+                // relocations (we have an active `str` reference here). We don't use this
+                // result to affect interpreter execution.
+                let slice = data.inspect_with_undef_and_ptr_outside_interpreter(start..end);
+                let s = ::std::str::from_utf8(slice)
+                    .expect("non utf8 str from miri");
+                p!(write("{:?}", s));
+                return Ok(self);
+            }
+        };
+
         match (ct.val, &ct.ty.kind) {
             (_,  ty::FnDef(did, substs)) => p!(print_value_path(*did, substs)),
             (ConstValue::Unevaluated(did, substs), _) => {
@@ -919,7 +962,16 @@ pub trait PrettyPrinter<'tcx>:
             },
             (ConstValue::Scalar(Scalar::Raw { data, .. }), ty::Char) =>
                 p!(write("{:?}", ::std::char::from_u32(data as u32).unwrap())),
-            (ConstValue::Scalar(_), ty::RawPtr(_)) => p!(write("{{pointer}}")),
+            (ConstValue::Scalar(value), ty::Ref(..)) |
+            (ConstValue::Scalar(value), ty::RawPtr(_)) => {
+                match value {
+                    Scalar::Raw { data, size } => {
+                        p!(write("0x{:01$x} : ", data, size as usize * 2));
+                    }
+                    _ => p!(write("{{pointer}} : "))
+                };
+                p!(print(ct.ty));
+            }
             (ConstValue::Scalar(Scalar::Ptr(ptr)), ty::FnPtr(_)) => {
                 let instance = {
                     let alloc_map = self.tcx().alloc_map.lock();
@@ -928,54 +980,8 @@ pub trait PrettyPrinter<'tcx>:
                 p!(print_value_path(instance.def_id(), instance.substs));
             },
             _ => {
-                let printed = if let ty::Ref(_, ref_ty, _) = ct.ty.kind {
-                    let byte_str = match (ct.val, &ref_ty.kind) {
-                        (ConstValue::Scalar(Scalar::Ptr(ptr)), ty::Array(t, n)) if *t == u8 => {
-                            let n = n.eval_usize(self.tcx(), ty::ParamEnv::empty());
-                            Some(self.tcx()
-                                .alloc_map.lock()
-                                .unwrap_memory(ptr.alloc_id)
-                                .get_bytes(&self.tcx(), ptr, Size::from_bytes(n)).unwrap())
-                        },
-                        (ConstValue::Slice { data, start, end }, ty::Slice(t)) if *t == u8 => {
-                            // The `inspect` here is okay since we checked the bounds, and there are
-                            // no relocations (we have an active slice reference here). We don't use
-                            // this result to affect interpreter execution.
-                            Some(data.inspect_with_undef_and_ptr_outside_interpreter(start..end))
-                        },
-                        _ => None,
-                    };
-
-                    if let Some(byte_str) = byte_str {
-                        p!(write("b\""));
-                        for &c in byte_str {
-                            for e in std::ascii::escape_default(c) {
-                                self.write_char(e as char)?;
-                            }
-                        }
-                        p!(write("\""));
-                        true
-                    } else if let (ConstValue::Slice { data, start, end }, ty::Str) =
-                        (ct.val, &ref_ty.kind)
-                    {
-                        // The `inspect` here is okay since we checked the bounds, and there are no
-                        // relocations (we have an active `str` reference here). We don't use this
-                        // result to affect interpreter execution.
-                        let slice = data.inspect_with_undef_and_ptr_outside_interpreter(start..end);
-                        let s = ::std::str::from_utf8(slice)
-                            .expect("non utf8 str from miri");
-                        p!(write("{:?}", s));
-                        true
-                    } else {
-                        false
-                    }
-                } else {
-                    false
-                };
-                if !printed {
-                    // fallback
-                    p!(write("{:?} : ", ct.val), print(ct.ty))
-                }
+                // fallback
+                p!(write("{:?} : ", ct.val), print(ct.ty))
             }
         };
         Ok(self)

src/test/mir-opt/const_prop/const_prop_fails_gracefully.rs

@@ -23,9 +23,9 @@ fn main() {
 // START rustc.main.ConstProp.after.mir
 //  bb0: {
 //      ...
-//      _4 = const Scalar(AllocId(1).0x0) : &i32;
-//      _3 = const Scalar(AllocId(1).0x0) : &i32;
-//      _2 = const Scalar(AllocId(1).0x0) : *const i32;
+//      _4 = const {pointer} : &i32;
+//      _3 = const {pointer} : &i32;
+//      _2 = const {pointer} : *const i32;
 //      ...
 //      _1 = move _2 as usize (Misc);
 //      ...

src/test/mir-opt/const_prop/ref_deref.rs

@@ -14,7 +14,7 @@ fn main() {
 // START rustc.main.ConstProp.after.mir
 // bb0: {
 //     ...
-//     _2 = const Scalar(AllocId(0).0x0) : &i32;
+//     _2 = const {pointer} : &i32;
 //     _1 = const 4i32;
 //     ...
 // }

src/test/mir-opt/const_prop/slice_len.rs

@@ -24,8 +24,8 @@ fn main() {
 // START rustc.main.ConstProp.after.mir
 //  bb0: {
 //      ...
-//      _4 = const Scalar(AllocId(0).0x0) : &[u32; 3];
-//      _3 = const Scalar(AllocId(0).0x0) : &[u32; 3];
+//      _4 = const {pointer} : &[u32; 3];
+//      _3 = const {pointer} : &[u32; 3];
 //      _2 = move _3 as &[u32] (Pointer(Unsize));
 //      ...
 //      _6 = const 1usize;

src/test/ui/const-generics/int-as-ref-const-param.rs

@@ -0,0 +1,26 @@
+// normalize-stderr-32bit: "0x" -> "$$PREFIX"
+// normalize-stderr-64bit: "0x00000000" -> "$$PREFIX"
+
+#![feature(const_generics, const_compare_raw_pointers)]
+//~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
+
+struct Const<const P: &'static ()>;
+
+#[repr(C)]
+union Transmuter {
+    pointer: *const (),
+    reference: &'static (),
+}
+
+fn main() {
+    const A: &'static () = {
+        unsafe { Transmuter { pointer: 10 as *const () }.reference }
+    };
+    const B: &'static () = {
+        unsafe { Transmuter { pointer: 11 as *const () }.reference }
+    };
+
+    let _: Const<{A}> = Const::<{B}>; //~ mismatched types
+    let _: Const<{A}> = Const::<{&()}>; //~ mismatched types
+    let _: Const<{A}> = Const::<{A}>;
+}

src/test/ui/const-generics/int-as-ref-const-param.stderr

@@ -0,0 +1,29 @@
+warning: the feature `const_generics` is incomplete and may cause the compiler to crash
+  --> $DIR/int-as-ref-const-param.rs:4:12
+   |
+LL | #![feature(const_generics, const_compare_raw_pointers)]
+   |            ^^^^^^^^^^^^^^
+   |
+   = note: `#[warn(incomplete_features)]` on by default
+
+error[E0308]: mismatched types
+  --> $DIR/int-as-ref-const-param.rs:23:25
+   |
+LL |     let _: Const<{A}> = Const::<{B}>;
+   |                         ^^^^^^^^^^^^ expected `$PREFIX0000000a : &()`, found `$PREFIX0000000b : &()`
+   |
+   = note: expected type `Const<$PREFIX0000000a : &()>`
+              found type `Const<$PREFIX0000000b : &()>`
+
+error[E0308]: mismatched types
+  --> $DIR/int-as-ref-const-param.rs:24:25
+   |
+LL |     let _: Const<{A}> = Const::<{&()}>;
+   |                         ^^^^^^^^^^^^^^ expected `$PREFIX0000000a : &()`, found `{pointer} : &()`
+   |
+   = note: expected type `Const<$PREFIX0000000a : &()>`
+              found type `Const<{pointer} : &()>`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.

src/test/ui/const-generics/raw-ptr-const-param.rs

@@ -1,3 +1,6 @@
+// normalize-stderr-32bit: "0x" -> "$$PREFIX"
+// normalize-stderr-64bit: "0x00000000" -> "$$PREFIX"
+
 #![feature(const_generics, const_compare_raw_pointers)]
 //~^ WARN the feature `const_generics` is incomplete and may cause the compiler to crash
 
@@ -6,4 +9,6 @@ struct Const<const P: *const u32>;
 fn main() {
     let _: Const<{15 as *const _}> = Const::<{10 as *const _}>; //~ mismatched types
     let _: Const<{10 as *const _}> = Const::<{10 as *const _}>;
+
+    let _: Const<{10 as *const _}> = Const::<{&8_u32 as *const _}>; //~ mismatched types
 }

src/test/ui/const-generics/raw-ptr-const-param.stderr

@@ -1,20 +1,29 @@
 warning: the feature `const_generics` is incomplete and may cause the compiler to crash
-  --> $DIR/raw-ptr-const-param.rs:1:12
+  --> $DIR/raw-ptr-const-param.rs:4:12
    |
 LL | #![feature(const_generics, const_compare_raw_pointers)]
    |            ^^^^^^^^^^^^^^
    |
    = note: `#[warn(incomplete_features)]` on by default
 
 error[E0308]: mismatched types
-  --> $DIR/raw-ptr-const-param.rs:7:38
+  --> $DIR/raw-ptr-const-param.rs:10:38
    |
 LL |     let _: Const<{15 as *const _}> = Const::<{10 as *const _}>;
-   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `{pointer}`, found `{pointer}`
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `$PREFIX0000000f : *const u32`, found `$PREFIX0000000a : *const u32`
    |
-   = note: expected type `Const<{pointer}>`
-              found type `Const<{pointer}>`
+   = note: expected type `Const<$PREFIX0000000f : *const u32>`
+              found type `Const<$PREFIX0000000a : *const u32>`
 
-error: aborting due to previous error
+error[E0308]: mismatched types
+  --> $DIR/raw-ptr-const-param.rs:13:38
+   |
+LL |     let _: Const<{10 as *const _}> = Const::<{&8_u32 as *const _}>;
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `$PREFIX0000000a : *const u32`, found `{pointer} : *const u32`
+   |
+   = note: expected type `Const<$PREFIX0000000a : *const u32>`
+              found type `Const<{pointer} : *const u32>`
+
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.