Rollup merge of #131730 - zlfn:master, r=tgross35

Refactor some `core::fmt` macros

While looking at the macros in `core::fmt`, find that the macros are not well organized. So I created a patch to fix it.

[`core/src/fmt/num.rs`](https://github.com/rust-lang/rust/blob/master/library/core/src/fmt/num.rs)
*  `impl_int!` and `impl_uint!` macro are **completly** same. It would be better to combine for readability
* `impl_int!` has a problem that the indenting is not uniform. It has unified into 4 spaces
* `debug` macro in `num` renamed to `impl_Debug`, And it was moved to a position close to the `impl_Display`.

[`core/src/fmt/float.rs`](https://github.com/rust-lang/rust/blob/master/library/core/src/fmt/float.rs)
[`core/src/fmt/nofloat.rs`](https://github.com/rust-lang/rust/blob/master/library/core/src/fmt/nofloat.rs)
* `floating` macro now receive multiple idents at once. It makes the code cleaner.
* Modified the panic message more clearly in fallback function of `cfg(no_fp_fmt_parse)`

library/core/src/fmt/float.rs

@@ -196,39 +196,40 @@ fn float_to_general_debug<T>(fmt: &mut Formatter<'_>, num: &T) -> Result
 }
 
 macro_rules! floating {
-    ($ty:ident) => {
+    ($($ty:ident)*) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
+        $(
-        impl Debug for $ty {
+            #[stable(feature = "rust1", since = "1.0.0")]
-            fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+            impl Debug for $ty {
-                float_to_general_debug(fmt, self)
+                fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+                    float_to_general_debug(fmt, self)
+                }
             }
-        }
 
-        #[stable(feature = "rust1", since = "1.0.0")]
+            #[stable(feature = "rust1", since = "1.0.0")]
-        impl Display for $ty {
+            impl Display for $ty {
-            fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+                fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
-                float_to_decimal_display(fmt, self)
+                    float_to_decimal_display(fmt, self)
+                }
             }
-        }
 
-        #[stable(feature = "rust1", since = "1.0.0")]
+            #[stable(feature = "rust1", since = "1.0.0")]
-        impl LowerExp for $ty {
+            impl LowerExp for $ty {
-            fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+                fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
-                float_to_exponential_common(fmt, self, false)
+                    float_to_exponential_common(fmt, self, false)
+                }
             }
-        }
 
-        #[stable(feature = "rust1", since = "1.0.0")]
+            #[stable(feature = "rust1", since = "1.0.0")]
-        impl UpperExp for $ty {
+            impl UpperExp for $ty {
-            fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
+                fn fmt(&self, fmt: &mut Formatter<'_>) -> Result {
-                float_to_exponential_common(fmt, self, true)
+                    float_to_exponential_common(fmt, self, true)
+                }
             }
-        }
+        )*
     };
 }
 
