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_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 = in the past, `false` and `true` were not accepted, so this was a common pattern
+    .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,29 @@ 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.
+    /// In the past, `false` and `true` were not accepted, so this was a common pattern.
+    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

src/tools/clippy/tests/ui/let_and_return.edition2021.fixed

@@ -9,14 +9,14 @@ use std::cell::RefCell;
 
 fn test() -> i32 {
     let _y = 0; // no warning
-    
+
     5
     //~^ let_and_return
 }
 
 fn test_inner() -> i32 {
     if true {
-        
+
         5
         //~^ let_and_return
     } else {
@@ -79,7 +79,7 @@ fn issue_3792() -> String {
     let stdin = io::stdin();
     // `Stdin::lock` returns `StdinLock<'static>` so `line` doesn't borrow from `stdin`
     // https://github.com/rust-lang/rust/pull/93965
-    
+
     stdin.lock().lines().next().unwrap().unwrap()
     //~^ let_and_return
 }
@@ -174,7 +174,7 @@ mod issue_5729 {
 
     impl<T: Foo + 'static> FooStorage for FooStorageImpl<T> {
         fn foo_cloned(&self) -> Arc<dyn Foo> {
-            
+
             (Arc::clone(&self.foo)) as _
             //~^ let_and_return
         }
@@ -189,7 +189,7 @@ mod issue_11335 {
 
     impl<T> E<T> {
         pub fn inner(&self) -> &T {
-            
+
 
             (match self {
                 E::A(x) => x,
@@ -212,39 +212,39 @@ fn_in_macro!({
 
 fn issue9150() -> usize {
     let x = 1;
-    #[cfg(any())]
+    #[cfg(false)]
     panic!("can't see me");
     x
 }
 
 fn issue12801() {
     fn left_is_if() -> String {
-        
+
         (if true { "a".to_string() } else { "b".to_string() } + "c")
         //~^ let_and_return
     }
 
     fn no_par_needed() -> String {
-        
+
         "c".to_string() + if true { "a" } else { "b" }
         //~^ let_and_return
     }
 
     fn conjunctive_blocks() -> String {
-        
+
         ({ "a".to_string() } + "b" + { "c" } + "d")
         //~^ let_and_return
     }
 
     #[allow(clippy::overly_complex_bool_expr)]
     fn other_ops() {
         let _ = || {
-            
+
             (if true { 2 } else { 3 } << 4)
             //~^ let_and_return
         };
         let _ = || {
-            
+
             ({ true } || { false } && { 2 <= 3 })
             //~^ let_and_return
         };