Merge branch 'rust-lang:master' into 1775-decimal_bit_mask

Author: Artur-Sulej

.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:

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, _) => {

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

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

clippy_lints/src/let_if_seq.rs

@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_hir_and_then;
 use clippy_utils::res::MaybeResPath;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_context;
 use clippy_utils::visitors::is_local_used;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -59,80 +59,88 @@ declare_lint_pass!(LetIfSeq => [USELESS_LET_IF_SEQ]);
 impl<'tcx> LateLintPass<'tcx> for LetIfSeq {
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx hir::Block<'_>) {
         for [stmt, next] in block.stmts.array_windows::<2>() {
-            if let hir::StmtKind::Let(local) = stmt.kind
-                && let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind
-                && let hir::StmtKind::Expr(if_) = next.kind
-                && let hir::ExprKind::If(cond, then, else_) = if_.kind
-                && !is_local_used(cx, cond, canonical_id)
-                && let hir::ExprKind::Block(then, _) = then.kind
-                && let Some(value) = check_assign(cx, canonical_id, then)
-                && !is_local_used(cx, value, canonical_id)
-            {
-                let span = stmt.span.to(if_.span);
+            if let hir::StmtKind::Expr(if_) = next.kind {
+                check_block_inner(cx, stmt, if_);
+            }
+        }
 
-                let has_interior_mutability = !cx
-                    .typeck_results()
-                    .node_type(canonical_id)
-                    .is_freeze(cx.tcx, cx.typing_env());
-                if has_interior_mutability {
-                    return;
-                }
+        if let Some(expr) = block.expr
+            && let Some(stmt) = block.stmts.last()
+        {
+            check_block_inner(cx, stmt, expr);
+        }
+    }
+}
+
+fn check_block_inner<'tcx>(cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'tcx>, if_: &'tcx hir::Expr<'tcx>) {
+    if let hir::StmtKind::Let(local) = stmt.kind
+        && let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.kind
+        && let hir::ExprKind::If(cond, then, else_) = if_.kind
+        && !is_local_used(cx, cond, canonical_id)
+        && let hir::ExprKind::Block(then, _) = then.kind
+        && let Some(value) = check_assign(cx, canonical_id, then)
+        && !is_local_used(cx, value, canonical_id)
+    {
+        let span = stmt.span.to(if_.span);
 
-                let (default_multi_stmts, default) = if let Some(else_) = else_ {
-                    if let hir::ExprKind::Block(else_, _) = else_.kind {
-                        if let Some(default) = check_assign(cx, canonical_id, else_) {
-                            (else_.stmts.len() > 1, default)
-                        } else if let Some(default) = local.init {
-                            (true, default)
-                        } else {
-                            continue;
-                        }
-                    } else {
-                        continue;
-                    }
+        let has_interior_mutability = !cx
+            .typeck_results()
+            .node_type(canonical_id)
+            .is_freeze(cx.tcx, cx.typing_env());
+        if has_interior_mutability {
+            return;
+        }
+
+        let (default_multi_stmts, default) = if let Some(else_) = else_ {
+            if let hir::ExprKind::Block(else_, _) = else_.kind {
+                if let Some(default) = check_assign(cx, canonical_id, else_) {
+                    (else_.stmts.len() > 1, default)
                 } else if let Some(default) = local.init {
-                    (false, default)
+                    (true, default)
                 } else {
-                    continue;
-                };
+                    return;
+                }
+            } else {
+                return;
+            }
+        } else if let Some(default) = local.init {
+            (false, default)
+        } else {
+            return;
+        };
 
-                let mutability = match mode {
-                    BindingMode(_, Mutability::Mut) => "<mut> ",
-                    _ => "",
-                };
+        let mutability = match mode {
+            BindingMode(_, Mutability::Mut) => "<mut> ",
+            _ => "",
+        };
 
-                // FIXME: this should not suggest `mut` if we can detect that the variable is not
-                // use mutably after the `if`
+        // FIXME: this should not suggest `mut` if we can detect that the variable is not
+        // use mutably after the `if`
 
-                let sug = format!(
-                    "let {mutability}{name} = if {cond} {{{then} {value} }} else {{{else} {default} }};",
-                    name=ident.name,
-                    cond=snippet(cx, cond.span, "_"),
-                    then=if then.stmts.len() > 1 { " ..;" } else { "" },
-                    else=if default_multi_stmts { " ..;" } else { "" },
-                    value=snippet(cx, value.span, "<value>"),
-                    default=snippet(cx, default.span, "<default>"),
-                );
-                span_lint_hir_and_then(
-                    cx,
-                    USELESS_LET_IF_SEQ,
-                    local.hir_id,
-                    span,
-                    "`if _ { .. } else { .. }` is an expression",
-                    |diag| {
-                        diag.span_suggestion(
-                            span,
-                            "it is more idiomatic to write",
-                            sug,
-                            Applicability::HasPlaceholders,
-                        );
-                        if !mutability.is_empty() {
-                            diag.note("you might not need `mut` at all");
-                        }
-                    },
-                );
-            }
-        }
+        let mut applicability = Applicability::HasPlaceholders;
+        let (cond_snip, _) = snippet_with_context(cx, cond.span, if_.span.ctxt(), "_", &mut applicability);
+        let (value_snip, _) = snippet_with_context(cx, value.span, if_.span.ctxt(), "<value>", &mut applicability);
+        let (default_snip, _) =
+            snippet_with_context(cx, default.span, if_.span.ctxt(), "<default>", &mut applicability);
+        let sug = format!(
+            "let {mutability}{name} = if {cond_snip} {{{then} {value_snip} }} else {{{else} {default_snip} }};",
+            name=ident.name,
+            then=if then.stmts.len() > 1 { " ..;" } else { "" },
+            else=if default_multi_stmts { " ..;" } else { "" },
+        );
+        span_lint_hir_and_then(
+            cx,
+            USELESS_LET_IF_SEQ,
+            local.hir_id,
+            span,
+            "`if _ { .. } else { .. }` is an expression",
+            |diag| {
+                diag.span_suggestion(span, "it is more idiomatic to write", sug, applicability);
+                if !mutability.is_empty() {
+                    diag.note("you might not need `mut` at all");
+                }
+            },
+        );
     }
 }
 

clippy_lints/src/manual_is_power_of_two.rs

@@ -70,12 +70,12 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsPowerOfTwo {
         if !expr.span.from_expansion()
             && let Some((lhs, rhs)) = unexpanded_binop_operands(expr, BinOpKind::Eq)
         {
-            if let Some(a) = count_ones_receiver(cx, lhs)
-                && is_integer_literal(rhs, 1)
+            if is_integer_literal(rhs, 1)
+                && let Some(a) = count_ones_receiver(cx, lhs)
             {
                 self.build_sugg(cx, expr, a);
-            } else if let Some(a) = count_ones_receiver(cx, rhs)
-                && is_integer_literal(lhs, 1)
+            } else if is_integer_literal(lhs, 1)
+                && let Some(a) = count_ones_receiver(cx, rhs)
             {
                 self.build_sugg(cx, expr, a);
             } else if is_integer_literal(rhs, 0)