fix

rust-lang · bors · Jul 29, 2023 · May 24, 2023 · May 25, 2023 · Jul 23, 2023
commit 626efab67f184658eb966d3a69c31d7f1deb47e4
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
@@ -413,7 413,7 @@ lint_non_upper_case_global = {$sort} `{$name}` should have an upper case name
 
 lint_noop_method_call = call to `.{$method}()` on a reference in this situation does nothing
  .label = unnecessary method call
- .note = the type `{$receiver_ty}` which `{$method}` is being called on is the same as the type returned from `{$method}`, so the method call does not do anything and can be removed
  .note = the type `{$orig_ty}` does not implement `{$trait_}`, so calling `{$method}` on `&{$orig_ty}` copies the reference, which does not do anything and can be removed
 
 lint_only_cast_u8_to_char = only `u8` can be cast into `char`
  .suggestion = use a `char` literal instead

diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
@@ -1231,7 1231,8 @@ pub enum NonUpperCaseGlobalSub {
 #[note]
 pub struct NoopMethodCallDiag<'a> {
  pub method: Symbol,
- pub receiver_ty: Ty<'a>,
  pub orig_ty: Ty<'a>,
  pub trait_: Symbol,
  #[label]
  pub label: Span,
 }

diff --git a/compiler/rustc_lint/src/noop_method_call.rs b/compiler/rustc_lint/src/noop_method_call.rs
@@ -85,10 85,9 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
 
  let Some(trait_id) = cx.tcx.trait_of_item(did) else { return };
 
