use if_chain::if_chain;
use rustc_errors::Applicability;
use rustc_hir as hir;
-use rustc_hir::{self, Expr, ExprKind, HirId, PatKind};
+use rustc_hir::{self, ExprKind, HirId, PatKind};
use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::LateContext;
use rustc_middle::hir::place::ProjectionKind;
then {
if let hir::PatKind::Ref(..) = closure_arg.pat.kind {
Some(search_snippet.replacen('&', "", 1))
- } else if let PatKind::Binding(..) = strip_pat_refs(closure_arg.pat).kind {
+ } else if let PatKind::Binding(_, binding_id, _, _) = strip_pat_refs(closure_arg.pat).kind {
+ // this binding is composed of at least two levels of references, so we need to remove one
+ let binding_type = cx.typeck_results().node_type(binding_id);
+ let innermost_is_ref = if let ty::Ref(_, inner,_) = binding_type.kind() {
+ matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_ref())
+ } else {
+ false
+ };
+
// `find()` provides a reference to the item, but `any` does not,
// so we should fix item usages for suggestion
if let Some(closure_sugg) = get_closure_suggestion(cx, search_arg, closure_body) {
applicability = closure_sugg.applicability;
- Some(closure_sugg.suggestion)
+ if innermost_is_ref {
+ Some(closure_sugg.suggestion.replacen('&', "", 1))
+ } else {
+ Some(closure_sugg.suggestion)
+ }
+ } else if innermost_is_ref {
+ Some(search_snippet.replacen('&', "", 1))
} else {
Some(search_snippet.to_string())
}
let ident_str = map.name(id).to_string();
let span = map.span(cmt.hir_id);
let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
- let start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+ let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
if cmt.place.projections.is_empty() {
// handle item without any projection, that needs an explicit borrowing
} else {
// cases where a parent call is using the item
// i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
- let parent_expr = get_parent_expr_for_hir(self.cx, cmt.hir_id);
- if let Some(Expr { hir_id: _, kind, .. }) = parent_expr {
- if let ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) = kind {
- let args_to_handle = args.iter().filter(|arg| arg.hir_id == cmt.hir_id).collect::<Vec<_>>();
- if !args_to_handle.is_empty() {
- for arg in &args_to_handle {
- let arg_ty_kind = self.cx.typeck_results().expr_ty(arg).kind();
- if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
- let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
- let start_snip =
- snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+ if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
+ if let ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) = parent_expr.kind {
+ let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
+ let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
- self.suggestion_start.push_str(&format!("{}&{}", start_snip, ident_str));
- self.next_pos = span.hi();
- } else {
- self.applicability = Applicability::Unspecified;
- }
- }
+ if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
+ let start_span = Span::new(self.next_pos, span.lo(), span.ctxt());
+ let start_snip =
+ snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+ // do not suggest ampersand if the ident is the method caller
+ let ident_sugg = if !call_args.is_empty() && call_args[0].hir_id == cmt.hir_id {
+ format!("{}{}", start_snip, ident_str)
+ } else {
+ format!("{}&{}", start_snip, ident_str)
+ };
+ self.suggestion_start.push_str(&ident_sugg);
+ self.next_pos = span.hi();
return;
+ } else {
+ self.applicability = Applicability::Unspecified;
}
}
}
// handle item projections by removing one explicit deref
// i.e.: suggest `*x` instead of `**x`
let mut replacement_str = ident_str;
- let last_deref = cmt
- .place
- .projections
- .iter()
- .rposition(|proj| proj.kind == ProjectionKind::Deref);
- if let Some(pos) = last_deref {
- let mut projections = cmt.place.projections.clone();
- projections.truncate(pos);
+ // handle index projection first
+ let index_handled = cmt.place.projections.iter().any(|proj| match proj.kind {
+ // Index projection like `|x| foo[x]`
+ // the index is dropped so we can't get it to build the suggestion,
+ // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
+ // instead of `span.lo()` (i.e.: `foo`)
+ ProjectionKind::Index => {
+ let start_span = Span::new(self.next_pos, span.hi(), span.ctxt());
+ start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
+ replacement_str.clear();
+ true
+ },
+ _ => false,
+ });
+
+ // looking for projections other that need to be handled differently
+ let other_projections_handled = cmt.place.projections.iter().enumerate().any(|(i, proj)| {
+ match proj.kind {
+ // Field projection like `|v| v.foo`
+ ProjectionKind::Field(idx, variant) => match cmt.place.ty_before_projection(i).kind() {
+ ty::Adt(def, ..) => {
+ replacement_str = format!(
+ "{}.{}",
+ replacement_str,
+ def.variants[variant].fields[idx as usize].ident.name.as_str()
+ );
+ true
+ },
+ ty::Tuple(_) => {
+ replacement_str = format!("{}.{}", replacement_str, idx);
+ true
+ },
+ _ => false,
+ },
+ // handled previously
+ ProjectionKind::Index |
+ // note: unable to trigger `Subslice` kind in tests
+ ProjectionKind::Subslice => false,
+ ProjectionKind::Deref => {
+ // explicit deref for arrays should be avoided in the suggestion
+ // i.e.: `|sub| *sub[1..4].len() == 3` is not expected
+ match cmt.place.ty_before_projection(i).kind() {
+ // dereferencing an array (i.e.: `|sub| sub[1..4].len() == 3`)
+ ty::Ref(_, inner, _) => {
+ matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array())
+ },
+ _ => false,
+ }
+ },
+ }
+ });
+
+ // handle `ProjectionKind::Deref` if no special case detected
+ if !index_handled && !other_projections_handled {
+ let last_deref = cmt
+ .place
+ .projections
+ .iter()
+ .rposition(|proj| proj.kind == ProjectionKind::Deref);
+
+ if let Some(pos) = last_deref {
+ let mut projections = cmt.place.projections.clone();
+ projections.truncate(pos);
- for item in projections {
- if item.kind == ProjectionKind::Deref {
- replacement_str = format!("*{}", replacement_str);
+ for item in projections {
+ if item.kind == ProjectionKind::Deref {
+ replacement_str = format!("*{}", replacement_str);
+ }
}
}
}
projects / rust.git / blobdiff