-floating! { f32 }
+floating! { f32 f64 }
-floating! { f64 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl Debug for f16 {

library/core/src/fmt/nofloat.rs

@@ -1,18 +1,17 @@
 use crate::fmt::{Debug, Formatter, Result};
 
 macro_rules! floating {
-    ($ty:ident) => {
+    ($($ty:ident)*) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
+        $(
-        impl Debug for $ty {
+            #[stable(feature = "rust1", since = "1.0.0")]
-            #[inline]
+            impl Debug for $ty {
-            fn fmt(&self, _fmt: &mut Formatter<'_>) -> Result {
+                #[inline]
-                panic!("floating point support is turned off");
+                fn fmt(&self, _fmt: &mut Formatter<'_>) -> Result {
+                    panic!("floating point fmt support is turned off");
+                }
             }
-        }
+        )*
     };
 }
 
-floating! { f16 }
+floating! { f16 f32 f64 f128 }
-floating! { f32 }
-floating! { f64 }
-floating! { f128 }

library/core/src/fmt/num.rs

@@ -20,33 +20,22 @@ trait DisplayInt:
 
 macro_rules! impl_int {
     ($($t:ident)*) => (
-      $(impl DisplayInt for $t {
+        $(impl DisplayInt for $t {
-          fn zero() -> Self { 0 }
+            fn zero() -> Self { 0 }
-          fn from_u8(u: u8) -> Self { u as Self }
+            fn from_u8(u: u8) -> Self { u as Self }
-          fn to_u8(&self) -> u8 { *self as u8 }
+            fn to_u8(&self) -> u8 { *self as u8 }
-          #[cfg(not(any(target_pointer_width = "64", target_arch = "wasm32")))]
+            #[cfg(not(any(target_pointer_width = "64", target_arch = "wasm32")))]
-          fn to_u32(&self) -> u32 { *self as u32 }
+            fn to_u32(&self) -> u32 { *self as u32 }
-          fn to_u64(&self) -> u64 { *self as u64 }
+            fn to_u64(&self) -> u64 { *self as u64 }
-          fn to_u128(&self) -> u128 { *self as u128 }
+            fn to_u128(&self) -> u128 { *self as u128 }
-      })*
+        })*
-    )
-}
-macro_rules! impl_uint {
-    ($($t:ident)*) => (
-      $(impl DisplayInt for $t {
-          fn zero() -> Self { 0 }
-          fn from_u8(u: u8) -> Self { u as Self }
-          fn to_u8(&self) -> u8 { *self as u8 }
-          #[cfg(not(any(target_pointer_width = "64", target_arch = "wasm32")))]
-          fn to_u32(&self) -> u32 { *self as u32 }
-          fn to_u64(&self) -> u64 { *self as u64 }
-          fn to_u128(&self) -> u128 { *self as u128 }
-      })*
     )
 }
 
-impl_int! { i8 i16 i32 i64 i128 isize }
+impl_int! {
-impl_uint! { u8 u16 u32 u64 u128 usize }
+    i8 i16 i32 i64 i128 isize
+    u8 u16 u32 u64 u128 usize
+}
 
 /// A type that represents a specific radix
 ///
@@ -178,26 +167,25 @@ macro_rules! integer {
 integer! { i32, u32 }
 integer! { i64, u64 }
 integer! { i128, u128 }
-macro_rules! debug {
+
-    ($($T:ident)*) => {$(
+macro_rules! impl_Debug {
-        #[stable(feature = "rust1", since = "1.0.0")]
+    ($($T:ident)*) => {
-        impl fmt::Debug for $T {
+        $(
-            #[inline]
+            #[stable(feature = "rust1", since = "1.0.0")]
-            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            impl fmt::Debug for $T {
-                if f.debug_lower_hex() {
+                #[inline]
-                    fmt::LowerHex::fmt(self, f)
+                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                } else if f.debug_upper_hex() {
+                    if f.debug_lower_hex() {
-                    fmt::UpperHex::fmt(self, f)
+                        fmt::LowerHex::fmt(self, f)
-                } else {
+                    } else if f.debug_upper_hex() {
-                    fmt::Display::fmt(self, f)
+                        fmt::UpperHex::fmt(self, f)
+                    } else {
+                        fmt::Display::fmt(self, f)
+                    }
                 }
             }
-        }
+        )*
-    )*};
+    };
-}
-debug! {
-  i8 i16 i32 i64 i128 isize
-  u8 u16 u32 u64 u128 usize
 }
 
 // 2 digit decimal look up table
@@ -521,6 +509,11 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     };
 }
 
+impl_Debug! {
+    i8 i16 i32 i64 i128 isize
+    u8 u16 u32 u64 u128 usize
+}
+
 // Include wasm32 in here since it doesn't reflect the native pointer size, and
 // often cares strongly about getting a smaller code size.
 #[cfg(any(target_pointer_width = "64", target_arch = "wasm32"))]