Merge remote-tracking branch 'upstream/master' into rustup

Author: flip1995

Cargo.toml

@@ -73,3 +73,10 @@ harness = false
 [[test]]
 name = "dogfood"
 harness = false
+
+# quine-mc_cluskey makes up a significant part of the runtime in dogfood
+# due to the number of conditions in the clippy_lints crate
+# and enabling optimizations for that specific dependency helps a bit
+# without increasing total build times.
+[profile.dev.package.quine-mc_cluskey]
+opt-level = 3

clippy_lints/src/assigning_clones.rs

@@ -3,14 +3,13 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::mir::{PossibleBorrowerMap, enclosing_mir};
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
-use clippy_utils::{is_diag_trait_item, is_in_test, last_path_segment, local_is_initialized, path_to_local};
+use clippy_utils::{is_diag_trait_item, is_in_test, last_path_segment, local_is_initialized, path_to_local, sym};
 use rustc_errors::Applicability;
 use rustc_hir::{self as hir, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::mir;
 use rustc_middle::ty::{self, Instance, Mutability};
 use rustc_session::impl_lint_pass;
-use rustc_span::symbol::sym;
 use rustc_span::{Span, SyntaxContext};
 
 declare_clippy_lint! {
@@ -86,9 +85,9 @@ impl<'tcx> LateLintPass<'tcx> for AssigningClones {
  && ctxt.is_root()
  && let which_trait = match fn_name {
  sym::clone if is_diag_trait_item(cx, fn_id, sym::Clone) => CloneTrait::Clone,
- _ if fn_name.as_str() == "to_owned"
- && is_diag_trait_item(cx, fn_id, sym::ToOwned)
- && self.msrv.meets(cx, msrvs::CLONE_INTO) =>
+ sym::to_owned
+ if is_diag_trait_item(cx, fn_id, sym::ToOwned)
+  && self.msrv.meets(cx, msrvs::CLONE_INTO) =>
  {
  CloneTrait::ToOwned
  },
@@ -112,7 +111,7 @@ impl<'tcx> LateLintPass<'tcx> for AssigningClones {
  && resolved_assoc_items.in_definition_order().any(|assoc|
  match which_trait {
  CloneTrait::Clone => assoc.name() == sym::clone_from,
- CloneTrait::ToOwned => assoc.name().as_str() == "clone_into",
+ CloneTrait::ToOwned => assoc.name() == sym::clone_into,
  }
  )
  && !clone_source_borrows_from_dest(cx, lhs, rhs.span)

clippy_lints/src/attrs/blanket_clippy_restriction_lints.rs

@@ -1,17 +1,15 @@
 use super::BLANKET_CLIPPY_RESTRICTION_LINTS;
 use super::utils::extract_clippy_lint;
 use clippy_utils::diagnostics::{span_lint_and_help, span_lint_and_then};
+use clippy_utils::sym;
 use rustc_ast::MetaItemInner;
 use rustc_lint::{EarlyContext, Level, LintContext};
+use rustc_span::DUMMY_SP;
 use rustc_span::symbol::Symbol;
-use rustc_span::{DUMMY_SP, sym};
 
 pub(super) fn check(cx: &EarlyContext<'_>, name: Symbol, items: &[MetaItemInner]) {
  for lint in items {
- if let Some(lint_name) = extract_clippy_lint(lint)
- && lint_name.as_str() == "restriction"
- && name != sym::allow
- {
+ if name != sym::allow && extract_clippy_lint(lint) == Some(sym::restriction) {
  span_lint_and_help(
  cx,
  BLANKET_CLIPPY_RESTRICTION_LINTS,

clippy_lints/src/attrs/deprecated_cfg_attr.rs

@@ -73,7 +73,7 @@ fn check_deprecated_cfg_recursively(cx: &EarlyContext<'_>, attr: &rustc_ast::Met
 }
 
 fn check_cargo_clippy_attr(cx: &EarlyContext<'_>, item: &rustc_ast::MetaItem) {
- if item.has_name(sym::feature) && item.value_str().is_some_and(|v| v.as_str() == "cargo-clippy") {
+ if item.has_name(sym::feature) && item.value_str() == Some(sym::cargo_clippy) {
  span_lint_and_sugg(
  cx,
  DEPRECATED_CLIPPY_CFG_ATTR,

clippy_lints/src/attrs/deprecated_semver.rs

@@ -1,13 +1,14 @@
 use super::DEPRECATED_SEMVER;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::sym;
 use rustc_ast::{LitKind, MetaItemLit};
 use rustc_lint::EarlyContext;
 use rustc_span::Span;
 use semver::Version;
 
 pub(super) fn check(cx: &EarlyContext<'_>, span: Span, lit: &MetaItemLit) {
  if let LitKind::Str(is, _) = lit.kind
- && (is.as_str() == "TBD" || Version::parse(is.as_str()).is_ok())
+ && (is == sym::TBD || Version::parse(is.as_str()).is_ok())
  {
  return;
  }

clippy_lints/src/casts/cast_abs_to_unsigned.rs

@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::Sugg;
+use clippy_utils::sym;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::LateContext;
@@ -19,7 +20,7 @@ pub(super) fn check(
  if let ty::Int(from) = cast_from.kind()
  && let ty::Uint(to) = cast_to.kind()
  && let ExprKind::MethodCall(method_path, receiver, [], _) = cast_expr.kind
- && method_path.ident.name.as_str() == "abs"
+ && method_path.ident.name == sym::abs
  && msrv.meets(cx, msrvs::UNSIGNED_ABS)
  {
  let span = if from.bit_width() == to.bit_width() {

clippy_lints/src/casts/cast_possible_truncation.rs

@@ -1,9 +1,9 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::expr_or_init;
 use clippy_utils::source::snippet;
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{get_discriminant_value, is_isize_or_usize};
+use clippy_utils::{expr_or_init, sym};
 use rustc_abi::IntegerType;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::def::{DefKind, Res};
@@ -73,7 +73,7 @@ fn apply_reductions(cx: &LateContext<'_>, nbits: u64, expr: &Expr<'_>, signed: b
  nbits
  },
  ExprKind::MethodCall(method, _value, [], _) => {
- if method.ident.name.as_str() == "signum" {
+ if method.ident.name == sym::signum {
  0 // do not lint if cast comes from a `signum` function
  } else {
  nbits

clippy_lints/src/casts/cast_ptr_alignment.rs

@@ -1,11 +1,10 @@
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::ty::is_c_void;
-use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant};
+use clippy_utils::{get_parent_expr, is_hir_ty_cfg_dependant, sym};
 use rustc_hir::{Expr, ExprKind, GenericArg};
 use rustc_lint::LateContext;
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, Ty};
-use rustc_span::sym;
 
 use super::CAST_PTR_ALIGNMENT;
 
@@ -20,7 +19,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {
  );
  lint_cast_ptr_alignment(cx, expr, cast_from, cast_to);
  } else if let ExprKind::MethodCall(method_path, self_arg, [], _) = &expr.kind
- && method_path.ident.name.as_str() == "cast"
+ && method_path.ident.name == sym::cast
  && let Some(generic_args) = method_path.args
  && let [GenericArg::Type(cast_to)] = generic_args.args
  // There probably is no obvious reason to do this, just to be consistent with `as` cases.

clippy_lints/src/casts/unnecessary_cast.rs

@@ -8,7 +8,9 @@ use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, Lit, Node, Path, QPath, TyKind, UnOp};
 use rustc_lint::{LateContext, LintContext};
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, FloatTy, InferTy, Ty};
+use rustc_span::{Symbol, sym};
 use std::ops::ControlFlow;
 
 use super::UNNECESSARY_CAST;
@@ -142,6 +144,33 @@ pub(super) fn check<'tcx>(
  }
 
  if cast_from.kind() == cast_to.kind() && !expr.span.in_external_macro(cx.sess().source_map()) {
+ enum MaybeParenOrBlock {
+ Paren,
+ Block,
+ Nothing,
+ }
+
+ fn is_borrow_expr(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ matches!(expr.kind, ExprKind::AddrOf(..))
+ || cx
+ .typeck_results()
+ .expr_adjustments(expr)
+ .first()
+ .is_some_and(|adj| matches!(adj.kind, Adjust::Borrow(_)))
+ }
+
+ fn is_in_allowed_macro(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ const ALLOWED_MACROS: &[Symbol] = &[
+ sym::format_args_macro,
+ sym::assert_eq_macro,
+ sym::debug_assert_eq_macro,
+ sym::assert_ne_macro,
+ sym::debug_assert_ne_macro,
+ ];
+ matches!(expr.span.ctxt().outer_expn_data().macro_def_id, Some(def_id) if 
+ cx.tcx.get_diagnostic_name(def_id).is_some_and(|sym| ALLOWED_MACROS.contains(&sym)))
+ }
+
  if let Some(id) = path_to_local(cast_expr)
  && !cx.tcx.hir_span(id).eq_ctxt(cast_expr.span)
  {
@@ -150,26 +179,26 @@ pub(super) fn check<'tcx>(
  return false;
  }
 
- // If the whole cast expression is a unary expression (`(*x as T)`) or an addressof
- // expression (`(&x as T)`), then not surrounding the suggestion into a block risks us
- // changing the precedence of operators if the cast expression is followed by an operation
- // with higher precedence than the unary operator (`(*x as T).foo()` would become
- // `*x.foo()`, which changes what the `*` applies on).
- // The same is true if the expression encompassing the cast expression is a unary
- // expression or an addressof expression.
- let needs_block = matches!(cast_expr.kind, ExprKind::Unary(..) | ExprKind::AddrOf(..))
-  || get_parent_expr(cx, expr).is_some_and(|e| matches!(e.kind, ExprKind::Unary(..) | ExprKind::AddrOf(..)));
+ // Changing `&(x as i32)` to `&x` would change the meaning of the code because the previous creates
+ // a reference to the temporary while the latter creates a reference to the original value.
+ let surrounding = match cx.tcx.parent_hir_node(expr.hir_id) {
+  Node::Expr(parent) if is_borrow_expr(cx, parent) && !is_in_allowed_macro(cx, parent) => {
+  MaybeParenOrBlock::Block
+  },
+  Node::Expr(parent) if cast_expr.precedence() < parent.precedence() => MaybeParenOrBlock::Paren,
+  _ => MaybeParenOrBlock::Nothing,
+ };
 
  span_lint_and_sugg(
  cx,
  UNNECESSARY_CAST,
  expr.span,
  format!("casting to the same type is unnecessary (`{cast_from}` -> `{cast_to}`)"),
  "try",
- if needs_block {
- format!("{{ {cast_str} }}")
- } else {
- cast_str
+ match surrounding {
+ MaybeParenOrBlock::Paren => format!("({cast_str})"),
+  MaybeParenOrBlock::Block => format!("{{ {cast_str} }}"),
+ MaybeParenOrBlock::Nothing => cast_str,
  },
  Applicability::MachineApplicable,
  );

clippy_lints/src/crate_in_macro_def.rs

@@ -5,8 +5,8 @@ use rustc_ast::tokenstream::{TokenStream, TokenTree};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass};
 use rustc_session::declare_lint_pass;
-use rustc_span::Span;
 use rustc_span::symbol::sym;
+use rustc_span::{Span, kw};
 
 declare_clippy_lint! {
  /// ### What it does
@@ -105,12 +105,11 @@ fn contains_unhygienic_crate_reference(tts: &TokenStream) -> Option<Span> {
 fn is_crate_keyword(tt: &TokenTree) -> Option<Span> {
  if let TokenTree::Token(
  Token {
- kind: TokenKind::Ident(symbol, _),
+ kind: TokenKind::Ident(kw::Crate, _),
  span,
  },
  _,
  ) = tt
- && symbol.as_str() == "crate"
  {
  Some(*span)
  } else {