Move lints for check-cfg to attribute parsing

Author: JonathanBrouwer

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -2,17 +2,16 @@ pub(crate) mod check_cfg;
 
 use rustc_ast::token::Delimiter;
 use rustc_ast::tokenstream::DelimSpan;
-use rustc_ast::{AttrItem, Attribute, CRATE_NODE_ID, LitKind, NodeId, ast, token};
+use rustc_ast::{AttrItem, Attribute, CRATE_NODE_ID, LitKind, ast, token};
 use rustc_errors::{Applicability, PResult};
 use rustc_feature::{AttrSuggestionStyle, AttributeTemplate, Features, template};
 use rustc_hir::attrs::CfgEntry;
+use rustc_hir::lints::AttributeLintKind;
 use rustc_hir::{AttrPath, RustcVersion};
 use rustc_parse::parser::{ForceCollect, Parser};
 use rustc_parse::{exp, parse_in};
 use rustc_session::Session;
 use rustc_session::config::ExpectedValues;
-use rustc_session::lint::BuiltinLintDiag;
-use rustc_session::lint::builtin::UNEXPECTED_CFGS;
 use rustc_session::parse::{ParseSess, feature_err};
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 use thin_vec::ThinVec;
@@ -23,10 +22,7 @@ use crate::session_diagnostics::{
     AttributeParseError, AttributeParseErrorReason, CfgAttrBadDelim, MetaBadDelimSugg,
     ParsedDescription,
 };
-use crate::{
-    AttributeParser, CfgMatchesLintEmitter, fluent_generated, parse_version, session_diagnostics,
-    try_gate_cfg,
-};
+use crate::{AttributeParser, fluent_generated, parse_version, session_diagnostics, try_gate_cfg};
 
 pub const CFG_TEMPLATE: AttributeTemplate = template!(
     List: &["predicate"],
@@ -195,43 +191,40 @@ fn parse_name_value<S: Stage>(
         }
     };
 
+    match cx.sess.psess.check_config.expecteds.get(&name) {
+        Some(ExpectedValues::Some(values)) if !values.contains(&value.map(|(v, _)| v)) => {
+            cx.emit_lint(AttributeLintKind::UnexpectedCfgValue { name, name_span, value }, span);
+        }
+        None if cx.sess.psess.check_config.exhaustive_names => {
+            cx.emit_lint(AttributeLintKind::UnexpectedCfgName { name, name_span, value }, span);
+        }
+        _ => { /* not unexpected */ }
+    }
+
     Ok(CfgEntry::NameValue { name, name_span, value, span })
 }
 
