wip

Signed-off-by: Jonathan Brouwer <jonathantbrouwer@gmail.com>

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/context.rs

@@ -4,15 +4,12 @@ use std::ops::{Deref, DerefMut};
 use std::sync::LazyLock;
 
 use private::Sealed;
-use rustc_ast::{self as ast, LitKind, MetaItemLit, NodeId, Safety};
+use rustc_ast::{self as ast, LitKind, MetaItemLit, NodeId};
 use rustc_attr_data_structures::AttributeKind;
 use rustc_attr_data_structures::lints::{AttributeLint, AttributeLintKind};
-use rustc_errors::{Applicability, DiagCtxtHandle, Diagnostic};
-use rustc_feature::{
-    AttributeSafety, AttributeTemplate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features,
-};
+use rustc_errors::{DiagCtxtHandle, Diagnostic};
+use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::{AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId, HirId};
-use rustc_parse::validate_attr::{is_attr_template_compatible, parse_meta};
 use rustc_session::Session;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
 
@@ -59,10 +56,7 @@ use crate::attributes::traits::{
 use crate::attributes::transparency::TransparencyParser;
 use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
 use crate::parser::{ArgParser, MetaItemParser, PathParser};
-use crate::session_diagnostics::{
-    AttributeParseError, AttributeParseErrorReason, InvalidAttrUnsafe, UnknownMetaItem,
-    UnsafeAttrOutsideUnsafe, UnsafeAttrOutsideUnsafeSuggestion,
-};
+use crate::session_diagnostics::{AttributeParseError, AttributeParseErrorReason, UnknownMetaItem};
 
 macro_rules! group_type {
     ($stage: ty) => {
@@ -753,6 +747,10 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         &self.sess
     }
 
+    pub(crate) fn stage(&self) -> &S {
+        &self.stage
+    }
+
     pub(crate) fn features(&self) -> &'sess Features {
         self.features.expect("features not available at this point in the compiler")
     }
@@ -897,201 +895,6 @@ impl<'sess, S: Stage> AttributeParser<'sess, S> {
         attributes
     }
 
-    fn validate_attribute(
-        &self,
-        attr: &ast::Attribute,
-        target_id: S::Id,
-        emit_lint: &mut impl FnMut(AttributeLint<S::Id>),
-        check_attr_template: bool,
-    ) -> bool {
-        if !self.stage.should_emit_errors() {
-            return true;
-        }
-        let ast::AttrKind::Normal(normal) = &attr.kind else { return true };
-        if attr.has_name(sym::cfg_trace) || attr.has_name(sym::cfg_attr_trace) {
-            return true;
-        }
-        self.check_attribute_safety(attr, target_id, emit_lint);
-
-        let builtin_attr_info =
-            attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name));
-        if (builtin_attr_info.is_none() || attr.has_name(sym::rustc_dummy))
-            && !matches!(normal.item.args, rustc_ast::AttrArgs::Eq { .. })
-        {
-            return true;
-        }
-
-        // FIXME
-        let meta = match parse_meta(&self.sess.psess, attr) {
-            Ok(meta) => meta,
-            Err(err) => {
-                err.emit();
-                return false;
-            }
-        };
-        if check_attr_template {
-            return true;
-        }
-
-        if let Some(BuiltinAttribute { name, template, .. }) = builtin_attr_info {
-            // FIXME when all attributes are parsed, this check can be removed
-            if !is_attr_template_compatible(&template, &meta.kind) {
-                self.emit_malformed_unparsed_attribute(
-                    attr.style, meta.span, *name, *template, target_id, emit_lint,
-                );
-                return false
-            }
-        }
-
-        true
-    }
-
-    fn check_attribute_safety(
-        &self,
-        attr: &ast::Attribute,
-        id: S::Id,
-        emit_lint: &mut impl FnMut(AttributeLint<S::Id>),
-    ) {
-        let builtin_attr_info =
-            attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name));
-
-        let builtin_attr_safety = builtin_attr_info.map(|x| x.safety);
-
-        let attr_item = attr.get_normal_item();
-        match (builtin_attr_safety, attr_item.unsafety) {
-            // - Unsafe builtin attribute
-            // - User wrote `#[unsafe(..)]`, which is permitted on any edition
-            (Some(AttributeSafety::Unsafe { .. }), Safety::Unsafe(..)) => {
-                // OK
-            }
-
-            // - Unsafe builtin attribute
-            // - User did not write `#[unsafe(..)]`
-            (Some(AttributeSafety::Unsafe { unsafe_since }), Safety::Default) => {
-                let path_span = attr_item.path.span;
-
-                // If the `attr_item`'s span is not from a macro, then just suggest
-                // wrapping it in `unsafe(...)`. Otherwise, we suggest putting the
-                // `unsafe(`, `)` right after and right before the opening and closing
-                // square bracket respectively.
-                let diag_span = attr_item.span();
-
-                // Attributes can be safe in earlier editions, and become unsafe in later ones.
-                //
-                // Use the span of the attribute's name to determine the edition: the span of the
-                // attribute as a whole may be inaccurate if it was emitted by a macro.
-                //
-                // See https://github.com/rust-lang/rust/issues/142182.
-                let emit_error = match unsafe_since {
-                    None => true,
-                    Some(unsafe_since) => path_span.edition() >= unsafe_since,
-                };
-
-                if emit_error {
-                    self.dcx().emit_err(UnsafeAttrOutsideUnsafe {
-                        span: path_span,
-                        suggestion: UnsafeAttrOutsideUnsafeSuggestion {
-                            left: diag_span.shrink_to_lo(),
-                            right: diag_span.shrink_to_hi(),
-                        },
-                    });
-                } else {
-                    emit_lint(AttributeLint {
-                        id,
-                        span: path_span,
-                        kind: AttributeLintKind::UnsafeAttrOutsideUnsafe {
-                            attribute_name_span: path_span,
-                            sugg_spans: (diag_span.shrink_to_lo(), diag_span.shrink_to_hi()),
-                        },
-                    });
-                }
-            }
-
-            // - Normal builtin attribute, or any non-builtin attribute
-            // - All non-builtin attributes are currently considered safe; writing `#[unsafe(..)]` is
-            //   not permitted on non-builtin attributes or normal builtin attributes
-            (Some(AttributeSafety::Normal) | None, Safety::Unsafe(unsafe_span)) => {
-                self.dcx().emit_err(InvalidAttrUnsafe {
-                    span: unsafe_span,
-                    name: attr_item.path.clone(),
-                });
-            }
-
-            // - Normal builtin attribute
-            // - No explicit `#[unsafe(..)]` written.
-            (Some(AttributeSafety::Normal), Safety::Default) => {
-                // OK
-            }
-
-            // - Non-builtin attribute
-            // - No explicit `#[unsafe(..)]` written.
-            (None, Safety::Default) => {
-                // OK
-            }
-
-            (
-                Some(AttributeSafety::Unsafe { .. } | AttributeSafety::Normal) | None,
-                Safety::Safe(..),
-            ) => {
-                self.sess.psess.dcx().span_delayed_bug(
-                    attr_item.span(),
-                    "`check_attribute_safety` does not expect `Safety::Safe` on attributes",
-                );
-            }
-        }
-    }
-
-    fn emit_malformed_unparsed_attribute(
-        &self,
-        style: ast::AttrStyle,
-        span: Span,
-        name: Symbol,
-        template: AttributeTemplate,
-        target_id: S::Id,
-        emit_lint: &mut impl FnMut(AttributeLint<S::Id>),
-    ) {
-        // Some of previously accepted forms were used in practice,
-        // report them as warnings for now.
-        let should_warn = |name| matches!(name, sym::doc | sym::link | sym::test | sym::bench);
-
-        let error_msg = format!("malformed `{name}` attribute input");
-        let mut suggestions = vec![];
-        let inner = if style == ast::AttrStyle::Inner { "!" } else { "" };
-        if template.word {
-            suggestions.push(format!("#{inner}[{name}]"));
-        }
-        if let Some(descr) = template.list {
-            suggestions.push(format!("#{inner}[{name}({descr})]"));
-        }
-        suggestions.extend(template.one_of.iter().map(|&word| format!("#{inner}[{name}({word})]")));
-        if let Some(descr) = template.name_value_str {
-            suggestions.push(format!("#{inner}[{name} = \"{descr}\"]"));
-        }
-        if should_warn(name) {
-            emit_lint(AttributeLint {
-                id: target_id,
-                span,
-                kind: AttributeLintKind::IllFormedAttributeInput { suggestions },
-            });
-        } else {
-            suggestions.sort();
-            self.sess
-                .dcx()
-                .struct_span_err(span, error_msg)
-                .with_span_suggestions(
-                    span,
-                    if suggestions.len() == 1 {
-                        "must be of the form"
-                    } else {
-                        "the following are the possible correct uses"
-                    },
-                    suggestions,
-                    Applicability::HasPlaceholders,
-                )
-                .emit();
-        }
-    }
-
     /// Returns whether there is a parser for an attribute with this name
     pub fn is_parsed_attribute(path: &[Symbol]) -> bool {
         Late::parsers().0.contains_key(path)

compiler/rustc_attr_parsing/src/lib.rs

@@ -89,6 +89,7 @@ pub(crate) mod context;
 mod lints;
 pub mod parser;
 mod session_diagnostics;
+mod validate_attr;
 
 pub use attributes::cfg::{CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg_attr};
 pub use attributes::cfg_old::*;
@@ -97,5 +98,8 @@ pub use attributes::util::{
 };
 pub use context::{AttributeParser, Early, Late, OmitDoc, ShouldEmit};
 pub use lints::emit_attribute_lint;
+pub use validate_attr::{
+    check_attribute_safety, check_builtin_meta_item, emit_fatal_malformed_builtin_attribute,
+};
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }