Use the new attribute validation from rustc_attr_parsing

Signed-off-by: Jonathan Brouwer <[email protected]>

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/stability.rs

@@ -247,7 +247,12 @@ pub(crate) fn parse_stability<S: Stage>(
     let mut feature = None;
     let mut since = None;
 
-    for param in args.list()?.mixed() {
+    let ArgParser::List(list) = args else {
+        cx.expected_list(cx.attr_span);
+        return None;
+    };
+
+    for param in list.mixed() {
         let param_span = param.span();
         let Some(param) = param.meta_item() else {
             cx.emit_err(session_diagnostics::UnsupportedLiteral {
@@ -322,7 +327,13 @@ pub(crate) fn parse_unstability<S: Stage>(
     let mut is_soft = false;
     let mut implied_by = None;
     let mut old_name = None;
-    for param in args.list()?.mixed() {
+
+    let ArgParser::List(list) = args else {
+        cx.expected_list(cx.attr_span);
+        return None;
+    };
+
+    for param in list.mixed() {
         let Some(param) = param.meta_item() else {
             cx.emit_err(session_diagnostics::UnsupportedLiteral {
                 span: param.span(),

compiler/rustc_builtin_macros/src/cfg_accessible.rs

@@ -1,9 +1,9 @@
 //! Implementation of the `#[cfg_accessible(path)]` attribute macro.
 
 use rustc_ast as ast;
+use rustc_attr_parsing::check_builtin_meta_item;
 use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt, Indeterminate, MultiItemModifier};
 use rustc_feature::AttributeTemplate;
-use rustc_parse::validate_attr;
 use rustc_span::{Span, sym};
 
 use crate::errors;
@@ -45,13 +45,12 @@ impl MultiItemModifier for Expander {
         _is_derive_const: bool,
     ) -> ExpandResult<Vec<Annotatable>, Annotatable> {
         let template = AttributeTemplate { list: Some("path"), ..Default::default() };
-        validate_attr::check_builtin_meta_item(
-            &ecx.sess.psess,
+        check_builtin_meta_item(
+            ecx.sess,
             meta_item,
             ast::AttrStyle::Outer,
             sym::cfg_accessible,
             template,
-            true,
         );
 
         let Some(path) = validate_input(ecx, meta_item) else {

compiler/rustc_builtin_macros/src/derive.rs

@@ -1,10 +1,10 @@
 use rustc_ast as ast;
 use rustc_ast::{GenericParamKind, ItemKind, MetaItemInner, MetaItemKind, StmtKind};
+use rustc_attr_parsing::check_builtin_meta_item;
 use rustc_expand::base::{
     Annotatable, DeriveResolution, ExpandResult, ExtCtxt, Indeterminate, MultiItemModifier,
 };
 use rustc_feature::AttributeTemplate;
-use rustc_parse::validate_attr;
 use rustc_session::Session;
 use rustc_span::{ErrorGuaranteed, Ident, Span, sym};
 
@@ -36,13 +36,12 @@ impl MultiItemModifier for Expander {
             ecx.resolver.resolve_derives(ecx.current_expansion.id, ecx.force_mode, &|| {
                 let template =
                     AttributeTemplate { list: Some("Trait1, Trait2, ..."), ..Default::default() };
-                validate_attr::check_builtin_meta_item(
-                    &sess.psess,
+                check_builtin_meta_item(
+                    sess,
                     meta_item,
                     ast::AttrStyle::Outer,
                     sym::derive,
                     template,
-                    true,
                 );
 
                 let mut resolutions = match &meta_item.kind {

compiler/rustc_builtin_macros/src/util.rs

@@ -1,13 +1,14 @@
 use rustc_ast::ptr::P;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{self as ast, AttrStyle, Attribute, MetaItem, attr, token};
+use rustc_attr_parsing::check_builtin_meta_item;
 use rustc_errors::{Applicability, Diag, ErrorGuaranteed};
 use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt};
 use rustc_expand::expand::AstFragment;
 use rustc_feature::AttributeTemplate;
 use rustc_lint_defs::BuiltinLintDiag;
 use rustc_lint_defs::builtin::DUPLICATE_MACRO_ATTRIBUTES;
-use rustc_parse::{exp, parser, validate_attr};
+use rustc_parse::{exp, parser};
 use rustc_session::errors::report_lit_error;
 use rustc_span::{BytePos, Span, Symbol};
 
@@ -16,14 +17,7 @@ use crate::errors;
 pub(crate) fn check_builtin_macro_attribute(ecx: &ExtCtxt<'_>, meta_item: &MetaItem, name: Symbol) {
     // All the built-in macro attributes are "words" at the moment.
     let template = AttributeTemplate { word: true, ..Default::default() };
-    validate_attr::check_builtin_meta_item(
-        &ecx.sess.psess,
-        meta_item,
-        AttrStyle::Outer,
-        name,
-        template,
-        true,
-    );
+    check_builtin_meta_item(ecx.sess, meta_item, AttrStyle::Outer, name, template);
 }
 
 /// Emit a warning if the item is annotated with the given attribute. This is used to diagnose when

compiler/rustc_expand/src/config.rs

@@ -12,16 +12,15 @@ use rustc_ast::{
 };
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
-    AttributeParser, CFG_TEMPLATE, EvalConfigResult, ShouldEmit, eval_config_entry, parse_cfg_attr,
+    AttributeParser, CFG_TEMPLATE, Early, EvalConfigResult, ShouldEmit, check_attribute_safety,
+    eval_config_entry, parse_cfg_attr,
 };
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_feature::{
-    ACCEPTED_LANG_FEATURES, AttributeSafety, EnabledLangFeature, EnabledLibFeature, Features,
-    REMOVED_LANG_FEATURES, UNSTABLE_LANG_FEATURES,
+    ACCEPTED_LANG_FEATURES, EnabledLangFeature, EnabledLibFeature, Features, REMOVED_LANG_FEATURES,
+    UNSTABLE_LANG_FEATURES,
 };
 use rustc_lint_defs::BuiltinLintDiag;
-use rustc_parse::validate_attr;
-use rustc_parse::validate_attr::deny_builtin_meta_unsafety;
 use rustc_session::Session;
 use rustc_session::parse::feature_err;
 use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
@@ -292,12 +291,7 @@ impl<'a> StripUnconfigured<'a> {
     /// is in the original source file. Gives a compiler error if the syntax of
     /// the attribute is incorrect.
     pub(crate) fn expand_cfg_attr(&self, cfg_attr: &Attribute, recursive: bool) -> Vec<Attribute> {
-        validate_attr::check_attribute_safety(
-            &self.sess.psess,
-            Some(AttributeSafety::Normal),
-            &cfg_attr,
-            ast::CRATE_NODE_ID,
-        );
+        check_attribute_safety::<Early>(self.sess, &cfg_attr, ast::CRATE_NODE_ID, &mut |_| {});
 
         // A trace attribute left in AST in place of the original `cfg_attr` attribute.
         // It can later be used by lints or other diagnostics.
@@ -415,23 +409,10 @@ impl<'a> StripUnconfigured<'a> {
         node: NodeId,
         emit_errors: ShouldEmit,
     ) -> EvalConfigResult {
-        // We need to run this to do basic validation of the attribute, such as that lits are valid, etc
-        // FIXME(jdonszelmann) this should not be necessary in the future
-        match validate_attr::parse_meta(&self.sess.psess, attr) {
-            Ok(_) => {}
-            Err(err) => {
-                err.emit();
-                return EvalConfigResult::True;
-            }
+        if !AttributeParser::validate_attribute_early(self.sess, attr, node) {
+            return EvalConfigResult::True;
         }
 
-        // Unsafety check needs to be done explicitly here because this attribute will be removed before the normal check
-        deny_builtin_meta_unsafety(
-            self.sess.dcx(),
-            attr.get_normal_item().unsafety,
-            &rustc_ast::Path::from_ident(attr.ident().unwrap()),
-        );
-
         let Some(cfg) = AttributeParser::parse_single(
             self.sess,
             attr,

compiler/rustc_expand/src/expand.rs

@@ -13,7 +13,7 @@ use rustc_ast::{
     MetaItemKind, ModKind, NodeId, PatKind, StmtKind, TyKind, token,
 };
 use rustc_ast_pretty::pprust;
-use rustc_attr_parsing::{EvalConfigResult, ShouldEmit};
+use rustc_attr_parsing::{AttributeParser, EvalConfigResult, ShouldEmit};
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_errors::PResult;
 use rustc_feature::Features;
@@ -2119,17 +2119,15 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
 
     // Detect use of feature-gated or invalid attributes on macro invocations
     // since they will not be detected after macro expansion.
-    fn check_attributes(&self, attrs: &[ast::Attribute], call: &ast::MacCall) {
+    fn check_attributes(&self, attrs: &[ast::Attribute], call: &ast::MacCall, call_id: NodeId) {
         let features = self.cx.ecfg.features;
         let mut attrs = attrs.iter().peekable();
         let mut span: Option<Span> = None;
         while let Some(attr) = attrs.next() {
+            // Attributes on a macro call will not be checked during late parsing since we'll remove them
+            // We do some basic checks now, but we don't fully parse them
             rustc_ast_passes::feature_gate::check_attribute(attr, self.cx.sess, features);
-            validate_attr::check_attr(
-                &self.cx.sess.psess,
-                attr,
-                self.cx.current_expansion.lint_node_id,
-            );
+            AttributeParser::validate_attribute_early(self.cx.sess, attr, call_id);
 
             let current_span = if let Some(sp) = span { sp.to(attr.span) } else { attr.span };
             span = Some(current_span);
@@ -2228,8 +2226,9 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                     }
                 },
                 None if node.is_mac_call() => {
+                    let mac_node_id = node.node_id();
                     let (mac, attrs, add_semicolon) = node.take_mac_call();
-                    self.check_attributes(&attrs, &mac);
+                    self.check_attributes(&attrs, &mac, mac_node_id);
                     let mut res = self.collect_bang(mac, Node::KIND).make_ast::<Node>();
                     Node::post_flat_map_node_collect_bang(&mut res, add_semicolon);
                     res
@@ -2315,7 +2314,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
                 None if node.is_mac_call() => {
                     let n = mem::replace(node, Node::dummy());
                     let (mac, attrs, _) = n.take_mac_call();
-                    self.check_attributes(&attrs, &mac);
+                    self.check_attributes(&attrs, &mac, node.node_id());
 
                     *node = self.collect_bang(mac, Node::KIND).make_ast::<Node>().into()
                 }

compiler/rustc_expand/src/module.rs

@@ -3,8 +3,9 @@ use std::path::{self, Path, PathBuf};
 
 use rustc_ast::ptr::P;
 use rustc_ast::{AttrVec, Attribute, Inline, Item, ModSpans};
+use rustc_attr_parsing::emit_fatal_malformed_builtin_attribute;
 use rustc_errors::{Diag, ErrorGuaranteed};
-use rustc_parse::{exp, new_parser_from_file, unwrap_or_emit_fatal, validate_attr};
+use rustc_parse::{exp, new_parser_from_file, unwrap_or_emit_fatal};
 use rustc_session::Session;
 use rustc_session::parse::ParseSess;
 use rustc_span::{Ident, Span, sym};
@@ -190,7 +191,7 @@ pub(crate) fn mod_file_path_from_attr(
         // Usually bad forms are checked during semantic analysis via
         // `TyCtxt::check_mod_attrs`), but by the time that runs the macro
         // is expanded, and it doesn't give an error.
-        validate_attr::emit_fatal_malformed_builtin_attribute(&sess.psess, first_path, sym::path);
+        emit_fatal_malformed_builtin_attribute(sess, first_path, sym::path);
     };
 
     let path_str = path_sym.as_str();

compiler/rustc_interface/src/passes.rs

@@ -6,6 +6,7 @@ use std::sync::{Arc, LazyLock, OnceLock};
 use std::{env, fs, iter};
 
 use rustc_ast as ast;
+use rustc_attr_parsing::emit_fatal_malformed_builtin_attribute;
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::jobserver::Proxy;
 use rustc_data_structures::steal::Steal;
@@ -25,9 +26,7 @@ use rustc_middle::arena::Arena;
 use rustc_middle::dep_graph::DepsType;
 use rustc_middle::ty::{self, CurrentGcx, GlobalCtxt, RegisteredTools, TyCtxt};
 use rustc_middle::util::Providers;
-use rustc_parse::{
-    new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal, validate_attr,
-};
+use rustc_parse::{new_parser_from_file, new_parser_from_source_str, unwrap_or_emit_fatal};
 use rustc_passes::{abi_test, input_stats, layout_test};
 use rustc_resolve::Resolver;
 use rustc_session::config::{CrateType, Input, OutFileName, OutputFilenames, OutputType};
@@ -1304,7 +1303,7 @@ fn validate_and_find_value_str_builtin_attr(
     // Validate *all* relevant attributes, not just the first occurrence.
     for attr in ast::attr::filter_by_name(krate_attrs, name) {
         let Some(value) = attr.value_str() else {
-            validate_attr::emit_fatal_malformed_builtin_attribute(&sess.psess, attr, name)
+            emit_fatal_malformed_builtin_attribute(sess, attr, name)
         };
         // Choose the first occurrence as our result.
         result.get_or_insert((value, attr.span));

compiler/rustc_interface/src/util.rs

@@ -5,12 +5,12 @@ use std::sync::{Arc, OnceLock};
 use std::{env, thread};
 
 use rustc_ast as ast;
+use rustc_attr_parsing::emit_fatal_malformed_builtin_attribute;
 use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::jobserver::Proxy;
 use rustc_data_structures::sync;
 use rustc_metadata::{DylibError, load_symbol_from_dylib};
 use rustc_middle::ty::CurrentGcx;
-use rustc_parse::validate_attr;
 use rustc_session::config::{Cfg, OutFileName, OutputFilenames, OutputTypes, Sysroot, host_tuple};
 use rustc_session::lint::{self, BuiltinLintDiag, LintBuffer};
 use rustc_session::output::{CRATE_TYPES, categorize_crate_type};
@@ -477,11 +477,7 @@ pub(crate) fn check_attr_crate_type(
                 // caught during semantic analysis via `TyCtxt::check_mod_attrs`,
                 // but by the time that runs the macro is expanded, and it doesn't
                 // give an error.
-                validate_attr::emit_fatal_malformed_builtin_attribute(
-                    &sess.psess,
-                    a,
-                    sym::crate_type,
-                );
+                emit_fatal_malformed_builtin_attribute(sess, a, sym::crate_type);
             }
         }
     }