EVERYTHING GREEN

Author: blyxyas

compiler/rustc_interface/src/passes.rs

@@ -895,7 +895,7 @@ fn analysis(tcx: TyCtxt<'_>, (): ()) -> Result<()> {
                         tcx.ensure().check_mod_privacy(module);
                     });
                 });
-            }
+            } // { sess.time("mir_checking", || { tcx.hir().mir_for }) }
         );
 
         // This check has to be run after all lints are done processing. We don't

compiler/rustc_lint/src/builtin.rs

@@ -20,6 +20,7 @@
 //! If you define a new `LateLintPass`, you will also need to add it to the
 //! `late_lint_methods!` invocation in `lib.rs`.
 
+use std::default::Default;
 use std::fmt::Write;
 
 use ast::token::TokenKind;
@@ -73,12 +74,10 @@ use crate::{
     fluent_generated as fluent, EarlyContext, EarlyLintPass, LateContext, LateLintPass, Level,
     LintContext,
 };
-
-use std::default::Default;
-use std::fmt::Write;
+// use std::fmt::Write;
 
 // hardwired lints from rustc_lint_defs
-pub use rustc_session::lint::builtin::*;
+// pub use rustc_session::lint::builtin::*;
 
 declare_lint! {
     /// The `while_true` lint detects `while true { }`.

compiler/rustc_lint/src/late.rs

@@ -24,13 +24,14 @@ use rustc_hir::def_id::{LocalDefId, LocalModDefId};
 use rustc_hir::{intravisit as hir_visit, HirId};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::{self, TyCtxt};
+use rustc_session::lint::builtin::HardwiredLints;
 use rustc_session::lint::LintPass;
 use rustc_session::Session;
 use rustc_span::Span;
 use tracing::debug;
 
 use crate::passes::LateLintPassObject;
-use crate::{LateContext, LateLintPass, LintStore, LintId};
+use crate::{LateContext, LateLintPass, LintId, LintStore};
 
 /// Extract the [`LintStore`] from [`Session`].
 ///
@@ -378,12 +379,18 @@ pub fn late_lint_mod<'tcx, T: LateLintPass<'tcx> + 'tcx>(
             .into_iter()
             .filter(|pass| {
                 let lints = LintPass::get_lints(pass);
-                lints.iter()
-                    .any(|lint|
-                        !lints_that_dont_need_to_run.contains(&LintId::of(lint)))
-        }).collect();
+                if lints.is_empty() {
+                    true
+                } else {
+                    lints
+                        .iter()
+                        .any(|lint| !lints_that_dont_need_to_run.contains(&LintId::of(lint)))
+                }
+            })
+            .collect();
 
         filtered_passes.push(Box::new(builtin_lints));
+        filtered_passes.push(Box::new(HardwiredLints));
 
         let pass = RuntimeCombinedLateLintPass { passes: &mut filtered_passes[..] };
         late_lint_mod_inner(tcx, module_def_id, context, pass);
@@ -438,14 +445,14 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
 
     // dbg!(&lints_that_dont_need_to_run);
     let mut filtered_passes: Vec<Box<dyn LateLintPass<'tcx>>> = passes
-    .into_iter()
-    .filter(|pass|{
-        let lints = LintPass::get_lints(pass);
-        // dbg!(&lints);
-        lints.iter()
-            .any(|lint|
-                !lints_that_dont_need_to_run.contains(&LintId::of(lint)))
-    }).collect();
+        .into_iter()
+        .filter(|pass| {
+            let lints = LintPass::get_lints(pass);
+            !lints.iter().all(|lint| lints_that_dont_need_to_run.contains(&LintId::of(lint)))
+        })
+        .collect();
+
+    filtered_passes.push(Box::new(HardwiredLints));
 
     // let mut filtered_passes: Vec<Box<dyn LateLintPass<'tcx>>> = passes
     // .into_iter()
