Rollup of 5 pull requests

Cargo.lock

@@ -3539,6 +3539,7 @@ dependencies = [
  "rustc_abi",
  "rustc_ast",
  "rustc_ast_pretty",
+ "rustc_data_structures",
  "rustc_errors",
  "rustc_feature",
  "rustc_hir",
@@ -3703,7 +3704,6 @@ dependencies = [
  "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
- "rustc_fluent_macro",
  "rustc_hir",
  "rustc_index",
  "rustc_infer",
@@ -4281,7 +4281,6 @@ dependencies = [
  "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
- "rustc_fluent_macro",
  "rustc_hir",
  "rustc_index",
  "rustc_infer",

compiler/rustc_ast_lowering/src/item.rs

@@ -827,7 +827,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
             hir_id,
             def_id: self.local_def_id(v.id),
             data: self.lower_variant_data(hir_id, item_kind, &v.data),
-            disr_expr: v.disr_expr.as_ref().map(|e| self.lower_anon_const_to_anon_const(e)),
+            disr_expr: v
+                .disr_expr
+                .as_ref()
+                .map(|e| self.lower_anon_const_to_anon_const(e, e.value.span)),
             ident: self.lower_ident(v.ident),
             span: self.lower_span(v.span),
         }
@@ -917,7 +920,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 None => Ident::new(sym::integer(index), self.lower_span(f.span)),
             },
             vis_span: self.lower_span(f.vis.span),
-            default: f.default.as_ref().map(|v| self.lower_anon_const_to_anon_const(v)),
+            default: f
+                .default
+                .as_ref()
+                .map(|v| self.lower_anon_const_to_anon_const(v, v.value.span)),
             ty,
             safety: self.lower_safety(f.safety, hir::Safety::Safe),
         }

compiler/rustc_ast_lowering/src/lib.rs

@@ -2425,15 +2425,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 );
 
                 let lowered_args = self.arena.alloc_from_iter(args.iter().map(|arg| {
-                    let const_arg = if let ExprKind::ConstBlock(anon_const) = &arg.kind {
-                        let def_id = self.local_def_id(anon_const.id);
-                        let def_kind = self.tcx.def_kind(def_id);
-                        assert_eq!(DefKind::AnonConst, def_kind);
-                        self.lower_anon_const_to_const_arg(anon_const)
-                    } else {
-                        self.lower_expr_to_const_arg_direct(arg)
-                    };
-
+                    let const_arg = self.lower_expr_to_const_arg_direct(arg);
                     &*self.arena.alloc(const_arg)
                 }));
 
