propagate default

jdonszelmann · jdonszelmann · commit f318fbc78ff1 · 2025-04-18T16:17:33.000+02:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -1961,11 +1961,11 @@ pub struct MacroDef {
     /// `true` if macro was defined with `macro_rules`.
     pub macro_rules: bool,
 
-    pub eii_macro_for: Option<EiiMacroFor>,
+    pub eii_macro_for: Option<EIIMacroFor>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
-pub struct EiiMacroFor {
+pub struct EIIMacroFor {
     pub extern_item_path: Path,
     pub impl_unsafe: bool,
 }
@@ -3605,6 +3605,7 @@ pub struct EIIImpl {
     pub impl_safety: Safety,
     pub span: Span,
     pub inner_span: Span,
+    pub is_default: bool,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug)]
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
@@ -751,7 +751,7 @@ fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {
 
 fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {
     let MacroDef { body, macro_rules: _, eii_macro_for } = macro_def;
-    if let Some(EiiMacroFor { extern_item_path, impl_unsafe: _ }) = eii_macro_for {
+    if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = eii_macro_for {
         vis.visit_path(extern_item_path);
     }
     visit_delim_args(vis, body);
diff --git a/compiler/rustc_ast/src/visit.rs b/compiler/rustc_ast/src/visit.rs
@@ -479,7 +479,7 @@ impl WalkItemKind for ItemKind {
             ItemKind::MacroDef(ident, ts) => {
                 try_visit!(visitor.visit_ident(ident));
                 try_visit!(visitor.visit_mac_def(ts, id));
-                if let Some(EiiMacroFor { extern_item_path, impl_unsafe: _ }) = &ts.eii_macro_for {
+                if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = &ts.eii_macro_for {
                     try_visit!(visitor.visit_path(extern_item_path, id));
                 }
             }
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -23,7 +23,6 @@ use super::{
     AstOwner, FnDeclKind, ImplTraitContext, ImplTraitPosition, LoweringContext, ParamMode,
     ResolverAstLoweringExt,
 };
-use crate::GenericArgsMode;
 
 pub(super) struct ItemLowerer<'a, 'hir> {
     pub(super) tcx: TyCtxt<'hir>,
@@ -156,7 +155,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
         match i {
             ItemKind::Fn(box Fn { eii_impl, .. }) => {
                 let mut eii_impls = ThinVec::new();
-                for EIIImpl { node_id, eii_macro_path, impl_safety, span, inner_span } in eii_impl {
+                for EIIImpl {
+                    node_id,
+                    eii_macro_path,
+                    impl_safety,
+                    span,
+                    inner_span,
+                    is_default,
+                } in eii_impl
+                {
                     let did = self.lower_path_simple_eii(*node_id, eii_macro_path);
                     eii_impls.push(rustc_attr_parsing::EIIImpl {
                         eii_macro: did,
@@ -165,12 +172,18 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         impl_marked_unsafe: self
                             .lower_safety(*impl_safety, hir::Safety::Safe)
                             .is_unsafe(),
+                        is_default: *is_default,
                     })
                 }
 
                 vec![hir::Attribute::Parsed(AttributeKind::EiiImpl(eii_impls))]
             }
-            ItemKind::MacroDef(_, MacroDef { eii_macro_for: Some(EiiMacroFor { extern_item_path, impl_unsafe }), .. }) => {
+            ItemKind::MacroDef(
+                _,
+                MacroDef {
+                    eii_macro_for: Some(EIIMacroFor { extern_item_path, impl_unsafe }), ..
+                },
+            ) => {
                 vec![hir::Attribute::Parsed(AttributeKind::EiiMacroFor {
                     eii_extern_item: self.lower_path_simple_eii(id, extern_item_path),
                     impl_unsafe: *impl_unsafe,
@@ -720,7 +733,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         )
                     });
 
-
                 // Unmarked safety in unsafe block defaults to unsafe.
                 let header = self.lower_fn_header(sig.header, hir::Safety::Unsafe, attrs);
 
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/item.rs b/compiler/rustc_ast_pretty/src/pprust/state/item.rs
@@ -678,7 +678,8 @@ impl<'a> State<'a> {
     }
 
     fn print_fn_full(&mut self, vis: &ast::Visibility, attrs: &[ast::Attribute], func: &ast::Fn) {
-        let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque, eii_impl } = func;
+        let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque, eii_impl } =
+            func;
         self.print_define_opaques(define_opaque.as_deref());
 
         for EIIImpl { eii_macro_path, impl_safety, .. } in eii_impl {
diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -145,6 +145,7 @@ pub struct EIIImpl {
     pub impl_marked_unsafe: bool,
     pub span: Span,
     pub inner_span: Span,
+    pub is_default: bool,
 }
 
 /// Represent parsed, *built in*, inert attributes.
diff --git a/compiler/rustc_builtin_macros/src/eii.rs b/compiler/rustc_builtin_macros/src/eii.rs
@@ -1,4 +1,4 @@
-use rustc_ast::{DUMMY_NODE_ID, EIIImpl, EiiMacroFor, ItemKind, ast};
+use rustc_ast::{DUMMY_NODE_ID, EIIImpl, EIIMacroFor, ItemKind, ast};
 use rustc_ast_pretty::pprust::path_to_string;
 use rustc_expand::base::{Annotatable, ExtCtxt};
 use rustc_span::{Span, kw};
@@ -50,7 +50,7 @@ pub(crate) fn eii_macro_for(
         false
     };
 
-    d.eii_macro_for = Some(EiiMacroFor { extern_item_path, impl_unsafe });
+    d.eii_macro_for = Some(EIIMacroFor { extern_item_path, impl_unsafe });
 
     // Return the original item and the new methods.
     vec![item]
@@ -94,8 +94,8 @@ pub(crate) fn eii_macro(
         eii_macro_path: meta_item.path.clone(),
         impl_safety: meta_item.unsafety,
         span,
-        inner_span: meta_item.span,
-        is_default: false,
+        inner_span: meta_item.path.span,
+        is_default,
     });
 
     vec![item]
diff --git a/compiler/rustc_hir_analysis/src/check/compare_eii.rs b/compiler/rustc_hir_analysis/src/check/compare_eii.rs
@@ -2,24 +2,19 @@ use std::borrow::Cow;
 use std::iter;
 
 use rustc_data_structures::fx::FxIndexSet;
-use rustc_errors::{
-    Applicability, E0050, E0053, E0053, E0053, struct_span_code_err, struct_span_code_err,
-    struct_span_code_err,
-};
+use rustc_errors::{Applicability, E0050, E0053, struct_span_code_err};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::{
-    self as hir, self as hir, self as hir, FnSig, HirId, HirId, HirId, ItemKind, ItemKind, ItemKind,
-};
+use rustc_hir::{self as hir, FnSig, HirId, ItemKind};
+use rustc_infer::infer::canonical::ir::TypingMode;
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_infer::traits::{ObligationCause, ObligationCauseCode};
 use rustc_middle::ty;
 use rustc_middle::ty::TyCtxt;
-use rustc_middle::ty::error::{ExpectedFound, TypeError, TypeError, TypeError};
-use rustc_span::{ErrorGuaranteed, Ident, Span};
+use rustc_middle::ty::error::{ExpectedFound, TypeError};
+use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::regions::InferCtxtRegionExt;
 use rustc_trait_selection::traits::ObligationCtxt;
-use rustc_type_ir::TypingMode;
 use tracing::{debug, instrument};
 
 use super::potentially_plural_count;
@@ -150,9 +145,9 @@ fn compare_number_of_method_arguments<'tcx>(
                     }
                 })
             })
-            .or_else(|| tcx.hir().span_if_local(declaration));
+            .or_else(|| tcx.hir_span_if_local(declaration));
 
-        let (external_impl_sig, _, _) = &tcx.hir().expect_item(external_impl).expect_fn();
+        let (_, external_impl_sig, _, _) = &tcx.hir_expect_item(external_impl).expect_fn();
         let pos = external_impl_number_args.saturating_sub(1);
         let impl_span = external_impl_sig
             .decl
@@ -326,7 +321,7 @@ fn report_eii_mismatch<'tcx>(
             if declaration_sig.inputs().len() == *i {
                 // Suggestion to change output type. We do not suggest in `async` functions
                 // to avoid complex logic or incorrect output.
-                if let ItemKind::Fn { sig, .. } = &tcx.hir().expect_item(external_impl_did).kind
+                if let ItemKind::Fn { sig, .. } = &tcx.hir_expect_item(external_impl_did).kind
                     && !sig.header.asyncness.is_async()
                 {
                     let msg = "change the output type to match the declaration";
@@ -381,12 +376,9 @@ fn extract_spans_for_error_reporting<'tcx>(
 ) -> (Span, Option<Span>, Ident) {
     let tcx = infcx.tcx;
     let (mut external_impl_args, external_impl_name) = {
-        let item = tcx.hir().expect_item(external_impl);
-        let (sig, _, _) = item.expect_fn();
-        (
-            sig.decl.inputs.iter().map(|t| t.span).chain(iter::once(sig.decl.output.span())),
-            item.ident,
-        )
+        let item = tcx.hir_expect_item(external_impl);
+        let (ident, sig, _, _) = item.expect_fn();
+        (sig.decl.inputs.iter().map(|t| t.span).chain(iter::once(sig.decl.output.span())), ident)
     };
 
     let declaration_args = declaration.as_local().map(|def_id| {
@@ -403,7 +395,7 @@ fn extract_spans_for_error_reporting<'tcx>(
             declaration_args.and_then(|mut args| args.nth(i)),
             external_impl_name,
         ),
-        _ => (cause.span, tcx.hir().span_if_local(declaration), external_impl_name),
+        _ => (cause.span, tcx.hir_span_if_local(declaration), external_impl_name),
     }
 }
 
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -40,7 +40,7 @@ use rustc_trait_selection::traits::{
 use tracing::{debug, instrument};
 use {rustc_ast as ast, rustc_hir as hir};
 
-use super::compare_eii::{compare_eii_function_types, compare_eii_predicate_entailment};
+use super::compare_eii::compare_eii_function_types;
 use crate::autoderef::Autoderef;
 use crate::collect::CollectItemTypesVisitor;
 use crate::constrained_generic_params::{Parameter, identify_constrained_generic_params};
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -1844,7 +1844,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     fn encode_info_for_macro(&mut self, def_id: LocalDefId) {
         let tcx = self.tcx;
 
-        let hir::ItemKind::Macro(_, macro_def, _) = tcx.hir_expect_item(def_id).kind else { bug!() };
+        let hir::ItemKind::Macro(_, macro_def, _) = tcx.hir_expect_item(def_id).kind else {
+            bug!()
+        };
         self.tables.is_macro_rules.set(def_id.local_def_index, macro_def.macro_rules);
         record!(self.tables.macro_definition[def_id.to_def_id()] <- &*macro_def.body);
     }
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
@@ -2198,9 +2198,10 @@ impl<'a> Parser<'a> {
         };
 
         self.psess.gated_spans.gate(sym::decl_macro, lo.to(self.prev_token.span));
-        Ok(
-            ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: false, eii_macro_for: None }),
-        )
+        Ok(ItemKind::MacroDef(
+            ident,
+            ast::MacroDef { body, macro_rules: false, eii_macro_for: None },
+        ))
     }
 
     /// Is this a possibly malformed start of a `macro_rules! foo` item definition?
@@ -2247,9 +2248,10 @@ impl<'a> Parser<'a> {
         self.eat_semi_for_macro_if_needed(&body);
         self.complain_if_pub_macro(vis, true);
 
-        Ok(
-            ItemKind::MacroDef(ident, ast::MacroDef { body, macro_rules: true, eii_macro_for: None }),
-        )
+        Ok(ItemKind::MacroDef(
+            ident,
+            ast::MacroDef { body, macro_rules: true, eii_macro_for: None },
+        ))
     }
 
     /// Item macro invocations or `macro_rules!` definitions need inherited visibility.
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
@@ -484,7 +484,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         _target_span: Span,
         target: Target,
     ) {
-        for EIIImpl { span, inner_span, eii_macro, impl_marked_unsafe } in impls {
+        for EIIImpl { span, inner_span, eii_macro, impl_marked_unsafe, is_default: _ } in impls {
             match target {
                 Target::Fn => {}
                 _ => {
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -1061,7 +1061,6 @@ impl<'ra: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'_, 'ast, 'r
         };
         debug!("(resolving function) entering function");
 
-
         if let FnKind::Fn(_, _, f) = fn_kind {
             for EIIImpl { node_id, eii_macro_path, .. } in &f.eii_impl {
                 self.smart_resolve_path(*node_id, &None, &eii_macro_path, PathSource::Macro);
@@ -2846,7 +2845,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                     self.parent_scope.macro_rules = self.r.macro_rules_scopes[&def_id];
                 }
 
-                if let Some(EiiMacroFor { extern_item_path, impl_unsafe: _ }) =
+                if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) =
                     &macro_def.eii_macro_for
                 {
                     self.smart_resolve_path(

Original file line number	Diff line number	Diff line change
`@@ -1961,11 +1961,11 @@ pub struct MacroDef {`
`1961`	`1961`	/// `true` if macro was defined with `macro_rules`.
`1962`	`1962`	`pub macro_rules: bool,`
`1963`	`1963`
`1964`		`- pub eii_macro_for: Option<EiiMacroFor>,`
	`1964`	`+ pub eii_macro_for: Option<EIIMacroFor>,`
`1965`	`1965`	`}`
`1966`	`1966`
`1967`	`1967`	`#[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]`
`1968`		`-pub struct EiiMacroFor {`
	`1968`	`+pub struct EIIMacroFor {`
`1969`	`1969`	`pub extern_item_path: Path,`
`1970`	`1970`	`pub impl_unsafe: bool,`
`1971`	`1971`	`}`
`@@ -3605,6 +3605,7 @@ pub struct EIIImpl {`
`3605`	`3605`	`pub impl_safety: Safety,`
`3606`	`3606`	`pub span: Span,`
`3607`	`3607`	`pub inner_span: Span,`
	`3608`	`+ pub is_default: bool,`
`3608`	`3609`	`}`
`3609`	`3610`
`3610`	`3611`	`#[derive(Clone, Encodable, Decodable, Debug)]`
Original file line number	Diff line number	Diff line change
`@@ -751,7 +751,7 @@ fn walk_mac<T: MutVisitor>(vis: &mut T, mac: &mut MacCall) {`
`751`	`751`
`752`	`752`	`fn walk_macro_def<T: MutVisitor>(vis: &mut T, macro_def: &mut MacroDef) {`
`753`	`753`	`let MacroDef { body, macro_rules: _, eii_macro_for } = macro_def;`
`754`		`- if let Some(EiiMacroFor { extern_item_path, impl_unsafe: _ }) = eii_macro_for {`
	`754`	`+ if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = eii_macro_for {`
`755`	`755`	`vis.visit_path(extern_item_path);`
`756`	`756`	`}`
`757`	`757`	`visit_delim_args(vis, body);`
Original file line number	Diff line number	Diff line change
`@@ -479,7 +479,7 @@ impl WalkItemKind for ItemKind {`
`479`	`479`	`ItemKind::MacroDef(ident, ts) => {`
`480`	`480`	`try_visit!(visitor.visit_ident(ident));`
`481`	`481`	`try_visit!(visitor.visit_mac_def(ts, id));`
`482`		`- if let Some(EiiMacroFor { extern_item_path, impl_unsafe: _ }) = &ts.eii_macro_for {`
	`482`	`+ if let Some(EIIMacroFor { extern_item_path, impl_unsafe: _ }) = &ts.eii_macro_for {`
`483`	`483`	`try_visit!(visitor.visit_path(extern_item_path, id));`
`484`	`484`	`}`
`485`	`485`	`}`
Original file line number	Diff line number	Diff line change
`@@ -678,7 +678,8 @@ impl<'a> State<'a> {`
`678`	`678`	`}`
`679`	`679`
`680`	`680`	`fn print_fn_full(&mut self, vis: &ast::Visibility, attrs: &[ast::Attribute], func: &ast::Fn) {`
`681`		`- let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque, eii_impl } = func;`
	`681`	`+ let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque, eii_impl } =`
	`682`	`+ func;`
`682`	`683`	`self.print_define_opaques(define_opaque.as_deref());`
`683`	`684`
`684`	`685`	`for EIIImpl { eii_macro_path, impl_safety, .. } in eii_impl {`
Original file line number	Diff line number	Diff line change
`@@ -145,6 +145,7 @@ pub struct EIIImpl {`
`145`	`145`	`pub impl_marked_unsafe: bool,`
`146`	`146`	`pub span: Span,`
`147`	`147`	`pub inner_span: Span,`
	`148`	`+ pub is_default: bool,`
`148`	`149`	`}`
`149`	`150`
`150`	`151`	`/// Represent parsed, built in, inert attributes.`