Make #[debug_format] an attribute in newtype_index

Noratrieb · Noratrieb · commit d679764fb6b8 · 2022-12-18T21:37:38.000+01:00
This removes the `custom` format functionality as its only user was
trivially migrated to using a normal format.

If a new use case for a custom formatting impl pops up, you can add it
back.
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -2555,8 +2555,8 @@ pub enum AttrStyle {
 
 rustc_index::newtype_index! {
     #[custom_encodable]
+    #[debug_format = "AttrId({})]"]
     pub struct AttrId {
-        DEBUG_FORMAT = "AttrId({})"
     }
 }
 
diff --git a/compiler/rustc_ast/src/node_id.rs b/compiler/rustc_ast/src/node_id.rs
@@ -8,8 +8,8 @@ rustc_index::newtype_index! {
     /// This is later turned into [`DefId`] and `HirId` for the HIR.
     ///
     /// [`DefId`]: rustc_span::def_id::DefId
+    #[debug_format = "NodeId({})"]
     pub struct NodeId {
-        DEBUG_FORMAT = "NodeId({})"
     }
 }
 
diff --git a/compiler/rustc_borrowck/src/constraints/mod.rs b/compiler/rustc_borrowck/src/constraints/mod.rs
@@ -115,13 +115,13 @@ impl<'tcx> fmt::Debug for OutlivesConstraint<'tcx> {
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "OutlivesConstraintIndex({})"]
     pub struct OutlivesConstraintIndex {
-        DEBUG_FORMAT = "OutlivesConstraintIndex({})"
     }
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "ConstraintSccIndex({})"]
     pub struct ConstraintSccIndex {
-        DEBUG_FORMAT = "ConstraintSccIndex({})"
     }
 }
diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs
@@ -108,8 +108,8 @@ impl_visitable! {
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "bw{}"]
     pub struct BorrowIndex {
-        DEBUG_FORMAT = "bw{}"
     }
 }
 
diff --git a/compiler/rustc_borrowck/src/location.rs b/compiler/rustc_borrowck/src/location.rs
@@ -20,8 +20,8 @@ pub struct LocationTable {
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "LocationIndex({})"]
     pub struct LocationIndex {
-        DEBUG_FORMAT = "LocationIndex({})"
     }
 }
 
diff --git a/compiler/rustc_borrowck/src/member_constraints.rs b/compiler/rustc_borrowck/src/member_constraints.rs
@@ -55,8 +55,8 @@ pub(crate) struct NllMemberConstraint<'tcx> {
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "MemberConstraintIndex({})"]
     pub(crate) struct NllMemberConstraintIndex {
-        DEBUG_FORMAT = "MemberConstraintIndex({})"
     }
 }
 
diff --git a/compiler/rustc_borrowck/src/region_infer/values.rs b/compiler/rustc_borrowck/src/region_infer/values.rs
@@ -90,12 +90,14 @@ impl RegionValueElements {
 rustc_index::newtype_index! {
     /// A single integer representing a `Location` in the MIR control-flow
     /// graph. Constructed efficiently from `RegionValueElements`.
-    pub struct PointIndex { DEBUG_FORMAT = "PointIndex({})" }
+    #[debug_format = "PointIndex({})"]
+    pub struct PointIndex {}
 }
 
 rustc_index::newtype_index! {
     /// A single integer representing a `ty::Placeholder`.
-    pub struct PlaceholderIndex { DEBUG_FORMAT = "PlaceholderIndex({})" }
+    #[debug_format = "PlaceholderIndex({})"]
+    pub struct PlaceholderIndex {}
 }
 
 /// An individual element in a region value -- the value of a
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
@@ -4,14 +4,14 @@ use rustc_index::vec::IndexVec;
 use rustc_middle::ty::error::TypeError;
 
 rustc_index::newtype_index! {
+    #[debug_format = "ExpectedIdx({})"]
     pub(crate) struct ExpectedIdx {
-        DEBUG_FORMAT = "ExpectedIdx({})",
     }
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "ProvidedIdx({})"]
     pub(crate) struct ProvidedIdx {
-        DEBUG_FORMAT = "ProvidedIdx({})",
     }
 }
 