@@ -2445,16 +2437,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
             ExprKind::Tup(exprs) => {
                 let exprs = self.arena.alloc_from_iter(exprs.iter().map(|expr| {
-                    let expr = if let ExprKind::ConstBlock(anon_const) = &expr.kind {
-                        let def_id = self.local_def_id(anon_const.id);
-                        let def_kind = self.tcx.def_kind(def_id);
-                        assert_eq!(DefKind::AnonConst, def_kind);
-
-                        self.lower_anon_const_to_const_arg(anon_const)
-                    } else {
-                        self.lower_expr_to_const_arg_direct(&expr)
-                    };
-
+                    let expr = self.lower_expr_to_const_arg_direct(&expr);
                     &*self.arena.alloc(expr)
                 }));
 
@@ -2494,16 +2477,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     // then go unused as the `Target::ExprField` is not actually
                     // corresponding to `Node::ExprField`.
                     self.lower_attrs(hir_id, &f.attrs, f.span, Target::ExprField);
-
-                    let expr = if let ExprKind::ConstBlock(anon_const) = &f.expr.kind {
-                        let def_id = self.local_def_id(anon_const.id);
-                        let def_kind = self.tcx.def_kind(def_id);
-                        assert_eq!(DefKind::AnonConst, def_kind);
-
-                        self.lower_anon_const_to_const_arg(anon_const)
-                    } else {
-                        self.lower_expr_to_const_arg_direct(&f.expr)
-                    };
+                    let expr = self.lower_expr_to_const_arg_direct(&f.expr);
 
                     &*self.arena.alloc(hir::ConstArgExprField {
                         hir_id,
@@ -2521,13 +2495,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             }
             ExprKind::Array(elements) => {
                 let lowered_elems = self.arena.alloc_from_iter(elements.iter().map(|element| {
-                    let const_arg = if let ExprKind::ConstBlock(anon_const) = &element.kind {
-                        let def_id = self.local_def_id(anon_const.id);
-                        assert_eq!(DefKind::AnonConst, self.tcx.def_kind(def_id));
-                        self.lower_anon_const_to_const_arg(anon_const)
-                    } else {
-                        self.lower_expr_to_const_arg_direct(element)
-                    };
+                    let const_arg = self.lower_expr_to_const_arg_direct(element);
                     &*self.arena.alloc(const_arg)
                 }));
                 let array_expr = self.arena.alloc(hir::ConstArgArrayExpr {
@@ -2557,6 +2525,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                             | ExprKind::Call(..)
                             | ExprKind::Tup(..)
                             | ExprKind::Array(..)
+                            | ExprKind::ConstBlock(..)
                     )
                 {
                     return self.lower_expr_to_const_arg_direct(expr);
@@ -2586,6 +2555,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     span,
                 }
             }
+            ExprKind::ConstBlock(anon_const) => {
+                let def_id = self.local_def_id(anon_const.id);
+                assert_eq!(DefKind::AnonConst, self.tcx.def_kind(def_id));
+                self.lower_anon_const_to_const_arg(anon_const, span)
+            }
             _ => overly_complex_const(self),
         }
     }
@@ -2596,11 +2570,15 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         &mut self,
         anon: &AnonConst,
     ) -> &'hir hir::ConstArg<'hir> {
-        self.arena.alloc(self.lower_anon_const_to_const_arg(anon))
+        self.arena.alloc(self.lower_anon_const_to_const_arg(anon, anon.value.span))
     }
 
     #[instrument(level = "debug", skip(self))]
-    fn lower_anon_const_to_const_arg(&mut self, anon: &AnonConst) -> hir::ConstArg<'hir> {
+    fn lower_anon_const_to_const_arg(
+        &mut self,
+        anon: &AnonConst,
+        span: Span,
+    ) -> hir::ConstArg<'hir> {
         let tcx = self.tcx;
 
         // We cannot change parsing depending on feature gates available,
@@ -2611,7 +2589,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         if tcx.features().min_generic_const_args() {
             return match anon.mgca_disambiguation {
                 MgcaDisambiguation::AnonConst => {
-                    let lowered_anon = self.lower_anon_const_to_anon_const(anon);
+                    let lowered_anon = self.lower_anon_const_to_anon_const(anon, span);
                     ConstArg {
                         hir_id: self.next_id(),
                         kind: hir::ConstArgKind::Anon(lowered_anon),
@@ -2657,7 +2635,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             };
         }
 
-        let lowered_anon = self.lower_anon_const_to_anon_const(anon);
+        let lowered_anon = self.lower_anon_const_to_anon_const(anon, anon.value.span);
         ConstArg {
             hir_id: self.next_id(),
             kind: hir::ConstArgKind::Anon(lowered_anon),
@@ -2667,15 +2645,19 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
     /// See [`hir::ConstArg`] for when to use this function vs
     /// [`Self::lower_anon_const_to_const_arg`].
-    fn lower_anon_const_to_anon_const(&mut self, c: &AnonConst) -> &'hir hir::AnonConst {
+    fn lower_anon_const_to_anon_const(
+        &mut self,
+        c: &AnonConst,
+        span: Span,
+    ) -> &'hir hir::AnonConst {
         self.arena.alloc(self.with_new_scopes(c.value.span, |this| {
             let def_id = this.local_def_id(c.id);
             let hir_id = this.lower_node_id(c.id);
             hir::AnonConst {
                 def_id,
                 hir_id,
                 body: this.lower_const_body(c.value.span, Some(&c.value)),
-                span: this.lower_span(c.value.span),
+                span: this.lower_span(span),
             }
         }))
     }

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 {