add test to reproduce #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

@@ -44,6 +44,7 @@ use rustc_errors::emitter::stderr_destination;
 use rustc_errors::registry::Registry;
 use rustc_errors::{ColorConfig, DiagCtxt, ErrCode, FatalError, PResult, markdown};
 use rustc_feature::find_gated_cfg;
+use rustc_interface::passes::get_crate_name;
 use rustc_interface::util::{self, get_codegen_backend};
 use rustc_interface::{Linker, create_and_enter_global_ctxt, interface, passes};
 use rustc_lint::unerased_lint_store;
@@ -290,7 +291,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 = print_crate_info(codegen_backend, sess, has_input);
+        if c == Compilation::Stop {
             return early_exit();
         }
 
@@ -667,11 +669,13 @@ fn print_crate_info(
                     return Compilation::Continue;
                 };
                 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(sess, attrs),
+                        &t_outputs,
                     );
                     println_info!("{}", fname.as_path().file_name().unwrap().to_string_lossy());
                 }
@@ -681,7 +685,7 @@ fn print_crate_info(
                     // no crate attributes, print out an error and exit
                     return Compilation::Continue;
                 };
-                println_info!("{}", passes::get_crate_name(sess, attrs));
+                println_info!("{}", get_crate_name(sess, attrs));
             }
             Cfg => {
                 let mut cfgs = sess

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;
@@ -1119,6 +1120,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 +1143,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);