@@ -455,6 +462,7 @@ fn late_lint_crate<'tcx>(tcx: TyCtxt<'tcx>) {
     //         .any(|lint|
     //             !lints_that_dont_need_to_run.contains(&LintId::of(lint)))
     // }).collect();
+    //
 
     let pass = RuntimeCombinedLateLintPass { passes: &mut filtered_passes[..] };
     late_lint_crate_inner(tcx, context, pass);

compiler/rustc_lint/src/levels.rs

@@ -1,5 +1,5 @@
 use rustc_ast_pretty::pprust;
-use rustc_data_structures::{fx::FxIndexMap, fx::FxIndexSet};
+use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_errors::{Diag, LintDiagnostic, MultiSpan};
 use rustc_feature::{Features, GateIssue};
 use rustc_hir::intravisit::{self, Visitor};
@@ -31,7 +31,7 @@ use crate::errors::{
     OverruledAttributeSub, RequestedLevel, UnknownToolInScopedLint, UnsupportedGroup,
 };
 use crate::fluent_generated as fluent;
-use crate::late::{unerased_lint_store, name_without_tool};
+use crate::late::{unerased_lint_store /*name_without_tool*/};
 use crate::lints::{
     DeprecatedLintName, DeprecatedLintNameFromCommandLine, IgnoredUnlessCrateSpecified,
     OverruledAttributeLint, RemovedLint, RemovedLintFromCommandLine, RenamedLint,
@@ -115,10 +115,7 @@ impl LintLevelSets {
     }
 }
 
-pub fn lints_that_dont_need_to_run(
-    tcx: TyCtxt<'_>,
-    (): (),
-) -> FxIndexSet<LintId> {
+pub fn lints_that_dont_need_to_run(tcx: TyCtxt<'_>, (): ()) -> FxIndexSet<LintId> {
     let store = unerased_lint_store(&tcx.sess);
 
     let dont_need_to_run: FxIndexSet<LintId> = store
@@ -394,8 +391,14 @@ impl<'tcx> Visitor<'tcx> for LintLevelMaximum<'tcx> {
 
                 for meta_list in meta_item_list {
                     // Convert Path to String
-                    let Some(meta_item) = meta_list.meta_item() else {return};
-                    let ident: &str = &meta_item.path.segments.iter().map(|segment| segment.ident.as_str()).collect::<Vec<&str>>().join("::");
+                    let Some(meta_item) = meta_list.meta_item() else { return };
+                    let ident: &str = &meta_item
+                        .path
+                        .segments
+                        .iter()
+                        .map(|segment| segment.ident.as_str())
+                        .collect::<Vec<&str>>()
+                        .join("::");
                     let Ok(lints) = store.find_lints(
                         // SAFETY: Lint attributes can only have literals
                         ident,
@@ -430,23 +433,25 @@ impl<'tcx> Visitor<'tcx> for LintLevelMaximum<'tcx> {
                     //             self.dont_need_to_run.swap_remove(&lint);
                     //         }
                     //     }
-                    }
+                }
                 // We handle #![allow]s differently, as these remove checking rather than adding.
             } // Some(Level::Allow) if ast::AttrStyle::Inner == attribute.style => {
-              //     for meta_list in meta.meta_item_list().unwrap() {
-              //         // If it's a tool lint (e.g. clippy::my_clippy_lint)
-              //         if let ast::NestedMetaItem::MetaItem(meta_item) = meta_list {
-              //             if meta_item.path.segments.len() == 1 {
-              //                 self.lints_allowed
-              //                     .insert(meta_list.name_or_empty().as_str().to_string());
-              //             } else {
-              //                 self.lints_allowed
-              //                     .insert(meta_item.path.segments[1].ident.name.as_str().to_string());
-              //             }
-              //         }
-              //     }
-              // }
-              _ => { return; }
+            //     for meta_list in meta.meta_item_list().unwrap() {
+            //         // If it's a tool lint (e.g. clippy::my_clippy_lint)
+            //         if let ast::NestedMetaItem::MetaItem(meta_item) = meta_list {
+            //             if meta_item.path.segments.len() == 1 {
+            //                 self.lints_allowed
+            //                     .insert(meta_list.name_or_empty().as_str().to_string());
+            //             } else {
+            //                 self.lints_allowed
+            //                     .insert(meta_item.path.segments[1].ident.name.as_str().to_string());
+            //             }
+            //         }
+            //     }
+            // }
+            _ => {
+                return;
+            }
         }
     }
 }