diff --git a/compiler/rustc_hir_typeck/src/generator_interior/drop_ranges/mod.rs b/compiler/rustc_hir_typeck/src/generator_interior/drop_ranges/mod.rs
@@ -96,14 +96,14 @@ fn for_each_consumable<'tcx>(hir: Map<'tcx>, place: TrackedValue, mut f: impl Fn
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "id({})"]
     pub struct PostOrderId {
-        DEBUG_FORMAT = "id({})",
     }
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "hidx({})"]
     pub struct TrackedValueIndex {
-        DEBUG_FORMAT = "hidx({})",
     }
 }
 
diff --git a/compiler/rustc_infer/src/infer/region_constraints/leak_check.rs b/compiler/rustc_infer/src/infer/region_constraints/leak_check.rs
@@ -357,14 +357,14 @@ impl<'tcx> SccUniverse<'tcx> {
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "LeakCheckNode({})"]
     struct LeakCheckNode {
-        DEBUG_FORMAT = "LeakCheckNode({})"
     }
 }
 
 rustc_index::newtype_index! {
+    #[debug_format = "LeakCheckScc({})"]
     struct LeakCheckScc {
-        DEBUG_FORMAT = "LeakCheckScc({})"
     }
 }
 
diff --git a/compiler/rustc_macros/src/newtype.rs b/compiler/rustc_macros/src/newtype.rs
@@ -3,22 +3,6 @@ use quote::quote;
 use syn::parse::*;
 use syn::*;
 
-mod kw {
-    syn::custom_keyword!(DEBUG_FORMAT);
-    syn::custom_keyword!(MAX);
-    syn::custom_keyword!(custom);
-}
-
-#[derive(Debug)]
-enum DebugFormat {
-    // The user will provide a custom `Debug` impl, so we shouldn't generate
-    // one
-    Custom,
-    // Use the specified format string in the generated `Debug` impl
-    // By default, this is "{}"
-    Format(String),
-}
-
 // We parse the input and emit the output in a single step.
 // This field stores the final macro output
 struct Newtype(TokenStream);
