Auto merge of rust-lang#10242 - flip1995:rustup, r=flip1995

Rustup

r? `@ghost`

changelog: none

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clippy"
-version = "0.1.68"
+version = "0.1.69"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"

clippy_lints/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clippy_lints"
-version = "0.1.68"
+version = "0.1.69"
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"

clippy_lints/src/attrs.rs

@@ -472,7 +472,7 @@ fn check_clippy_lint_names(cx: &LateContext<'_>, name: Symbol, items: &[NestedMe
 
 fn check_lint_reason(cx: &LateContext<'_>, name: Symbol, items: &[NestedMetaItem], attr: &'_ Attribute) {
  // Check for the feature
- if !cx.tcx.sess.features_untracked().lint_reasons {
+ if !cx.tcx.features().lint_reasons {
  return;
  }
 

clippy_lints/src/derive.rs

@@ -251,7 +251,7 @@ fn check_hash_peq<'tcx>(
 
  // Only care about `impl PartialEq<Foo> for Foo`
  // For `impl PartialEq<B> for A, input_types is [A, B]
- if trait_ref.substs.type_at(1) == ty {
+ if trait_ref.subst_identity().substs.type_at(1) == ty {
  span_lint_and_then(
  cx,
  DERIVED_HASH_WITH_MANUAL_EQ,
@@ -299,7 +299,7 @@ fn check_ord_partial_ord<'tcx>(
 
  // Only care about `impl PartialOrd<Foo> for Foo`
  // For `impl PartialOrd<B> for A, input_types is [A, B]
- if trait_ref.substs.type_at(1) == ty {
+ if trait_ref.subst_identity().substs.type_at(1) == ty {
  let mess = if partial_ord_is_automatically_derived {
  "you are implementing `Ord` explicitly but have derived `PartialOrd`"
  } else {

clippy_lints/src/fallible_impl_from.rs

@@ -56,7 +56,7 @@ impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom {
  if_chain! {
  if let hir::ItemKind::Impl(impl_) = &item.kind;
  if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id);
- if cx.tcx.is_diagnostic_item(sym::From, impl_trait_ref.def_id);
+ if cx.tcx.is_diagnostic_item(sym::From, impl_trait_ref.skip_binder().def_id);
  then {
  lint_impl_body(cx, item.span, impl_.items);
  }

clippy_lints/src/format_args.rs

@@ -7,14 +7,14 @@ use clippy_utils::macros::{
 };
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet_opt;
-use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
+use clippy_utils::ty::{implements_trait, is_type_lang_item};
 use if_chain::if_chain;
 use itertools::Itertools;
 use rustc_errors::{
  Applicability,
  SuggestionStyle::{CompletelyHidden, ShowCode},
 };
-use rustc_hir::{Expr, ExprKind, HirId, QPath};
+use rustc_hir::{Expr, ExprKind, HirId, LangItem, QPath};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
 use rustc_middle::ty::Ty;
@@ -237,7 +237,7 @@ fn check_unused_format_specifier(cx: &LateContext<'_>, arg: &FormatArg<'_>) {
  );
  }
 
- if is_type_diagnostic_item(cx, param_ty, sym::Arguments) && !arg.format.is_default_for_trait() {
+ if is_type_lang_item(cx, param_ty, LangItem::FormatArguments) && !arg.format.is_default_for_trait() {
  span_lint_and_then(
  cx,
  UNUSED_FORMAT_SPECS,

clippy_lints/src/from_over_into.rs

@@ -76,7 +76,7 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
  && let Some(into_trait_seg) = hir_trait_ref.path.segments.last()
  // `impl Into<target_ty> for self_ty`
  && let Some(GenericArgs { args: [GenericArg::Type(target_ty)], .. }) = into_trait_seg.args
- && let Some(middle_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
+ && let Some(middle_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id).map(ty::EarlyBinder::subst_identity)
  && cx.tcx.is_diagnostic_item(sym::Into, middle_trait_ref.def_id)
  && !matches!(middle_trait_ref.substs.type_at(1).kind(), ty::Alias(ty::Opaque, _))
  {

clippy_lints/src/future_not_send.rs

@@ -78,7 +78,8 @@ impl<'tcx> LateLintPass<'tcx> for FutureNotSend {
  let send_trait = cx.tcx.get_diagnostic_item(sym::Send).unwrap();
  let span = decl.output.span();
  let infcx = cx.tcx.infer_ctxt().build();
- let cause = traits::ObligationCause::misc(span, hir_id);
+ let def_id = cx.tcx.hir().local_def_id(hir_id);
+ let cause = traits::ObligationCause::misc(span, def_id);
  let send_errors = traits::fully_solve_bound(&infcx, cause, cx.param_env, ret_ty, send_trait);
  if !send_errors.is_empty() {
  span_lint_and_then(

clippy_lints/src/inherent_impl.rs

@@ -52,21 +52,19 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl {
  // List of spans to lint. (lint_span, first_span)
  let mut lint_spans = Vec::new();
 
- for (_, impl_ids) in cx
+ let inherent_impls = cx
  .tcx
- .crate_inherent_impls(())
- .inherent_impls
- .iter()
- .filter(|(&id, impls)| {
- impls.len() > 1
- // Check for `#[allow]` on the type definition
- && !is_lint_allowed(
- cx,
- MULTIPLE_INHERENT_IMPL,
- cx.tcx.hir().local_def_id_to_hir_id(id),
- )
- })
- {
+ .with_stable_hashing_context(|hcx| cx.tcx.crate_inherent_impls(()).inherent_impls.to_sorted(&hcx, true));
+
+ for (_, impl_ids) in inherent_impls.into_iter().filter(|(&id, impls)| {
+ impls.len() > 1
+ // Check for `#[allow]` on the type definition
+ && !is_lint_allowed(
+ cx,
+ MULTIPLE_INHERENT_IMPL,
+ cx.tcx.hir().local_def_id_to_hir_id(id),
+ )
+ }) {
  for impl_id in impl_ids.iter().map(|id| id.expect_local()) {
  match type_map.entry(cx.tcx.type_of(impl_id)) {
  Entry::Vacant(e) => {

clippy_lints/src/len_zero.rs

@@ -219,7 +219,7 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items
  let is_empty = sym!(is_empty);
 
  let is_empty_method_found = current_and_super_traits
- .iter()
+ .items()
  .flat_map(|&i| cx.tcx.associated_items(i).filter_by_name_unhygienic(is_empty))
  .any(|i| {
  i.kind == ty::AssocKind::Fn

clippy_lints/src/loops/while_immutable_condition.rs

@@ -35,7 +35,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, cond: &'tcx Expr<'_>, expr: &'
  } else {
  return;
  };
- let mutable_static_in_cond = var_visitor.def_ids.iter().any(|(_, v)| *v);
+ let mutable_static_in_cond = var_visitor.def_ids.items().any(|(_, v)| *v);
 
  let mut has_break_or_return_visitor = HasBreakOrReturnVisitor {
  has_break_or_return: false,

clippy_lints/src/methods/unnecessary_to_owned.rs

@@ -371,7 +371,7 @@ fn can_change_type<'a>(cx: &LateContext<'a>, mut expr: &'a Expr<'a>, mut ty: Ty<
  && let output_ty = return_ty(cx, item.hir_id())
  && let local_def_id = cx.tcx.hir().local_def_id(item.hir_id())
  && Inherited::build(cx.tcx, local_def_id).enter(|inherited| {
- let fn_ctxt = FnCtxt::new(inherited, cx.param_env, item.hir_id());
+ let fn_ctxt = FnCtxt::new(inherited, cx.param_env, local_def_id);
  fn_ctxt.can_coerce(ty, output_ty)
  }) {
  if has_lifetime(output_ty) && has_lifetime(ty) {

clippy_lints/src/missing_inline.rs

@@ -155,7 +155,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline {
  let container_id = assoc_item.container_id(cx.tcx);
  let trait_def_id = match assoc_item.container {
  TraitContainer => Some(container_id),
- ImplContainer => cx.tcx.impl_trait_ref(container_id).map(|t| t.def_id),
+ ImplContainer => cx.tcx.impl_trait_ref(container_id).map(|t| t.skip_binder().def_id),
  };
 
  if let Some(trait_def_id) = trait_def_id {

clippy_lints/src/missing_trait_methods.rs

@@ -80,19 +80,21 @@ impl<'tcx> LateLintPass<'tcx> for MissingTraitMethods {
  }
  }
 
- for assoc in provided.values() {
- let source_map = cx.tcx.sess.source_map();
- let definition_span = source_map.guess_head_span(cx.tcx.def_span(assoc.def_id));
+ cx.tcx.with_stable_hashing_context(|hcx| {
+ for assoc in provided.values_sorted(&hcx, true) {
+ let source_map = cx.tcx.sess.source_map();
+ let definition_span = source_map.guess_head_span(cx.tcx.def_span(assoc.def_id));
 
- span_lint_and_help(
- cx,
- MISSING_TRAIT_METHODS,
- source_map.guess_head_span(item.span),
- &format!("missing trait method provided by default: `{}`", assoc.name),
- Some(definition_span),
- "implement the method",
- );
- }
+ span_lint_and_help(
+ cx,
+ MISSING_TRAIT_METHODS,
+ source_map.guess_head_span(item.span),
+ &format!("missing trait method provided by default: `{}`", assoc.name),
+ Some(definition_span),
+ "implement the method",
+ );
+ }
+ });
  }
  }
 }

clippy_lints/src/needless_pass_by_value.rs

@@ -24,7 +24,7 @@ use rustc_span::symbol::kw;
 use rustc_span::{sym, Span};
 use rustc_target::spec::abi::Abi;
 use rustc_trait_selection::traits;
-use rustc_trait_selection::traits::misc::can_type_implement_copy;
+use rustc_trait_selection::traits::misc::type_allowed_to_implement_copy;
 use std::borrow::Cow;
 
 declare_clippy_lint! {
@@ -200,7 +200,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByValue {
  let sugg = |diag: &mut Diagnostic| {
  if let ty::Adt(def, ..) = ty.kind() {
  if let Some(span) = cx.tcx.hir().span_if_local(def.did()) {
- if can_type_implement_copy(
+ if type_allowed_to_implement_copy(
  cx.tcx,
  cx.param_env,
  ty,

clippy_lints/src/non_send_fields_in_send_ty.rs

@@ -90,7 +90,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSendFieldInSendTy {
  if send_trait == trait_id;
  if hir_impl.polarity == ImplPolarity::Positive;
  if let Some(ty_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id);
- if let self_ty = ty_trait_ref.self_ty();
+ if let self_ty = ty_trait_ref.subst_identity().self_ty();
  if let ty::Adt(adt_def, impl_trait_substs) = self_ty.kind();
  then {
  let mut non_send_fields = Vec::new();

clippy_lints/src/only_used_in_recursion.rs

@@ -7,7 +7,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::hir_id::HirIdMap;
 use rustc_hir::{Body, Expr, ExprKind, HirId, ImplItem, ImplItemKind, Node, PatKind, TraitItem, TraitItemKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
+use rustc_middle::ty::subst::{EarlyBinder, GenericArgKind, SubstsRef};
 use rustc_middle::ty::{self, ConstKind};
 use rustc_session::{declare_tool_lint, impl_lint_pass};
 use rustc_span::symbol::{kw, Ident};
@@ -244,7 +244,7 @@ impl<'tcx> LateLintPass<'tcx> for OnlyUsedInRecursion {
  })) => {
  #[allow(trivial_casts)]
  if let Some(Node::Item(item)) = get_parent_node(cx.tcx, owner_id.into())
- && let Some(trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
+ && let Some(trait_ref) = cx.tcx.impl_trait_ref(item.owner_id).map(EarlyBinder::subst_identity)
  && let Some(trait_item_id) = cx.tcx.associated_item(owner_id).trait_item_def_id
  {
  (

clippy_lints/src/pass_by_ref_or_value.rs

@@ -190,10 +190,10 @@ impl<'tcx> PassByRefOrValue {
  // Don't lint if an unsafe pointer is created.
  // TODO: Limit the check only to unsafe pointers to the argument (or part of the argument)
  // which escape the current function.
- if typeck.node_types().iter().any(|(_, &ty)| ty.is_unsafe_ptr())
+ if typeck.node_types().items().any(|(_, &ty)| ty.is_unsafe_ptr())
  || typeck
  .adjustments()
- .iter()
+ .items()
  .flat_map(|(_, a)| a)
  .any(|a| matches!(a.kind, Adjust::Pointer(PointerCast::UnsafeFnPointer)))
  {

clippy_lints/src/transmute/utils.rs

@@ -34,7 +34,7 @@ pub(super) fn check_cast<'tcx>(
  let local_def_id = hir_id.owner.def_id;
 
  Inherited::build(cx.tcx, local_def_id).enter(|inherited| {
- let fn_ctxt = FnCtxt::new(inherited, cx.param_env, hir_id);
+ let fn_ctxt = FnCtxt::new(inherited, cx.param_env, local_def_id);
 
  // If we already have errors, we can't be sure we can pointer cast.
  assert!(

clippy_lints/src/use_self.rs

@@ -137,7 +137,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
  then {
  // `self_ty` is the semantic self type of `impl <trait> for <type>`. This cannot be
  // `Self`.
- let self_ty = impl_trait_ref.self_ty();
+ let self_ty = impl_trait_ref.subst_identity().self_ty();
 
  // `trait_method_sig` is the signature of the function, how it is declared in the
  // trait, not in the impl of the trait.

clippy_utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "clippy_utils"
-version = "0.1.68"
+version = "0.1.69"
 edition = "2021"
 publish = false
 

clippy_utils/src/macros.rs

@@ -1,14 +1,13 @@
 #![allow(clippy::similar_names)] // `expr` and `expn`
 
-use crate::is_path_diagnostic_item;
 use crate::source::snippet_opt;
 use crate::visitors::{for_each_expr, Descend};
 
 use arrayvec::ArrayVec;
 use itertools::{izip, Either, Itertools};
 use rustc_ast::ast::LitKind;
 use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{self as hir, Expr, ExprField, ExprKind, HirId, Node, QPath};
+use rustc_hir::{self as hir, Expr, ExprField, ExprKind, HirId, LangItem, Node, QPath, TyKind};
 use rustc_lexer::unescape::unescape_literal;
 use rustc_lexer::{tokenize, unescape, LiteralKind, TokenKind};
 use rustc_lint::LateContext;
@@ -439,8 +438,7 @@ impl<'tcx> FormatArgsValues<'tcx> {
  // ArgumentV1::from_usize(<val>)
  if let ExprKind::Call(callee, [val]) = expr.kind
  && let ExprKind::Path(QPath::TypeRelative(ty, _)) = callee.kind
- && let hir::TyKind::Path(QPath::Resolved(_, path)) = ty.kind
- && path.segments.last().unwrap().ident.name == sym::ArgumentV1
+ && let TyKind::Path(QPath::LangItem(LangItem::FormatArgument, _, _)) = ty.kind
  {
  let val_idx = if val.span.ctxt() == expr.span.ctxt()
  && let ExprKind::Field(_, field) = val.kind
@@ -486,20 +484,6 @@ struct ParamPosition {
 
 impl<'tcx> Visitor<'tcx> for ParamPosition {
  fn visit_expr_field(&mut self, field: &'tcx ExprField<'tcx>) {
- fn parse_count(expr: &Expr<'_>) -> Option<usize> {
- // ::core::fmt::rt::v1::Count::Param(1usize),
- if let ExprKind::Call(ctor, [val]) = expr.kind
- && let ExprKind::Path(QPath::Resolved(_, path)) = ctor.kind
- && path.segments.last()?.ident.name == sym::Param
- && let ExprKind::Lit(lit) = &val.kind
- && let LitKind::Int(pos, _) = lit.node
- {
- Some(pos as usize)
- } else {
- None
- }
- }
-
  match field.ident.name {
  sym::position => {
  if let ExprKind::Lit(lit) = &field.expr.kind
@@ -519,15 +503,41 @@ impl<'tcx> Visitor<'tcx> for ParamPosition {
  }
 }
 
+fn parse_count(expr: &Expr<'_>) -> Option<usize> {
+ // <::core::fmt::rt::v1::Count>::Param(1usize),
+ if let ExprKind::Call(ctor, [val]) = expr.kind
+ && let ExprKind::Path(QPath::TypeRelative(_, path)) = ctor.kind
+ && path.ident.name == sym::Param
+ && let ExprKind::Lit(lit) = &val.kind
+ && let LitKind::Int(pos, _) = lit.node
+ {
+ Some(pos as usize)
+ } else {
+ None
+ }
+}
+
 /// Parses the `fmt` arg of `Arguments::new_v1_formatted(pieces, args, fmt, _)`
 fn parse_rt_fmt<'tcx>(fmt_arg: &'tcx Expr<'tcx>) -> Option<impl Iterator<Item = ParamPosition> + 'tcx> {
  if let ExprKind::AddrOf(.., array) = fmt_arg.kind
  && let ExprKind::Array(specs) = array.kind
  {
  Some(specs.iter().map(|spec| {
- let mut position = ParamPosition::default();
- position.visit_expr(spec);
- position
+ if let ExprKind::Call(f, args) = spec.kind
+ && let ExprKind::Path(QPath::TypeRelative(ty, f)) = f.kind
+ && let TyKind::Path(QPath::LangItem(LangItem::FormatPlaceholder, _, _)) = ty.kind
+ && f.ident.name == sym::new
+ && let [position, _fill, _align, _flags, precision, width] = args
+ && let ExprKind::Lit(position) = &position.kind
+ && let LitKind::Int(position, _) = position.node {
+ ParamPosition {
+ value: position as usize,
+ width: parse_count(width),
+ precision: parse_count(precision),
+ }
+ } else {
+ ParamPosition::default()
+ }
  }))
  } else {
  None
@@ -890,7 +900,7 @@ impl<'tcx> FormatArgsExpn<'tcx> {
  // ::core::fmt::Arguments::new_v1_formatted(pieces, args, fmt, _unsafe_arg)
  if let ExprKind::Call(callee, [pieces, args, rest @ ..]) = expr.kind
  && let ExprKind::Path(QPath::TypeRelative(ty, seg)) = callee.kind
- && is_path_diagnostic_item(cx, ty, sym::Arguments)
+ && let TyKind::Path(QPath::LangItem(LangItem::FormatArguments, _, _)) = ty.kind
  && matches!(seg.ident.as_str(), "new_v1" | "new_v1_formatted")
  {
  let format_string = FormatString::new(cx, pieces)?;

clippy_utils/src/sugg.rs

@@ -219,6 +219,7 @@ impl<'a> Sugg<'a> {
  | ast::ExprKind::Repeat(..)
  | ast::ExprKind::Ret(..)
  | ast::ExprKind::Yeet(..)
+ | ast::ExprKind::FormatArgs(..)
  | ast::ExprKind::Struct(..)
  | ast::ExprKind::Try(..)
  | ast::ExprKind::TryBlock(..)