Auto merge of #149960 - folkertdev:cfg-select-unreachable-lint, r=JonathanBrouwer,Urgau

add `unreachable_cfg_select_predicates` lint

tracking issue: #115585

Split out from #149783. This lint is emitted on branches of a `cfg_select!` that are statically known to be unreachable. The lint is only emitted when the feature is enabled, so this change specifically does not need an FCP, and the lint will be stabilized alongside the feature (see #149783 (comment)).

Author: bors

Cargo.lock

@@ -3539,6 +3539,7 @@ dependencies = [
  "rustc_abi",
  "rustc_ast",
  "rustc_ast_pretty",
+ "rustc_data_structures",
  "rustc_errors",
  "rustc_feature",
  "rustc_hir",

compiler/rustc_attr_parsing/Cargo.toml

@@ -8,6 +8,7 @@ edition = "2024"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
+rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_hir = { path = "../rustc_hir" }

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -1,22 +1,35 @@
 use rustc_ast::token::Token;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{AttrStyle, NodeId, token};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_feature::{AttributeTemplate, Features};
 use rustc_hir::attrs::CfgEntry;
 use rustc_hir::{AttrPath, Target};
 use rustc_parse::exp;
 use rustc_parse::parser::{Parser, Recovery};
 use rustc_session::Session;
-use rustc_span::{ErrorGuaranteed, Span, sym};
+use rustc_session::lint::BuiltinLintDiag;
+use rustc_session::lint::builtin::UNREACHABLE_CFG_SELECT_PREDICATES;
+use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 
 use crate::parser::MetaItemOrLitParser;
 use crate::{AttributeParser, ParsedDescription, ShouldEmit, parse_cfg_entry};
 
+#[derive(Clone)]
 pub enum CfgSelectPredicate {
     Cfg(CfgEntry),
     Wildcard(Token),
 }
 
+impl CfgSelectPredicate {
+    fn span(&self) -> Span {
+        match self {
+            CfgSelectPredicate::Cfg(cfg_entry) => cfg_entry.span(),
+            CfgSelectPredicate::Wildcard(token) => token.span,
+        }
+    }
+}
+
 #[derive(Default)]
 pub struct CfgSelectBranches {
     /// All the conditional branches.
@@ -115,5 +128,102 @@ pub fn parse_cfg_select(
         }
     }
 
+    if let Some(features) = features
+        && features.enabled(sym::cfg_select)
+    {
+        let it = branches
+            .reachable
+            .iter()
+            .map(|(entry, _, _)| CfgSelectPredicate::Cfg(entry.clone()))
+            .chain(branches.wildcard.as_ref().map(|(t, _, _)| CfgSelectPredicate::Wildcard(*t)))
+            .chain(
+                branches.unreachable.iter().map(|(entry, _, _)| CfgSelectPredicate::clone(entry)),
+            );
+
+        lint_unreachable(p, it, lint_node_id);
+    }
+
     Ok(branches)
 }
+
+fn lint_unreachable(
+    p: &mut Parser<'_>,
+    predicates: impl Iterator<Item = CfgSelectPredicate>,
+    lint_node_id: NodeId,
+) {
+    // Symbols that have a known value.
+    let mut known = FxHashMap::<Symbol, bool>::default();
+    let mut wildcard_span = None;
+    let mut it = predicates;
+
+    let branch_is_unreachable = |predicate: CfgSelectPredicate, wildcard_span| {
+        let span = predicate.span();
+        p.psess.buffer_lint(
+            UNREACHABLE_CFG_SELECT_PREDICATES,
+            span,
+            lint_node_id,
+            BuiltinLintDiag::UnreachableCfg { span, wildcard_span },
+        );
+    };
+
+    for predicate in &mut it {
+        let CfgSelectPredicate::Cfg(ref cfg_entry) = predicate else {
+            wildcard_span = Some(predicate.span());
+            break;
+        };
+
+        match cfg_entry {
+            CfgEntry::Bool(true, _) => {
+                wildcard_span = Some(predicate.span());
+                break;
+            }
+            CfgEntry::Bool(false, _) => continue,
+            CfgEntry::NameValue { name, value, .. } => match value {
+                None => {
+                    // `name` will be false in all subsequent branches.
+                    let current = known.insert(*name, false);
+
+                    match current {
+                        None => continue,
+                        Some(false) => {
+                            branch_is_unreachable(predicate, None);
+                            break;
+                        }
+                        Some(true) => {
+                            // this branch will be taken, so all subsequent branches are unreachable.
+                            break;
+                        }
+                    }
+                }
+                Some(_) => { /* for now we don't bother solving these */ }
+            },
+            CfgEntry::Not(inner, _) => match &**inner {
+                CfgEntry::NameValue { name, value: None, .. } => {
+                    // `name` will be true in all subsequent branches.
+                    let current = known.insert(*name, true);
+
+                    match current {
+                        None => continue,
+                        Some(true) => {
+                            branch_is_unreachable(predicate, None);
+                            break;
+                        }
+                        Some(false) => {
+                            // this branch will be taken, so all subsequent branches are unreachable.
+                            break;
+                        }
+                    }
+                }
+                _ => { /* for now we don't bother solving these */ }
+            },
+            CfgEntry::All(_, _) | CfgEntry::Any(_, _) => {
+                /* for now we don't bother solving these */
+            }
+            CfgEntry::Version(..) => { /* don't bother solving these */ }
+        }
+    }
+
+    for predicate in it {
+        branch_is_unreachable(predicate, wildcard_span)
+    }
+}

compiler/rustc_builtin_macros/src/cfg_select.rs

@@ -1,14 +1,12 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{Expr, ast};
 use rustc_attr_parsing as attr;
