Use feature parser throughout the compiler

Co-authored-by: jdonszelmann <janabent@gmail.com>

Author: JonathanBrouwer

compiler/rustc_ast_passes/Cargo.toml

@@ -13,6 +13,7 @@ rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
+rustc_hir = { path = "../rustc_hir" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -1,11 +1,14 @@
 use rustc_ast::visit::{self, AssocCtxt, FnCtxt, FnKind, Visitor};
 use rustc_ast::{self as ast, AttrVec, NodeId, PatKind, attr, token};
+use rustc_attr_parsing::AttributeParser;
 use rustc_errors::msg;
 use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features};
+use rustc_hir::Attribute;
+use rustc_hir::attrs::AttributeKind;
 use rustc_session::Session;
 use rustc_session::parse::{feature_err, feature_warn};
 use rustc_span::source_map::Spanned;
-use rustc_span::{Span, Symbol, sym};
+use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 use thin_vec::ThinVec;
 
 use crate::errors;
@@ -636,17 +639,27 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
         return;
     }
     let mut errored = false;
-    for attr in krate.attrs.iter().filter(|attr| attr.has_name(sym::feature)) {
+
+    if let Some(Attribute::Parsed(AttributeKind::Feature(feature_idents, first_span))) =
+        AttributeParser::parse_limited(
+            sess,
+            &krate.attrs,
+            sym::feature,
+            DUMMY_SP,
+            krate.id,
+            Some(&features),
+        )
+    {
         // `feature(...)` used on non-nightly. This is definitely an error.
         let mut err = errors::FeatureOnNonNightly {
-            span: attr.span,
+            span: first_span,
             channel: option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)"),
             stable_features: vec![],
             sugg: None,
         };
 
         let mut all_stable = true;
-        for ident in attr.meta_item_list().into_iter().flatten().flat_map(|nested| nested.ident()) {
+        for ident in feature_idents {
             let name = ident.name;
             let stable_since = features
                 .enabled_lang_features()
@@ -661,7 +674,7 @@ fn maybe_stage_features(sess: &Session, features: &Features, krate: &ast::Crate)
             }
         }
         if all_stable {
-            err.sugg = Some(attr.span);
+            err.sugg = Some(first_span);
         }
         sess.dcx().emit_err(err);
         errored = true;

compiler/rustc_expand/src/config.rs

@@ -7,8 +7,8 @@ use rustc_ast::tokenstream::{
     AttrTokenStream, AttrTokenTree, LazyAttrTokenStream, Spacing, TokenTree,
 };
 use rustc_ast::{
-    self as ast, AttrItemKind, AttrKind, AttrStyle, Attribute, EarlyParsedAttribute, HasAttrs,
-    HasTokens, MetaItem, MetaItemInner, NodeId, NormalAttr,
+    self as ast, AttrItemKind, AttrKind, AttrStyle, Attribute, DUMMY_NODE_ID, EarlyParsedAttribute,
+    HasAttrs, HasTokens, MetaItem, MetaItemInner, NodeId, NormalAttr,
 };
 use rustc_attr_parsing as attr;
 use rustc_attr_parsing::{
@@ -20,18 +20,19 @@ use rustc_feature::{
     ACCEPTED_LANG_FEATURES, EnabledLangFeature, EnabledLibFeature, Features, REMOVED_LANG_FEATURES,
     UNSTABLE_LANG_FEATURES,
 };
-use rustc_hir::Target;
+use rustc_hir::attrs::AttributeKind;
+use rustc_hir::{
+    Target, {self as hir},
+};
 use rustc_parse::parser::Recovery;
 use rustc_session::Session;
 use rustc_session::parse::feature_err;
-use rustc_span::{STDLIB_STABLE_CRATES, Span, Symbol, sym};
-use thin_vec::ThinVec;
+use rustc_span::{DUMMY_SP, STDLIB_STABLE_CRATES, Span, Symbol, sym};
 use tracing::instrument;
 
 use crate::errors::{
     CrateNameInCfgAttr, CrateTypeInCfgAttr, FeatureNotAllowed, FeatureRemoved,
-    FeatureRemovedReason, InvalidCfg, MalformedFeatureAttribute, MalformedFeatureAttributeHelp,
-    RemoveExprNotSupported,
+    FeatureRemovedReason, InvalidCfg, RemoveExprNotSupported,
 };
 
 /// A folder that strips out items that do not belong in the current configuration.
@@ -46,44 +47,23 @@ pub struct StripUnconfigured<'a> {
 }
 
 pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -> Features {
-    fn feature_list(attr: &Attribute) -> ThinVec<ast::MetaItemInner> {
-        if attr.has_name(sym::feature)
-            && let Some(list) = attr.meta_item_list()
-        {
-            list
-        } else {
-            ThinVec::new()
-        }
-    }
-
     let mut features = Features::default();
 
-    // Process all features enabled in the code.
-    for attr in krate_attrs {
-        for mi in feature_list(attr) {
-            let name = match mi.ident() {
-                Some(ident) if mi.is_word() => ident.name,
-                Some(ident) => {
-                    sess.dcx().emit_err(MalformedFeatureAttribute {
-                        span: mi.span(),
-                        help: MalformedFeatureAttributeHelp::Suggestion {
-                            span: mi.span(),
-                            suggestion: ident.name,
-                        },
-                    });
-                    continue;
-                }
-                None => {
-                    sess.dcx().emit_err(MalformedFeatureAttribute {
-                        span: mi.span(),
-                        help: MalformedFeatureAttributeHelp::Label { span: mi.span() },
-                    });
-                    continue;
-                }
-            };
-
+    if let Some(hir::Attribute::Parsed(AttributeKind::Feature(feature_idents, _))) =
+        AttributeParser::parse_limited(
+            sess,
+            krate_attrs,
+            sym::feature,
+            DUMMY_SP,
+            DUMMY_NODE_ID,
+            Some(&features),
+        )
+    {
+        for feature_ident in feature_idents {
             // If the enabled feature has been removed, issue an error.
-            if let Some(f) = REMOVED_LANG_FEATURES.iter().find(|f| name == f.feature.name) {
+            if let Some(f) =
+                REMOVED_LANG_FEATURES.iter().find(|f| feature_ident.name == f.feature.name)
+            {
                 let pull_note = if let Some(pull) = f.pull {
                     format!(
                         "; see <https://github.com/rust-lang/rust/pull/{pull}> for more information",
@@ -92,7 +72,7 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
                     "".to_owned()
                 };
                 sess.dcx().emit_err(FeatureRemoved {
-                    span: mi.span(),
+                    span: feature_ident.span,
                     reason: f.reason.map(|reason| FeatureRemovedReason { reason }),
                     removed_rustc_version: f.feature.since,
                     pull_note,
@@ -101,10 +81,10 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
             }
 
             // If the enabled feature is stable, record it.
-            if let Some(f) = ACCEPTED_LANG_FEATURES.iter().find(|f| name == f.name) {
+            if let Some(f) = ACCEPTED_LANG_FEATURES.iter().find(|f| feature_ident.name == f.name) {
                 features.set_enabled_lang_feature(EnabledLangFeature {
-                    gate_name: name,
-                    attr_sp: mi.span(),
+                    gate_name: feature_ident.name,
+                    attr_sp: feature_ident.span,
                     stable_since: Some(Symbol::intern(f.since)),
                 });
                 continue;
@@ -114,38 +94,46 @@ pub fn features(sess: &Session, krate_attrs: &[Attribute], crate_name: Symbol) -
             // unstable and not also listed as one of the allowed features,
             // issue an error.
             if let Some(allowed) = sess.opts.unstable_opts.allow_features.as_ref() {
-                if allowed.iter().all(|f| name.as_str() != f) {
-                    sess.dcx().emit_err(FeatureNotAllowed { span: mi.span(), name });
+                if allowed.iter().all(|f| feature_ident.name.as_str() != f) {
+                    sess.dcx().emit_err(FeatureNotAllowed {
+                        span: feature_ident.span,
+                        name: feature_ident.name,
+                    });
                     continue;
                 }
             }
 
             // If the enabled feature is unstable, record it.
-            if UNSTABLE_LANG_FEATURES.iter().find(|f| name == f.name).is_some() {
+            if UNSTABLE_LANG_FEATURES.iter().find(|f| feature_ident.name == f.name).is_some() {
                 // When the ICE comes from a standard library crate, there's a chance that the person
                 // hitting the ICE may be using -Zbuild-std or similar with an untested target.
                 // The bug is probably in the standard library and not the compiler in that case,
                 // but that doesn't really matter - we want a bug report.
-                if features.internal(name) && !STDLIB_STABLE_CRATES.contains(&crate_name) {
+                if features.internal(feature_ident.name)
+                    && !STDLIB_STABLE_CRATES.contains(&crate_name)
+                {
                     sess.using_internal_features.store(true, std::sync::atomic::Ordering::Relaxed);
                 }
 
                 features.set_enabled_lang_feature(EnabledLangFeature {
-                    gate_name: name,
-                    attr_sp: mi.span(),
+                    gate_name: feature_ident.name,
+                    attr_sp: feature_ident.span,
                     stable_since: None,
                 });
                 continue;
             }
 
             // Otherwise, the feature is unknown. Enable it as a lib feature.
             // It will be checked later whether the feature really exists.
-            features
-                .set_enabled_lib_feature(EnabledLibFeature { gate_name: name, attr_sp: mi.span() });
+            features.set_enabled_lib_feature(EnabledLibFeature {
+                gate_name: feature_ident.name,
+                attr_sp: feature_ident.span,
+            });
 
             // Similar to above, detect internal lib features to suppress
             // the ICE message that asks for a report.
-            if features.internal(name) && !STDLIB_STABLE_CRATES.contains(&crate_name) {
+            if features.internal(feature_ident.name) && !STDLIB_STABLE_CRATES.contains(&crate_name)
+            {
                 sess.using_internal_features.store(true, std::sync::atomic::Ordering::Relaxed);
             }
         }

compiler/rustc_expand/src/errors.rs

@@ -183,34 +183,6 @@ pub(crate) struct RecursionLimitReached {
     pub crate_name: Symbol,
 }
 
-#[derive(Diagnostic)]
-#[diag("malformed `feature` attribute input", code = E0556)]
-pub(crate) struct MalformedFeatureAttribute {
-    #[primary_span]
-    pub span: Span,
-    #[subdiagnostic]
-    pub help: MalformedFeatureAttributeHelp,
-}
-
-#[derive(Subdiagnostic)]
-pub(crate) enum MalformedFeatureAttributeHelp {
-    #[label("expected just one word")]
-    Label {
-        #[primary_span]
-        span: Span,
-    },
-    #[suggestion(
-        "expected just one word",
-        code = "{suggestion}",
-        applicability = "maybe-incorrect"
-    )]
-    Suggestion {
-        #[primary_span]
-        span: Span,
-        suggestion: Symbol,
-    },
-}
-
 #[derive(Diagnostic)]
 #[diag("removing an expression is not supported in this position")]
 pub(crate) struct RemoveExprNotSupported {

compiler/rustc_lint/src/builtin.rs

@@ -1120,12 +1120,10 @@ declare_lint_pass!(
 );
 
 impl<'tcx> LateLintPass<'tcx> for UnstableFeatures {
-    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &hir::Attribute) {
-        if attr.has_name(sym::feature)
-            && let Some(items) = attr.meta_item_list()
-        {
-            for item in items {
-                cx.emit_span_lint(UNSTABLE_FEATURES, item.span(), BuiltinUnstableFeatures);
+    fn check_attributes(&mut self, cx: &LateContext<'_>, attrs: &[hir::Attribute]) {
+        if let Some(features) = find_attr!(attrs, Feature(features, _) => features) {
+            for feature in features {
+                cx.emit_span_lint(UNSTABLE_FEATURES, feature.span, BuiltinUnstableFeatures);
             }
         }
     }