-pub fn eval_config_entry(
-    sess: &Session,
-    cfg_entry: &CfgEntry,
-    id: NodeId,
-    emit_lints: ShouldEmit,
-) -> EvalConfigResult {
+pub fn eval_config_entry(sess: &Session, cfg_entry: &CfgEntry) -> EvalConfigResult {
     match cfg_entry {
         CfgEntry::All(subs, ..) => {
-            let mut all = None;
             for sub in subs {
-                let res = eval_config_entry(sess, sub, id, emit_lints);
-                // We cannot short-circuit because `eval_config_entry` emits some lints
+                let res = eval_config_entry(sess, sub);
                 if !res.as_bool() {
-                    all.get_or_insert(res);
+                    return res;
                 }
             }
-            all.unwrap_or_else(|| EvalConfigResult::True)
+            EvalConfigResult::True
         }
         CfgEntry::Any(subs, span) => {
-            let mut any = None;
             for sub in subs {
-                let res = eval_config_entry(sess, sub, id, emit_lints);
-                // We cannot short-circuit because `eval_config_entry` emits some lints
-                if res.as_bool() {
-                    any.get_or_insert(res);
+                if eval_config_entry(sess, sub).as_bool() {
+                    return EvalConfigResult::True;
                 }
             }
-            any.unwrap_or_else(|| EvalConfigResult::False {
-                reason: cfg_entry.clone(),
-                reason_span: *span,
-            })
+            EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
         }
         CfgEntry::Not(sub, span) => {
-            if eval_config_entry(sess, sub, id, emit_lints).as_bool() {
+            if eval_config_entry(sess, sub).as_bool() {
                 EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             } else {
                 EvalConfigResult::True
@@ -244,31 +237,7 @@ pub fn eval_config_entry(
                 EvalConfigResult::False { reason: cfg_entry.clone(), reason_span: *span }
             }
         }
-        CfgEntry::NameValue { name, name_span, value, span } => {
-            if let ShouldEmit::ErrorsAndLints = emit_lints {
-                match sess.psess.check_config.expecteds.get(name) {
-                    Some(ExpectedValues::Some(values))
-                        if !values.contains(&value.map(|(v, _)| v)) =>
-                    {
-                        id.emit_span_lint(
-                            sess,
-                            UNEXPECTED_CFGS,
-                            *span,
-                            BuiltinLintDiag::UnexpectedCfgValue((*name, *name_span), *value),
-                        );
-                    }
-                    None if sess.psess.check_config.exhaustive_names => {
-                        id.emit_span_lint(
-                            sess,
-                            UNEXPECTED_CFGS,
-                            *span,
-                            BuiltinLintDiag::UnexpectedCfgName((*name, *name_span), *value),
-                        );
-                    }
-                    _ => { /* not unexpected */ }
-                }
-            }
-
+        CfgEntry::NameValue { name, name_span: _, value, span } => {
             if sess.psess.config.contains(&(*name, value.map(|(v, _)| v))) {
                 EvalConfigResult::True
             } else {

compiler/rustc_attr_parsing/src/interface.rs

@@ -115,7 +115,7 @@ impl<'sess> AttributeParser<'sess, Early> {
             OmitDoc::Skip,
             std::convert::identity,
             |lint| {
-                crate::lints::emit_attribute_lint(&lint, sess);
+                crate::lints::emit_attribute_lint(&lint, sess, sess);
             },
         )
     }
@@ -187,7 +187,7 @@ impl<'sess> AttributeParser<'sess, Early> {
                 target_span,
                 target_id: target_node_id,
                 emit_lint: &mut |lint| {
-                    crate::lints::emit_attribute_lint(&lint, sess);
+                    crate::lints::emit_attribute_lint(&lint, sess, sess);
                 },
             },
             attr_span,

compiler/rustc_attr_parsing/src/lints.rs

@@ -3,11 +3,17 @@ use std::borrow::Cow;
 use rustc_errors::{DiagArgValue, LintEmitter};
 use rustc_hir::Target;
 use rustc_hir::lints::{AttributeLint, AttributeLintKind};
+use rustc_session::Session;
 use rustc_span::sym;
 
-use crate::session_diagnostics;
+use crate::{session_diagnostics, unexpected_cfg_name, unexpected_cfg_value};
 
-pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<L::Id>, lint_emitter: L) {
+//tcx: TyCtxt<'_>
+pub fn emit_attribute_lint<L: LintEmitter>(
+    lint: &AttributeLint<L::Id>,
+    lint_emitter: L,
+    sess: &Session,
+) {
     let AttributeLint { id, span, kind } = lint;
 
     match kind {
@@ -98,5 +104,19 @@ pub fn emit_attribute_lint<L: LintEmitter>(lint: &AttributeLint<L::Id>, lint_emi
                 },
             )
         }
+        &AttributeLintKind::UnexpectedCfgName { name, name_span, value } => lint_emitter
+            .emit_node_span_lint(
+                rustc_session::lint::builtin::UNEXPECTED_CFGS,
+                *id,
+                *span,
+                unexpected_cfg_name(sess, None, (name, name_span), value),
+            ),
+        &AttributeLintKind::UnexpectedCfgValue { name, name_span, value } => lint_emitter
+            .emit_node_span_lint(
+                rustc_session::lint::builtin::UNEXPECTED_CFGS,
+                *id,
+                *span,
+                unexpected_cfg_value(sess, None, (name, name_span), value),
+            ),
     }
 }

compiler/rustc_builtin_macros/src/cfg.rs

@@ -26,13 +26,7 @@ pub(crate) fn expand_cfg(
 
     ExpandResult::Ready(match parse_cfg(cx, sp, tts) {
         Ok(cfg) => {
-            let matches_cfg = attr::eval_config_entry(
-                cx.sess,
-                &cfg,
-                cx.current_expansion.lint_node_id,
-                ShouldEmit::ErrorsAndLints,
-            )
-            .as_bool();
+            let matches_cfg = attr::eval_config_entry(cx.sess, &cfg).as_bool();
 
             MacEager::expr(cx.expr_bool(sp, matches_cfg))
         }

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -11,12 +11,7 @@ use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
 /// Selects the first arm whose predicate evaluates to true.
 fn select_arm(ecx: &ExtCtxt<'_>, branches: CfgSelectBranches) -> Option<(TokenStream, Span)> {
     for (cfg, tt, arm_span) in branches.reachable {
-        if let EvalConfigResult::True = attr::eval_config_entry(
-            &ecx.sess,
-            &cfg,
-            ecx.current_expansion.lint_node_id,
-            ShouldEmit::ErrorsAndLints,
-        ) {
+        if let EvalConfigResult::True = attr::eval_config_entry(&ecx.sess, &cfg) {
             return Some((tt, arm_span));
         }
     }

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -13,8 +13,7 @@ use find_msvc_tools;
 use itertools::Itertools;
 use regex::Regex;
 use rustc_arena::TypedArena;
-use rustc_ast::CRATE_NODE_ID;
-use rustc_attr_parsing::{ShouldEmit, eval_config_entry};
+use rustc_attr_parsing::eval_config_entry;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::temp_dir::MaybeTempDir;
@@ -3033,9 +3032,7 @@ fn add_dynamic_crate(cmd: &mut dyn Linker, sess: &Session, cratepath: &Path) {
 
 fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {
     match lib.cfg {
-        Some(ref cfg) => {
-            eval_config_entry(sess, cfg, CRATE_NODE_ID, ShouldEmit::ErrorsAndLints).as_bool()
-        }
+        Some(ref cfg) => eval_config_entry(sess, cfg).as_bool(),
         None => true,
     }
 }

compiler/rustc_expand/src/config.rs

@@ -165,10 +165,7 @@ pub fn pre_configure_attrs(sess: &Session, attrs: &[Attribute]) -> ast::AttrVec
         .iter()
         .flat_map(|attr| strip_unconfigured.process_cfg_attr(attr))
         .take_while(|attr| {
-            !is_cfg(attr)
-                || strip_unconfigured
-                    .cfg_true(attr, strip_unconfigured.lint_node_id, ShouldEmit::Nothing)
-                    .as_bool()
+            !is_cfg(attr) || strip_unconfigured.cfg_true(attr, ShouldEmit::Nothing).as_bool()
         })
         .collect()
 }
@@ -318,14 +315,7 @@ impl<'a> StripUnconfigured<'a> {
             );
         }
 
-        if !attr::eval_config_entry(
-            self.sess,
-            &cfg_predicate,
-            ast::CRATE_NODE_ID,
-            ShouldEmit::ErrorsAndLints,
-        )
-        .as_bool()
-        {
+        if !attr::eval_config_entry(self.sess, &cfg_predicate).as_bool() {
             return vec![trace_attr];
         }
 
@@ -409,18 +399,12 @@ impl<'a> StripUnconfigured<'a> {
 
     /// Determines if a node with the given attributes should be included in this configuration.
     fn in_cfg(&self, attrs: &[Attribute]) -> bool {
-        attrs.iter().all(|attr| {
-            !is_cfg(attr)
-                || self.cfg_true(attr, self.lint_node_id, ShouldEmit::ErrorsAndLints).as_bool()
-        })
+        attrs
+            .iter()
+            .all(|attr| !is_cfg(attr) || self.cfg_true(attr, ShouldEmit::ErrorsAndLints).as_bool())
     }
 
-    pub(crate) fn cfg_true(
-        &self,
-        attr: &Attribute,
-        node: NodeId,
-        emit_errors: ShouldEmit,
-    ) -> EvalConfigResult {
+    pub(crate) fn cfg_true(&self, attr: &Attribute, emit_errors: ShouldEmit) -> EvalConfigResult {
         // 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(),
@@ -432,7 +416,7 @@ impl<'a> StripUnconfigured<'a> {
             self.sess,
             attr,
             attr.span,
-            node,
+            self.lint_node_id,
             self.features,
             emit_errors,
             parse_cfg,
@@ -442,7 +426,7 @@ impl<'a> StripUnconfigured<'a> {
             return EvalConfigResult::True;
         };
 
-        eval_config_entry(self.sess, &cfg, self.lint_node_id, emit_errors)
+        eval_config_entry(self.sess, &cfg)
     }
 
     /// If attributes are not allowed on expressions, emit an error for `attr`

compiler/rustc_expand/src/expand.rs

@@ -2213,11 +2213,11 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
 
     fn expand_cfg_true(
         &mut self,
-        node: &mut (impl HasAttrs + HasNodeId),
+        node: &mut impl HasAttrs,
         attr: ast::Attribute,
         pos: usize,
     ) -> EvalConfigResult {
-        let res = self.cfg().cfg_true(&attr, node.node_id(), ShouldEmit::ErrorsAndLints);
+        let res = self.cfg().cfg_true(&attr, ShouldEmit::ErrorsAndLints);
         if res.as_bool() {
             // A trace attribute left in AST in place of the original `cfg` attribute.
             // It can later be used by lints or other diagnostics.

compiler/rustc_hir/src/lints.rs

@@ -1,6 +1,6 @@
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_macros::HashStable_Generic;
-use rustc_span::Span;
+use rustc_span::{Span, Symbol};
 
 use crate::{AttrPath, HirId, Target};
 
@@ -62,4 +62,14 @@ pub enum AttributeLintKind {
         target: Target,
         target_span: Span,
     },
+    UnexpectedCfgName {
+        name: Symbol,
+        name_span: Span,
+        value: Option<(Symbol, Span)>,
+    },
+    UnexpectedCfgValue {
+        name: Symbol,
+        name_span: Span,
+        value: Option<(Symbol, Span)>,
+    },
 }

compiler/rustc_hir_analysis/src/lib.rs

@@ -158,7 +158,7 @@ pub fn provide(providers: &mut Providers) {
 fn emit_delayed_lint(lint: &DelayedLint, tcx: TyCtxt<'_>) {
     match lint {
         DelayedLint::AttributeParsing(attribute_lint) => {
-            rustc_attr_parsing::emit_attribute_lint(attribute_lint, tcx)
+            rustc_attr_parsing::emit_attribute_lint(attribute_lint, tcx, tcx.sess)
         }
     }
 }