@@ -35,7 +19,7 @@ impl Parse for Newtype {
 
         // Any additional `#[derive]` macro paths to apply
         let mut derive_paths: Vec<Path> = Vec::new();
-        let mut debug_format: Option<DebugFormat> = None;
+        let mut debug_format: Option<Lit> = None;
         let mut max = None;
         let mut consts = Vec::new();
         let mut encodable = true;
@@ -65,7 +49,18 @@ impl Parse for Newtype {
                     };
 
                     if let Some(old) = max.replace(literal.lit) {
-                        panic!("Specified multiple MAX: {:?}", old);
+                        panic!("Specified multiple max: {:?}", old);
+                    }
+
+                    false
+                }
+                "debug_format" => {
+                    let Ok(Meta::NameValue(literal) )= attr.parse_meta() else {
+                        panic!("#[debug_format = FMT] attribute requires a format");
+                    };
+
+                    if let Some(old) = debug_format.replace(literal.lit) {
+                        panic!("Specified multiple debug format options: {:?}", old);
                     }
 
                     false
@@ -79,23 +74,6 @@ impl Parse for Newtype {
             body.parse::<Token![..]>()?;
         } else {
             loop {
-                if body.lookahead1().peek(kw::DEBUG_FORMAT) {
-                    body.parse::<kw::DEBUG_FORMAT>()?;
-                    body.parse::<Token![=]>()?;
-                    let new_debug_format = if body.lookahead1().peek(kw::custom) {
-                        body.parse::<kw::custom>()?;
-                        DebugFormat::Custom
-                    } else {
-                        let format_str: LitStr = body.parse()?;
-                        DebugFormat::Format(format_str.value())
-                    };
-                    try_comma()?;
-                    if let Some(old) = debug_format.replace(new_debug_format) {
-                        panic!("Specified multiple debug format options: {:?}", old);
-                    }
-                    continue;
-                }
-
                 // We've parsed everything that the user provided, so we're done
                 if body.is_empty() {
                     break;
@@ -112,7 +90,9 @@ impl Parse for Newtype {
             }
         }
 
-        let debug_format = debug_format.unwrap_or(DebugFormat::Format("{}".to_string()));
+        let debug_format =
+            debug_format.unwrap_or_else(|| Lit::Str(LitStr::new("{}", Span::call_site())));
+
         // shave off 256 indices at the end to allow space for packing these indices into enums
         let max = max.unwrap_or_else(|| Lit::Int(LitInt::new("0xFFFF_FF00", Span::call_site())));
 
@@ -167,18 +147,14 @@ impl Parse for Newtype {
             quote! {}
         };
 
-        let debug_impl = match debug_format {
-            DebugFormat::Custom => quote! {},
-            DebugFormat::Format(format) => {
-                quote! {
-                    impl ::std::fmt::Debug for #name {
-                        fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
-                            write!(fmt, #format, self.as_u32())
-                        }
-                    }
+        let debug_impl = quote! {
+            impl ::std::fmt::Debug for #name {
+                fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                    write!(fmt, #debug_format, self.as_u32())
                 }
             }
         };
+
         let spec_partial_eq_impl = if let Lit::Int(max) = &max {
             if let Ok(max_val) = max.base10_parse::<u32>() {
                 quote! {
diff --git a/compiler/rustc_middle/src/mir/coverage.rs b/compiler/rustc_middle/src/mir/coverage.rs
@@ -12,8 +12,8 @@ rustc_index::newtype_index! {
     /// constant value of `0`.
     #[derive(HashStable)]
     #[max = 0xFFFF_FFFF]
+    #[debug_format = "ExpressionOperandId({})"]
     pub struct ExpressionOperandId {
-        DEBUG_FORMAT = "ExpressionOperandId({})",
     }
 }
 
@@ -34,8 +34,8 @@ impl ExpressionOperandId {
 rustc_index::newtype_index! {
     #[derive(HashStable)]
     #[max = 0xFFFF_FFFF]
+    #[debug_format = "CounterValueReference({})"]
     pub struct CounterValueReference {
-        DEBUG_FORMAT = "CounterValueReference({})",
     }
 }
 
@@ -58,8 +58,8 @@ rustc_index::newtype_index! {
     /// Values descend from u32::MAX.
     #[derive(HashStable)]
     #[max = 0xFFFF_FFFF]
+    #[debug_format = "InjectedExpressionId({})"]
     pub struct InjectedExpressionId {
-        DEBUG_FORMAT = "InjectedExpressionId({})",
     }
 }
 
@@ -69,8 +69,8 @@ rustc_index::newtype_index! {
     /// Values ascend from 0.
     #[derive(HashStable)]
     #[max = 0xFFFF_FFFF]
+    #[debug_format = "InjectedExpressionIndex({})"]
     pub struct InjectedExpressionIndex {
-        DEBUG_FORMAT = "InjectedExpressionIndex({})",
     }
 }
 
@@ -80,8 +80,8 @@ rustc_index::newtype_index! {
     /// "mapgen" process. They cannot be computed algorithmically, from the other `newtype_index`s.
     #[derive(HashStable)]
     #[max = 0xFFFF_FFFF]
+    #[debug_format = "MappedExpressionIndex({})"]
     pub struct MappedExpressionIndex {
-        DEBUG_FORMAT = "MappedExpressionIndex({})",
     }
 }
 
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
@@ -655,8 +655,8 @@ impl SourceInfo {
 
 rustc_index::newtype_index! {
     #[derive(HashStable)]
+    #[debug_format = "_{}"]
     pub struct Local {
-        DEBUG_FORMAT = "_{}",
         const RETURN_PLACE = 0,
     }
 }
@@ -1147,8 +1147,8 @@ rustc_index::newtype_index! {
     /// [`CriticalCallEdges`]: ../../rustc_const_eval/transform/add_call_guards/enum.AddCallGuards.html#variant.CriticalCallEdges
     /// [guide-mir]: https://rustc-dev-guide.rust-lang.org/mir/
     #[derive(HashStable)]
+    #[debug_format = "bb{}"]
     pub struct BasicBlock {
-        DEBUG_FORMAT = "bb{}",
         const START_BLOCK = 0,
     }
 }
@@ -1531,8 +1531,8 @@ rustc_index::newtype_index! {
     /// [CFG]: https://rustc-dev-guide.rust-lang.org/appendix/background.html#cfg
     /// [mir-datatypes]: https://rustc-dev-guide.rust-lang.org/mir/index.html#mir-data-types
     #[derive(HashStable)]
+    #[debug_format = "field[{}]"]
     pub struct Field {
-        DEBUG_FORMAT = "field[{}]"
     }
 }
 
@@ -1758,8 +1758,8 @@ impl Debug for Place<'_> {
 
 rustc_index::newtype_index! {
     #[derive(HashStable)]
+    #[debug_format = "scope[{}]"]
     pub struct SourceScope {
-        DEBUG_FORMAT = "scope[{}]",
         const OUTERMOST_SOURCE_SCOPE = 0,
     }
 }
@@ -2756,8 +2756,8 @@ impl<'tcx> TypeVisitable<'tcx> for UserTypeProjection {
 
 rustc_index::newtype_index! {
     #[derive(HashStable)]
+    #[debug_format = "promoted[{}]"]
     pub struct Promoted {
-        DEBUG_FORMAT = "promoted[{}]"
     }
 }
 
diff --git a/compiler/rustc_middle/src/mir/query.rs b/compiler/rustc_middle/src/mir/query.rs
@@ -131,8 +131,8 @@ pub struct UnsafetyCheckResult {
 
 rustc_index::newtype_index! {
     #[derive(HashStable)]
+    #[debug_format = "_{}"]
     pub struct GeneratorSavedLocal {
-        DEBUG_FORMAT = "_{}",
     }
 }
 
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
@@ -35,8 +35,8 @@ macro_rules! thir_with_elements {
         $(
             newtype_index! {
                 #[derive(HashStable)]
+                #[debug_format = $format]
                 pub struct $id {
-                    DEBUG_FORMAT = $format
                 }
             }
         )*
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -99,12 +99,6 @@ impl<'tcx> fmt::Debug for ty::ConstVid<'tcx> {
     }
 }
 
-impl fmt::Debug for ty::RegionVid {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "'_#{}r", self.index())
-    }
-}
-
 impl<'tcx> fmt::Debug for ty::TraitRef<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         with_no_trimmed_paths!(fmt::Display::fmt(self, f))
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
@@ -1378,8 +1378,8 @@ pub struct ConstVid<'tcx> {
 rustc_index::newtype_index! {
     /// A **region** (lifetime) **v**ariable **ID**.
     #[derive(HashStable)]
+    #[debug_format = "'_#{}r"]
     pub struct RegionVid {
-        DEBUG_FORMAT = custom,
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -609,8 +609,8 @@ impl<'a, V> LocalTableInContextMut<'a, V> {
 
 rustc_index::newtype_index! {
     #[derive(HashStable)]
+    #[debug_format = "UserType({})"]
     pub struct UserTypeAnnotationIndex {
-        DEBUG_FORMAT = "UserType({})",
         const START_INDEX = 0,
     }
 }
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/mod.rs b/compiler/rustc_mir_dataflow/src/move_paths/mod.rs
diff --git a/compiler/rustc_mir_transform/src/coverage/graph.rs b/compiler/rustc_mir_transform/src/coverage/graph.rs
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
diff --git a/compiler/rustc_span/src/def_id.rs b/compiler/rustc_span/src/def_id.rs
diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -2555,8 +2555,8 @@ pub enum AttrStyle {`
`2555`	`2555`
`2556`	`2556`	`rustc_index::newtype_index! {`
`2557`	`2557`	`#[custom_encodable]`
	`2558`	`+ #[debug_format = "AttrId({})]"]`
`2558`	`2559`	`pub struct AttrId {`
`2559`		`- DEBUG_FORMAT = "AttrId({})"`
`2560`	`2560`	`}`
`2561`	`2561`	`}`
`2562`	`2562`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ rustc_index::newtype_index! {`
`8`	`8`	/// This is later turned into [`DefId`] and `HirId` for the HIR.
`9`	`9`	`///`
`10`	`10`	/// [`DefId`]: rustc_span::def_id::DefId
	`11`	`+ #[debug_format = "NodeId({})"]`
`11`	`12`	`pub struct NodeId {`
`12`		`- DEBUG_FORMAT = "NodeId({})"`
`13`	`13`	`}`
`14`	`14`	`}`
`15`	`15`
Original file line number	Diff line number	Diff line change
`@@ -115,13 +115,13 @@ impl<'tcx> fmt::Debug for OutlivesConstraint<'tcx> {`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`rustc_index::newtype_index! {`
	`118`	`+ #[debug_format = "OutlivesConstraintIndex({})"]`
`118`	`119`	`pub struct OutlivesConstraintIndex {`
`119`		`- DEBUG_FORMAT = "OutlivesConstraintIndex({})"`
`120`	`120`	`}`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`rustc_index::newtype_index! {`
	`124`	`+ #[debug_format = "ConstraintSccIndex({})"]`
`124`	`125`	`pub struct ConstraintSccIndex {`
`125`		`- DEBUG_FORMAT = "ConstraintSccIndex({})"`
`126`	`126`	`}`
`127`	`127`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,8 +108,8 @@ impl_visitable! {`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`rustc_index::newtype_index! {`
	`111`	`+ #[debug_format = "bw{}"]`
`111`	`112`	`pub struct BorrowIndex {`
`112`		`- DEBUG_FORMAT = "bw{}"`
`113`	`113`	`}`
`114`	`114`	`}`
`115`	`115`
Original file line number	Diff line number	Diff line change
`@@ -20,8 +20,8 @@ pub struct LocationTable {`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`rustc_index::newtype_index! {`
	`23`	`+ #[debug_format = "LocationIndex({})"]`
`23`	`24`	`pub struct LocationIndex {`
`24`		`- DEBUG_FORMAT = "LocationIndex({})"`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
Original file line number	Diff line number	Diff line change
`@@ -55,8 +55,8 @@ pub(crate) struct NllMemberConstraint<'tcx> {`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`rustc_index::newtype_index! {`
	`58`	`+ #[debug_format = "MemberConstraintIndex({})"]`
`58`	`59`	`pub(crate) struct NllMemberConstraintIndex {`
`59`		`- DEBUG_FORMAT = "MemberConstraintIndex({})"`
`60`	`60`	`}`
`61`	`61`	`}`
`62`	`62`
Original file line number	Diff line number	Diff line change
`@@ -4,14 +4,14 @@ use rustc_index::vec::IndexVec;`
`4`	`4`	`use rustc_middle::ty::error::TypeError;`
`5`	`5`
`6`	`6`	`rustc_index::newtype_index! {`
	`7`	`+ #[debug_format = "ExpectedIdx({})"]`
`7`	`8`	`pub(crate) struct ExpectedIdx {`
`8`		`- DEBUG_FORMAT = "ExpectedIdx({})",`
`9`	`9`	`}`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`rustc_index::newtype_index! {`
	`13`	`+ #[debug_format = "ProvidedIdx({})"]`
`13`	`14`	`pub(crate) struct ProvidedIdx {`
`14`		`- DEBUG_FORMAT = "ProvidedIdx({})",`
`15`	`15`	`}`
`16`	`16`	`}`
`17`	`17`
Original file line number	Diff line number	Diff line change
`@@ -96,14 +96,14 @@ fn for_each_consumable<'tcx>(hir: Map<'tcx>, place: TrackedValue, mut f: impl Fn`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`rustc_index::newtype_index! {`
	`99`	`+ #[debug_format = "id({})"]`
`99`	`100`	`pub struct PostOrderId {`
`100`		`- DEBUG_FORMAT = "id({})",`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`rustc_index::newtype_index! {`
	`105`	`+ #[debug_format = "hidx({})"]`
`105`	`106`	`pub struct TrackedValueIndex {`
`106`		`- DEBUG_FORMAT = "hidx({})",`
`107`	`107`	`}`
`108`	`108`	`}`
`109`	`109`
Original file line number	Diff line number	Diff line change
`@@ -357,14 +357,14 @@ impl<'tcx> SccUniverse<'tcx> {`
`357`	`357`	`}`
`358`	`358`
`359`	`359`	`rustc_index::newtype_index! {`
	`360`	`+ #[debug_format = "LeakCheckNode({})"]`
`360`	`361`	`struct LeakCheckNode {`
`361`		`- DEBUG_FORMAT = "LeakCheckNode({})"`
`362`	`362`	`}`
`363`	`363`	`}`
`364`	`364`
`365`	`365`	`rustc_index::newtype_index! {`
	`366`	`+ #[debug_format = "LeakCheckScc({})"]`
`366`	`367`	`struct LeakCheckScc {`
`367`		`- DEBUG_FORMAT = "LeakCheckScc({})"`
`368`	`368`	`}`
`369`	`369`	`}`
`370`	`370`