Auto merge of #150949 - Bryntet:port_symbol_mangler_attrs, r=<try>

Port symbol mangler attrs

Author: rust-bors[bot]

Cargo.lock

@@ -4455,6 +4455,7 @@ dependencies = [
  "rustc_privacy",
  "rustc_session",
  "rustc_span",
+ "rustc_symbol_mangling",
  "rustc_target",
  "rustc_trait_selection",
  "tracing",

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -305,3 +305,47 @@ impl<S: Stage> SingleAttributeParser<S> for RustcScalableVectorParser {
         Some(AttributeKind::RustcScalableVector { element_count: Some(n), span: cx.attr_span })
     }
 }
+
+const SYMBOL_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
+    Allow(Target::Fn),
+    Allow(Target::Method(MethodKind::TraitImpl)),
+    Allow(Target::Method(MethodKind::Inherent)),
+    Allow(Target::Method(MethodKind::Trait { body: true })),
+    Allow(Target::ForeignFn),
+    Allow(Target::ForeignStatic),
+    Allow(Target::Impl { of_trait: false }),
+]);
+
+pub(crate) struct RustcSymbolName;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcSymbolName {
+    const ALLOWED_TARGETS: AllowedTargets = SYMBOL_TARGETS;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const PATH: &[Symbol] = &[sym::rustc_symbol_name];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const TEMPLATE: AttributeTemplate = template!(Word);
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        if let Err(span) = args.no_args() {
+            cx.expected_no_args(span);
+            return None;
+        }
+        Some(AttributeKind::RustcSymbolName(cx.attr_span))
+    }
+}
+
+pub(crate) struct RustcDefPath;
+
+impl<S: Stage> SingleAttributeParser<S> for RustcDefPath {
+    const ALLOWED_TARGETS: AllowedTargets = SYMBOL_TARGETS;
+    const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Error;
+    const PATH: &[Symbol] = &[sym::rustc_def_path];
+    const ATTRIBUTE_ORDER: AttributeOrder = AttributeOrder::KeepInnermost;
+    const TEMPLATE: AttributeTemplate = template!(Word);
+    fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<AttributeKind> {
+        if let Err(span) = args.no_args() {
+            cx.expected_no_args(span);
+            return None;
+        }
+        Some(AttributeKind::RustcDefPath(cx.attr_span))
+    }
+}

compiler/rustc_attr_parsing/src/context.rs