- if !matches!(
- cx.tcx.get_diagnostic_name(trait_id),
- Some(sym::Borrow | sym::Clone | sym::Deref)
- ) {
  let Some(trait_) = cx.tcx.get_diagnostic_name(trait_id) else { return };
 
  if !matches!(trait_, sym::Borrow | sym::Clone | sym::Deref) {
  return;
  };
 
@@ -113,11 112,13 @@ impl<'tcx> LateLintPass<'tcx> for NoopMethodCall {
  let expr_span = expr.span;
  let span = expr_span.with_lo(receiver.span.hi());
 
  let orig_ty = expr_ty.peel_refs();
 
  if receiver_ty == expr_ty {
  cx.emit_spanned_lint(
  NOOP_METHOD_CALL,
  span,
- NoopMethodCallDiag { method: call.ident.name, receiver_ty, label: span },
  NoopMethodCallDiag { method: call.ident.name, orig_ty, trait_, label: span },
  );
  } else {
  match name {

diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -41,7 41,6 @@ use rustc_span::{BytePos, DesugaringKind, ExpnKind, MacroKind, Span, DUMMY_SP};
 use rustc_target::spec::abi;
 use std::borrow::Cow;
 use std::iter;
-use std::ops::Deref;
 
 use super::InferCtxtPrivExt;
 use crate::infer::InferCtxtExt as _;
@@ -3580,7 3579,7 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  // to an associated type (as seen from `trait_pred`) in the predicate. Like in
  // trait_pred `S: Sum<<Self as Iterator>::Item>` and predicate `i32: Sum<&()>`
  let mut type_diffs = vec![];
- if let ObligationCauseCode::ExprBindingObligation(def_id, _, _, idx) = parent_code.deref()
  if let ObligationCauseCode::ExprBindingObligation(def_id, _, _, idx) = parent_code
  && let Some(node_args) = typeck_results.node_args_opt(call_hir_id)
  && let where_clauses = self.tcx.predicates_of(def_id).instantiate(self.tcx, node_args)
  && let Some(where_pred) = where_clauses.predicates.get(*idx)

diff --git a/library/core/benches/iter.rs b/library/core/benches/iter.rs
@@ -473,6 473,7 @@ fn bench_next_chunk_copied(b: &mut Bencher) {
 
 /// Exercises the TrustedRandomAccess specialization in ArrayChunks
 #[bench]
 #[allow(noop_method_call)]
 fn bench_next_chunk_trusted_random_access(b: &mut Bencher) {
  let v = vec![1u8; 1024];
 

diff --git a/src/tools/clippy/tests/ui/explicit_deref_methods.fixed b/src/tools/clippy/tests/ui/explicit_deref_methods.fixed
@@ -4,6 4,7 @@
 #![allow(
  clippy::borrow_deref_ref,
  suspicious_double_ref_op,
  noop_method_call,
  clippy::explicit_auto_deref,
  clippy::needless_borrow,
  clippy::no_effect,

diff --git a/src/tools/clippy/tests/ui/explicit_deref_methods.rs b/src/tools/clippy/tests/ui/explicit_deref_methods.rs
@@ -4,6 4,7 @@
 #![allow(
  clippy::borrow_deref_ref,
  suspicious_double_ref_op,
  noop_method_call,
  clippy::explicit_auto_deref,
  clippy::needless_borrow,
  clippy::no_effect,

diff --git a/src/tools/clippy/tests/ui/explicit_deref_methods.stderr b/src/tools/clippy/tests/ui/explicit_deref_methods.stderr
@@ -1,73 1,73 @@
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:54:19
  --> $DIR/explicit_deref_methods.rs:55:19
  |
 LL | let b: &str = a.deref();
  | ^^^^^^^^^ help: try: `&*a`
  |
  = note: `-D clippy::explicit-deref-methods` implied by `-D warnings`
 
 error: explicit `deref_mut` method call
- --> $DIR/explicit_deref_methods.rs:56:23
  --> $DIR/explicit_deref_methods.rs:57:23
  |
 LL | let b: &mut str = a.deref_mut();
  | ^^^^^^^^^^^^^ help: try: `&mut **a`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:59:39
  --> $DIR/explicit_deref_methods.rs:60:39
  |
 LL | let b: String = format!("{}, {}", a.deref(), a.deref());
  | ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:59:50
  --> $DIR/explicit_deref_methods.rs:60:50
  |
 LL | let b: String = format!("{}, {}", a.deref(), a.deref());
  | ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:61:20
  --> $DIR/explicit_deref_methods.rs:62:20
  |
 LL | println!("{}", a.deref());
  | ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:64:11
  --> $DIR/explicit_deref_methods.rs:65:11
  |
 LL | match a.deref() {
  | ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:68:28
  --> $DIR/explicit_deref_methods.rs:69:28
  |
 LL | let b: String = concat(a.deref());
  | ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:70:13
  --> $DIR/explicit_deref_methods.rs:71:13
  |
 LL | let b = just_return(a).deref();
  | ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:72:28
  --> $DIR/explicit_deref_methods.rs:73:28
  |
 LL | let b: String = concat(just_return(a).deref());
  | ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:74:19
  --> $DIR/explicit_deref_methods.rs:75:19
  |
 LL | let b: &str = a.deref().deref();
  | ^^^^^^^^^^^^^^^^^ help: try: `&**a`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:77:13
  --> $DIR/explicit_deref_methods.rs:78:13
  |
 LL | let b = opt_a.unwrap().deref();
  | ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*opt_a.unwrap()`
 
 error: explicit `deref` method call
- --> $DIR/explicit_deref_methods.rs:114:31
  --> $DIR/explicit_deref_methods.rs:115:31
  |
 LL | let b: &str = expr_deref!(a.deref());
  | ^^^^^^^^^ help: try: `&*a`

diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
@@ -1119,7 1119,7 @@ fn check_overlapping_tests(found_paths: &BTreeSet<PathBuf>) {
  for path in found_paths {
  for ancestor in path.ancestors().skip(1) {
  if found_paths.contains(ancestor) {
- collisions.push((path, ancestor.clone()));
  collisions.push((path, ancestor));
  }
  }
  }

diff --git a/tests/ui/lint/noop-method-call.stderr b/tests/ui/lint/noop-method-call.stderr
@@ -4,7 4,7 @@ warning: call to `.clone()` on a reference in this situation does nothing
 LL | let non_clone_type_ref_clone: &PlainType<u32> = non_clone_type_ref.clone();
  | ^^^^^^^^ unnecessary method call
  |
- = note: the type `&PlainType<u32>` which `clone` is being called on is the same as the type returned from `clone`, so the method call does not do anything and can be removed
  = note: the type `PlainType<u32>` does not implement `Clone`, so calling `clone` on `&PlainType<u32>` copies the reference, which does not do anything and can be removed
  = note: `#[warn(noop_method_call)]` on by default
 
 warning: using `.clone()` on a double reference, which returns `&CloneType<u32>` instead of cloning the inner type
@@ -21,7 21,7 @@ warning: call to `.deref()` on a reference in this situation does nothing
 LL | let non_deref_type_deref: &PlainType<u32> = non_deref_type.deref();
  | ^^^^^^^^ unnecessary method call
  |
- = note: the type `&PlainType<u32>` which `deref` is being called on is the same as the type returned from `deref`, so the method call does not do anything and can be removed
  = note: the type `PlainType<u32>` does not implement `Deref`, so calling `deref` on `&PlainType<u32>` copies the reference, which does not do anything and can be removed
 
 warning: using `.deref()` on a double reference, which returns `&PlainType<u32>` instead of dereferencing the inner type
  --> $DIR/noop-method-call.rs:30:63
@@ -35,7 35,7 @@ warning: call to `.borrow()` on a reference in this situation does nothing
 LL | let non_borrow_type_borrow: &PlainType<u32> = non_borrow_type.borrow();
  | ^^^^^^^^^ unnecessary method call
  |
- = note: the type `&PlainType<u32>` which `borrow` is being called on is the same as the type returned from `borrow`, so the method call does not do anything and can be removed
  = note: the type `PlainType<u32>` does not implement `Borrow`, so calling `borrow` on `&PlainType<u32>` copies the reference, which does not do anything and can be removed
 
 warning: using `.clone()` on a double reference, which returns `&str` instead of cloning the inner type
  --> $DIR/noop-method-call.rs:42:44
@@ -49,15 49,15 @@ warning: call to `.clone()` on a reference in this situation does nothing
 LL | non_clone_type.clone();
  | ^^^^^^^^ unnecessary method call
  |
- = note: the type `&PlainType<T>` which `clone` is being called on is the same as the type returned from `clone`, so the method call does not do anything and can be removed
  = note: the type `PlainType<T>` does not implement `Clone`, so calling `clone` on `&PlainType<T>` copies the reference, which does not do anything and can be removed
 
 warning: call to `.clone()` on a reference in this situation does nothing
  --> $DIR/noop-method-call.rs:52:19
  |
 LL | non_clone_type.clone();
  | ^^^^^^^^ unnecessary method call
  |
- = note: the type `&PlainType<u32>` which `clone` is being called on is the same as the type returned from `clone`, so the method call does not do anything and can be removed
  = note: the type `PlainType<u32>` does not implement `Clone`, so calling `clone` on `&PlainType<u32>` copies the reference, which does not do anything and can be removed
 
 warning: 8 warnings emitted
 
diff --git a/tests/ui/lint/suspicious-double-ref-op.stderr b/tests/ui/lint/suspicious-double-ref-op.stderr
@@ -16,7 16,7 @@ error: call to `.clone()` on a reference in this situation does nothing
 LL | let _ = &mut encoded.clone();
  | ^^^^^^^^ unnecessary method call
  |
- = note: the type `&[u8]` which `clone` is being called on is the same as the type returned from `clone`, so the method call does not do anything and can be removed
  = note: the type `[u8]` does not implement `Clone`, so calling `clone` on `&[u8]` copies the reference, which does not do anything and can be removed
 note: the lint level is defined here
  --> $DIR/suspicious-double-ref-op.rs:2:35
  |
@@ -29,7 29,7 @@ error: call to `.clone()` on a reference in this situation does nothing
 LL | let _ = &encoded.clone();
  | ^^^^^^^^ unnecessary method call
  |
- = note: the type `&[u8]` which `clone` is being called on is the same as the type returned from `clone`, so the method call does not do anything and can be removed
  = note: the type `[u8]` does not implement `Clone`, so calling `clone` on `&[u8]` copies the reference, which does not do anything and can be removed
 
 error: aborting due to 3 previous errors