2022-06-16 15:39:06 +00:00
|
|
|
use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
|
2021-12-06 11:33:31 +00:00
|
|
|
use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
|
2022-01-27 14:12:45 +00:00
|
|
|
use clippy_utils::sugg::has_enclosing_paren;
|
2023-11-16 18:13:24 +00:00
|
|
|
use clippy_utils::ty::{implements_trait, is_manually_drop, peel_mid_ty_refs};
|
2022-08-31 13:24:45 +00:00
|
|
|
use clippy_utils::{
|
2023-07-31 21:53:53 +00:00
|
|
|
expr_use_ctxt, get_parent_expr, get_parent_node, is_lint_allowed, path_to_local, DefinedTy, ExprUseNode,
|
2022-08-31 13:24:45 +00:00
|
|
|
};
|
2023-11-16 18:13:24 +00:00
|
|
|
use core::mem;
|
2021-12-06 11:33:31 +00:00
|
|
|
use rustc_ast::util::parser::{PREC_POSTFIX, PREC_PREFIX};
|
|
|
|
use rustc_data_structures::fx::FxIndexMap;
|
2020-01-23 15:28:01 +00:00
|
|
|
use rustc_errors::Applicability;
|
2022-06-30 08:50:09 +00:00
|
|
|
use rustc_hir::intravisit::{walk_ty, Visitor};
|
2021-12-06 11:33:31 +00:00
|
|
|
use rustc_hir::{
|
2023-09-25 09:28:58 +00:00
|
|
|
self as hir, BindingAnnotation, Body, BodyId, BorrowKind, Expr, ExprKind, HirId, MatchSource, Mutability, Node,
|
|
|
|
Pat, PatKind, Path, QPath, TyKind, UnOp,
|
2021-12-06 11:33:31 +00:00
|
|
|
};
|
2020-01-23 15:28:01 +00:00
|
|
|
use rustc_lint::{LateContext, LateLintPass};
|
2022-01-27 14:12:45 +00:00
|
|
|
use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
|
2023-09-25 09:28:58 +00:00
|
|
|
use rustc_middle::ty::{self, ParamEnv, Ty, TyCtxt, TypeVisitableExt, TypeckResults};
|
2023-12-01 17:21:58 +00:00
|
|
|
use rustc_session::impl_lint_pass;
|
2023-07-17 08:19:29 +00:00
|
|
|
use rustc_span::symbol::sym;
|
|
|
|
use rustc_span::{Span, Symbol};
|
2018-10-03 16:53:39 +00:00
|
|
|
|
|
|
|
declare_clippy_lint! {
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### What it does
|
|
|
|
/// Checks for explicit `deref()` or `deref_mut()` method calls.
|
2020-01-23 15:28:01 +00:00
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Why is this bad?
|
|
|
|
/// Dereferencing by `&*x` or `&mut *x` is clearer and more concise,
|
2020-01-23 15:28:01 +00:00
|
|
|
/// when not part of a method chain.
|
|
|
|
///
|
2021-07-29 10:16:06 +00:00
|
|
|
/// ### Example
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2020-02-25 22:06:24 +00:00
|
|
|
/// use std::ops::Deref;
|
|
|
|
/// let a: &mut String = &mut String::from("foo");
|
|
|
|
/// let b: &str = a.deref();
|
2020-01-23 15:28:01 +00:00
|
|
|
/// ```
|
2022-06-16 15:39:06 +00:00
|
|
|
///
|
|
|
|
/// Use instead:
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2020-02-25 22:06:24 +00:00
|
|
|
/// let a: &mut String = &mut String::from("foo");
|
2020-01-23 15:28:01 +00:00
|
|
|
/// let b = &*a;
|
|
|
|
/// ```
|
2020-01-26 18:48:30 +00:00
|
|
|
///
|
2023-07-02 12:35:19 +00:00
|
|
|
/// This lint excludes all of:
|
2020-02-25 22:06:24 +00:00
|
|
|
/// ```rust,ignore
|
|
|
|
/// let _ = d.unwrap().deref();
|
2023-07-02 12:35:19 +00:00
|
|
|
/// let _ = Foo::deref(&foo);
|
|
|
|
/// let _ = <Foo as Deref>::deref(&foo);
|
2020-01-23 15:28:01 +00:00
|
|
|
/// ```
|
2021-12-06 11:33:31 +00:00
|
|
|
#[clippy::version = "1.44.0"]
|
2020-03-07 14:33:27 +00:00
|
|
|
pub EXPLICIT_DEREF_METHODS,
|
2018-10-03 16:53:39 +00:00
|
|
|
pedantic,
|
|
|
|
"Explicit use of deref or deref_mut method while not in a method chain."
|
|
|
|
}
|
|
|
|
|
2021-12-06 11:33:31 +00:00
|
|
|
declare_clippy_lint! {
|
|
|
|
/// ### What it does
|
|
|
|
/// Checks for address of operations (`&`) that are going to
|
|
|
|
/// be dereferenced immediately by the compiler.
|
|
|
|
///
|
|
|
|
/// ### Why is this bad?
|
|
|
|
/// Suggests that the receiver of the expression borrows
|
|
|
|
/// the expression.
|
|
|
|
///
|
2023-07-17 08:19:29 +00:00
|
|
|
/// ### Known problems
|
|
|
|
/// The lint cannot tell when the implementation of a trait
|
|
|
|
/// for `&T` and `T` do different things. Removing a borrow
|
|
|
|
/// in such a case can change the semantics of the code.
|
|
|
|
///
|
2021-12-06 11:33:31 +00:00
|
|
|
/// ### Example
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2021-12-06 11:33:31 +00:00
|
|
|
/// fn fun(_a: &i32) {}
|
|
|
|
///
|
|
|
|
/// let x: &i32 = &&&&&&5;
|
|
|
|
/// fun(&x);
|
2022-06-16 15:39:06 +00:00
|
|
|
/// ```
|
2021-12-06 11:33:31 +00:00
|
|
|
///
|
2022-06-16 15:39:06 +00:00
|
|
|
/// Use instead:
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2022-06-16 15:39:06 +00:00
|
|
|
/// # fn fun(_a: &i32) {}
|
2021-12-06 11:33:31 +00:00
|
|
|
/// let x: &i32 = &5;
|
|
|
|
/// fun(x);
|
|
|
|
/// ```
|
|
|
|
#[clippy::version = "pre 1.29.0"]
|
|
|
|
pub NEEDLESS_BORROW,
|
|
|
|
style,
|
|
|
|
"taking a reference that is going to be automatically dereferenced"
|
|
|
|
}
|
|
|
|
|
|
|
|
declare_clippy_lint! {
|
|
|
|
/// ### What it does
|
|
|
|
/// Checks for `ref` bindings which create a reference to a reference.
|
|
|
|
///
|
|
|
|
/// ### Why is this bad?
|
|
|
|
/// The address-of operator at the use site is clearer about the need for a reference.
|
|
|
|
///
|
|
|
|
/// ### Example
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2021-12-06 11:33:31 +00:00
|
|
|
/// let x = Some("");
|
|
|
|
/// if let Some(ref x) = x {
|
|
|
|
/// // use `x` here
|
|
|
|
/// }
|
2022-06-16 15:39:06 +00:00
|
|
|
/// ```
|
2021-12-06 11:33:31 +00:00
|
|
|
///
|
2022-06-16 15:39:06 +00:00
|
|
|
/// Use instead:
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2021-12-06 11:33:31 +00:00
|
|
|
/// let x = Some("");
|
|
|
|
/// if let Some(x) = x {
|
|
|
|
/// // use `&x` here
|
|
|
|
/// }
|
|
|
|
/// ```
|
|
|
|
#[clippy::version = "1.54.0"]
|
|
|
|
pub REF_BINDING_TO_REFERENCE,
|
|
|
|
pedantic,
|
|
|
|
"`ref` binding to a reference"
|
|
|
|
}
|
|
|
|
|
2022-06-30 08:50:09 +00:00
|
|
|
declare_clippy_lint! {
|
|
|
|
/// ### What it does
|
|
|
|
/// Checks for dereferencing expressions which would be covered by auto-deref.
|
|
|
|
///
|
|
|
|
/// ### Why is this bad?
|
|
|
|
/// This unnecessarily complicates the code.
|
|
|
|
///
|
|
|
|
/// ### Example
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2022-06-30 08:50:09 +00:00
|
|
|
/// let x = String::new();
|
|
|
|
/// let y: &str = &*x;
|
|
|
|
/// ```
|
|
|
|
/// Use instead:
|
2023-11-02 16:35:56 +00:00
|
|
|
/// ```no_run
|
2022-06-30 08:50:09 +00:00
|
|
|
/// let x = String::new();
|
|
|
|
/// let y: &str = &x;
|
|
|
|
/// ```
|
2022-10-06 07:44:38 +00:00
|
|
|
#[clippy::version = "1.64.0"]
|
2022-06-30 08:50:09 +00:00
|
|
|
pub EXPLICIT_AUTO_DEREF,
|
|
|
|
complexity,
|
|
|
|
"dereferencing when the compiler would automatically dereference"
|
|
|
|
}
|
|
|
|
|
2022-10-23 13:18:45 +00:00
|
|
|
impl_lint_pass!(Dereferencing<'_> => [
|
2021-03-25 18:29:11 +00:00
|
|
|
EXPLICIT_DEREF_METHODS,
|
2021-12-06 11:33:31 +00:00
|
|
|
NEEDLESS_BORROW,
|
|
|
|
REF_BINDING_TO_REFERENCE,
|
2022-06-30 08:50:09 +00:00
|
|
|
EXPLICIT_AUTO_DEREF,
|
2020-01-23 15:28:01 +00:00
|
|
|
]);
|
2018-10-03 16:53:39 +00:00
|
|
|
|
2021-03-25 18:29:11 +00:00
|
|
|
#[derive(Default)]
|
2022-10-23 13:18:45 +00:00
|
|
|
pub struct Dereferencing<'tcx> {
|
2023-07-31 21:53:53 +00:00
|
|
|
state: Option<(State, StateData<'tcx>)>,
|
2021-03-25 18:29:11 +00:00
|
|
|
|
|
|
|
// While parsing a `deref` method call in ufcs form, the path to the function is itself an
|
|
|
|
// expression. This is to store the id of that expression so it can be skipped when
|
|
|
|
// `check_expr` is called for it.
|
|
|
|
skip_expr: Option<HirId>,
|
2021-12-06 11:33:31 +00:00
|
|
|
|
|
|
|
/// The body the first local was found in. Used to emit lints when the traversal of the body has
|
|
|
|
/// been finished. Note we can't lint at the end of every body as they can be nested within each
|
|
|
|
/// other.
|
|
|
|
current_body: Option<BodyId>,
|
2022-08-31 13:24:45 +00:00
|
|
|
|
2021-12-06 11:33:31 +00:00
|
|
|
/// The list of locals currently being checked by the lint.
|
|
|
|
/// If the value is `None`, then the binding has been seen as a ref pattern, but is not linted.
|
|
|
|
/// This is needed for or patterns where one of the branches can be linted, but another can not
|
|
|
|
/// be.
|
|
|
|
///
|
|
|
|
/// e.g. `m!(x) | Foo::Bar(ref x)`
|
|
|
|
ref_locals: FxIndexMap<HirId, Option<RefPat>>,
|
2021-03-25 18:29:11 +00:00
|
|
|
}
|
|
|
|
|
2022-10-06 07:44:38 +00:00
|
|
|
#[derive(Debug)]
|
2023-07-31 21:53:53 +00:00
|
|
|
struct StateData<'tcx> {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: &'tcx Expr<'tcx>,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty: Ty<'tcx>,
|
2022-06-30 08:50:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct DerefedBorrow {
|
|
|
|
count: usize,
|
|
|
|
msg: &'static str,
|
2023-07-31 21:53:53 +00:00
|
|
|
stability: TyCoercionStability,
|
|
|
|
for_field_access: Option<Symbol>,
|
2021-03-25 18:29:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
enum State {
|
|
|
|
// Any number of deref method calls.
|
|
|
|
DerefMethod {
|
|
|
|
// The number of calls in a sequence which changed the referenced type
|
|
|
|
ty_changed_count: usize,
|
2023-07-31 21:53:53 +00:00
|
|
|
is_ufcs: bool,
|
2022-01-27 14:12:45 +00:00
|
|
|
/// The required mutability
|
2023-07-31 21:53:53 +00:00
|
|
|
mutbl: Mutability,
|
2021-03-25 18:29:11 +00:00
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
DerefedBorrow(DerefedBorrow),
|
|
|
|
ExplicitDeref {
|
2022-08-11 17:42:16 +00:00
|
|
|
mutability: Option<Mutability>,
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
|
|
|
ExplicitDerefField {
|
|
|
|
name: Symbol,
|
2023-11-16 18:13:24 +00:00
|
|
|
derefs_manually_drop: bool,
|
2021-12-06 11:33:31 +00:00
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
Reborrow {
|
2022-08-11 17:42:16 +00:00
|
|
|
mutability: Mutability,
|
|
|
|
},
|
|
|
|
Borrow {
|
|
|
|
mutability: Mutability,
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
2021-03-25 18:29:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// A reference operation considered by this lint pass
|
|
|
|
enum RefOp {
|
2023-07-31 21:53:53 +00:00
|
|
|
Method { mutbl: Mutability, is_ufcs: bool },
|
2021-03-25 18:29:11 +00:00
|
|
|
Deref,
|
2022-08-11 17:42:16 +00:00
|
|
|
AddrOf(Mutability),
|
2021-03-25 18:29:11 +00:00
|
|
|
}
|
|
|
|
|
2021-12-06 11:33:31 +00:00
|
|
|
struct RefPat {
|
|
|
|
/// Whether every usage of the binding is dereferenced.
|
|
|
|
always_deref: bool,
|
|
|
|
/// The spans of all the ref bindings for this local.
|
|
|
|
spans: Vec<Span>,
|
|
|
|
/// The applicability of this suggestion.
|
|
|
|
app: Applicability,
|
|
|
|
/// All the replacements which need to be made.
|
|
|
|
replacements: Vec<(Span, String)>,
|
2022-06-16 15:39:06 +00:00
|
|
|
/// The [`HirId`] that the lint should be emitted at.
|
|
|
|
hir_id: HirId,
|
2021-12-06 11:33:31 +00:00
|
|
|
}
|
|
|
|
|
2022-10-23 13:18:45 +00:00
|
|
|
impl<'tcx> LateLintPass<'tcx> for Dereferencing<'tcx> {
|
2022-05-21 11:24:00 +00:00
|
|
|
#[expect(clippy::too_many_lines)]
|
2020-06-25 20:41:36 +00:00
|
|
|
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
|
2021-03-25 18:29:11 +00:00
|
|
|
// Skip path expressions from deref calls. e.g. `Deref::deref(e)`
|
|
|
|
if Some(expr.hir_id) == self.skip_expr.take() {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2021-12-06 11:33:31 +00:00
|
|
|
if let Some(local) = path_to_local(expr) {
|
|
|
|
self.check_local_usage(cx, expr, local);
|
|
|
|
}
|
|
|
|
|
2021-03-25 18:29:11 +00:00
|
|
|
// Stop processing sub expressions when a macro call is seen
|
2021-12-06 11:33:31 +00:00
|
|
|
if expr.span.from_expansion() {
|
2021-03-25 18:29:11 +00:00
|
|
|
if let Some((state, data)) = self.state.take() {
|
2023-11-16 18:13:24 +00:00
|
|
|
report(cx, expr, state, data, cx.typeck_results());
|
2021-03-25 18:29:11 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let typeck = cx.typeck_results();
|
2022-11-21 19:34:47 +00:00
|
|
|
let Some((kind, sub_expr)) = try_parse_ref_op(cx.tcx, typeck, expr) else {
|
2021-03-25 18:29:11 +00:00
|
|
|
// The whole chain of reference operations has been seen
|
|
|
|
if let Some((state, data)) = self.state.take() {
|
2023-11-16 18:13:24 +00:00
|
|
|
report(cx, expr, state, data, typeck);
|
2021-03-25 18:29:11 +00:00
|
|
|
}
|
|
|
|
return;
|
|
|
|
};
|
|
|
|
|
|
|
|
match (self.state.take(), kind) {
|
|
|
|
(None, kind) => {
|
|
|
|
let expr_ty = typeck.expr_ty(expr);
|
2023-07-31 21:53:53 +00:00
|
|
|
let use_cx = expr_use_ctxt(cx, expr);
|
|
|
|
let adjusted_ty = match &use_cx {
|
|
|
|
Some(use_cx) => match use_cx.adjustments {
|
|
|
|
[.., a] => a.target,
|
|
|
|
_ => expr_ty,
|
|
|
|
},
|
|
|
|
_ => typeck.expr_ty_adjusted(expr),
|
|
|
|
};
|
|
|
|
|
|
|
|
match (use_cx, kind) {
|
|
|
|
(Some(use_cx), RefOp::Deref) => {
|
2022-12-01 17:29:38 +00:00
|
|
|
let sub_ty = typeck.expr_ty(sub_expr);
|
2023-07-31 21:53:53 +00:00
|
|
|
if let ExprUseNode::FieldAccess(name) = use_cx.node
|
2023-11-16 18:13:24 +00:00
|
|
|
&& !use_cx.moved_before_use
|
2023-07-31 21:53:53 +00:00
|
|
|
&& !ty_contains_field(sub_ty, name.name)
|
2022-06-30 08:50:09 +00:00
|
|
|
{
|
|
|
|
self.state = Some((
|
2023-11-16 18:13:24 +00:00
|
|
|
State::ExplicitDerefField {
|
|
|
|
name: name.name,
|
|
|
|
derefs_manually_drop: is_manually_drop(sub_ty),
|
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: expr,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty,
|
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
));
|
2023-07-31 21:53:53 +00:00
|
|
|
} else if sub_ty.is_ref()
|
|
|
|
// Linting method receivers would require verifying that name lookup
|
|
|
|
// would resolve the same way. This is complicated by trait methods.
|
|
|
|
&& !use_cx.node.is_recv()
|
|
|
|
&& let Some(ty) = use_cx.node.defined_ty(cx)
|
|
|
|
&& TyCoercionStability::for_defined_ty(cx, ty, use_cx.node.is_return()).is_deref_stable()
|
|
|
|
{
|
2022-06-30 08:50:09 +00:00
|
|
|
self.state = Some((
|
2022-08-11 17:42:16 +00:00
|
|
|
State::ExplicitDeref { mutability: None },
|
2023-07-31 21:53:53 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: expr,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty,
|
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
));
|
|
|
|
}
|
2022-12-01 17:29:38 +00:00
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
(_, RefOp::Method { mutbl, is_ufcs })
|
2021-07-15 08:44:10 +00:00
|
|
|
if !is_lint_allowed(cx, EXPLICIT_DEREF_METHODS, expr.hir_id)
|
2023-07-31 21:53:53 +00:00
|
|
|
// Allow explicit deref in method chains. e.g. `foo.deref().bar()`
|
|
|
|
&& (is_ufcs || !in_postfix_position(cx, expr)) =>
|
2021-03-25 18:29:11 +00:00
|
|
|
{
|
2022-09-21 17:02:37 +00:00
|
|
|
let ty_changed_count = usize::from(!deref_method_same_type(expr_ty, typeck.expr_ty(sub_expr)));
|
2021-03-25 18:29:11 +00:00
|
|
|
self.state = Some((
|
|
|
|
State::DerefMethod {
|
2022-09-21 17:02:37 +00:00
|
|
|
ty_changed_count,
|
2023-07-31 21:53:53 +00:00
|
|
|
is_ufcs,
|
|
|
|
mutbl,
|
2021-03-25 18:29:11 +00:00
|
|
|
},
|
2022-06-16 15:39:06 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: expr,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty,
|
2022-06-16 15:39:06 +00:00
|
|
|
},
|
2021-03-25 18:29:11 +00:00
|
|
|
));
|
2021-11-04 12:52:36 +00:00
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
(Some(use_cx), RefOp::AddrOf(mutability)) => {
|
2021-12-06 11:33:31 +00:00
|
|
|
// Find the number of times the borrow is auto-derefed.
|
2023-07-31 21:53:53 +00:00
|
|
|
let mut iter = use_cx.adjustments.iter();
|
2022-01-27 14:12:45 +00:00
|
|
|
let mut deref_count = 0usize;
|
|
|
|
let next_adjust = loop {
|
|
|
|
match iter.next() {
|
|
|
|
Some(adjust) => {
|
|
|
|
if !matches!(adjust.kind, Adjust::Deref(_)) {
|
|
|
|
break Some(adjust);
|
|
|
|
} else if !adjust.target.is_ref() {
|
|
|
|
deref_count += 1;
|
|
|
|
break iter.next();
|
|
|
|
}
|
|
|
|
deref_count += 1;
|
|
|
|
},
|
|
|
|
None => break None,
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2023-09-25 09:28:58 +00:00
|
|
|
let stability = use_cx.node.defined_ty(cx).map_or(TyCoercionStability::None, |ty| {
|
2023-07-31 21:53:53 +00:00
|
|
|
TyCoercionStability::for_defined_ty(cx, ty, use_cx.node.is_return())
|
|
|
|
});
|
|
|
|
let can_auto_borrow = match use_cx.node {
|
2023-11-16 18:13:24 +00:00
|
|
|
ExprUseNode::FieldAccess(_)
|
|
|
|
if !use_cx.moved_before_use && matches!(sub_expr.kind, ExprKind::Field(..)) =>
|
|
|
|
{
|
|
|
|
// `DerefMut` will not be automatically applied to `ManuallyDrop<_>`
|
|
|
|
// field expressions when the base type is a union and the parent
|
|
|
|
// expression is also a field access.
|
|
|
|
//
|
|
|
|
// e.g. `&mut x.y.z` where `x` is a union, and accessing `z` requires a
|
|
|
|
// deref through `ManuallyDrop<_>` will not compile.
|
|
|
|
!adjust_derefs_manually_drop(use_cx.adjustments, expr_ty)
|
|
|
|
},
|
|
|
|
ExprUseNode::Callee | ExprUseNode::FieldAccess(_) => true,
|
2023-07-31 21:53:53 +00:00
|
|
|
ExprUseNode::MethodArg(hir_id, _, 0) if !use_cx.moved_before_use => {
|
|
|
|
// Check for calls to trait methods where the trait is implemented
|
|
|
|
// on a reference.
|
|
|
|
// Two cases need to be handled:
|
|
|
|
// * `self` methods on `&T` will never have auto-borrow
|
|
|
|
// * `&self` methods on `&T` can have auto-borrow, but `&self` methods on `T` will take
|
|
|
|
// priority.
|
|
|
|
if let Some(fn_id) = typeck.type_dependent_def_id(hir_id)
|
|
|
|
&& let Some(trait_id) = cx.tcx.trait_of_item(fn_id)
|
2023-11-02 16:35:56 +00:00
|
|
|
&& let arg_ty = cx
|
|
|
|
.tcx
|
|
|
|
.erase_regions(use_cx.adjustments.last().map_or(expr_ty, |a| a.target))
|
2023-07-31 21:53:53 +00:00
|
|
|
&& let ty::Ref(_, sub_ty, _) = *arg_ty.kind()
|
2023-11-16 18:13:24 +00:00
|
|
|
&& let args =
|
|
|
|
typeck.node_args_opt(hir_id).map(|args| &args[1..]).unwrap_or_default()
|
2023-11-02 16:35:56 +00:00
|
|
|
&& let impl_ty =
|
|
|
|
if cx.tcx.fn_sig(fn_id).instantiate_identity().skip_binder().inputs()[0]
|
|
|
|
.is_ref()
|
|
|
|
{
|
|
|
|
// Trait methods taking `&self`
|
|
|
|
sub_ty
|
|
|
|
} else {
|
|
|
|
// Trait methods taking `self`
|
|
|
|
arg_ty
|
|
|
|
}
|
|
|
|
&& impl_ty.is_ref()
|
2023-09-12 16:13:53 +00:00
|
|
|
&& implements_trait(
|
|
|
|
cx,
|
|
|
|
impl_ty,
|
|
|
|
trait_id,
|
|
|
|
&args[..cx.tcx.generics_of(trait_id).params.len() - 1],
|
|
|
|
)
|
2023-07-31 21:53:53 +00:00
|
|
|
{
|
|
|
|
false
|
|
|
|
} else {
|
|
|
|
true
|
|
|
|
}
|
|
|
|
},
|
|
|
|
_ => false,
|
|
|
|
};
|
|
|
|
|
|
|
|
let deref_msg =
|
|
|
|
"this expression creates a reference which is immediately dereferenced by the compiler";
|
|
|
|
let borrow_msg = "this expression borrows a value the compiler would automatically borrow";
|
|
|
|
|
2022-01-27 14:12:45 +00:00
|
|
|
// Determine the required number of references before any can be removed. In all cases the
|
|
|
|
// reference made by the current expression will be removed. After that there are four cases to
|
|
|
|
// handle.
|
|
|
|
//
|
|
|
|
// 1. Auto-borrow will trigger in the current position, so no further references are required.
|
|
|
|
// 2. Auto-deref ends at a reference, or the underlying type, so one extra needs to be left to
|
|
|
|
// handle the automatically inserted re-borrow.
|
|
|
|
// 3. Auto-deref hits a user-defined `Deref` impl, so at least one reference needs to exist to
|
|
|
|
// start auto-deref.
|
|
|
|
// 4. If the chain of non-user-defined derefs ends with a mutable re-borrow, and re-borrow
|
|
|
|
// adjustments will not be inserted automatically, then leave one further reference to avoid
|
2023-07-02 12:35:19 +00:00
|
|
|
// moving a mutable borrow. e.g.
|
|
|
|
//
|
|
|
|
// ```rust
|
|
|
|
// fn foo<T>(x: &mut Option<&mut T>, y: &mut T) {
|
|
|
|
// let x = match x {
|
|
|
|
// // Removing the borrow will cause `x` to be moved
|
|
|
|
// Some(x) => &mut *x,
|
|
|
|
// None => y
|
|
|
|
// };
|
|
|
|
// }
|
|
|
|
// ```
|
2023-07-31 21:53:53 +00:00
|
|
|
let (required_refs, msg) = if can_auto_borrow {
|
|
|
|
(1, if deref_count == 1 { borrow_msg } else { deref_msg })
|
|
|
|
} else if let Some(&Adjustment {
|
2023-11-02 16:35:56 +00:00
|
|
|
kind: Adjust::Borrow(AutoBorrow::Ref(_, mutability)),
|
|
|
|
..
|
|
|
|
}) = next_adjust
|
2023-07-31 21:53:53 +00:00
|
|
|
&& matches!(mutability, AutoBorrowMutability::Mut { .. })
|
|
|
|
&& !stability.is_reborrow_stable()
|
2022-01-27 14:12:45 +00:00
|
|
|
{
|
2023-07-31 21:53:53 +00:00
|
|
|
(3, deref_msg)
|
2022-01-27 14:12:45 +00:00
|
|
|
} else {
|
2023-07-31 21:53:53 +00:00
|
|
|
(2, deref_msg)
|
2022-01-27 14:12:45 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
if deref_count >= required_refs {
|
|
|
|
self.state = Some((
|
2022-06-30 08:50:09 +00:00
|
|
|
State::DerefedBorrow(DerefedBorrow {
|
2022-01-27 14:12:45 +00:00
|
|
|
// One of the required refs is for the current borrow expression, the remaining ones
|
|
|
|
// can't be removed without breaking the code. See earlier comment.
|
|
|
|
count: deref_count - required_refs,
|
|
|
|
msg,
|
2023-07-31 21:53:53 +00:00
|
|
|
stability,
|
2023-11-16 18:13:24 +00:00
|
|
|
for_field_access: if let ExprUseNode::FieldAccess(name) = use_cx.node
|
|
|
|
&& !use_cx.moved_before_use
|
|
|
|
{
|
|
|
|
Some(name.name)
|
|
|
|
} else {
|
|
|
|
None
|
2023-07-31 21:53:53 +00:00
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
}),
|
2022-12-01 17:29:38 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: expr,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
|
2022-12-01 17:29:38 +00:00
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
));
|
2023-07-31 21:53:53 +00:00
|
|
|
} else if stability.is_deref_stable()
|
2022-08-11 17:42:16 +00:00
|
|
|
// Auto-deref doesn't combine with other adjustments
|
|
|
|
&& next_adjust.map_or(true, |a| matches!(a.kind, Adjust::Deref(_) | Adjust::Borrow(_)))
|
|
|
|
&& iter.all(|a| matches!(a.kind, Adjust::Deref(_) | Adjust::Borrow(_)))
|
|
|
|
{
|
2022-06-30 08:50:09 +00:00
|
|
|
self.state = Some((
|
2022-08-11 17:42:16 +00:00
|
|
|
State::Borrow { mutability },
|
2022-06-16 15:39:06 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: expr,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty: use_cx.adjustments.last().map_or(expr_ty, |a| a.target),
|
2022-06-16 15:39:06 +00:00
|
|
|
},
|
2022-01-27 14:12:45 +00:00
|
|
|
));
|
2021-12-06 11:33:31 +00:00
|
|
|
}
|
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
(None, _) | (_, RefOp::Method { .. }) => (),
|
2020-01-26 18:48:30 +00:00
|
|
|
}
|
2021-03-25 18:29:11 +00:00
|
|
|
},
|
2022-01-27 14:12:45 +00:00
|
|
|
(
|
|
|
|
Some((
|
|
|
|
State::DerefMethod {
|
2023-07-31 21:53:53 +00:00
|
|
|
mutbl,
|
2022-01-27 14:12:45 +00:00
|
|
|
ty_changed_count,
|
|
|
|
..
|
|
|
|
},
|
|
|
|
data,
|
|
|
|
)),
|
2023-07-31 21:53:53 +00:00
|
|
|
RefOp::Method { is_ufcs, .. },
|
2022-01-27 14:12:45 +00:00
|
|
|
) => {
|
2021-03-25 18:29:11 +00:00
|
|
|
self.state = Some((
|
|
|
|
State::DerefMethod {
|
|
|
|
ty_changed_count: if deref_method_same_type(typeck.expr_ty(expr), typeck.expr_ty(sub_expr)) {
|
|
|
|
ty_changed_count
|
|
|
|
} else {
|
|
|
|
ty_changed_count + 1
|
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
is_ufcs,
|
|
|
|
mutbl,
|
2021-03-25 18:29:11 +00:00
|
|
|
},
|
|
|
|
data,
|
|
|
|
));
|
|
|
|
},
|
2022-08-11 17:42:16 +00:00
|
|
|
(Some((State::DerefedBorrow(state), data)), RefOp::AddrOf(_)) if state.count != 0 => {
|
2022-06-30 08:50:09 +00:00
|
|
|
self.state = Some((
|
|
|
|
State::DerefedBorrow(DerefedBorrow {
|
|
|
|
count: state.count - 1,
|
|
|
|
..state
|
|
|
|
}),
|
|
|
|
data,
|
|
|
|
));
|
|
|
|
},
|
2022-08-11 17:42:16 +00:00
|
|
|
(Some((State::DerefedBorrow(state), data)), RefOp::AddrOf(mutability)) => {
|
2023-07-31 21:53:53 +00:00
|
|
|
let adjusted_ty = data.adjusted_ty;
|
|
|
|
let stability = state.stability;
|
2023-11-16 18:13:24 +00:00
|
|
|
report(cx, expr, State::DerefedBorrow(state), data, typeck);
|
2023-07-31 21:53:53 +00:00
|
|
|
if stability.is_deref_stable() {
|
2022-06-30 08:50:09 +00:00
|
|
|
self.state = Some((
|
2022-08-11 17:42:16 +00:00
|
|
|
State::Borrow { mutability },
|
2022-06-30 08:50:09 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: expr,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty,
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
|
|
|
));
|
|
|
|
}
|
|
|
|
},
|
|
|
|
(Some((State::DerefedBorrow(state), data)), RefOp::Deref) => {
|
2023-07-31 21:53:53 +00:00
|
|
|
let adjusted_ty = data.adjusted_ty;
|
|
|
|
let stability = state.stability;
|
|
|
|
let for_field_access = state.for_field_access;
|
2023-11-16 18:13:24 +00:00
|
|
|
report(cx, expr, State::DerefedBorrow(state), data, typeck);
|
2023-07-31 21:53:53 +00:00
|
|
|
if let Some(name) = for_field_access
|
2023-11-16 18:13:24 +00:00
|
|
|
&& let sub_expr_ty = typeck.expr_ty(sub_expr)
|
|
|
|
&& !ty_contains_field(sub_expr_ty, name)
|
2022-06-30 08:50:09 +00:00
|
|
|
{
|
|
|
|
self.state = Some((
|
2023-11-16 18:13:24 +00:00
|
|
|
State::ExplicitDerefField {
|
|
|
|
name,
|
|
|
|
derefs_manually_drop: is_manually_drop(sub_expr_ty),
|
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: expr,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty,
|
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
));
|
2023-09-12 16:13:53 +00:00
|
|
|
} else if stability.is_deref_stable()
|
|
|
|
&& let Some(parent) = get_parent_expr(cx, expr)
|
|
|
|
{
|
2022-06-30 08:50:09 +00:00
|
|
|
self.state = Some((
|
2022-08-11 17:42:16 +00:00
|
|
|
State::ExplicitDeref { mutability: None },
|
2023-07-31 21:53:53 +00:00
|
|
|
StateData {
|
2023-11-16 18:13:24 +00:00
|
|
|
first_expr: parent,
|
2023-07-31 21:53:53 +00:00
|
|
|
adjusted_ty,
|
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
));
|
|
|
|
}
|
|
|
|
},
|
|
|
|
|
2022-08-11 17:42:16 +00:00
|
|
|
(Some((State::Borrow { mutability }, data)), RefOp::Deref) => {
|
2022-06-30 08:50:09 +00:00
|
|
|
if typeck.expr_ty(sub_expr).is_ref() {
|
2022-08-11 17:42:16 +00:00
|
|
|
self.state = Some((State::Reborrow { mutability }, data));
|
2022-06-30 08:50:09 +00:00
|
|
|
} else {
|
|
|
|
self.state = Some((
|
|
|
|
State::ExplicitDeref {
|
2022-08-11 17:42:16 +00:00
|
|
|
mutability: Some(mutability),
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
|
|
|
data,
|
|
|
|
));
|
|
|
|
}
|
|
|
|
},
|
2022-08-11 17:42:16 +00:00
|
|
|
(Some((State::Reborrow { mutability }, data)), RefOp::Deref) => {
|
2022-01-27 14:12:45 +00:00
|
|
|
self.state = Some((
|
2022-06-30 08:50:09 +00:00
|
|
|
State::ExplicitDeref {
|
2022-08-11 17:42:16 +00:00
|
|
|
mutability: Some(mutability),
|
2022-01-27 14:12:45 +00:00
|
|
|
},
|
|
|
|
data,
|
|
|
|
));
|
2021-12-06 11:33:31 +00:00
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
(state @ Some((State::ExplicitDeref { .. }, _)), RefOp::Deref) => {
|
|
|
|
self.state = state;
|
|
|
|
},
|
2023-11-16 18:13:24 +00:00
|
|
|
(
|
|
|
|
Some((
|
|
|
|
State::ExplicitDerefField {
|
|
|
|
name,
|
|
|
|
derefs_manually_drop,
|
|
|
|
},
|
|
|
|
data,
|
|
|
|
)),
|
|
|
|
RefOp::Deref,
|
|
|
|
) if let sub_expr_ty = typeck.expr_ty(sub_expr)
|
|
|
|
&& !ty_contains_field(sub_expr_ty, name) =>
|
2022-06-30 08:50:09 +00:00
|
|
|
{
|
2023-11-16 18:13:24 +00:00
|
|
|
self.state = Some((
|
|
|
|
State::ExplicitDerefField {
|
|
|
|
name,
|
|
|
|
derefs_manually_drop: derefs_manually_drop || is_manually_drop(sub_expr_ty),
|
|
|
|
},
|
|
|
|
data,
|
|
|
|
));
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
2021-03-25 18:29:11 +00:00
|
|
|
|
2023-11-16 18:13:24 +00:00
|
|
|
(Some((state, data)), _) => report(cx, expr, state, data, typeck),
|
2018-10-03 16:53:39 +00:00
|
|
|
}
|
|
|
|
}
|
2021-12-06 11:33:31 +00:00
|
|
|
|
|
|
|
fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
|
2022-08-30 22:36:53 +00:00
|
|
|
if let PatKind::Binding(BindingAnnotation::REF, id, name, _) = pat.kind {
|
2021-12-06 11:33:31 +00:00
|
|
|
if let Some(opt_prev_pat) = self.ref_locals.get_mut(&id) {
|
|
|
|
// This binding id has been seen before. Add this pattern to the list of changes.
|
|
|
|
if let Some(prev_pat) = opt_prev_pat {
|
|
|
|
if pat.span.from_expansion() {
|
|
|
|
// Doesn't match the context of the previous pattern. Can't lint here.
|
|
|
|
*opt_prev_pat = None;
|
|
|
|
} else {
|
|
|
|
prev_pat.spans.push(pat.span);
|
|
|
|
prev_pat.replacements.push((
|
|
|
|
pat.span,
|
|
|
|
snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut prev_pat.app)
|
|
|
|
.0
|
|
|
|
.into(),
|
|
|
|
));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2023-11-16 18:13:24 +00:00
|
|
|
if !pat.span.from_expansion()
|
|
|
|
&& let ty::Ref(_, tam, _) = *cx.typeck_results().pat_ty(pat).kind()
|
2021-12-06 11:33:31 +00:00
|
|
|
// only lint immutable refs, because borrowed `&mut T` cannot be moved out
|
2023-11-16 18:13:24 +00:00
|
|
|
&& let ty::Ref(_, _, Mutability::Not) = *tam.kind()
|
|
|
|
{
|
|
|
|
let mut app = Applicability::MachineApplicable;
|
|
|
|
let snip = snippet_with_context(cx, name.span, pat.span.ctxt(), "..", &mut app).0;
|
|
|
|
self.current_body = self.current_body.or(cx.enclosing_body);
|
|
|
|
self.ref_locals.insert(
|
|
|
|
id,
|
|
|
|
Some(RefPat {
|
|
|
|
always_deref: true,
|
|
|
|
spans: vec![pat.span],
|
|
|
|
app,
|
|
|
|
replacements: vec![(pat.span, snip.into())],
|
|
|
|
hir_id: pat.hir_id,
|
|
|
|
}),
|
|
|
|
);
|
2021-12-06 11:33:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check_body_post(&mut self, cx: &LateContext<'tcx>, body: &'tcx Body<'_>) {
|
|
|
|
if Some(body.id()) == self.current_body {
|
|
|
|
for pat in self.ref_locals.drain(..).filter_map(|(_, x)| x) {
|
|
|
|
let replacements = pat.replacements;
|
|
|
|
let app = pat.app;
|
2022-06-16 15:39:06 +00:00
|
|
|
let lint = if pat.always_deref {
|
|
|
|
NEEDLESS_BORROW
|
|
|
|
} else {
|
|
|
|
REF_BINDING_TO_REFERENCE
|
|
|
|
};
|
|
|
|
span_lint_hir_and_then(
|
2021-12-06 11:33:31 +00:00
|
|
|
cx,
|
2022-06-16 15:39:06 +00:00
|
|
|
lint,
|
|
|
|
pat.hir_id,
|
2021-12-06 11:33:31 +00:00
|
|
|
pat.spans,
|
|
|
|
"this pattern creates a reference to a reference",
|
|
|
|
|diag| {
|
2023-07-17 08:19:29 +00:00
|
|
|
diag.multipart_suggestion("try", replacements, app);
|
2021-12-06 11:33:31 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
}
|
|
|
|
self.current_body = None;
|
|
|
|
}
|
|
|
|
}
|
2018-10-03 16:53:39 +00:00
|
|
|
}
|
2020-01-26 18:48:30 +00:00
|
|
|
|
2022-01-13 12:18:19 +00:00
|
|
|
fn try_parse_ref_op<'tcx>(
|
2021-03-25 18:29:11 +00:00
|
|
|
tcx: TyCtxt<'tcx>,
|
|
|
|
typeck: &'tcx TypeckResults<'_>,
|
|
|
|
expr: &'tcx Expr<'_>,
|
|
|
|
) -> Option<(RefOp, &'tcx Expr<'tcx>)> {
|
2023-07-31 21:53:53 +00:00
|
|
|
let (is_ufcs, def_id, arg) = match expr.kind {
|
|
|
|
ExprKind::MethodCall(_, arg, [], _) => (false, typeck.type_dependent_def_id(expr.hir_id)?, arg),
|
2021-03-25 18:29:11 +00:00
|
|
|
ExprKind::Call(
|
|
|
|
Expr {
|
|
|
|
kind: ExprKind::Path(path),
|
|
|
|
hir_id,
|
|
|
|
..
|
|
|
|
},
|
|
|
|
[arg],
|
2023-07-31 21:53:53 +00:00
|
|
|
) => (true, typeck.qpath_res(path, *hir_id).opt_def_id()?, arg),
|
2021-03-25 18:29:11 +00:00
|
|
|
ExprKind::Unary(UnOp::Deref, sub_expr) if !typeck.expr_ty(sub_expr).is_unsafe_ptr() => {
|
|
|
|
return Some((RefOp::Deref, sub_expr));
|
2020-01-26 18:48:30 +00:00
|
|
|
},
|
2022-08-11 17:42:16 +00:00
|
|
|
ExprKind::AddrOf(BorrowKind::Ref, mutability, sub_expr) => return Some((RefOp::AddrOf(mutability), sub_expr)),
|
2021-03-25 18:29:11 +00:00
|
|
|
_ => return None,
|
|
|
|
};
|
|
|
|
if tcx.is_diagnostic_item(sym::deref_method, def_id) {
|
2023-07-31 21:53:53 +00:00
|
|
|
Some((
|
|
|
|
RefOp::Method {
|
|
|
|
mutbl: Mutability::Not,
|
|
|
|
is_ufcs,
|
|
|
|
},
|
|
|
|
arg,
|
|
|
|
))
|
2021-03-25 18:29:11 +00:00
|
|
|
} else if tcx.trait_of_item(def_id)? == tcx.lang_items().deref_mut_trait()? {
|
2023-07-31 21:53:53 +00:00
|
|
|
Some((
|
|
|
|
RefOp::Method {
|
|
|
|
mutbl: Mutability::Mut,
|
|
|
|
is_ufcs,
|
|
|
|
},
|
|
|
|
arg,
|
|
|
|
))
|
2021-03-25 18:29:11 +00:00
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-11-16 18:13:24 +00:00
|
|
|
// Checks if the adjustments contains a deref of `ManuallyDrop<_>`
|
|
|
|
fn adjust_derefs_manually_drop<'tcx>(adjustments: &'tcx [Adjustment<'tcx>], mut ty: Ty<'tcx>) -> bool {
|
|
|
|
adjustments.iter().any(|a| {
|
|
|
|
let ty = mem::replace(&mut ty, a.target);
|
|
|
|
matches!(a.kind, Adjust::Deref(Some(ref op)) if op.mutbl == Mutability::Mut) && is_manually_drop(ty)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2021-03-25 18:29:11 +00:00
|
|
|
// Checks whether the type for a deref call actually changed the type, not just the mutability of
|
|
|
|
// the reference.
|
2022-05-23 15:48:17 +00:00
|
|
|
fn deref_method_same_type<'tcx>(result_ty: Ty<'tcx>, arg_ty: Ty<'tcx>) -> bool {
|
2021-03-25 18:29:11 +00:00
|
|
|
match (result_ty.kind(), arg_ty.kind()) {
|
2022-01-25 07:42:52 +00:00
|
|
|
(ty::Ref(_, result_ty, _), ty::Ref(_, arg_ty, _)) => result_ty == arg_ty,
|
2021-03-25 18:29:11 +00:00
|
|
|
|
|
|
|
// The result type for a deref method is always a reference
|
|
|
|
// Not matching the previous pattern means the argument type is not a reference
|
|
|
|
// This means that the type did change
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
fn in_postfix_position<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {
|
|
|
|
if let Some(parent) = get_parent_expr(cx, e)
|
2023-10-16 20:52:50 +00:00
|
|
|
&& parent.span.eq_ctxt(e.span)
|
2023-07-31 21:53:53 +00:00
|
|
|
{
|
|
|
|
match parent.kind {
|
2023-08-03 19:43:17 +00:00
|
|
|
ExprKind::Call(child, _) | ExprKind::MethodCall(_, child, _, _) | ExprKind::Index(child, _, _)
|
2023-11-02 16:35:56 +00:00
|
|
|
if child.hir_id == e.hir_id =>
|
|
|
|
{
|
|
|
|
true
|
|
|
|
},
|
|
|
|
ExprKind::Match(.., MatchSource::TryDesugar(_) | MatchSource::AwaitDesugar) | ExprKind::Field(_, _) => true,
|
2023-07-31 21:53:53 +00:00
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
false
|
2022-01-27 14:12:45 +00:00
|
|
|
}
|
2023-07-31 21:53:53 +00:00
|
|
|
}
|
2022-01-27 14:12:45 +00:00
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
enum TyCoercionStability {
|
|
|
|
Deref,
|
|
|
|
Reborrow,
|
|
|
|
None,
|
|
|
|
}
|
|
|
|
impl TyCoercionStability {
|
|
|
|
fn is_deref_stable(self) -> bool {
|
|
|
|
matches!(self, Self::Deref)
|
2022-01-27 14:12:45 +00:00
|
|
|
}
|
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
fn is_reborrow_stable(self) -> bool {
|
|
|
|
matches!(self, Self::Deref | Self::Reborrow)
|
2022-06-30 08:50:09 +00:00
|
|
|
}
|
2021-12-06 11:33:31 +00:00
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
fn for_defined_ty<'tcx>(cx: &LateContext<'tcx>, ty: DefinedTy<'tcx>, for_return: bool) -> Self {
|
|
|
|
match ty {
|
|
|
|
DefinedTy::Hir(ty) => Self::for_hir_ty(ty),
|
|
|
|
DefinedTy::Mir(ty) => Self::for_mir_ty(
|
|
|
|
cx.tcx,
|
|
|
|
ty.param_env,
|
2023-11-17 09:29:48 +00:00
|
|
|
cx.tcx.instantiate_bound_regions_with_erased(ty.value),
|
2023-07-31 21:53:53 +00:00
|
|
|
for_return,
|
|
|
|
),
|
2022-06-30 08:50:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
// Checks the stability of type coercions when assigned to a binding with the given explicit type.
|
|
|
|
//
|
|
|
|
// e.g.
|
|
|
|
// let x = Box::new(Box::new(0u32));
|
|
|
|
// let y1: &Box<_> = x.deref();
|
|
|
|
// let y2: &Box<_> = &x;
|
|
|
|
//
|
|
|
|
// Here `y1` and `y2` would resolve to different types, so the type `&Box<_>` is not stable when
|
|
|
|
// switching to auto-dereferencing.
|
|
|
|
fn for_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> Self {
|
|
|
|
let TyKind::Ref(_, ty) = &ty.kind else {
|
|
|
|
return Self::None;
|
|
|
|
};
|
|
|
|
let mut ty = ty;
|
2022-07-31 21:22:27 +00:00
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
loop {
|
|
|
|
break match ty.ty.kind {
|
|
|
|
TyKind::Ref(_, ref ref_ty) => {
|
|
|
|
ty = ref_ty;
|
|
|
|
continue;
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
TyKind::Path(
|
|
|
|
QPath::TypeRelative(_, path)
|
|
|
|
| QPath::Resolved(
|
|
|
|
_,
|
|
|
|
Path {
|
|
|
|
segments: [.., path], ..
|
|
|
|
},
|
|
|
|
),
|
|
|
|
) => {
|
|
|
|
if let Some(args) = path.args
|
|
|
|
&& args.args.iter().any(|arg| match arg {
|
|
|
|
hir::GenericArg::Infer(_) => true,
|
|
|
|
hir::GenericArg::Type(ty) => ty_contains_infer(ty),
|
|
|
|
_ => false,
|
2022-08-31 13:24:45 +00:00
|
|
|
})
|
2023-07-31 21:53:53 +00:00
|
|
|
{
|
|
|
|
Self::Reborrow
|
|
|
|
} else {
|
|
|
|
Self::Deref
|
2022-09-02 13:48:14 +00:00
|
|
|
}
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
2023-07-31 21:53:53 +00:00
|
|
|
TyKind::Slice(_)
|
|
|
|
| TyKind::Array(..)
|
|
|
|
| TyKind::Ptr(_)
|
|
|
|
| TyKind::BareFn(_)
|
|
|
|
| TyKind::Never
|
|
|
|
| TyKind::Tup(_)
|
|
|
|
| TyKind::Path(_) => Self::Deref,
|
|
|
|
TyKind::OpaqueDef(..)
|
|
|
|
| TyKind::Infer
|
|
|
|
| TyKind::Typeof(..)
|
|
|
|
| TyKind::TraitObject(..)
|
2023-11-26 12:57:31 +00:00
|
|
|
| TyKind::InferDelegation(..)
|
2024-01-04 13:53:06 +00:00
|
|
|
| TyKind::AnonAdt(..)
|
2023-07-31 21:53:53 +00:00
|
|
|
| TyKind::Err(_) => Self::Reborrow,
|
|
|
|
};
|
2022-06-30 08:50:09 +00:00
|
|
|
}
|
2022-08-11 17:42:16 +00:00
|
|
|
}
|
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
fn for_mir_ty<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>, for_return: bool) -> Self {
|
|
|
|
let ty::Ref(_, mut ty, _) = *ty.kind() else {
|
|
|
|
return Self::None;
|
|
|
|
};
|
2022-06-30 08:50:09 +00:00
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
ty = tcx.try_normalize_erasing_regions(param_env, ty).unwrap_or(ty);
|
|
|
|
loop {
|
|
|
|
break match *ty.kind() {
|
|
|
|
ty::Ref(_, ref_ty, _) => {
|
|
|
|
ty = ref_ty;
|
|
|
|
continue;
|
|
|
|
},
|
|
|
|
ty::Param(_) if for_return => Self::Deref,
|
|
|
|
ty::Alias(ty::Weak | ty::Inherent, _) => unreachable!("should have been normalized away above"),
|
|
|
|
ty::Alias(ty::Projection, _) if !for_return && ty.has_non_region_param() => Self::Reborrow,
|
|
|
|
ty::Infer(_)
|
|
|
|
| ty::Error(_)
|
|
|
|
| ty::Bound(..)
|
|
|
|
| ty::Alias(ty::Opaque, ..)
|
|
|
|
| ty::Placeholder(_)
|
|
|
|
| ty::Dynamic(..)
|
|
|
|
| ty::Param(_) => Self::Reborrow,
|
|
|
|
ty::Adt(_, args)
|
|
|
|
if ty.has_placeholders()
|
|
|
|
|| ty.has_opaque_types()
|
|
|
|
|| (!for_return && args.has_non_region_param()) =>
|
2022-06-30 08:50:09 +00:00
|
|
|
{
|
2023-07-31 21:53:53 +00:00
|
|
|
Self::Reborrow
|
|
|
|
},
|
|
|
|
ty::Bool
|
|
|
|
| ty::Char
|
|
|
|
| ty::Int(_)
|
|
|
|
| ty::Uint(_)
|
|
|
|
| ty::Array(..)
|
|
|
|
| ty::Float(_)
|
|
|
|
| ty::RawPtr(..)
|
|
|
|
| ty::FnPtr(_)
|
|
|
|
| ty::Str
|
|
|
|
| ty::Slice(..)
|
|
|
|
| ty::Adt(..)
|
|
|
|
| ty::Foreign(_)
|
|
|
|
| ty::FnDef(..)
|
2023-10-19 16:06:43 +00:00
|
|
|
| ty::Coroutine(..)
|
|
|
|
| ty::CoroutineWitness(..)
|
2023-07-31 21:53:53 +00:00
|
|
|
| ty::Closure(..)
|
2024-01-24 18:01:56 +00:00
|
|
|
| ty::CoroutineClosure(..)
|
2023-07-31 21:53:53 +00:00
|
|
|
| ty::Never
|
|
|
|
| ty::Tuple(_)
|
|
|
|
| ty::Alias(ty::Projection, _) => Self::Deref,
|
|
|
|
};
|
|
|
|
}
|
2022-06-30 08:50:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Checks whether a type is inferred at some point.
|
|
|
|
// e.g. `_`, `Box<_>`, `[_]`
|
|
|
|
fn ty_contains_infer(ty: &hir::Ty<'_>) -> bool {
|
|
|
|
struct V(bool);
|
|
|
|
impl Visitor<'_> for V {
|
|
|
|
fn visit_ty(&mut self, ty: &hir::Ty<'_>) {
|
|
|
|
if self.0
|
|
|
|
|| matches!(
|
|
|
|
ty.kind,
|
2023-02-23 02:46:49 +00:00
|
|
|
TyKind::OpaqueDef(..) | TyKind::Infer | TyKind::Typeof(_) | TyKind::Err(_)
|
2022-06-30 08:50:09 +00:00
|
|
|
)
|
|
|
|
{
|
|
|
|
self.0 = true;
|
|
|
|
} else {
|
|
|
|
walk_ty(self, ty);
|
|
|
|
}
|
2021-12-06 11:33:31 +00:00
|
|
|
}
|
2022-06-30 08:50:09 +00:00
|
|
|
|
2023-07-31 21:53:53 +00:00
|
|
|
fn visit_generic_arg(&mut self, arg: &hir::GenericArg<'_>) {
|
|
|
|
if self.0 || matches!(arg, hir::GenericArg::Infer(_)) {
|
2022-06-30 08:50:09 +00:00
|
|
|
self.0 = true;
|
2023-07-31 21:53:53 +00:00
|
|
|
} else if let hir::GenericArg::Type(ty) = arg {
|
2022-06-30 08:50:09 +00:00
|
|
|
self.visit_ty(ty);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
let mut v = V(false);
|
|
|
|
v.visit_ty(ty);
|
|
|
|
v.0
|
|
|
|
}
|
|
|
|
|
|
|
|
fn ty_contains_field(ty: Ty<'_>, name: Symbol) -> bool {
|
|
|
|
if let ty::Adt(adt, _) = *ty.kind() {
|
|
|
|
adt.is_struct() && adt.all_fields().any(|f| f.name == name)
|
|
|
|
} else {
|
|
|
|
false
|
2021-12-06 11:33:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-06-30 08:50:09 +00:00
|
|
|
#[expect(clippy::needless_pass_by_value, clippy::too_many_lines)]
|
2023-11-16 18:13:24 +00:00
|
|
|
fn report<'tcx>(
|
|
|
|
cx: &LateContext<'tcx>,
|
|
|
|
expr: &'tcx Expr<'_>,
|
|
|
|
state: State,
|
|
|
|
data: StateData<'tcx>,
|
|
|
|
typeck: &'tcx TypeckResults<'tcx>,
|
|
|
|
) {
|
2021-03-25 18:29:11 +00:00
|
|
|
match state {
|
|
|
|
State::DerefMethod {
|
|
|
|
ty_changed_count,
|
2023-07-31 21:53:53 +00:00
|
|
|
is_ufcs,
|
|
|
|
mutbl,
|
2021-03-25 18:29:11 +00:00
|
|
|
} => {
|
|
|
|
let mut app = Applicability::MachineApplicable;
|
2023-11-16 18:13:24 +00:00
|
|
|
let (expr_str, _expr_is_macro_call) =
|
|
|
|
snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
|
|
|
|
let ty = typeck.expr_ty(expr);
|
2021-03-25 18:29:11 +00:00
|
|
|
let (_, ref_count) = peel_mid_ty_refs(ty);
|
|
|
|
let deref_str = if ty_changed_count >= ref_count && ref_count != 0 {
|
|
|
|
// a deref call changing &T -> &U requires two deref operators the first time
|
|
|
|
// this occurs. One to remove the reference, a second to call the deref impl.
|
|
|
|
"*".repeat(ty_changed_count + 1)
|
|
|
|
} else {
|
|
|
|
"*".repeat(ty_changed_count)
|
|
|
|
};
|
|
|
|
let addr_of_str = if ty_changed_count < ref_count {
|
|
|
|
// Check if a reborrow from &mut T -> &T is required.
|
2023-07-31 21:53:53 +00:00
|
|
|
if mutbl == Mutability::Not && matches!(ty.kind(), ty::Ref(_, _, Mutability::Mut)) {
|
2021-03-25 18:29:11 +00:00
|
|
|
"&*"
|
|
|
|
} else {
|
|
|
|
""
|
|
|
|
}
|
2023-07-31 21:53:53 +00:00
|
|
|
} else if mutbl == Mutability::Mut {
|
2021-03-25 18:29:11 +00:00
|
|
|
"&mut "
|
|
|
|
} else {
|
|
|
|
"&"
|
|
|
|
};
|
|
|
|
|
2023-07-02 12:35:19 +00:00
|
|
|
// expr_str (the suggestion) is never shown if is_final_ufcs is true, since it's
|
|
|
|
// `expr.kind == ExprKind::Call`. Therefore, this is, afaik, always unnecessary.
|
|
|
|
/*
|
|
|
|
expr_str = if !expr_is_macro_call && is_final_ufcs && expr.precedence().order() < PREC_PREFIX {
|
|
|
|
Cow::Owned(format!("({expr_str})"))
|
2021-03-25 18:29:11 +00:00
|
|
|
} else {
|
2023-07-02 12:35:19 +00:00
|
|
|
expr_str
|
2021-03-25 18:29:11 +00:00
|
|
|
};
|
2023-07-02 12:35:19 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
// Fix #10850, do not lint if it's `Foo::deref` instead of `foo.deref()`.
|
2023-07-31 21:53:53 +00:00
|
|
|
if is_ufcs {
|
2023-07-02 12:35:19 +00:00
|
|
|
return;
|
|
|
|
}
|
2021-03-25 18:29:11 +00:00
|
|
|
|
|
|
|
span_lint_and_sugg(
|
|
|
|
cx,
|
|
|
|
EXPLICIT_DEREF_METHODS,
|
2023-11-16 18:13:24 +00:00
|
|
|
data.first_expr.span,
|
2023-07-31 21:53:53 +00:00
|
|
|
match mutbl {
|
2021-03-25 18:29:11 +00:00
|
|
|
Mutability::Not => "explicit `deref` method call",
|
|
|
|
Mutability::Mut => "explicit `deref_mut` method call",
|
|
|
|
},
|
2023-07-17 08:19:29 +00:00
|
|
|
"try",
|
2022-10-06 07:44:38 +00:00
|
|
|
format!("{addr_of_str}{deref_str}{expr_str}"),
|
2021-03-25 18:29:11 +00:00
|
|
|
app,
|
|
|
|
);
|
2020-01-26 18:48:30 +00:00
|
|
|
},
|
2022-06-30 08:50:09 +00:00
|
|
|
State::DerefedBorrow(state) => {
|
2021-12-06 11:33:31 +00:00
|
|
|
let mut app = Applicability::MachineApplicable;
|
2023-11-16 18:13:24 +00:00
|
|
|
let (snip, snip_is_macro) =
|
|
|
|
snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
|
|
|
|
span_lint_hir_and_then(
|
|
|
|
cx,
|
|
|
|
NEEDLESS_BORROW,
|
|
|
|
data.first_expr.hir_id,
|
|
|
|
data.first_expr.span,
|
|
|
|
state.msg,
|
|
|
|
|diag| {
|
|
|
|
let (precedence, calls_field) = match get_parent_node(cx.tcx, data.first_expr.hir_id) {
|
|
|
|
Some(Node::Expr(e)) => match e.kind {
|
|
|
|
ExprKind::Call(callee, _) if callee.hir_id != data.first_expr.hir_id => (0, false),
|
|
|
|
ExprKind::Call(..) => (PREC_POSTFIX, matches!(expr.kind, ExprKind::Field(..))),
|
|
|
|
_ => (e.precedence().order(), false),
|
|
|
|
},
|
|
|
|
_ => (0, false),
|
|
|
|
};
|
|
|
|
let sugg = if !snip_is_macro
|
|
|
|
&& (calls_field || expr.precedence().order() < precedence)
|
|
|
|
&& !has_enclosing_paren(&snip)
|
|
|
|
{
|
|
|
|
format!("({snip})")
|
|
|
|
} else {
|
|
|
|
snip.into()
|
|
|
|
};
|
|
|
|
diag.span_suggestion(data.first_expr.span, "change this to", sugg, app);
|
|
|
|
},
|
|
|
|
);
|
2021-12-06 11:33:31 +00:00
|
|
|
},
|
2022-08-11 17:42:16 +00:00
|
|
|
State::ExplicitDeref { mutability } => {
|
|
|
|
if matches!(
|
|
|
|
expr.kind,
|
|
|
|
ExprKind::Block(..)
|
|
|
|
| ExprKind::ConstBlock(_)
|
|
|
|
| ExprKind::If(..)
|
|
|
|
| ExprKind::Loop(..)
|
|
|
|
| ExprKind::Match(..)
|
2023-07-31 21:53:53 +00:00
|
|
|
) && let ty::Ref(_, ty, _) = data.adjusted_ty.kind()
|
|
|
|
&& ty.is_sized(cx.tcx, cx.param_env)
|
2022-08-11 17:42:16 +00:00
|
|
|
{
|
|
|
|
// Rustc bug: auto deref doesn't work on block expression when targeting sized types.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
let (prefix, precedence) = if let Some(mutability) = mutability
|
2023-11-16 18:13:24 +00:00
|
|
|
&& !typeck.expr_ty(expr).is_ref()
|
2022-06-30 08:50:09 +00:00
|
|
|
{
|
2022-08-11 17:42:16 +00:00
|
|
|
let prefix = match mutability {
|
|
|
|
Mutability::Not => "&",
|
|
|
|
Mutability::Mut => "&mut ",
|
|
|
|
};
|
2023-07-31 21:53:53 +00:00
|
|
|
(prefix, PREC_PREFIX)
|
2022-06-30 08:50:09 +00:00
|
|
|
} else {
|
2023-07-31 21:53:53 +00:00
|
|
|
("", 0)
|
2022-06-30 08:50:09 +00:00
|
|
|
};
|
|
|
|
span_lint_hir_and_then(
|
|
|
|
cx,
|
|
|
|
EXPLICIT_AUTO_DEREF,
|
2023-11-16 18:13:24 +00:00
|
|
|
data.first_expr.hir_id,
|
|
|
|
data.first_expr.span,
|
2022-06-30 08:50:09 +00:00
|
|
|
"deref which would be done by auto-deref",
|
|
|
|
|diag| {
|
|
|
|
let mut app = Applicability::MachineApplicable;
|
2023-11-16 18:13:24 +00:00
|
|
|
let (snip, snip_is_macro) =
|
|
|
|
snippet_with_context(cx, expr.span, data.first_expr.span.ctxt(), "..", &mut app);
|
2022-06-30 08:50:09 +00:00
|
|
|
let sugg =
|
|
|
|
if !snip_is_macro && expr.precedence().order() < precedence && !has_enclosing_paren(&snip) {
|
2022-10-06 07:44:38 +00:00
|
|
|
format!("{prefix}({snip})")
|
2022-06-30 08:50:09 +00:00
|
|
|
} else {
|
2022-10-06 07:44:38 +00:00
|
|
|
format!("{prefix}{snip}")
|
2022-06-30 08:50:09 +00:00
|
|
|
};
|
2023-11-16 18:13:24 +00:00
|
|
|
diag.span_suggestion(data.first_expr.span, "try", sugg, app);
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
},
|
2023-11-16 18:13:24 +00:00
|
|
|
State::ExplicitDerefField {
|
|
|
|
derefs_manually_drop, ..
|
|
|
|
} => {
|
|
|
|
let (snip_span, needs_parens) = if matches!(expr.kind, ExprKind::Field(..))
|
|
|
|
&& (derefs_manually_drop
|
|
|
|
|| adjust_derefs_manually_drop(
|
|
|
|
typeck.expr_adjustments(data.first_expr),
|
|
|
|
typeck.expr_ty(data.first_expr),
|
|
|
|
)) {
|
|
|
|
// `DerefMut` will not be automatically applied to `ManuallyDrop<_>`
|
|
|
|
// field expressions when the base type is a union and the parent
|
|
|
|
// expression is also a field access.
|
|
|
|
//
|
|
|
|
// e.g. `&mut x.y.z` where `x` is a union, and accessing `z` requires a
|
|
|
|
// deref through `ManuallyDrop<_>` will not compile.
|
2024-02-09 20:58:36 +00:00
|
|
|
let parent_id = cx.tcx.parent_hir_id(expr.hir_id);
|
2023-11-16 18:13:24 +00:00
|
|
|
if parent_id == data.first_expr.hir_id {
|
|
|
|
return;
|
|
|
|
}
|
2023-12-01 13:28:34 +00:00
|
|
|
(cx.tcx.hir_node(parent_id).expect_expr().span, true)
|
2023-11-16 18:13:24 +00:00
|
|
|
} else {
|
|
|
|
(expr.span, false)
|
|
|
|
};
|
2022-06-30 08:50:09 +00:00
|
|
|
span_lint_hir_and_then(
|
|
|
|
cx,
|
|
|
|
EXPLICIT_AUTO_DEREF,
|
2023-11-16 18:13:24 +00:00
|
|
|
data.first_expr.hir_id,
|
|
|
|
data.first_expr.span,
|
2022-06-30 08:50:09 +00:00
|
|
|
"deref which would be done by auto-deref",
|
|
|
|
|diag| {
|
|
|
|
let mut app = Applicability::MachineApplicable;
|
2023-11-16 18:13:24 +00:00
|
|
|
let snip = snippet_with_context(cx, snip_span, data.first_expr.span.ctxt(), "..", &mut app).0;
|
|
|
|
let sugg = if needs_parens {
|
|
|
|
format!("({snip})")
|
|
|
|
} else {
|
|
|
|
snip.into_owned()
|
|
|
|
};
|
|
|
|
diag.span_suggestion(data.first_expr.span, "try", sugg, app);
|
2022-06-30 08:50:09 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
},
|
2022-08-11 17:42:16 +00:00
|
|
|
State::Borrow { .. } | State::Reborrow { .. } => (),
|
2021-12-06 11:33:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-10-23 13:18:45 +00:00
|
|
|
impl<'tcx> Dereferencing<'tcx> {
|
|
|
|
fn check_local_usage(&mut self, cx: &LateContext<'tcx>, e: &Expr<'tcx>, local: HirId) {
|
2021-12-06 11:33:31 +00:00
|
|
|
if let Some(outer_pat) = self.ref_locals.get_mut(&local) {
|
|
|
|
if let Some(pat) = outer_pat {
|
|
|
|
// Check for auto-deref
|
|
|
|
if !matches!(
|
|
|
|
cx.typeck_results().expr_adjustments(e),
|
|
|
|
[
|
|
|
|
Adjustment {
|
|
|
|
kind: Adjust::Deref(_),
|
|
|
|
..
|
|
|
|
},
|
|
|
|
Adjustment {
|
|
|
|
kind: Adjust::Deref(_),
|
|
|
|
..
|
|
|
|
},
|
|
|
|
..
|
|
|
|
]
|
|
|
|
) {
|
|
|
|
match get_parent_expr(cx, e) {
|
|
|
|
// Field accesses are the same no matter the number of references.
|
|
|
|
Some(Expr {
|
|
|
|
kind: ExprKind::Field(..),
|
|
|
|
..
|
|
|
|
}) => (),
|
|
|
|
Some(&Expr {
|
|
|
|
span,
|
|
|
|
kind: ExprKind::Unary(UnOp::Deref, _),
|
|
|
|
..
|
|
|
|
}) if !span.from_expansion() => {
|
|
|
|
// Remove explicit deref.
|
|
|
|
let snip = snippet_with_context(cx, e.span, span.ctxt(), "..", &mut pat.app).0;
|
|
|
|
pat.replacements.push((span, snip.into()));
|
|
|
|
},
|
|
|
|
Some(parent) if !parent.span.from_expansion() => {
|
|
|
|
// Double reference might be needed at this point.
|
|
|
|
if parent.precedence().order() == PREC_POSTFIX {
|
|
|
|
// Parentheses would be needed here, don't lint.
|
|
|
|
*outer_pat = None;
|
|
|
|
} else {
|
|
|
|
pat.always_deref = false;
|
|
|
|
let snip = snippet_with_context(cx, e.span, parent.span.ctxt(), "..", &mut pat.app).0;
|
2022-10-06 07:44:38 +00:00
|
|
|
pat.replacements.push((e.span, format!("&{snip}")));
|
2021-12-06 11:33:31 +00:00
|
|
|
}
|
|
|
|
},
|
|
|
|
_ if !e.span.from_expansion() => {
|
|
|
|
// Double reference might be needed at this point.
|
|
|
|
pat.always_deref = false;
|
|
|
|
let snip = snippet_with_applicability(cx, e.span, "..", &mut pat.app);
|
2022-10-06 07:44:38 +00:00
|
|
|
pat.replacements.push((e.span, format!("&{snip}")));
|
2021-12-06 11:33:31 +00:00
|
|
|
},
|
|
|
|
// Edge case for macros. The span of the identifier will usually match the context of the
|
|
|
|
// binding, but not if the identifier was created in a macro. e.g. `concat_idents` and proc
|
|
|
|
// macros
|
|
|
|
_ => *outer_pat = None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-01-26 18:48:30 +00:00
|
|
|
}
|
|
|
|
}
|