add test to reproduce rust-lang#137687 and fix it

Author: jdonszelmann

compiler/rustc_attr_data_structures/src/attributes.rs

@@ -175,6 +175,11 @@ pub enum AttributeKind {
         span: Span,
     },
     ConstStabilityIndirect,
+    CrateName {
+        name: Symbol,
+        name_span: Span,
+        style: AttrStyle,
+    },
     Deprecation {
         deprecation: Deprecation,
         span: Span,
@@ -195,3 +200,24 @@ pub enum AttributeKind {
     },
     // tidy-alphabetical-end
 }
+
+impl AttributeKind {
+    pub fn crate_level(&self) -> Option<(AttrStyle, Span)> {
+        match self {
+            AttributeKind::AllowConstFnUnstable(..)
+            | AttributeKind::AllowInternalUnstable(..)
+            | AttributeKind::BodyStability { .. }
+            | AttributeKind::Confusables { .. }
+            | AttributeKind::ConstStability { .. }
+            | AttributeKind::ConstStabilityIndirect
+            | AttributeKind::Deprecation { .. }
+            | AttributeKind::Diagnostic(..)
+            | AttributeKind::DocComment { .. }
+            | AttributeKind::MacroTransparency(..)
+            | AttributeKind::Repr(..)
+            | AttributeKind::Stability { .. } => None,
+
+            AttributeKind::CrateName { style, name_span, .. } => Some((*style, *name_span)),
+        }
+    }
+}

compiler/rustc_attr_parsing/messages.ftl

@@ -87,6 +87,8 @@ attr_parsing_multiple_item =
 attr_parsing_multiple_stability_levels =
     multiple stability levels
 
+attr_parsing_name_value = malformed `{$name}` attribute: expected to be of the form `#[{$name} = ...]`
+
 attr_parsing_non_ident_feature =
     'feature' is not an identifier
 

compiler/rustc_attr_parsing/src/attributes/crate_name.rs

@@ -0,0 +1,42 @@
+use rustc_attr_data_structures::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use super::SingleAttributeParser;
+use crate::context::AcceptContext;
+use crate::parser::ArgParser;
+use crate::session_diagnostics::{ExpectedNameValue, IncorrectMetaItem, UnusedMultiple};
+
+pub(crate) struct CratenameParser;
+
+impl SingleAttributeParser for CratenameParser {
+    const PATH: &'static [Symbol] = &[sym::crate_name];
+
+    fn on_duplicate(cx: &AcceptContext<'_>, first_span: Span) {
+        // FIXME(jdonszelmann): better duplicate reporting (WIP)
+        cx.emit_err(UnusedMultiple {
+            this: cx.attr_span,
+            other: first_span,
+            name: sym::crate_name,
+        });
+    }
+
+    fn convert(cx: &AcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        if let ArgParser::NameValue(n) = args {
+            if let Some(name) = n.value_as_str() {
+                Some(AttributeKind::CrateName {
+                    name,
+                    name_span: n.value_span,
+                    style: cx.attr_style,
+                })
+            } else {
+                cx.emit_err(IncorrectMetaItem { span: cx.attr_span, suggestion: None });
+
+                None
+            }
+        } else {
+            cx.emit_err(ExpectedNameValue { span: cx.attr_span, name: sym::crate_name });
+
+            None
+        }
+    }
+}

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -26,6 +26,7 @@ use crate::parser::ArgParser;
 pub(crate) mod allow_unstable;
 pub(crate) mod cfg;
 pub(crate) mod confusables;
+pub(crate) mod crate_name;
 pub(crate) mod deprecation;
 pub(crate) mod repr;
 pub(crate) mod stability;

compiler/rustc_attr_parsing/src/attributes/util.rs

@@ -1,7 +1,7 @@
-use rustc_ast::attr::{AttributeExt, first_attr_value_str_by_name};
+use rustc_ast::attr::AttributeExt;
 use rustc_attr_data_structures::RustcVersion;
 use rustc_feature::is_builtin_attr_name;
