[squashme] fix tests

- we cannot define `new_{display,debug,noop_debug,...}` in a macro
  because the macro name leaks out in compilation errors arising from
  formatting macros.
- amazingly, this changes the known miscompilation in
  rust-lang#107975 - formatting no longer
  changes the result of pointer comparison.

Author: tamird

library/core/src/fmt/rt.rs

@@ -62,34 +62,31 @@ pub struct Argument<'a> {
     ty: ArgumentType<'a>,
 }
 
-macro_rules! define_argument_constructor {
-    ($method:ident, $trait:ident, $fmt:item) => {
-        #[inline]
-        pub fn $method<T: $trait>(x: &T) -> Argument<'_> {
-            #[repr(transparent)]
-            struct Wrapper<T>(T);
-
-            // SAFETY: `Wrapper<T>` has the same memory layout as `T` due to #[repr(transparent)].
-            let thunk = unsafe { mem::transmute::<&T, &Wrapper<T>>(x) };
-
-            impl<T: $trait> FormatThunk for Wrapper<T> {
-                #[inline]
-                $fmt
-            }
+macro_rules! implement_argument_constructor {
+    ($trait:ident, $operand:expr, $fmt:item) => {{
+        #[repr(transparent)]
+        struct Wrapper<T>(T);
+
+        // SAFETY: `Wrapper<T>` has the same memory layout as `T` due to #[repr(transparent)].
+        let thunk = unsafe { mem::transmute::<&T, &Wrapper<T>>($operand) };
 
-            Self::new(thunk)
+        impl<T: $trait> FormatThunk for Wrapper<T> {
+            #[inline]
+            $fmt
         }
-    };
 
-    ($method:ident, $trait:ident) => {
-        define_argument_constructor!(
-            $method,
+        Self::new(thunk)
+    }};
+
+    ($trait:ident, $operand:expr) => {
+        implement_argument_constructor!(
             $trait,
+            $operand,
             fn fmt(&self, f: &mut Formatter<'_>) -> Result {
                 let Self(inner) = self;
                 inner.fmt(f)
             }
-        );
+        )
     };
 }
 
@@ -100,22 +97,52 @@ impl Argument<'_> {
         Argument { ty: ArgumentType::Placeholder(x) }
     }
 
-    define_argument_constructor!(new_display, Display);
-    define_argument_constructor!(new_debug, Debug);
-    define_argument_constructor!(
-        new_debug_noop,
-        Debug,
-        fn fmt(&self, _: &mut Formatter<'_>) -> Result {
-            Ok(())
-        }
-    );
-    define_argument_constructor!(new_octal, Octal);
-    define_argument_constructor!(new_lower_hex, LowerHex);
-    define_argument_constructor!(new_upper_hex, UpperHex);
-    define_argument_constructor!(new_pointer, Pointer);
-    define_argument_constructor!(new_binary, Binary);
-    define_argument_constructor!(new_lower_exp, LowerExp);
-    define_argument_constructor!(new_upper_exp, UpperExp);
+    #[inline]
+    pub fn new_display<T: Display>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(Display, x)
+    }
+    #[inline]
+    pub fn new_debug<T: Debug>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(Debug, x)
+    }
+    #[inline]
+    pub fn new_debug_noop<T: Debug>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(
+            Debug,
+            x,
+            fn fmt(&self, _: &mut Formatter<'_>) -> Result {
+                Ok(())
+            }
+        )
+    }
+    #[inline]
+    pub fn new_octal<T: Octal>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(Octal, x)
+    }
+    #[inline]
+    pub fn new_lower_hex<T: LowerHex>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(LowerHex, x)
+    }
+    #[inline]
+    pub fn new_upper_hex<T: UpperHex>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(UpperHex, x)
+    }
+    #[inline]
+    pub fn new_pointer<T: Pointer>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(Pointer, x)
+    }
+    #[inline]
+    pub fn new_binary<T: Binary>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(Binary, x)
+    }
+    #[inline]
+    pub fn new_lower_exp<T: LowerExp>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(LowerExp, x)
+    }
+    #[inline]
+    pub fn new_upper_exp<T: UpperExp>(x: &T) -> Argument<'_> {
+        implement_argument_constructor!(UpperExp, x)
+    }
 
     #[inline]
     #[track_caller]

tests/ui/codegen/equal-pointers-unequal/as-cast/basic.rs

@@ -16,6 +16,6 @@ fn main() {
     assert_ne!(a, b);
     // But they are the same number.
     assert_eq!(format!("{a}"), format!("{b}"));
-    // And they are equal.
-    assert_eq!(a, b);
+    // And they are still not equal.
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/as-cast/function.rs

@@ -17,6 +17,6 @@ fn main() {
     assert_ne!(a, b);
     // But they are the same number.
     assert_eq!(format!("{a}"), format!("{b}"));
-    // And they are equal.
-    assert_eq!(a, b);
+    // And they are still not equal.
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/as-cast/print.rs

@@ -16,5 +16,5 @@ fn main() {
 
     assert_ne!(a, b);
     println!("{a}"); // or b
-    assert_eq!(a, b);
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/exposed-provenance/basic.rs

@@ -18,6 +18,6 @@ fn main() {
     assert_ne!(a, b);
     // But they are the same number.
     assert_eq!(format!("{a}"), format!("{b}"));
-    // And they are equal.
-    assert_eq!(a, b);
+    // And they are still not equal.
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/exposed-provenance/function.rs

@@ -19,6 +19,6 @@ fn main() {
     assert_ne!(a, b);
     // But they are the same number.
     assert_eq!(format!("{a}"), format!("{b}"));
-    // And they are equal.
-    assert_eq!(a, b);
+    // And they are still not equal.
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/exposed-provenance/print.rs

@@ -18,5 +18,5 @@ fn main() {
 
     assert_ne!(a, b);
     println!("{a}"); // or b
-    assert_eq!(a, b);
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/strict-provenance/basic.rs

@@ -18,6 +18,6 @@ fn main() {
     assert_ne!(a, b);
     // But they are the same number.
     assert_eq!(format!("{a}"), format!("{b}"));
-    // And they are equal.
-    assert_eq!(a, b);
+    // And they are still not equal.
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/strict-provenance/function.rs

@@ -19,6 +19,6 @@ fn main() {
     assert_ne!(a, b);
     // But they are the same number.
     assert_eq!(format!("{a}"), format!("{b}"));
-    // And they are equal.
-    assert_eq!(a, b);
+    // And they are still not equal.
+    assert_ne!(a, b);
 }

tests/ui/codegen/equal-pointers-unequal/strict-provenance/print.rs

@@ -18,5 +18,5 @@ fn main() {
 
     assert_ne!(a, b);
     println!("{a}"); // or b
-    assert_eq!(a, b);
+    assert_ne!(a, b);
 }