Lint against cfg(any()) and cfg(all())

Author: jamie-osec

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -12,7 +12,7 @@ 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::builtin::UNEXPECTED_CFGS;
+use rustc_session::lint::builtin::{EMPTY_CFG_PREDICATE, UNEXPECTED_CFGS};
 use rustc_session::parse::{ParseSess, feature_err};
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 use thin_vec::ThinVec;
@@ -63,14 +63,42 @@ pub fn parse_cfg_entry<S: Stage>(
                     };
                     CfgEntry::Not(Box::new(parse_cfg_entry(cx, single)?), list.span)
                 }
-                Some(sym::any) => CfgEntry::Any(
-                    list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
-                    list.span,
-                ),
-                Some(sym::all) => CfgEntry::All(
-                    list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
-                    list.span,
-                ),
+                Some(sym::any) => {
+                    if list.is_empty() && !list.span.from_expansion() {
+                        let span = meta.span();
+                        cx.emit_lint(
+                            EMPTY_CFG_PREDICATE,
+                            AttributeLintKind::EmptyCfgPredictate {
+                                predicate_span: span,
+                                predicate: sym::any,
+                                lit: false,
+                            },
+                            span,
+                        );
+                    }
+                    CfgEntry::Any(
+                        list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
+                        list.span,
+                    )
+                }
+                Some(sym::all) => {
+                    if list.is_empty() && !list.span.from_expansion() {
+                        let span = meta.span();
+                        cx.emit_lint(
+                            EMPTY_CFG_PREDICATE,
+                            AttributeLintKind::EmptyCfgPredictate {
+                                predicate_span: span,
+                                predicate: sym::all,
+                                lit: true,
+                            },
+                            span,
+                        );
+                    }
+                    CfgEntry::All(
+                        list.mixed().flat_map(|sub_item| parse_cfg_entry(cx, sub_item)).collect(),
+                        list.span,
+                    )
+                }
                 Some(sym::target) => parse_cfg_entry_target(cx, list, meta.span())?,
                 Some(sym::version) => parse_cfg_entry_version(cx, list, meta.span())?,
                 _ => {

compiler/rustc_codegen_cranelift/src/base.rs

@@ -167,7 +167,7 @@ pub(crate) fn compile_fn(
     context.clear();
     context.func = codegened_func.func;
 
-    #[cfg(any())] // This is never true
+    #[cfg(false)]
     let _clif_guard = {
         use std::fmt::Write;
 

compiler/rustc_lint/messages.ftl

@@ -256,6 +256,10 @@ lint_empty_attribute =
         *[other] using `{$attr_path}` with an empty list has no effect
     }
 
+lint_empty_cfg_predicate = use of empty `cfg({$predicate}())`
+    .note = this used to be a common pattern before `cfg(true)` and `cfg(false)` were added to the language in Rust 1.88
+    .suggestion = consider using a boolean literal
+
 -lint_previously_accepted =
     this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
 lint_enum_intrinsics_mem_discriminant =

compiler/rustc_lint/src/early/diagnostics.rs

@@ -367,5 +367,8 @@ pub fn decorate_attribute_lint(
         &AttributeLintKind::UnexpectedCfgValue(name, value) => {
             check_cfg::unexpected_cfg_value(sess, tcx, name, value).decorate_lint(diag)
         }
+        &AttributeLintKind::EmptyCfgPredictate { predicate_span, predicate, lit } => {
+            lints::EmptyCfgPredicate { predicate_span, predicate, lit }.decorate_lint(diag)
+        }
     }
 }

compiler/rustc_lint/src/lints.rs

@@ -3137,6 +3137,16 @@ pub(crate) struct EmptyAttributeList {
     pub valid_without_list: bool,
 }
 
+#[derive(LintDiagnostic)]
+#[diag(lint_empty_cfg_predicate)]
+#[note]
+pub(crate) struct EmptyCfgPredicate {
+    #[suggestion(code = "{lit}", applicability = "machine-applicable", style = "verbose")]
+    pub predicate_span: Span,
+    pub predicate: Symbol,
+    pub lit: bool,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(lint_invalid_target)]
 #[warning]

compiler/rustc_lint_defs/src/builtin.rs

@@ -40,6 +40,7 @@ declare_lint_pass! {
         DUPLICATE_MACRO_ATTRIBUTES,
         ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
         ELIDED_LIFETIMES_IN_PATHS,
+        EMPTY_CFG_PREDICATE,
         EXPLICIT_BUILTIN_CFGS_IN_FLAGS,
         EXPORTED_PRIVATE_DEPENDENCIES,
         FFI_UNWIND_CALLS,
@@ -5368,3 +5369,30 @@ declare_lint! {
         report_in_deps: false,
     };
 }
+
+declare_lint! {
+    /// The `empty_cfg_predicate` lint detects the use of empty `cfg` predicate lists.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,compile_fail
+    /// #![deny(empty_cfg_predicate)]
+    /// #[cfg(any())]
+    /// fn foo() {}
+    ///
+    /// #[cfg(all())]
+    /// fn bar() {}
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// The meaning of `cfg(any())` and `cfg(all())` is not immediately obvious;
+    /// `cfg(false)` and `cfg(true)` respectively may be used instead.
+    /// This used to be a common pattern before `cfg(true)` and `cfg(false)`
+    /// were added to the language in Rust 1.88
+    pub EMPTY_CFG_PREDICATE,
+    Warn,
+    "detects use of empty `cfg(any())` and `cfg(all())`"
+}

compiler/rustc_lint_defs/src/lib.rs

@@ -733,6 +733,14 @@ pub enum AttributeLintKind {
     },
     UnexpectedCfgName((Symbol, Span), Option<(Symbol, Span)>),
     UnexpectedCfgValue((Symbol, Span), Option<(Symbol, Span)>),
+    EmptyCfgPredictate {
+        /// Span of `any()`/`all()`
+        predicate_span: Span,
+        /// Either `any` or `all`
+        predicate: Symbol,
+        /// The boolean literal to replace with
+        lit: bool,
+    },
 }
 
 pub type RegisteredTools = FxIndexSet<Ident>;

src/tools/clippy/tests/ui/empty_line_after/doc_comments.1.fixed

@@ -125,7 +125,7 @@ pub struct EmptyInBlockComment;
 pub struct BlockComment;
 
 /// Ignore the empty line inside a cfg_attr'd out attribute
-#[cfg_attr(any(), multiline(
+#[cfg_attr(false, multiline(
     foo = 1
 
     bar = 2

src/tools/clippy/tests/ui/empty_line_after/doc_comments.2.fixed

@@ -134,7 +134,7 @@ pub struct EmptyInBlockComment;
 pub struct BlockComment;
 
 /// Ignore the empty line inside a cfg_attr'd out attribute
-#[cfg_attr(any(), multiline(
+#[cfg_attr(false, multiline(
     foo = 1
 
     bar = 2

src/tools/clippy/tests/ui/empty_line_after/doc_comments.rs

@@ -137,7 +137,7 @@ pub struct EmptyInBlockComment;
 pub struct BlockComment;
 
 /// Ignore the empty line inside a cfg_attr'd out attribute
-#[cfg_attr(any(), multiline(
+#[cfg_attr(false, multiline(
     foo = 1
 
     bar = 2