-use rustc_span::{Symbol, sym};
+use rustc_span::Symbol;
 
 /// Parse a rustc version number written inside string literal in an attribute,
 /// like appears in `since = "1.0.0"`. Suffixes like "-dev" and "-nightly" are
@@ -22,7 +22,3 @@ pub fn parse_version(s: Symbol) -> Option<RustcVersion> {
 pub fn is_builtin_attr(attr: &impl AttributeExt) -> bool {
     attr.is_doc_comment() || attr.ident().is_some_and(|ident| is_builtin_attr_name(ident.name))
 }
-
-pub fn find_crate_name(attrs: &[impl AttributeExt]) -> Option<Symbol> {
-    first_attr_value_str_by_name(attrs, sym::crate_name)
-}

compiler/rustc_attr_parsing/src/context.rs

@@ -3,7 +3,7 @@ use std::collections::BTreeMap;
 use std::ops::Deref;
 use std::sync::LazyLock;
 
-use rustc_ast::{self as ast, DelimArgs};
+use rustc_ast::{self as ast, AttrStyle, DelimArgs};
 use rustc_attr_data_structures::AttributeKind;
 use rustc_errors::{DiagCtxtHandle, Diagnostic};
 use rustc_feature::Features;
@@ -14,6 +14,7 @@ use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 
 use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
 use crate::attributes::confusables::ConfusablesParser;
+use crate::attributes::crate_name::CratenameParser;
 use crate::attributes::deprecation::DeprecationParser;
 use crate::attributes::repr::ReprParser;
 use crate::attributes::stability::{
@@ -76,6 +77,7 @@ attribute_groups!(
 
         // tidy-alphabetical-start
         Single<ConstStabilityIndirectParser>,
+        Single<CratenameParser>,
         Single<DeprecationParser>,
         Single<TransparencyParser>,
         // tidy-alphabetical-end
@@ -89,6 +91,7 @@ pub(crate) struct AcceptContext<'a> {
     pub(crate) group_cx: &'a FinalizeContext<'a>,
     /// The span of the attribute currently being parsed
     pub(crate) attr_span: Span,
+    pub(crate) attr_style: AttrStyle,
 }
 
 impl<'a> AcceptContext<'a> {
@@ -269,6 +272,7 @@ impl<'sess> AttributeParser<'sess> {
                             let cx = AcceptContext {
                                 group_cx: &group_cx,
                                 attr_span: lower_span(attr.span),
+                                attr_style: attr.style,
                             };
 
                             f(&cx, &args)

compiler/rustc_attr_parsing/src/lib.rs

@@ -90,7 +90,7 @@ pub mod parser;
 mod session_diagnostics;
 
 pub use attributes::cfg::*;
-pub use attributes::util::{find_crate_name, is_builtin_attr, parse_version};
+pub use attributes::util::{is_builtin_attr, parse_version};
 pub use context::{AttributeParser, OmitDoc};
 pub use rustc_attr_data_structures::*;
 

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -479,3 +479,11 @@ pub(crate) struct UnrecognizedReprHint {
     #[primary_span]
     pub span: Span,
 }
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_name_value, code = E0539)]
+pub(crate) struct ExpectedNameValue {
+    #[primary_span]
+    pub span: Span,
+    pub name: Symbol,
+}

compiler/rustc_driver_impl/src/lib.rs

@@ -59,7 +59,7 @@ use rustc_session::getopts::{self, Matches};
 use rustc_session::lint::{Lint, LintId};
 use rustc_session::output::collect_crate_types;
 use rustc_session::{EarlyDiagCtxt, Session, config, filesearch};
-use rustc_span::FileName;
+use rustc_span::{FileName, Symbol};
 use rustc_target::json::ToJson;
 use rustc_target::spec::{Target, TargetTuple};
 use time::OffsetDateTime;
@@ -290,7 +290,8 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
             return early_exit();
         }
 
-        if print_crate_info(codegen_backend, sess, has_input) == Compilation::Stop {
+        let (c, crate_name) = print_crate_info(codegen_backend, sess, has_input);
+        if c == Compilation::Stop {
             return early_exit();
         }
 
@@ -316,7 +317,7 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         // If pretty printing is requested: Figure out the representation, print it and exit
         if let Some(pp_mode) = sess.opts.pretty {
             if pp_mode.needs_ast_map() {
-                create_and_enter_global_ctxt(compiler, krate, |tcx| {
+                create_and_enter_global_ctxt(compiler, krate, crate_name, |tcx| {
                     tcx.ensure_ok().early_lint_checks(());
                     pretty::print(sess, pp_mode, pretty::PrintExtra::NeedsAstMap { tcx });
                     passes::write_dep_info(tcx);
@@ -336,7 +337,7 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
             return early_exit();
         }
 
-        let linker = create_and_enter_global_ctxt(compiler, krate, |tcx| {
+        let linker = create_and_enter_global_ctxt(compiler, krate, crate_name, |tcx| {
             let early_exit = || {
                 sess.dcx().abort_if_errors();
                 None
@@ -607,18 +608,22 @@ fn print_crate_info(
     codegen_backend: &dyn CodegenBackend,
     sess: &Session,
     parse_attrs: bool,
-) -> Compilation {
+) -> (Compilation, Option<Symbol>) {
     use rustc_session::config::PrintKind::*;
     // This import prevents the following code from using the printing macros
     // used by the rest of the module. Within this function, we only write to
     // the output specified by `sess.io.output_file`.
     #[allow(unused_imports)]
     use {do_not_use_safe_print as safe_print, do_not_use_safe_print as safe_println};
 
+    let mut crate_name = None;
+    let mut get_crate_name =
+        |attrs| *crate_name.get_or_insert_with(|| passes::get_crate_name(sess, attrs));
+
     // NativeStaticLibs and LinkArgs are special - printed during linking
     // (empty iterator returns true)
     if sess.opts.prints.iter().all(|p| p.kind == NativeStaticLibs || p.kind == LinkArgs) {
-        return Compilation::Continue;
+        return (Compilation::Continue, crate_name);
     }
 
     let attrs = if parse_attrs {
@@ -627,7 +632,7 @@ fn print_crate_info(
             Ok(attrs) => Some(attrs),
             Err(parse_error) => {
                 parse_error.emit();
-                return Compilation::Stop;
+                return (Compilation::Stop, crate_name);
             }
         }
     } else {
@@ -664,24 +669,26 @@ fn print_crate_info(
             FileNames => {
                 let Some(attrs) = attrs.as_ref() else {
                     // no crate attributes, print out an error and exit
-                    return Compilation::Continue;
+                    return (Compilation::Continue, crate_name);
                 };
                 let t_outputs = rustc_interface::util::build_output_filenames(attrs, sess);
-                let crate_name = passes::get_crate_name(sess, attrs);
                 let crate_types = collect_crate_types(sess, attrs);
                 for &style in &crate_types {
                     let fname = rustc_session::output::filename_for_input(
-                        sess, style, crate_name, &t_outputs,
+                        sess,
+                        style,
+                        get_crate_name(attrs),
+                        &t_outputs,
                     );
                     println_info!("{}", fname.as_path().file_name().unwrap().to_string_lossy());
                 }
             }
             CrateName => {
                 let Some(attrs) = attrs.as_ref() else {
                     // no crate attributes, print out an error and exit
-                    return Compilation::Continue;
+                    return (Compilation::Continue, crate_name);
                 };
-                println_info!("{}", passes::get_crate_name(sess, attrs));
+                println_info!("{}", get_crate_name(attrs));
             }
             Cfg => {
                 let mut cfgs = sess
@@ -786,7 +793,7 @@ fn print_crate_info(
 
         req.out.overwrite(&crate_info, sess);
     }
-    Compilation::Stop
+    (Compilation::Stop, crate_name)
 }
 
 /// Prints version information

compiler/rustc_interface/src/passes.rs

@@ -6,6 +6,7 @@ use std::sync::{Arc, LazyLock};
 use std::{env, fs, iter};
 
 use rustc_ast as ast;
+use rustc_attr_parsing::{AttributeKind, AttributeParser};
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::parallel;
 use rustc_data_structures::steal::Steal;
@@ -32,7 +33,7 @@ use rustc_session::output::{collect_crate_types, filename_for_input};
 use rustc_session::search_paths::PathKind;
 use rustc_session::{Limit, Session};
 use rustc_span::{
-    ErrorGuaranteed, FileName, SourceFileHash, SourceFileHashAlgorithm, Span, Symbol, sym,
+    DUMMY_SP, ErrorGuaranteed, FileName, SourceFileHash, SourceFileHashAlgorithm, Span, Symbol, sym,
 };
 use rustc_target::spec::PanicStrategy;
 use rustc_trait_selection::traits;
@@ -753,6 +754,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
 pub fn create_and_enter_global_ctxt<T, F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> T>(
     compiler: &Compiler,
     mut krate: rustc_ast::Crate,
+    crate_name: Option<Symbol>,
     f: F,
 ) -> T {
     let sess = &compiler.sess;
@@ -765,7 +767,7 @@ pub fn create_and_enter_global_ctxt<T, F: for<'tcx> FnOnce(TyCtxt<'tcx>) -> T>(
 
     let pre_configured_attrs = rustc_expand::config::pre_configure_attrs(sess, &krate.attrs);
 
-    let crate_name = get_crate_name(sess, &pre_configured_attrs);
+    let crate_name = crate_name.unwrap_or_else(|| get_crate_name(sess, &pre_configured_attrs));
     let crate_types = collect_crate_types(sess, &pre_configured_attrs);
     let stable_crate_id = StableCrateId::new(
         crate_name,
@@ -1119,6 +1121,20 @@ pub(crate) fn start_codegen<'tcx>(
     codegen
 }
 
+pub(crate) fn parse_crate_name(
+    sess: &Session,
+    attrs: &[ast::Attribute],
+    limit_diagnostics: bool,
+) -> Option<(Symbol, Span)> {
+    let rustc_hir::Attribute::Parsed(AttributeKind::CrateName { name, name_span, .. }) =
+        AttributeParser::parse_limited(sess, &attrs, sym::crate_name, DUMMY_SP, limit_diagnostics)?
+    else {
+        unreachable!("crate_name is the only attr we could've parsed here");
+    };
+
+    Some((name, name_span))
+}
+
 /// Compute and validate the crate name.
 pub fn get_crate_name(sess: &Session, krate_attrs: &[ast::Attribute]) -> Symbol {
     // We validate *all* occurrences of `#![crate_name]`, pick the first find and
@@ -1128,8 +1144,7 @@ pub fn get_crate_name(sess: &Session, krate_attrs: &[ast::Attribute]) -> Symbol
     // in all code paths that require the crate name very early on, namely before
     // macro expansion.
 
-    let attr_crate_name =
-        validate_and_find_value_str_builtin_attr(sym::crate_name, sess, krate_attrs);
+    let attr_crate_name = parse_crate_name(sess, krate_attrs, false);
 
     let validate = |name, span| {
         rustc_session::output::validate_crate_name(sess, name, span);

compiler/rustc_interface/src/util.rs

@@ -23,6 +23,7 @@ use rustc_target::spec::Target;
 use tracing::info;
 
 use crate::errors;
+use crate::passes::parse_crate_name;
 
 /// Function pointer type that constructs a new CodegenBackend.
 type MakeBackendFn = fn() -> Box<dyn CodegenBackend>;
@@ -485,7 +486,7 @@ pub fn build_output_filenames(attrs: &[ast::Attribute], sess: &Session) -> Outpu
         .opts
         .crate_name
         .clone()
-        .or_else(|| rustc_attr_parsing::find_crate_name(attrs).map(|n| n.to_string()));
+        .or_else(|| parse_crate_name(sess, attrs, true).map(|i| i.0.to_string()));
 
     match sess.io.output_file {
         None => {