-use rustc_attr_parsing::{
-    CfgSelectBranches, CfgSelectPredicate, EvalConfigResult, parse_cfg_select,
-};
+use rustc_attr_parsing::{CfgSelectBranches, EvalConfigResult, parse_cfg_select};
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacResult, MacroExpanderResult};
 use rustc_span::{Ident, Span, sym};
 use smallvec::SmallVec;
 
-use crate::errors::{CfgSelectNoMatches, CfgSelectUnreachable};
+use crate::errors::CfgSelectNoMatches;
 
 /// This intermediate structure is used to emit parse errors for the branches that are not chosen.
 /// The `MacResult` instance below parses all branches, emitting any errors it encounters, but only
@@ -75,18 +73,6 @@ pub(super) fn expand_cfg_select<'cx>(
             ecx.current_expansion.lint_node_id,
         ) {
             Ok(mut branches) => {
-                if let Some((underscore, _, _)) = branches.wildcard {
-                    // Warn for every unreachable predicate. We store the fully parsed branch for rustfmt.
-                    for (predicate, _, _) in &branches.unreachable {
-                        let span = match predicate {
-                            CfgSelectPredicate::Wildcard(underscore) => underscore.span,
-                            CfgSelectPredicate::Cfg(cfg) => cfg.span(),
-                        };
-                        let err = CfgSelectUnreachable { span, wildcard_span: underscore.span };
-                        ecx.dcx().emit_warn(err);
-                    }
-                }
-
                 if let Some((selected_tts, selected_span)) = branches.pop_first_match(|cfg| {
                     matches!(attr::eval_config_entry(&ecx.sess, cfg), EvalConfigResult::True)
                 }) {

compiler/rustc_builtin_macros/src/errors.rs

@@ -1086,17 +1086,6 @@ pub(crate) struct CfgSelectNoMatches {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag("unreachable predicate")]
-pub(crate) struct CfgSelectUnreachable {
-    #[primary_span]
-    #[label("this predicate is never reached")]
-    pub span: Span,
-
-    #[label("always matches")]
-    pub wildcard_span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag("`#[eii_declaration(...)]` is only valid on macros")]
 pub(crate) struct EiiExternTargetExpectedMacro {

compiler/rustc_feature/src/unstable.rs

@@ -392,6 +392,8 @@ declare_features! (
     (unstable, cfg_sanitize, "1.41.0", Some(39699)),
     /// Allows `cfg(sanitizer_cfi_generalize_pointers)` and `cfg(sanitizer_cfi_normalize_integers)`.
     (unstable, cfg_sanitizer_cfi, "1.77.0", Some(89653)),
+    /// Provides a native way to easily manage multiple conditional flags without having to rewrite each clause multiple times.
+    (unstable, cfg_select, "CURRENT_RUSTC_VERSION", Some(115585)),
     /// Allows `cfg(target(abi = "..."))`.
     (unstable, cfg_target_compact, "1.63.0", Some(96901)),
     /// Allows `cfg(target_has_atomic_load_store = "...")`.

compiler/rustc_lint/messages.ftl

@@ -998,6 +998,13 @@ lint_unpredictable_fn_pointer_comparisons = function pointer comparisons do not
 
 lint_unqualified_local_imports = `use` of a local item without leading `self::`, `super::`, or `crate::`
 
+lint_unreachable_cfg_select_predicate = unreachable configuration predicate
+    .label = this configuration predicate is never reached
+
+lint_unreachable_cfg_select_predicate_wildcard = unreachable configuration predicate
+    .label = always matches
+    .label2 = this configuration predicate is never reached
+
 lint_unsafe_attr_outside_unsafe = unsafe attribute used without unsafe
     .label = usage of unsafe attribute
 lint_unsafe_attr_outside_unsafe_suggestion = wrap the attribute in `unsafe(...)`

compiler/rustc_lint/src/early/diagnostics.rs

@@ -293,6 +293,14 @@ pub fn decorate_builtin_lint(
             }
             .decorate_lint(diag);
         }
+        BuiltinLintDiag::UnreachableCfg { span, wildcard_span } => match wildcard_span {
+            Some(wildcard_span) => {
+                lints::UnreachableCfgSelectPredicateWildcard { span, wildcard_span }
+                    .decorate_lint(diag)
+            }
+            None => lints::UnreachableCfgSelectPredicate { span }.decorate_lint(diag),
+        },
+
         BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => {
             lints::UnusedCrateDependency { extern_crate, local_crate }.decorate_lint(diag)
         }

compiler/rustc_lint/src/lib.rs

@@ -297,6 +297,9 @@ fn register_builtins(store: &mut LintStore) {
         UNUSED_ASSIGNMENTS,
         DEAD_CODE,
         UNUSED_MUT,
+        // FIXME: add this lint when it becomes stable,
+        // see https://github.com/rust-lang/rust/issues/115585.
+        // UNREACHABLE_CFG_SELECT_PREDICATES,
         UNREACHABLE_CODE,
         UNREACHABLE_PATTERNS,
         UNUSED_MUST_USE,

compiler/rustc_lint/src/lints.rs

@@ -3340,3 +3340,20 @@ pub(crate) struct UnknownCrateTypesSuggestion {
     pub span: Span,
     pub snippet: Symbol,
 }
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unreachable_cfg_select_predicate)]
+pub(crate) struct UnreachableCfgSelectPredicate {
+    #[label]
+    pub span: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unreachable_cfg_select_predicate_wildcard)]
+pub(crate) struct UnreachableCfgSelectPredicateWildcard {
+    #[label(lint_label2)]
+    pub span: Span,
+
+    #[label]
+    pub wildcard_span: Span,
+}