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>;

library/core/src/primitive_docs.rs

@@ -591,7 +591,7 @@ impl () {}
 /// # pub unsafe fn malloc(_size: usize) -> *mut core::ffi::c_void { core::ptr::NonNull::dangling().as_ptr() }
 /// # pub unsafe fn free(_ptr: *mut core::ffi::c_void) {}
 /// # }
-/// # #[cfg(any())]
+/// # #[cfg(false)]
 /// #[allow(unused_extern_crates)]
 /// extern crate libc;
 ///

src/tools/clippy/clippy_lints/src/attrs/non_minimal_cfg.rs

@@ -39,14 +39,6 @@ fn check_nested_cfg(cx: &EarlyContext<'_>, items: &[MetaItemInner]) {
                             }
                         },
                     );
-                } else if list.is_empty() && meta.has_name(sym::all) {
-                    span_lint_and_then(
-                        cx,
-                        NON_MINIMAL_CFG,
-                        meta.span,
-                        "unneeded sub `cfg` when there is no condition",
-                        |_| {},
-                    );
                 }
             }
         }

src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.fixed

@@ -46,36 +46,36 @@ mod field_attributes {
 // https://github.com/rust-lang/rust-clippy/pull/13737#discussion_r1874539800
 mod cfgs_between_fields {
     #[allow(clippy::non_minimal_cfg)]
-    fn cfg_all() {
+    fn cfg_true() {
         struct S {
             a: i32,
             b: i32,
-            #[cfg(all())]
+            #[cfg(true)]
             c: i32,
             d: i32,
         }
         let s = S {
             a: 3,
             //~^ inconsistent_struct_constructor
             b: 2,
-            #[cfg(all())]
+            #[cfg(true)]
             c: 1,
             d: 0,
         };
     }
 
-    fn cfg_any() {
+    fn cfg_false() {
         struct S {
             a: i32,
             b: i32,
-            #[cfg(any())]
+            #[cfg(false)]
             c: i32,
             d: i32,
         }
         let s = S {
             a: 3,
             //~^ inconsistent_struct_constructor
-            #[cfg(any())]
+            #[cfg(false)]
             c: 1,
             b: 2,
             d: 0,