compiler/rustc_lint/src/lib.rs

@@ -194,7 +194,6 @@ late_lint_methods!(
             ForLoopsOverFallibles: ForLoopsOverFallibles,
             DerefIntoDynSupertrait: DerefIntoDynSupertrait,
             DropForgetUseless: DropForgetUseless,
-            HardwiredLints: HardwiredLints,
             ImproperCTypesDeclarations: ImproperCTypesDeclarations,
             ImproperCTypesDefinitions: ImproperCTypesDefinitions,
             InvalidFromUtf8: InvalidFromUtf8,
@@ -272,6 +271,7 @@ fn register_builtins(store: &mut LintStore) {
     store.register_lints(&BuiltinCombinedEarlyLintPass::get_lints());
     store.register_lints(&BuiltinCombinedModuleLateLintPass::get_lints());
     store.register_lints(&foreign_modules::get_lints());
+    store.register_lints(&HardwiredLints::default().get_lints());
 
     add_lint_group!(
         "nonstandard_style",

compiler/rustc_lint/src/passes.rs

@@ -68,7 +68,18 @@ macro_rules! declare_late_lint_pass {
 // for all the `check_*` methods.
 late_lint_methods!(declare_late_lint_pass, []);
 
-impl LateLintPass<'_> for HardwiredLints {}
+impl LateLintPass<'_> for HardwiredLints {
+    fn check_fn(
+        &mut self,
+        _: &LateContext<'_>,
+        _: rustc_hir::intravisit::FnKind<'_>,
+        _: &'_ rustc_hir::FnDecl<'_>,
+        _: &'_ rustc_hir::Body<'_>,
+        _: rustc_span::Span,
+        _: rustc_span::def_id::LocalDefId,
+    ) {
+    }
+}
 
 #[macro_export]
 macro_rules! expand_combined_late_lint_pass_method {

compiler/rustc_lint_defs/src/builtin.rs

@@ -12,8 +12,6 @@ use rustc_span::edition::Edition;
 use crate::{declare_lint, declare_lint_pass, FutureIncompatibilityReason};
 
 declare_lint_pass! {
-    /// Does nothing as a lint pass, but registers some `Lint`s
-    /// that are used by other parts of the compiler.
     HardwiredLints => [
         // tidy-alphabetical-start
         ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
@@ -403,7 +401,8 @@ declare_lint! {
     /// `panic!` or `unreachable!` macro instead in case the panic is intended.
     pub UNCONDITIONAL_PANIC,
     Deny,
-    "operation will cause a panic at runtime"
+    "operation will cause a panic at runtime",
+    [loadbearing: true]
 }
 
 declare_lint! {

compiler/rustc_session/src/session.rs

@@ -186,6 +186,7 @@ pub struct Session {
     /// errors.
     pub ctfe_backtrace: Lock<CtfeBacktrace>,
 
+    // pub force_ctfe: bool,
     /// This tracks where `-Zunleash-the-miri-inside-of-you` was used to get around a
     /// const check, optionally with the relevant feature gate. We use this to
     /// warn about unleashing, but with a single diagnostic instead of dozens that

src/tools/clippy/clippy_lints/src/asm_syntax.rs

@@ -3,7 +3,7 @@ use std::fmt;
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast::{Expr, ExprKind, InlineAsmOptions};
 use rustc_ast::{InlineAsm, Item, ItemKind};
-use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass, Lint, LintContext};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
 use rustc_target::asm::InlineAsmArch;

src/tools/clippy/clippy_lints/src/cognitive_complexity.rs

@@ -4,6 +4,7 @@ use clippy_utils::source::{IntoSpan, SpanRangeExt};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{get_async_fn_body, is_async_fn, LimitStack};
+use rustc_lint::{Level::Allow, Lint};
 use core::ops::ControlFlow;
 use rustc_ast::ast::Attribute;
 use rustc_hir::intravisit::FnKind;
@@ -13,25 +14,62 @@ use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{sym, Span};
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for methods with high cognitive complexity.
-    ///
-    /// ### Why is this bad?
-    /// Methods of high cognitive complexity tend to be hard to
-    /// both read and maintain. Also LLVM will tend to optimize small methods better.
-    ///
-    /// ### Known problems
-    /// Sometimes it's hard to find a way to reduce the
-    /// complexity.
-    ///
-    /// ### Example
-    /// You'll see it when you get the warning.
-    #[clippy::version = "1.35.0"]
-    pub COGNITIVE_COMPLEXITY,
-    nursery,
-    "functions that should be split up into multiple functions"
-}
+use crate::LintInfo;
+
+// declare_clippy_lint! {
+//     /// ### What it does
+//     /// Checks for methods with high cognitive complexity.
+//     ///
+//     /// ### Why is this bad?
+//     /// Methods of high cognitive complexity tend to be hard to
+//     /// both read and maintain. Also LLVM will tend to optimize small methods better.
+//     ///
+//     /// ### Known problems
+//     /// Sometimes it's hard to find a way to reduce the
+//     /// complexity.
+//     ///
+//     /// ### Example
+//     /// You'll see it when you get the warning.
+//     #[clippy::version = "1.35.0"]
+//     pub COGNITIVE_COMPLEXITY,
+//     nursery,
+//     "functions that should be split up into multiple functions"
+// }
+
+// Recursive expansion of declare_clippy_lint! macro
+// ==================================================
+
+#[doc = " ### What it does"]
+#[doc = " Checks for methods with high cognitive complexity."]
+#[doc = ""]
+#[doc = " ### Why is this bad?"]
+#[doc = " Methods of high cognitive complexity tend to be hard to"]
+#[doc = " both read and maintain. Also LLVM will tend to optimize small methods better."]
+#[doc = ""]
+#[doc = " ### Known problems"]
+#[doc = " Sometimes it\'s hard to find a way to reduce the"]
+#[doc = " complexity."]
+#[doc = ""]
+#[doc = " ### Example"]
+#[doc = " You\'ll see it when you get the warning."]
+#[clippy::version = "1.35.0"]
+pub static COGNITIVE_COMPLEXITY: &Lint = &Lint {
+    name: &"clippy::COGNITIVE_COMPLEXITY",
+    default_level: Allow,
+    desc: "functions that should be split up into multiple functions",
+    edition_lint_opts: None,
+    report_in_external_macro: true,
+    future_incompatible: None,
+    is_externally_loaded: true,
+    crate_level_only: false,
+    loadbearing: true,
+    ..Lint::default_fields_for_macro()
+};
+pub(crate) static COGNITIVE_COMPLEXITY_INFO: &'static LintInfo = &LintInfo {
+    lint: &COGNITIVE_COMPLEXITY,
+    category: crate::LintCategory::Nursery,
+    explanation: "### What it does\nChecks for methods with high cognitive complexity.\n\n### Why is this bad?\nMethods of high cognitive complexity tend to be hard to\nboth read and maintain. Also LLVM will tend to optimize small methods better.\n\n### Known problems\nSometimes it's hard to find a way to reduce the\ncomplexity.\n\n### Example\nYou'll see it when you get the warning.\n",
+};
 
 pub struct CognitiveComplexity {
     limit: LimitStack,