Introduce ModernIdent type to unify macro 2.0 hygiene handling

1. Added ModernIdent type. Wraps Ident and automatically calls normalize_to_macros_2_0()
    Used for "item hygiene" comparisons, ensuring type safety.
2. Unified identifier normalization. Replaced scattered
    ident.normalize_to_macros_2_0() calls with ModernIdent::new(ident)

Signed-off-by: xizheyin <[email protected]>

Author: xizheyin

compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs

@@ -7,7 +7,7 @@ use rustc_hir::def_id::DefId;
 use rustc_index::IndexVec;
 use rustc_middle::traits::specialization_graph::OverlapMode;
 use rustc_middle::ty::{self, TyCtxt};
-use rustc_span::{ErrorGuaranteed, Symbol};
+use rustc_span::{ErrorGuaranteed, ModernIdent, Symbol};
 use rustc_trait_selection::traits::{self, SkipLeakCheck};
 use smallvec::SmallVec;
 use tracing::debug;
@@ -65,8 +65,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
     fn compare_hygienically(&self, item1: ty::AssocItem, item2: ty::AssocItem) -> bool {
         // Symbols and namespace match, compare hygienically.
         item1.namespace() == item2.namespace()
-            && item1.ident(self.tcx).normalize_to_macros_2_0()
-                == item2.ident(self.tcx).normalize_to_macros_2_0()
+            && ModernIdent::new(item1.ident(self.tcx)) == ModernIdent::new(item2.ident(self.tcx))
     }
 
     fn check_for_duplicate_items_in_impl(&self, impl_: DefId) -> Result<(), ErrorGuaranteed> {
@@ -78,7 +77,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
             let span = self.tcx.def_span(impl_item.def_id);
             let ident = impl_item.ident(self.tcx);
 
-            let norm_ident = ident.normalize_to_macros_2_0();
+            let norm_ident = ModernIdent::new(ident);
             match seen_items.entry(norm_ident) {
                 IndexEntry::Occupied(entry) => {
                     let former = entry.get();
@@ -117,7 +116,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
                 .find(|&&item2| self.compare_hygienically(item1, item2));
 
             if let Some(item2) = collision {
-                let name = item1.ident(self.tcx).normalize_to_macros_2_0();
+                let name = ModernIdent::new(item1.ident(self.tcx));
                 let mut err = struct_span_code_err!(
                     self.tcx.dcx(),
                     self.tcx.def_span(item1.def_id),

compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs

@@ -45,7 +45,7 @@ use rustc_middle::ty::{
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::AMBIGUOUS_ASSOCIATED_ITEMS;
 use rustc_session::parse::feature_err;
-use rustc_span::{DUMMY_SP, Ident, Span, kw, sym};
+use rustc_span::{DUMMY_SP, Ident, ModernIdent, Span, kw, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::wf::object_region_bounds;
 use rustc_trait_selection::traits::{self, FulfillmentError};
@@ -1545,7 +1545,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let item = tcx
             .associated_items(scope)
             .filter_by_name_unhygienic(ident.name)
-            .find(|i| i.as_tag() == assoc_tag && i.ident(tcx).normalize_to_macros_2_0() == ident)?;
+            .find(|i| i.as_tag() == assoc_tag && ModernIdent::new(i.ident(tcx)) == ident)?;
 
         Some((*item, def_scope))
     }

compiler/rustc_hir_typeck/src/expr.rs

@@ -33,7 +33,7 @@ use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::hygiene::DesugaringKind;
 use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, Symbol, kw, sym};
+use rustc_span::{Ident, ModernIdent, Span, Symbol, kw, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{self, ObligationCauseCode, ObligationCtxt};
 use tracing::{debug, instrument, trace};
@@ -2035,7 +2035,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let mut remaining_fields = variant
             .fields
             .iter_enumerated()
-            .map(|(i, field)| (field.ident(tcx).normalize_to_macros_2_0(), (i, field)))
+            .map(|(i, field)| (ModernIdent::new(field.ident(tcx)), (i, field)))
             .collect::<UnordMap<_, _>>();
 
         let mut seen_fields = FxHashMap::default();
@@ -2072,7 +2072,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     self.dcx().emit_err(FieldMultiplySpecifiedInInitializer {
                         span: field.ident.span,
                         prev_span: *prev_span,
-                        ident,
+                        ident: ident.0,
                     })
                 } else {
                     self.report_unknown_field(
@@ -2388,7 +2388,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         adt_ty: Ty<'tcx>,
         span: Span,
         full_span: Span,
-        remaining_fields: UnordMap<Ident, (FieldIdx, &ty::FieldDef)>,
+        remaining_fields: UnordMap<ModernIdent, (FieldIdx, &ty::FieldDef)>,
         variant: &'tcx ty::VariantDef,
         hir_fields: &'tcx [hir::ExprField<'tcx>],
         args: GenericArgsRef<'tcx>,
@@ -2818,15 +2818,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn find_adt_field(
         &self,
         base_def: ty::AdtDef<'tcx>,
-        ident: Ident,
+        ident: ModernIdent,
     ) -> Option<(FieldIdx, &'tcx ty::FieldDef)> {
         // No way to find a field in an enum.
         if base_def.is_enum() {
             return None;
         }
 
         for (field_idx, field) in base_def.non_enum_variant().fields.iter_enumerated() {
-            if field.ident(self.tcx).normalize_to_macros_2_0() == ident {
+            if ModernIdent::new(field.ident(self.tcx)) == ident {
                 // We found the field we wanted.
                 return Some((field_idx, field));
             }
@@ -3449,10 +3449,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         matches: &impl Fn(&ty::FieldDef, Ty<'tcx>) -> bool,
         candidate_field: &ty::FieldDef,
         subst: GenericArgsRef<'tcx>,
-        mut field_path: Vec<Ident>,
+        mut field_path: Vec<ModernIdent>,
         mod_id: DefId,
         hir_id: HirId,
-    ) -> Option<Vec<Ident>> {
+    ) -> Option<Vec<ModernIdent>> {
         debug!(
             "check_for_nested_field_satisfying(span: {:?}, candidate_field: {:?}, field_path: {:?}",
             span, candidate_field, field_path
@@ -3463,7 +3463,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // up to a depth of three
             None
         } else {
-            field_path.push(candidate_field.ident(self.tcx).normalize_to_macros_2_0());
+            field_path.push(ModernIdent::new(candidate_field.ident(self.tcx)));
             let field_ty = candidate_field.ty(self.tcx, subst);
             if matches(candidate_field, field_ty) {
                 return Some(field_path);
@@ -3860,10 +3860,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let Some((index, variant)) = container_def
                         .variants()
                         .iter_enumerated()
-                        .find(|(_, v)| v.ident(self.tcx).normalize_to_macros_2_0() == ident)
+                        .find(|(_, v)| ModernIdent::new(v.ident(self.tcx)) == ident)
                     else {
                         self.dcx()
-                            .create_err(NoVariantNamed { span: ident.span, ident, ty: container })
+                            .create_err(NoVariantNamed {
+                                span: ident.span,
+                                ident: ident.0,
+                                ty: container,
+                            })
                             .with_span_label(field.span, "variant not found")
                             .emit_unless_delay(container.references_error());
                         break;
@@ -3886,13 +3890,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let Some((subindex, field)) = variant
                         .fields
                         .iter_enumerated()
-                        .find(|(_, f)| f.ident(self.tcx).normalize_to_macros_2_0() == subident)
+                        .find(|(_, f)| ModernIdent::new(f.ident(self.tcx)) == subident)
                     else {
                         self.dcx()
                             .create_err(NoFieldOnVariant {
                                 span: ident.span,
                                 container,
-                                ident,
+                                ident: ident.0,
                                 field: subfield,
                                 enum_span: field.span,
                                 field_span: subident.span,
@@ -3918,7 +3922,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     if field.vis.is_accessible_from(sub_def_scope, self.tcx) {
                         self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span, None);
                     } else {
-                        self.private_field_err(ident, container_def.did()).emit();
+                        self.private_field_err(ident.0, container_def.did()).emit();
                     }
 
                     // Save the index of all fields regardless of their visibility in case
@@ -3936,7 +3940,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     let fields = &container_def.non_enum_variant().fields;
                     if let Some((index, field)) = fields
                         .iter_enumerated()
-                        .find(|(_, f)| f.ident(self.tcx).normalize_to_macros_2_0() == ident)
+                        .find(|(_, f)| ModernIdent::new(f.ident(self.tcx)) == ident)
                     {
                         let field_ty = self.field_ty(expr.span, field, args);
 
@@ -3953,7 +3957,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         if field.vis.is_accessible_from(def_scope, self.tcx) {
                             self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span, None);
                         } else {
-                            self.private_field_err(ident, container_def.did()).emit();
+                            self.private_field_err(ident.0, container_def.did()).emit();
                         }
 
                         // Save the index of all fields regardless of their visibility in case

compiler/rustc_hir_typeck/src/fn_ctxt/adjust_fulfillment_errors.rs

@@ -515,7 +515,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             for expr_field in expr_fields {
                 // Look for the ExprField that matches the field, using the
                 // same rules that check_expr_struct uses for macro hygiene.
-                if self.tcx.adjust_ident(expr_field.ident, variant_def_id) == field.ident(self.tcx)
+                if self.tcx.adjust_ident(expr_field.ident, variant_def_id).0
+                    == field.ident(self.tcx)
                 {
                     return Some((
                         expr_field.expr,

compiler/rustc_hir_typeck/src/pat.rs

@@ -25,7 +25,7 @@ use rustc_session::parse::feature_err;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::edition::Edition;
 use rustc_span::source_map::Spanned;
-use rustc_span::{BytePos, DUMMY_SP, Ident, Span, kw, sym};
+use rustc_span::{BytePos, DUMMY_SP, Ident, ModernIdent, Span, kw, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
 use tracing::{debug, instrument, trace};
@@ -1907,7 +1907,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let field_map = variant
             .fields
             .iter_enumerated()
-            .map(|(i, field)| (field.ident(self.tcx).normalize_to_macros_2_0(), (i, field)))
+            .map(|(i, field)| (ModernIdent::new(field.ident(self.tcx)), (i, field)))
             .collect::<FxHashMap<_, _>>();
 
         // Keep track of which fields have already appeared in the pattern.
@@ -1947,7 +1947,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let mut unmentioned_fields = variant
             .fields
             .iter()
-            .map(|field| (field, field.ident(self.tcx).normalize_to_macros_2_0()))
+            .map(|field| (field, ModernIdent::new(field.ident(self.tcx))))
             .filter(|(_, ident)| !used_fields.contains_key(ident))
             .collect::<Vec<_>>();
 
@@ -2115,7 +2115,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         &self,
         kind_name: &str,
         inexistent_fields: &[&hir::PatField<'tcx>],
-        unmentioned_fields: &mut Vec<(&'tcx ty::FieldDef, Ident)>,
+        unmentioned_fields: &mut Vec<(&'tcx ty::FieldDef, ModernIdent)>,
         pat: &'tcx Pat<'tcx>,
         variant: &ty::VariantDef,
         args: ty::GenericArgsRef<'tcx>,
@@ -2351,10 +2351,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn lint_non_exhaustive_omitted_patterns(
         &self,
         pat: &Pat<'_>,
-        unmentioned_fields: &[(&ty::FieldDef, Ident)],
+        unmentioned_fields: &[(&ty::FieldDef, ModernIdent)],
         ty: Ty<'tcx>,
     ) {
-        fn joined_uncovered_patterns(witnesses: &[&Ident]) -> String {
+        fn joined_uncovered_patterns(witnesses: &[&ModernIdent]) -> String {
             const LIMIT: usize = 3;
             match witnesses {
                 [] => {
@@ -2402,7 +2402,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn error_unmentioned_fields(
         &self,
         pat: &Pat<'_>,
-        unmentioned_fields: &[(&ty::FieldDef, Ident)],
+        unmentioned_fields: &[(&ty::FieldDef, ModernIdent)],
         have_inaccessible_fields: bool,
         fields: &'tcx [hir::PatField<'tcx>],
     ) -> Diag<'a> {

compiler/rustc_middle/src/ty/mod.rs

@@ -49,7 +49,7 @@ use rustc_serialize::{Decodable, Encodable};
 use rustc_session::lint::LintBuffer;
 pub use rustc_session::lint::RegisteredTools;
 use rustc_span::hygiene::MacroKind;
-use rustc_span::{DUMMY_SP, ExpnId, ExpnKind, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, ExpnId, ExpnKind, Ident, ModernIdent, Span, Symbol, kw, sym};
 pub use rustc_type_ir::data_structures::{DelayedMap, DelayedSet};
 pub use rustc_type_ir::fast_reject::DeepRejectCtxt;
 #[allow(
@@ -2061,21 +2061,19 @@ impl<'tcx> TyCtxt<'tcx> {
                 .hygienic_eq(def_ident.span.ctxt(), self.expn_that_defined(def_parent_def_id))
     }
 
-    pub fn adjust_ident(self, mut ident: Ident, scope: DefId) -> Ident {
-        ident.span.normalize_to_macros_2_0_and_adjust(self.expn_that_defined(scope));
-        ident
+    pub fn adjust_ident(self, ident: Ident, scope: DefId) -> ModernIdent {
+        ModernIdent::new_and_adjust(ident, self.expn_that_defined(scope)).0
     }
 
     // FIXME(vincenzopalazzo): move the HirId to a LocalDefId
     pub fn adjust_ident_and_get_scope(
         self,
-        mut ident: Ident,
+        ident: Ident,
         scope: DefId,
         block: hir::HirId,
-    ) -> (Ident, DefId) {
-        let scope = ident
-            .span
-            .normalize_to_macros_2_0_and_adjust(self.expn_that_defined(scope))
+    ) -> (ModernIdent, DefId) {
+        let (ident, expnid) = ModernIdent::new_and_adjust(ident, self.expn_that_defined(scope));
+        let scope = expnid
             .and_then(|actual_expansion| actual_expansion.expn_data().parent_module)
             .unwrap_or_else(|| self.parent_module(block).to_def_id());
         (ident, scope)

compiler/rustc_resolve/src/build_reduced_graph.rs

@@ -24,7 +24,7 @@ use rustc_middle::bug;
 use rustc_middle::metadata::ModChild;
 use rustc_middle::ty::{Feed, Visibility};
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind};
-use rustc_span::{Ident, Span, Symbol, kw, sym};
+use rustc_span::{Ident, ModernIdent, Span, Symbol, kw, sym};
 use tracing::debug;
 
 use crate::Namespace::{MacroNS, TypeNS, ValueNS};
@@ -933,8 +933,8 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         self.r.potentially_unused_imports.push(import);
         let imported_binding = self.r.import(binding, import);
         if parent == self.r.graph_root {
-            let ident = ident.normalize_to_macros_2_0();
-            if let Some(entry) = self.r.extern_prelude.get(&ident)
+            let ident = ModernIdent::new(ident);
+            if let Some(entry) = self.r.extern_prelude.get(&ident.0)
                 && expansion != LocalExpnId::ROOT
                 && orig_name.is_some()
                 && !entry.is_import()
@@ -951,7 +951,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
             let entry = self
                 .r
                 .extern_prelude
-                .entry(ident)
+                .entry(ident.0)
                 .or_insert(ExternPreludeEntry { binding: None, introduced_by_item: true });
             if orig_name.is_some() {
                 entry.introduced_by_item = true;
@@ -1216,7 +1216,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         self.r.local_macro_def_scopes.insert(def_id, parent_scope.module);
 
         if macro_rules {
-            let ident = ident.normalize_to_macros_2_0();
+            let ident = ModernIdent::new(ident);
             self.r.macro_names.insert(ident);
             let is_macro_export = ast::attr::contains_name(&item.attrs, sym::macro_export);
             let vis = if is_macro_export {
@@ -1243,17 +1243,17 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                 });
                 self.r.import_use_map.insert(import, Used::Other);
                 let import_binding = self.r.import(binding, import);
-                self.r.define_binding(self.r.graph_root, ident, MacroNS, import_binding);
+                self.r.define_binding(self.r.graph_root, ident.0, MacroNS, import_binding);
             } else {
                 self.r.check_reserved_macro_name(ident, res);
-                self.insert_unused_macro(ident, def_id, item.id);
+                self.insert_unused_macro(ident.0, def_id, item.id);
             }
             self.r.feed_visibility(feed, vis);
             let scope = self.r.arenas.alloc_macro_rules_scope(MacroRulesScope::Binding(
                 self.r.arenas.alloc_macro_rules_binding(MacroRulesBinding {
                     parent_macro_rules_scope: parent_scope.macro_rules,
                     binding,
-                    ident,
+                    ident: ident.0,
                 }),
             ));
             self.r.macro_rules_scopes.insert(def_id, scope);

compiler/rustc_resolve/src/diagnostics.rs

@@ -1441,7 +1441,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     self.resolutions(parent_scope.module).borrow().iter().any(
                         |(key, name_resolution)| {
                             if key.ns == TypeNS
-                                && key.ident == ident
+                                && key.ident.0 == ident
                                 && let Some(binding) = name_resolution.borrow().best_binding()
                             {
                                 match binding.res() {