Clippy subtree update

Cargo.lock

@@ -600,6 +600,7 @@ dependencies = [
  "serde_json",
  "tempfile",
  "termize",
+ "tikv-jemalloc-sys",
  "toml 0.9.7",
  "ui_test",
  "walkdir",
@@ -5537,9 +5538,9 @@ version = "0.1.0"
 
 [[package]]
 name = "tikv-jemalloc-sys"
-version = "0.6.0+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
+version = "0.6.1+5.3.0-1-ge13ca993e8ccb9ba9847cc330696e02839f328f7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd3c60906412afa9c2b5b5a48ca6a5abe5736aec9eb48ad05037a677e52e4e2d"
+checksum = "cd8aa5b2ab86a2cefa406d889139c162cbb230092f7d1d7cbc1716405d852a3b"
 dependencies = [
  "cc",
  "libc",

src/tools/clippy/.github/ISSUE_TEMPLATE/bug_report.yml

@@ -20,15 +20,15 @@ body:
       label: Reproducer
       description: Please provide the code and steps to reproduce the bug
       value: |
-        I tried this code:
+        Code:
 
         ```rust
         <code>
         ```
 
-        I expected to see this happen:
+        Current output:
 
-        Instead, this happened:
+        Desired output:
   - type: textarea
     id: version
     attributes:

src/tools/clippy/.github/workflows/clippy_mq.yml

@@ -25,8 +25,6 @@ jobs:
           host: i686-unknown-linux-gnu
         - os: windows-latest
           host: x86_64-pc-windows-msvc
-        - os: macos-13
-          host: x86_64-apple-darwin
         - os: macos-latest
           host: aarch64-apple-darwin
 

src/tools/clippy/Cargo.toml

@@ -31,6 +31,7 @@ tempfile = { version = "3.20", optional = true }
 termize = "0.2"
 color-print = "0.3.4"
 anstream = "0.6.18"
+tikv-jemalloc-sys = { version = "0.6.1", optional = true, features = ['override_allocator_on_supported_platforms'] }
 
 [dev-dependencies]
 cargo_metadata = "0.18.1"
@@ -56,7 +57,7 @@ rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }
 [features]
 integration = ["dep:tempfile"]
 internal = ["dep:clippy_lints_internal", "dep:tempfile"]
-jemalloc = []
+jemalloc = ["dep:tikv-jemalloc-sys"]
 
 [package.metadata.rust-analyzer]
 # This package uses #[feature(rustc_private)]

src/tools/clippy/clippy_dev/src/new_lint.rs

@@ -157,18 +157,19 @@ fn add_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
     let path = "clippy_lints/src/lib.rs";
     let mut lib_rs = fs::read_to_string(path).context("reading")?;
 
-    let comment_start = lib_rs.find("// add lints here,").expect("Couldn't find comment");
-    let ctor_arg = if lint.pass == Pass::Late { "_" } else { "" };
-    let lint_pass = lint.pass;
+    let (comment, ctor_arg) = if lint.pass == Pass::Late {
+        ("// add late passes here", "_")
+    } else {
+        ("// add early passes here", "")
+    };
+    let comment_start = lib_rs.find(comment).expect("Couldn't find comment");
     let module_name = lint.name;
     let camel_name = to_camel_case(lint.name);
 
     let new_lint = if enable_msrv {
-        format!(
-            "store.register_{lint_pass}_pass(move |{ctor_arg}| Box::new({module_name}::{camel_name}::new(conf)));\n    ",
-        )
+        format!("Box::new(move |{ctor_arg}| Box::new({module_name}::{camel_name}::new(conf))),\n        ",)
     } else {
-        format!("store.register_{lint_pass}_pass(|{ctor_arg}| Box::new({module_name}::{camel_name}));\n    ",)
+        format!("Box::new(|{ctor_arg}| Box::new({module_name}::{camel_name})),\n        ",)
     };
 
     lib_rs.insert_str(comment_start, &new_lint);

src/tools/clippy/clippy_lints/src/booleans.rs

@@ -3,7 +3,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::higher::has_let_expr;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::res::MaybeDef;
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::{SpanRangeExt, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::implements_trait;
 use clippy_utils::{eq_expr_value, sym};
@@ -415,19 +415,20 @@ fn simplify_not(cx: &LateContext<'_>, curr_msrv: Msrv, expr: &Expr<'_>) -> Optio
                 BinOpKind::Ge => Some(" < "),
                 _ => None,
             }
-            .and_then(|op| {
-                let lhs_snippet = lhs.span.get_source_text(cx)?;
-                let rhs_snippet = rhs.span.get_source_text(cx)?;
+            .map(|op| {
+                let mut app = Applicability::MachineApplicable;
+                let (lhs_snippet, _) = snippet_with_context(cx, lhs.span, SyntaxContext::root(), "", &mut app);
+                let (rhs_snippet, _) = snippet_with_context(cx, rhs.span, SyntaxContext::root(), "", &mut app);
 
                 if !(lhs_snippet.starts_with('(') && lhs_snippet.ends_with(')'))
                     && let (ExprKind::Cast(..), BinOpKind::Ge) = (&lhs.kind, binop.node)
                 {
                     // e.g. `(a as u64) < b`. Without the parens the `<` is
                     // interpreted as a start of generic arguments for `u64`
-                    return Some(format!("({lhs_snippet}){op}{rhs_snippet}"));
+                    return format!("({lhs_snippet}){op}{rhs_snippet}");
                 }
 
-                Some(format!("{lhs_snippet}{op}{rhs_snippet}"))
+                format!("{lhs_snippet}{op}{rhs_snippet}")
             })
         },
         ExprKind::MethodCall(path, receiver, args, _) => {

src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs

@@ -2,14 +2,13 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::res::{MaybeDef, MaybeQPath};
 use clippy_utils::source::{snippet_with_applicability, snippet_with_context, walk_span_to_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::{
-    contains_return, expr_adjustment_requires_coercion, higher, is_else_clause, is_in_const_context, peel_blocks, sym,
+    as_some_expr, contains_return, expr_adjustment_requires_coercion, higher, is_else_clause, is_in_const_context,
+    is_none_expr, peel_blocks, sym,
 };
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -70,11 +69,10 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
         }) = higher::If::hir(expr)
             && let ExprKind::Block(then_block, _) = then.kind
             && let Some(then_expr) = then_block.expr
-            && let ExprKind::Call(then_call, [then_arg]) = then_expr.kind
+            && let Some(then_arg) = as_some_expr(cx, then_expr)
             && !expr.span.from_expansion()
             && !then_expr.span.from_expansion()
-            && then_call.res(cx).ctor_parent(cx).is_lang_item(cx, OptionSome)
-            && peel_blocks(els).res(cx).ctor_parent(cx).is_lang_item(cx, OptionNone)
+            && is_none_expr(cx, peel_blocks(els))
             && !is_else_clause(cx.tcx, expr)
             && !is_in_const_context(cx)
             && self.msrv.meets(cx, msrvs::BOOL_THEN)

src/tools/clippy/clippy_lints/src/incompatible_msrv.rs

@@ -1,14 +1,14 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::Msrv;
-use clippy_utils::{is_in_const_context, is_in_test};
+use clippy_utils::{is_in_const_context, is_in_test, sym};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::{self as hir, AmbigArg, Expr, ExprKind, HirId, RustcVersion, StabilityLevel, StableSince};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::{CrateNum, DefId};
-use rustc_span::{ExpnKind, Span, sym};
+use rustc_span::{ExpnKind, Span};
 
 declare_clippy_lint! {
     /// ### What it does
@@ -77,11 +77,36 @@ enum Availability {
     Since(RustcVersion),
 }
 
+/// All known std crates containing a stability attribute.
+struct StdCrates([Option<CrateNum>; 6]);
+impl StdCrates {
+    fn new(tcx: TyCtxt<'_>) -> Self {
+        let mut res = Self([None; _]);
+        for &krate in tcx.crates(()) {
+            // FIXME(@Jarcho): We should have an internal lint to detect when this list is out of date.
+            match tcx.crate_name(krate) {
+                sym::alloc => res.0[0] = Some(krate),
+                sym::core => res.0[1] = Some(krate),
+                sym::core_arch => res.0[2] = Some(krate),
+                sym::proc_macro => res.0[3] = Some(krate),
+                sym::std => res.0[4] = Some(krate),
+                sym::std_detect => res.0[5] = Some(krate),
+                _ => {},
+            }
+        }
+        res
+    }
+
+    fn contains(&self, krate: CrateNum) -> bool {
+        self.0.contains(&Some(krate))
+    }
+}
+
 pub struct IncompatibleMsrv {
     msrv: Msrv,
     availability_cache: FxHashMap<(DefId, bool), Availability>,
     check_in_tests: bool,
-    core_crate: Option<CrateNum>,
+    std_crates: StdCrates,
 
     // The most recently called path. Used to skip checking the path after it's
     // been checked when visiting the call expression.
@@ -96,11 +121,7 @@ impl IncompatibleMsrv {
             msrv: conf.msrv,
             availability_cache: FxHashMap::default(),
             check_in_tests: conf.check_incompatible_msrv_in_tests,
-            core_crate: tcx
-                .crates(())
-                .iter()
-                .find(|krate| tcx.crate_name(**krate) == sym::core)
-                .copied(),
+            std_crates: StdCrates::new(tcx),
             called_path: None,
         }
     }
@@ -152,21 +173,24 @@ impl IncompatibleMsrv {
         node: HirId,
         span: Span,
     ) {
-        if def_id.is_local() {
-            // We don't check local items since their MSRV is supposed to always be valid.
+        if !self.std_crates.contains(def_id.krate) {
+            // No stability attributes to lookup for these items.
             return;
         }
-        let expn_data = span.ctxt().outer_expn_data();
-        if let ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) = expn_data.kind {
-            // Desugared expressions get to cheat and stability is ignored.
-            // Intentionally not using `.from_expansion()`, since we do still care about macro expansions
-            return;
-        }
-        // Functions coming from `core` while expanding a macro such as `assert*!()` get to cheat too: the
-        // macros may have existed prior to the checked MSRV, but their expansion with a recent compiler
-        // might use recent functions or methods. Compiling with an older compiler would not use those.
-        if Some(def_id.krate) == self.core_crate && expn_data.macro_def_id.map(|did| did.krate) == self.core_crate {
-            return;
+        // Use `from_expansion` to fast-path the common case.
+        if span.from_expansion() {
+            let expn = span.ctxt().outer_expn_data();
+            match expn.kind {
+                // FIXME(@Jarcho): Check that the actual desugaring or std macro is supported by the
+                // current MSRV. Note that nested expansions need to be handled as well.
+                ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => return,
+                ExpnKind::Macro(..) if expn.macro_def_id.is_some_and(|did| self.std_crates.contains(did.krate)) => {
+                    return;
+                },
+                // All other expansions share the target's MSRV.
+                // FIXME(@Jarcho): What should we do about version dependant macros from external crates?
+                _ => {},
+            }
         }
 
         if (self.check_in_tests || !is_in_test(cx.tcx, node))

src/tools/clippy/clippy_lints/src/inherent_impl.rs

@@ -1,7 +1,7 @@
 use clippy_config::Conf;
 use clippy_config::types::InherentImplLintScope;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::fulfill_or_allowed;
+use clippy_utils::{fulfill_or_allowed, is_cfg_test, is_in_cfg_test};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def_id::{LocalDefId, LocalModDefId};
 use rustc_hir::{Item, ItemKind, Node};
@@ -100,7 +100,8 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
                     },
                     InherentImplLintScope::Crate => Criterion::Crate,
                 };
-                match type_map.entry((impl_ty, criterion)) {
+                let is_test = is_cfg_test(cx.tcx, hir_id) || is_in_cfg_test(cx.tcx, hir_id);
+                match type_map.entry((impl_ty, criterion, is_test)) {
                     Entry::Vacant(e) => {
                         // Store the id for the first impl block of this type. The span is retrieved lazily.
                         e.insert(IdOrSpan::Id(impl_id));