@@ -62,13 +62,13 @@ use crate::attributes::proc_macro_attrs::{
 use crate::attributes::prototype::CustomMirParser;
 use crate::attributes::repr::{AlignParser, AlignStaticParser, ReprParser};
 use crate::attributes::rustc_internal::{
-    RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser,
+    RustcDefPath, RustcLayoutScalarValidRangeEndParser, RustcLayoutScalarValidRangeStartParser,
     RustcLegacyConstGenericsParser, RustcLintDiagnosticsParser, RustcLintOptDenyFieldAccessParser,
     RustcLintOptTyParser, RustcLintQueryInstabilityParser,
     RustcLintUntrackedQueryInformationParser, RustcMainParser, RustcMustImplementOneOfParser,
     RustcNeverReturnsNullPointerParser, RustcNoImplicitAutorefsParser,
     RustcObjectLifetimeDefaultParser, RustcScalableVectorParser,
-    RustcSimdMonomorphizeLaneLimitParser,
+    RustcSimdMonomorphizeLaneLimitParser, RustcSymbolName,
 };
 use crate::attributes::semantics::MayDangleParser;
 use crate::attributes::stability::{
@@ -215,6 +215,7 @@ attribute_parsers!(
         Single<ProcMacroDeriveParser>,
         Single<RecursionLimitParser>,
         Single<RustcBuiltinMacroParser>,
+        Single<RustcDefPath>,
         Single<RustcForceInlineParser>,
         Single<RustcLayoutScalarValidRangeEndParser>,
         Single<RustcLayoutScalarValidRangeStartParser>,
@@ -224,6 +225,7 @@ attribute_parsers!(
         Single<RustcObjectLifetimeDefaultParser>,
         Single<RustcScalableVectorParser>,
         Single<RustcSimdMonomorphizeLaneLimitParser>,
+        Single<RustcSymbolName>,
         Single<SanitizeParser>,
         Single<ShouldPanicParser>,
         Single<SkipDuringMethodDispatchParser>,

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -880,6 +880,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_coherence_is_core]`
     RustcCoherenceIsCore(Span),
 
+    /// Represents `#[rustc_def_path]`
+    RustcDefPath(Span),
+
     /// Represents `#[rustc_layout_scalar_valid_range_end]`.
     RustcLayoutScalarValidRangeEnd(Box<u128>, Span),
 
@@ -936,6 +939,9 @@ pub enum AttributeKind {
     /// Represents `#[rustc_simd_monomorphize_lane_limit = "N"]`.
     RustcSimdMonomorphizeLaneLimit(Limit),
 
+    /// Represents `#[rustc_symbol_name]`
+    RustcSymbolName(Span),
+
     /// Represents `#[sanitize]`
     ///
     /// the on set and off set are distjoint since there's a third option: unset.

compiler/rustc_hir/src/attrs/encode_cross_crate.rs

@@ -95,6 +95,7 @@ impl AttributeKind {
             Repr { .. } => No,
             RustcBuiltinMacro { .. } => Yes,
             RustcCoherenceIsCore(..) => No,
+            RustcDefPath(..) => No,
             RustcLayoutScalarValidRangeEnd(..) => Yes,
             RustcLayoutScalarValidRangeStart(..) => Yes,
             RustcLegacyConstGenerics { .. } => Yes,
@@ -112,6 +113,7 @@ impl AttributeKind {
             RustcScalableVector { .. } => Yes,
             RustcShouldNotBeCalledOnConstItems(..) => Yes,
             RustcSimdMonomorphizeLaneLimit(..) => Yes, // Affects layout computation, which needs to work cross-crate
+            RustcSymbolName(..) => Yes,
             Sanitize { .. } => No,
             ShouldPanic { .. } => No,
             SkipDuringMethodDispatch { .. } => No,

compiler/rustc_interface/src/passes.rs

@@ -1234,12 +1234,6 @@ pub(crate) fn start_codegen<'tcx>(
         tcx.ensure_ok().trigger_delayed_bug(def_id);
     }
 
-    // Don't run this test assertions when not doing codegen. Compiletest tries to build
-    // build-fail tests in check mode first and expects it to not give an error in that case.
-    if tcx.sess.opts.output_types.should_codegen() {
-        rustc_symbol_mangling::test::report_symbol_names(tcx);
-    }
-
     // Don't do code generation if there were any errors. Likewise if
     // there were any delayed bugs, because codegen will likely cause
     // more ICEs, obscuring the original problem.

compiler/rustc_passes/Cargo.toml

@@ -21,6 +21,7 @@ rustc_middle = { path = "../rustc_middle" }
 rustc_privacy = { path = "../rustc_privacy" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
+rustc_symbol_mangling = { path = "../rustc_symbol_mangling" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 tracing = "0.1"

compiler/rustc_passes/src/check_attr.rs

@@ -55,7 +55,15 @@ use rustc_trait_selection::traits::ObligationCtxt;
 use tracing::debug;
 
 use crate::{errors, fluent_generated as fluent};
-
+const SYMBOL_TARGETS: &'static [Target] = &[
+    Target::Fn,
+    Target::Method(MethodKind::TraitImpl),
+    Target::Method(MethodKind::Inherent),
+    Target::Method(MethodKind::Trait { body: true }),
+    Target::ForeignFn,
+    Target::ForeignStatic,
+    Target::Impl { of_trait: false },
+];
 #[derive(LintDiagnostic)]
 #[diag(passes_diagnostic_diagnostic_on_unimplemented_only_for_traits)]
 struct DiagnosticOnUnimplementedOnlyForTraits;
@@ -222,7 +230,13 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 },
                 Attribute::Parsed(AttributeKind::RustcMustImplementOneOf { attr_span, fn_names }) => {
                     self.check_rustc_must_implement_one_of(*attr_span, fn_names, hir_id,target)
-                },
+                }
+                Attribute::Parsed(AttributeKind::RustcSymbolName(attr_span)) => {
+                    self.check_rustc_symbol_name(*attr_span, hir_id, target)
+                }
+                Attribute::Parsed(AttributeKind::RustcDefPath(attr_span)) => {
+                    self.check_rustc_def_path(*attr_span, hir_id, target);
+                }
                 Attribute::Parsed(
                     AttributeKind::EiiExternTarget { .. }
                     | AttributeKind::EiiExternItem
@@ -448,6 +462,30 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         self.check_mix_no_mangle_export(hir_id, attrs);
     }
 
+    fn check_rustc_symbol_name(&self, attr_span: Span, hir_id: HirId, target: Target) {
+        // Don't run this test assertions when not doing codegen. Compiletest tries to build
+        // build-fail tests in check mode first and expects it to not give an error in that case.
+        if self.tcx.sess.opts.output_types.should_codegen() && SYMBOL_TARGETS.contains(&target) {
+            rustc_symbol_mangling::test::process_symbol_name_attr(
+                self.tcx,
+                hir_id.owner.def_id,
+                attr_span,
+            );
+        }
+    }
+
+    fn check_rustc_def_path(&self, attr_span: Span, hir_id: HirId, target: Target) {
+        // Don't run this test assertions when not doing codegen. Compiletest tries to build
+        // build-fail tests in check mode first and expects it to not give an error in that case.
+        if self.tcx.sess.opts.output_types.should_codegen() && SYMBOL_TARGETS.contains(&target) {
+            rustc_symbol_mangling::test::process_def_path_attr(
+                self.tcx,
+                hir_id.owner.def_id,
+                attr_span,
+            );
+        }
+    }
+
     fn check_rustc_must_implement_one_of(
         &self,
         attr_span: Span,

compiler/rustc_symbol_mangling/src/test.rs

@@ -7,85 +7,42 @@
 use rustc_hir::def_id::LocalDefId;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{GenericArgs, Instance, TyCtxt};
-use rustc_span::{Symbol, sym};
+use rustc_span::Span;
 
 use crate::errors::{Kind, TestOutput};
 
-const SYMBOL_NAME: Symbol = sym::rustc_symbol_name;
-const DEF_PATH: Symbol = sym::rustc_def_path;
-
-pub fn report_symbol_names(tcx: TyCtxt<'_>) {
-    // if the `rustc_attrs` feature is not enabled, then the
-    // attributes we are interested in cannot be present anyway, so
-    // skip the walk.
-    if !tcx.features().rustc_attrs() {
-        return;
+#[inline(always)]
+pub fn process_symbol_name_attr<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId, attr_span: Span) {
+    let def_id = def_id.to_def_id();
+    let instance = Instance::new_raw(
+        def_id,
+        tcx.erase_and_anonymize_regions(GenericArgs::identity_for_item(tcx, def_id)),
+    );
+    let mangled = tcx.symbol_name(instance);
+    tcx.dcx().emit_err(TestOutput {
+        span: attr_span,
+        kind: Kind::SymbolName,
+        content: format!("{mangled}"),
+    });
+    if let Ok(demangling) = rustc_demangle::try_demangle(mangled.name) {
+        tcx.dcx().emit_err(TestOutput {
+            span: attr_span,
+            kind: Kind::Demangling,
+            content: format!("{demangling}"),
+        });
+        tcx.dcx().emit_err(TestOutput {
+            span: attr_span,
+            kind: Kind::DemanglingAlt,
+            content: format!("{demangling:#}"),
+        });
     }
-
-    tcx.dep_graph.with_ignore(|| {
-        let mut symbol_names = SymbolNamesTest { tcx };
-        let crate_items = tcx.hir_crate_items(());
-
-        for id in crate_items.free_items() {
-            symbol_names.process_attrs(id.owner_id.def_id);
-        }
-
-        for id in crate_items.trait_items() {
-            symbol_names.process_attrs(id.owner_id.def_id);
-        }
-
-        for id in crate_items.impl_items() {
-            symbol_names.process_attrs(id.owner_id.def_id);
-        }
-
-        for id in crate_items.foreign_items() {
-            symbol_names.process_attrs(id.owner_id.def_id);
-        }
-    })
-}
-
-struct SymbolNamesTest<'tcx> {
-    tcx: TyCtxt<'tcx>,
 }
 
-impl SymbolNamesTest<'_> {
-    fn process_attrs(&mut self, def_id: LocalDefId) {
-        let tcx = self.tcx;
-        // The formatting of `tag({})` is chosen so that tests can elect
-        // to test the entirety of the string, if they choose, or else just
-        // some subset.
-        for attr in tcx.get_attrs(def_id, SYMBOL_NAME) {
-            let def_id = def_id.to_def_id();
-            let instance = Instance::new_raw(
-                def_id,
-                tcx.erase_and_anonymize_regions(GenericArgs::identity_for_item(tcx, def_id)),
-            );
-            let mangled = tcx.symbol_name(instance);
-            tcx.dcx().emit_err(TestOutput {
-                span: attr.span(),
-                kind: Kind::SymbolName,
-                content: format!("{mangled}"),
-            });
-            if let Ok(demangling) = rustc_demangle::try_demangle(mangled.name) {
-                tcx.dcx().emit_err(TestOutput {
-                    span: attr.span(),
-                    kind: Kind::Demangling,
-                    content: format!("{demangling}"),
-                });
-                tcx.dcx().emit_err(TestOutput {
-                    span: attr.span(),
-                    kind: Kind::DemanglingAlt,
-                    content: format!("{demangling:#}"),
-                });
-            }
-        }
-
-        for attr in tcx.get_attrs(def_id, DEF_PATH) {
-            tcx.dcx().emit_err(TestOutput {
-                span: attr.span(),
-                kind: Kind::DefPath,
-                content: with_no_trimmed_paths!(tcx.def_path_str(def_id)),
-            });
-        }
-    }
+#[inline(always)]
+pub fn process_def_path_attr<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId, attr_span: Span) {
+    tcx.dcx().emit_err(TestOutput {
+        span: attr_span,
+        kind: Kind::DefPath,
+        content: with_no_trimmed_paths!(tcx.def_path_str(def_id)),
+    });
 }

tests/ui/symbol-names/basic.legacy.stderr

@@ -1,3 +1,9 @@
+error: def-path(main)
+  --> $DIR/basic.rs:15:1
+   |
+LL | #[rustc_def_path]
+   | ^^^^^^^^^^^^^^^^^
+
 error: symbol-name(_ZN5basic4main17h1dddcfd03744167fE)
   --> $DIR/basic.rs:8:1
    |
@@ -16,11 +22,5 @@ error: demangling-alt(basic::main)
 LL | #[rustc_symbol_name]
    | ^^^^^^^^^^^^^^^^^^^^
 
-error: def-path(main)
-  --> $DIR/basic.rs:15:1
-   |
-LL | #[rustc_def_path]
-   | ^^^^^^^^^^^^^^^^^
-
 error: aborting due to 4 previous errors