clippy_utils/
sugg.rs

1//! Contains utility functions to generate suggestions.
2#![deny(clippy::missing_docs_in_private_items)]
3
4use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_with_context};
5use crate::ty::expr_sig;
6use crate::{get_parent_expr_for_hir, higher};
7use rustc_ast::util::parser::AssocOp;
8use rustc_ast::ast;
9use rustc_errors::Applicability;
10use rustc_hir as hir;
11use rustc_hir::{Closure, ExprKind, HirId, MutTy, TyKind};
12use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
13use rustc_lint::{EarlyContext, LateContext, LintContext};
14use rustc_middle::hir::place::ProjectionKind;
15use rustc_middle::mir::{FakeReadCause, Mutability};
16use rustc_middle::ty;
17use rustc_span::{BytePos, CharPos, Pos, Span, SyntaxContext};
18use std::borrow::Cow;
19use std::fmt::{self, Display, Write as _};
20use std::ops::{Add, Neg, Not, Sub};
21
22/// A helper type to build suggestion correctly handling parentheses.
23#[derive(Clone, Debug, PartialEq)]
24pub enum Sugg<'a> {
25    /// An expression that never needs parentheses such as `1337` or `[0; 42]`.
26    NonParen(Cow<'a, str>),
27    /// An expression that does not fit in other variants.
28    MaybeParen(Cow<'a, str>),
29    /// A binary operator expression, including `as`-casts and explicit type
30    /// coercion.
31    BinOp(AssocOp, Cow<'a, str>, Cow<'a, str>),
32}
33
34/// Literal constant `0`, for convenience.
35pub const ZERO: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("0"));
36/// Literal constant `1`, for convenience.
37pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1"));
38/// a constant represents an empty string, for convenience.
39pub const EMPTY: Sugg<'static> = Sugg::NonParen(Cow::Borrowed(""));
40
41impl Display for Sugg<'_> {
42    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
43        match *self {
44            Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) => s.fmt(f),
45            Sugg::BinOp(op, ref lhs, ref rhs) => binop_to_string(op, lhs, rhs).fmt(f),
46        }
47    }
48}
49
50#[expect(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
51impl<'a> Sugg<'a> {
52    /// Prepare a suggestion from an expression.
53    pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> {
54        let ctxt = expr.span.ctxt();
55        let get_snippet = |span| snippet_with_context(cx, span, ctxt, "", &mut Applicability::Unspecified).0;
56        snippet_opt(cx, expr.span).map(|_| Self::hir_from_snippet(expr, get_snippet))
57    }
58
59    /// Convenience function around `hir_opt` for suggestions with a default
60    /// text.
61    pub fn hir(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
62        Self::hir_opt(cx, expr).unwrap_or(Sugg::NonParen(Cow::Borrowed(default)))
63    }
64
65    /// Same as `hir`, but it adapts the applicability level by following rules:
66    ///
67    /// - Applicability level `Unspecified` will never be changed.
68    /// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
69    /// - If the default value is used and the applicability level is `MachineApplicable`, change it
70    ///   to `HasPlaceholders`
71    pub fn hir_with_applicability(
72        cx: &LateContext<'_>,
73        expr: &hir::Expr<'_>,
74        default: &'a str,
75        applicability: &mut Applicability,
76    ) -> Self {
77        if *applicability != Applicability::Unspecified && expr.span.from_expansion() {
78            *applicability = Applicability::MaybeIncorrect;
79        }
80        Self::hir_opt(cx, expr).unwrap_or_else(|| {
81            if *applicability == Applicability::MachineApplicable {
82                *applicability = Applicability::HasPlaceholders;
83            }
84            Sugg::NonParen(Cow::Borrowed(default))
85        })
86    }
87
88    /// Same as `hir`, but first walks the span up to the given context. This will result in the
89    /// macro call, rather than the expansion, if the span is from a child context. If the span is
90    /// not from a child context, it will be used directly instead.
91    ///
92    /// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR
93    /// node would result in `box []`. If given the context of the address of expression, this
94    /// function will correctly get a snippet of `vec![]`.
95    pub fn hir_with_context(
96        cx: &LateContext<'_>,
97        expr: &hir::Expr<'_>,
98        ctxt: SyntaxContext,
99        default: &'a str,
100        applicability: &mut Applicability,
101    ) -> Self {
102        if expr.span.ctxt() == ctxt {
103            Self::hir_from_snippet(expr, |span| {
104                snippet_with_context(cx, span, ctxt, default, applicability).0
105            })
106        } else {
107            let (snip, _) = snippet_with_context(cx, expr.span, ctxt, default, applicability);
108            Sugg::NonParen(snip)
109        }
110    }
111
112    /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
113    /// function variants of `Sugg`, since these use different snippet functions.
114    fn hir_from_snippet(expr: &hir::Expr<'_>, mut get_snippet: impl FnMut(Span) -> Cow<'a, str>) -> Self {
115        if let Some(range) = higher::Range::hir(expr) {
116            let op = AssocOp::Range(range.limits);
117            let start = range.start.map_or("".into(), |expr| get_snippet(expr.span));
118            let end = range.end.map_or("".into(), |expr| get_snippet(expr.span));
119
120            return Sugg::BinOp(op, start, end);
121        }
122
123        match expr.kind {
124            ExprKind::AddrOf(..)
125            | ExprKind::If(..)
126            | ExprKind::Let(..)
127            | ExprKind::Closure { .. }
128            | ExprKind::Unary(..)
129            | ExprKind::Match(..) => Sugg::MaybeParen(get_snippet(expr.span)),
130            ExprKind::Continue(..)
131            | ExprKind::Yield(..)
132            | ExprKind::Array(..)
133            | ExprKind::Block(..)
134            | ExprKind::Break(..)
135            | ExprKind::Call(..)
136            | ExprKind::Field(..)
137            | ExprKind::Index(..)
138            | ExprKind::InlineAsm(..)
139            | ExprKind::OffsetOf(..)
140            | ExprKind::ConstBlock(..)
141            | ExprKind::Lit(..)
142            | ExprKind::Loop(..)
143            | ExprKind::MethodCall(..)
144            | ExprKind::Path(..)
145            | ExprKind::Repeat(..)
146            | ExprKind::Ret(..)
147            | ExprKind::Become(..)
148            | ExprKind::Struct(..)
149            | ExprKind::Tup(..)
150            | ExprKind::Use(..)
151            | ExprKind::Err(_)
152            | ExprKind::UnsafeBinderCast(..) => Sugg::NonParen(get_snippet(expr.span)),
153            ExprKind::DropTemps(inner) => Self::hir_from_snippet(inner, get_snippet),
154            ExprKind::Assign(lhs, rhs, _) => {
155                Sugg::BinOp(AssocOp::Assign, get_snippet(lhs.span), get_snippet(rhs.span))
156            },
157            ExprKind::AssignOp(op, lhs, rhs) => {
158                Sugg::BinOp(AssocOp::AssignOp(op.node), get_snippet(lhs.span), get_snippet(rhs.span))
159            },
160            ExprKind::Binary(op, lhs, rhs) => Sugg::BinOp(
161                AssocOp::Binary(op.node),
162                get_snippet(lhs.span),
163                get_snippet(rhs.span),
164            ),
165            ExprKind::Cast(lhs, ty) |
166            //FIXME(chenyukang), remove this after type ascription is removed from AST
167            ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::Cast, get_snippet(lhs.span), get_snippet(ty.span)),
168        }
169    }
170
171    /// Prepare a suggestion from an expression.
172    pub fn ast(
173        cx: &EarlyContext<'_>,
174        expr: &ast::Expr,
175        default: &'a str,
176        ctxt: SyntaxContext,
177        app: &mut Applicability,
178    ) -> Self {
179        let mut snippet = |span: Span| snippet_with_context(cx, span, ctxt, default, app).0;
180
181        match expr.kind {
182            _ if expr.span.ctxt() != ctxt => Sugg::NonParen(snippet(expr.span)),
183            ast::ExprKind::AddrOf(..)
184            | ast::ExprKind::Closure { .. }
185            | ast::ExprKind::If(..)
186            | ast::ExprKind::Let(..)
187            | ast::ExprKind::Unary(..)
188            | ast::ExprKind::Match(..) => match snippet_with_context(cx, expr.span, ctxt, default, app) {
189                (snip, false) => Sugg::MaybeParen(snip),
190                (snip, true) => Sugg::NonParen(snip),
191            },
192            ast::ExprKind::Gen(..)
193            | ast::ExprKind::Block(..)
194            | ast::ExprKind::Break(..)
195            | ast::ExprKind::Call(..)
196            | ast::ExprKind::Continue(..)
197            | ast::ExprKind::Yield(..)
198            | ast::ExprKind::Field(..)
199            | ast::ExprKind::ForLoop { .. }
200            | ast::ExprKind::Index(..)
201            | ast::ExprKind::InlineAsm(..)
202            | ast::ExprKind::OffsetOf(..)
203            | ast::ExprKind::ConstBlock(..)
204            | ast::ExprKind::Lit(..)
205            | ast::ExprKind::IncludedBytes(..)
206            | ast::ExprKind::Loop(..)
207            | ast::ExprKind::MacCall(..)
208            | ast::ExprKind::MethodCall(..)
209            | ast::ExprKind::Paren(..)
210            | ast::ExprKind::Underscore
211            | ast::ExprKind::Path(..)
212            | ast::ExprKind::Repeat(..)
213            | ast::ExprKind::Ret(..)
214            | ast::ExprKind::Become(..)
215            | ast::ExprKind::Yeet(..)
216            | ast::ExprKind::FormatArgs(..)
217            | ast::ExprKind::Struct(..)
218            | ast::ExprKind::Try(..)
219            | ast::ExprKind::TryBlock(..)
220            | ast::ExprKind::Tup(..)
221            | ast::ExprKind::Use(..)
222            | ast::ExprKind::Array(..)
223            | ast::ExprKind::While(..)
224            | ast::ExprKind::Await(..)
225            | ast::ExprKind::Err(_)
226            | ast::ExprKind::Dummy
227            | ast::ExprKind::UnsafeBinderCast(..) => Sugg::NonParen(snippet(expr.span)),
228            ast::ExprKind::Range(ref lhs, ref rhs, limits) => Sugg::BinOp(
229                AssocOp::Range(limits),
230                lhs.as_ref().map_or("".into(), |lhs| snippet(lhs.span)),
231                rhs.as_ref().map_or("".into(), |rhs| snippet(rhs.span)),
232            ),
233            ast::ExprKind::Assign(ref lhs, ref rhs, _) => Sugg::BinOp(
234                AssocOp::Assign,
235                snippet(lhs.span),
236                snippet(rhs.span),
237            ),
238            ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => Sugg::BinOp(
239                AssocOp::AssignOp(op.node),
240                snippet(lhs.span),
241                snippet(rhs.span),
242            ),
243            ast::ExprKind::Binary(op, ref lhs, ref rhs) => Sugg::BinOp(
244                AssocOp::Binary(op.node),
245                snippet(lhs.span),
246                snippet(rhs.span),
247            ),
248            ast::ExprKind::Cast(ref lhs, ref ty) |
249            //FIXME(chenyukang), remove this after type ascription is removed from AST
250            ast::ExprKind::Type(ref lhs, ref ty) => Sugg::BinOp(
251                AssocOp::Cast,
252                snippet(lhs.span),
253                snippet(ty.span),
254            ),
255        }
256    }
257
258    /// Convenience method to create the `<lhs> && <rhs>` suggestion.
259    pub fn and(self, rhs: &Self) -> Sugg<'static> {
260        make_binop(ast::BinOpKind::And, &self, rhs)
261    }
262
263    /// Convenience method to create the `<lhs> & <rhs>` suggestion.
264    pub fn bit_and(self, rhs: &Self) -> Sugg<'static> {
265        make_binop(ast::BinOpKind::BitAnd, &self, rhs)
266    }
267
268    /// Convenience method to create the `<lhs> as <rhs>` suggestion.
269    pub fn as_ty<R: Display>(self, rhs: R) -> Sugg<'static> {
270        make_assoc(AssocOp::Cast, &self, &Sugg::NonParen(rhs.to_string().into()))
271    }
272
273    /// Convenience method to create the `&<expr>` suggestion.
274    pub fn addr(self) -> Sugg<'static> {
275        make_unop("&", self)
276    }
277
278    /// Convenience method to create the `&mut <expr>` suggestion.
279    pub fn mut_addr(self) -> Sugg<'static> {
280        make_unop("&mut ", self)
281    }
282
283    /// Convenience method to create the `*<expr>` suggestion.
284    pub fn deref(self) -> Sugg<'static> {
285        make_unop("*", self)
286    }
287
288    /// Convenience method to create the `&*<expr>` suggestion. Currently this
289    /// is needed because `sugg.deref().addr()` produces an unnecessary set of
290    /// parentheses around the deref.
291    pub fn addr_deref(self) -> Sugg<'static> {
292        make_unop("&*", self)
293    }
294
295    /// Convenience method to create the `&mut *<expr>` suggestion. Currently
296    /// this is needed because `sugg.deref().mut_addr()` produces an unnecessary
297    /// set of parentheses around the deref.
298    pub fn mut_addr_deref(self) -> Sugg<'static> {
299        make_unop("&mut *", self)
300    }
301
302    /// Convenience method to transform suggestion into a return call
303    pub fn make_return(self) -> Sugg<'static> {
304        Sugg::NonParen(Cow::Owned(format!("return {self}")))
305    }
306
307    /// Convenience method to transform suggestion into a block
308    /// where the suggestion is a trailing expression
309    pub fn blockify(self) -> Sugg<'static> {
310        Sugg::NonParen(Cow::Owned(format!("{{ {self} }}")))
311    }
312
313    /// Convenience method to prefix the expression with the `async` keyword.
314    /// Can be used after `blockify` to create an async block.
315    pub fn asyncify(self) -> Sugg<'static> {
316        Sugg::NonParen(Cow::Owned(format!("async {self}")))
317    }
318
319    /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
320    /// suggestion.
321    pub fn range(self, end: &Self, limits: ast::RangeLimits) -> Sugg<'static> {
322        make_assoc(AssocOp::Range(limits), &self, end)
323    }
324
325    /// Adds parentheses to any expression that might need them. Suitable to the
326    /// `self` argument of a method call
327    /// (e.g., to build `bar.foo()` or `(1 + 2).foo()`).
328    #[must_use]
329    pub fn maybe_par(self) -> Self {
330        match self {
331            Sugg::NonParen(..) => self,
332            // `(x)` and `(x).y()` both don't need additional parens.
333            Sugg::MaybeParen(sugg) => {
334                if has_enclosing_paren(&sugg) {
335                    Sugg::MaybeParen(sugg)
336                } else {
337                    Sugg::NonParen(format!("({sugg})").into())
338                }
339            },
340            Sugg::BinOp(op, lhs, rhs) => {
341                let sugg = binop_to_string(op, &lhs, &rhs);
342                Sugg::NonParen(format!("({sugg})").into())
343            },
344        }
345    }
346
347    pub fn into_string(self) -> String {
348        match self {
349            Sugg::NonParen(p) | Sugg::MaybeParen(p) => p.into_owned(),
350            Sugg::BinOp(b, l, r) => binop_to_string(b, &l, &r),
351        }
352    }
353}
354
355/// Generates a string from the operator and both sides.
356fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
357    match op {
358        AssocOp::Binary(op) => format!("{lhs} {} {rhs}", op.as_str()),
359        AssocOp::Assign => format!("{lhs} = {rhs}"),
360        AssocOp::AssignOp(op) => format!("{lhs} {}= {rhs}", op.as_str()),
361        AssocOp::Cast => format!("{lhs} as {rhs}"),
362        AssocOp::Range(limits) => format!("{lhs}{}{rhs}", limits.as_str()),
363    }
364}
365
366/// Returns `true` if `sugg` is enclosed in parenthesis.
367pub fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
368    let mut chars = sugg.as_ref().chars();
369    if chars.next() == Some('(') {
370        let mut depth = 1;
371        for c in &mut chars {
372            if c == '(' {
373                depth += 1;
374            } else if c == ')' {
375                depth -= 1;
376            }
377            if depth == 0 {
378                break;
379            }
380        }
381        chars.next().is_none()
382    } else {
383        false
384    }
385}
386
387/// Copied from the rust standard library, and then edited
388macro_rules! forward_binop_impls_to_ref {
389    (impl $imp:ident, $method:ident for $t:ty, type Output = $o:ty) => {
390        impl $imp<$t> for &$t {
391            type Output = $o;
392
393            fn $method(self, other: $t) -> $o {
394                $imp::$method(self, &other)
395            }
396        }
397
398        impl $imp<&$t> for $t {
399            type Output = $o;
400
401            fn $method(self, other: &$t) -> $o {
402                $imp::$method(&self, other)
403            }
404        }
405
406        impl $imp for $t {
407            type Output = $o;
408
409            fn $method(self, other: $t) -> $o {
410                $imp::$method(&self, &other)
411            }
412        }
413    };
414}
415
416impl Add for &Sugg<'_> {
417    type Output = Sugg<'static>;
418    fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
419        make_binop(ast::BinOpKind::Add, self, rhs)
420    }
421}
422
423impl Sub for &Sugg<'_> {
424    type Output = Sugg<'static>;
425    fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
426        make_binop(ast::BinOpKind::Sub, self, rhs)
427    }
428}
429
430forward_binop_impls_to_ref!(impl Add, add for Sugg<'_>, type Output = Sugg<'static>);
431forward_binop_impls_to_ref!(impl Sub, sub for Sugg<'_>, type Output = Sugg<'static>);
432
433impl Neg for Sugg<'_> {
434    type Output = Sugg<'static>;
435    fn neg(self) -> Sugg<'static> {
436        match &self {
437            Self::BinOp(AssocOp::Cast, ..) => Sugg::MaybeParen(format!("-({self})").into()),
438            _ => make_unop("-", self),
439        }
440    }
441}
442
443impl<'a> Not for Sugg<'a> {
444    type Output = Sugg<'a>;
445    fn not(self) -> Sugg<'a> {
446        use AssocOp::Binary;
447        use ast::BinOpKind::{Eq, Gt, Ge, Lt, Le, Ne};
448
449        if let Sugg::BinOp(op, lhs, rhs) = self {
450            let to_op = match op {
451                Binary(Eq) => Binary(Ne),
452                Binary(Ne) => Binary(Eq),
453                Binary(Lt) => Binary(Ge),
454                Binary(Ge) => Binary(Lt),
455                Binary(Gt) => Binary(Le),
456                Binary(Le) => Binary(Gt),
457                _ => return make_unop("!", Sugg::BinOp(op, lhs, rhs)),
458            };
459            Sugg::BinOp(to_op, lhs, rhs)
460        } else {
461            make_unop("!", self)
462        }
463    }
464}
465
466/// Helper type to display either `foo` or `(foo)`.
467struct ParenHelper<T> {
468    /// `true` if parentheses are needed.
469    paren: bool,
470    /// The main thing to display.
471    wrapped: T,
472}
473
474impl<T> ParenHelper<T> {
475    /// Builds a `ParenHelper`.
476    fn new(paren: bool, wrapped: T) -> Self {
477        Self { paren, wrapped }
478    }
479}
480
481impl<T: Display> Display for ParenHelper<T> {
482    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
483        if self.paren {
484            write!(f, "({})", self.wrapped)
485        } else {
486            self.wrapped.fmt(f)
487        }
488    }
489}
490
491/// Builds the string for `<op><expr>` adding parenthesis when necessary.
492///
493/// For convenience, the operator is taken as a string because all unary
494/// operators have the same
495/// precedence.
496pub fn make_unop(op: &str, expr: Sugg<'_>) -> Sugg<'static> {
497    Sugg::MaybeParen(format!("{op}{}", expr.maybe_par()).into())
498}
499
500/// Builds the string for `<lhs> <op> <rhs>` adding parenthesis when necessary.
501///
502/// Precedence of shift operator relative to other arithmetic operation is
503/// often confusing so
504/// parenthesis will always be added for a mix of these.
505pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
506    /// Returns `true` if the operator is a shift operator `<<` or `>>`.
507    fn is_shift(op: AssocOp) -> bool {
508        matches!(op, AssocOp::Binary(ast::BinOpKind::Shl | ast::BinOpKind::Shr))
509    }
510
511    /// Returns `true` if the operator is an arithmetic operator
512    /// (i.e., `+`, `-`, `*`, `/`, `%`).
513    fn is_arith(op: AssocOp) -> bool {
514        matches!(
515            op,
516            AssocOp::Binary(
517                ast::BinOpKind::Add
518                | ast::BinOpKind::Sub
519                | ast::BinOpKind::Mul
520                | ast::BinOpKind::Div
521                | ast::BinOpKind::Rem
522            )
523        )
524    }
525
526    /// Returns `true` if the operator `op` needs parenthesis with the operator
527    /// `other` in the direction `dir`.
528    fn needs_paren(op: AssocOp, other: AssocOp, dir: Associativity) -> bool {
529        other.precedence() < op.precedence()
530            || (other.precedence() == op.precedence()
531                && ((op != other && associativity(op) != dir)
532                    || (op == other && associativity(op) != Associativity::Both)))
533            || is_shift(op) && is_arith(other)
534            || is_shift(other) && is_arith(op)
535    }
536
537    let lhs_paren = if let Sugg::BinOp(lop, _, _) = *lhs {
538        needs_paren(op, lop, Associativity::Left)
539    } else {
540        false
541    };
542
543    let rhs_paren = if let Sugg::BinOp(rop, _, _) = *rhs {
544        needs_paren(op, rop, Associativity::Right)
545    } else {
546        false
547    };
548
549    let lhs = ParenHelper::new(lhs_paren, lhs).to_string();
550    let rhs = ParenHelper::new(rhs_paren, rhs).to_string();
551    Sugg::BinOp(op, lhs.into(), rhs.into())
552}
553
554/// Convenience wrapper around `make_assoc` and `AssocOp::Binary`.
555pub fn make_binop(op: ast::BinOpKind, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
556    make_assoc(AssocOp::Binary(op), lhs, rhs)
557}
558
559#[derive(PartialEq, Eq, Clone, Copy)]
560/// Operator associativity.
561enum Associativity {
562    /// The operator is both left-associative and right-associative.
563    Both,
564    /// The operator is left-associative.
565    Left,
566    /// The operator is not associative.
567    None,
568    /// The operator is right-associative.
569    Right,
570}
571
572/// Returns the associativity/fixity of an operator. The difference with
573/// `AssocOp::fixity` is that an operator can be both left and right associative
574/// (such as `+`: `a + b + c == (a + b) + c == a + (b + c)`.
575///
576/// Chained `as` and explicit `:` type coercion never need inner parenthesis so
577/// they are considered
578/// associative.
579#[must_use]
580fn associativity(op: AssocOp) -> Associativity {
581    use rustc_ast::util::parser::AssocOp::{Assign, AssignOp, Binary, Cast, Range};
582    use ast::BinOpKind::{
583        Add, BitAnd, BitOr, BitXor, Div, Eq, Gt, Ge, And, Or, Lt, Le, Rem, Mul, Ne, Shl, Shr, Sub,
584    };
585
586    match op {
587        Assign | AssignOp(_) => Associativity::Right,
588        Binary(Add | BitAnd | BitOr | BitXor | And | Or | Mul) | Cast => Associativity::Both,
589        Binary(Div | Eq | Gt | Ge | Lt | Le | Rem | Ne | Shl | Shr | Sub) => Associativity::Left,
590        Range(_) => Associativity::None,
591    }
592}
593
594/// Returns the indentation before `span` if there are nothing but `[ \t]`
595/// before it on its line.
596fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
597    let lo = cx.sess().source_map().lookup_char_pos(span.lo());
598    lo.file
599        .get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */)
600        .and_then(|line| {
601            if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
602                // We can mix char and byte positions here because we only consider `[ \t]`.
603                if lo.col == CharPos(pos) {
604                    Some(line[..pos].into())
605                } else {
606                    None
607                }
608            } else {
609                None
610            }
611        })
612}
613
614/// Convenience extension trait for `Diag`.
615pub trait DiagExt<T: LintContext> {
616    /// Suggests to add an attribute to an item.
617    ///
618    /// Correctly handles indentation of the attribute and item.
619    ///
620    /// # Example
621    ///
622    /// ```rust,ignore
623    /// diag.suggest_item_with_attr(cx, item, "#[derive(Default)]");
624    /// ```
625    fn suggest_item_with_attr<D: Display + ?Sized>(
626        &mut self,
627        cx: &T,
628        item: Span,
629        msg: &str,
630        attr: &D,
631        applicability: Applicability,
632    );
633
634    /// Suggest to add an item before another.
635    ///
636    /// The item should not be indented (except for inner indentation).
637    ///
638    /// # Example
639    ///
640    /// ```rust,ignore
641    /// diag.suggest_prepend_item(cx, item,
642    /// "fn foo() {
643    ///     bar();
644    /// }");
645    /// ```
646    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability);
647
648    /// Suggest to completely remove an item.
649    ///
650    /// This will remove an item and all following whitespace until the next non-whitespace
651    /// character. This should work correctly if item is on the same indentation level as the
652    /// following item.
653    ///
654    /// # Example
655    ///
656    /// ```rust,ignore
657    /// diag.suggest_remove_item(cx, item, "remove this")
658    /// ```
659    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability);
660}
661
662impl<T: LintContext> DiagExt<T> for rustc_errors::Diag<'_, ()> {
663    fn suggest_item_with_attr<D: Display + ?Sized>(
664        &mut self,
665        cx: &T,
666        item: Span,
667        msg: &str,
668        attr: &D,
669        applicability: Applicability,
670    ) {
671        if let Some(indent) = indentation(cx, item) {
672            let span = item.with_hi(item.lo());
673
674            self.span_suggestion(span, msg.to_string(), format!("{attr}\n{indent}"), applicability);
675        }
676    }
677
678    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability) {
679        if let Some(indent) = indentation(cx, item) {
680            let span = item.with_hi(item.lo());
681
682            let mut first = true;
683            let new_item = new_item
684                .lines()
685                .map(|l| {
686                    if first {
687                        first = false;
688                        format!("{l}\n")
689                    } else {
690                        format!("{indent}{l}\n")
691                    }
692                })
693                .collect::<String>();
694
695            self.span_suggestion(span, msg.to_string(), format!("{new_item}\n{indent}"), applicability);
696        }
697    }
698
699    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability) {
700        let mut remove_span = item;
701        let fmpos = cx.sess().source_map().lookup_byte_offset(remove_span.hi());
702
703        if let Some(ref src) = fmpos.sf.src {
704            let non_whitespace_offset = src[fmpos.pos.to_usize()..].find(|c| c != ' ' && c != '\t' && c != '\n');
705
706            if let Some(non_whitespace_offset) = non_whitespace_offset {
707                remove_span = remove_span
708                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")));
709            }
710        }
711
712        self.span_suggestion(remove_span, msg.to_string(), "", applicability);
713    }
714}
715
716/// Suggestion results for handling closure
717/// args dereferencing and borrowing
718pub struct DerefClosure {
719    /// confidence on the built suggestion
720    pub applicability: Applicability,
721    /// gradually built suggestion
722    pub suggestion: String,
723}
724
725/// Build suggestion gradually by handling closure arg specific usages,
726/// such as explicit deref and borrowing cases.
727/// Returns `None` if no such use cases have been triggered in closure body
728///
729/// note: this only works on single line immutable closures with exactly one input parameter.
730pub fn deref_closure_args(cx: &LateContext<'_>, closure: &hir::Expr<'_>) -> Option<DerefClosure> {
731    if let ExprKind::Closure(&Closure {
732        fn_decl, def_id, body, ..
733    }) = closure.kind
734    {
735        let closure_body = cx.tcx.hir_body(body);
736        // is closure arg a type annotated double reference (i.e.: `|x: &&i32| ...`)
737        // a type annotation is present if param `kind` is different from `TyKind::Infer`
738        let closure_arg_is_type_annotated_double_ref = if let TyKind::Ref(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind
739        {
740            matches!(ty.kind, TyKind::Ref(_, MutTy { .. }))
741        } else {
742            false
743        };
744
745        let mut visitor = DerefDelegate {
746            cx,
747            closure_span: closure.span,
748            closure_arg_is_type_annotated_double_ref,
749            next_pos: closure.span.lo(),
750            suggestion_start: String::new(),
751            applicability: Applicability::MachineApplicable,
752        };
753
754        ExprUseVisitor::for_clippy(cx, def_id, &mut visitor)
755            .consume_body(closure_body)
756            .into_ok();
757
758        if !visitor.suggestion_start.is_empty() {
759            return Some(DerefClosure {
760                applicability: visitor.applicability,
761                suggestion: visitor.finish(),
762            });
763        }
764    }
765    None
766}
767
768/// Visitor struct used for tracking down
769/// dereferencing and borrowing of closure's args
770struct DerefDelegate<'a, 'tcx> {
771    /// The late context of the lint
772    cx: &'a LateContext<'tcx>,
773    /// The span of the input closure to adapt
774    closure_span: Span,
775    /// Indicates if the arg of the closure is a type annotated double reference
776    closure_arg_is_type_annotated_double_ref: bool,
777    /// last position of the span to gradually build the suggestion
778    next_pos: BytePos,
779    /// starting part of the gradually built suggestion
780    suggestion_start: String,
781    /// confidence on the built suggestion
782    applicability: Applicability,
783}
784
785impl<'tcx> DerefDelegate<'_, 'tcx> {
786    /// build final suggestion:
787    /// - create the ending part of suggestion
788    /// - concatenate starting and ending parts
789    /// - potentially remove needless borrowing
790    pub fn finish(&mut self) -> String {
791        let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt(), None);
792        let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
793        let sugg = format!("{}{end_snip}", self.suggestion_start);
794        if self.closure_arg_is_type_annotated_double_ref {
795            sugg.replacen('&', "", 1)
796        } else {
797            sugg
798        }
799    }
800
801    /// indicates whether the function from `parent_expr` takes its args by double reference
802    fn func_takes_arg_by_double_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
803        let ty = match parent_expr.kind {
804            ExprKind::MethodCall(_, receiver, call_args, _) => {
805                if let Some(sig) = self
806                    .cx
807                    .typeck_results()
808                    .type_dependent_def_id(parent_expr.hir_id)
809                    .map(|did| self.cx.tcx.fn_sig(did).instantiate_identity().skip_binder())
810                {
811                    std::iter::once(receiver)
812                        .chain(call_args.iter())
813                        .position(|arg| arg.hir_id == cmt_hir_id)
814                        .map(|i| sig.inputs()[i])
815                } else {
816                    return false;
817                }
818            },
819            ExprKind::Call(func, call_args) => {
820                if let Some(sig) = expr_sig(self.cx, func) {
821                    call_args
822                        .iter()
823                        .position(|arg| arg.hir_id == cmt_hir_id)
824                        .and_then(|i| sig.input(i))
825                        .map(ty::Binder::skip_binder)
826                } else {
827                    return false;
828                }
829            },
830            _ => return false,
831        };
832
833        ty.is_some_and(|ty| matches!(ty.kind(), ty::Ref(_, inner, _) if inner.is_ref()))
834    }
835}
836
837impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
838    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
839
840    fn use_cloned(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
841
842    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
843        if let PlaceBase::Local(id) = cmt.place.base {
844            let map = self.cx.tcx.hir();
845            let span = map.span(cmt.hir_id);
846            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt(), None);
847            let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
848
849            // identifier referring to the variable currently triggered (i.e.: `fp`)
850            let ident_str = self.cx.tcx.hir_name(id).to_string();
851            // full identifier that includes projection (i.e.: `fp.field`)
852            let ident_str_with_proj = snippet(self.cx, span, "..").to_string();
853
854            if cmt.place.projections.is_empty() {
855                // handle item without any projection, that needs an explicit borrowing
856                // i.e.: suggest `&x` instead of `x`
857                let _: fmt::Result = write!(self.suggestion_start, "{start_snip}&{ident_str}");
858            } else {
859                // cases where a parent `Call` or `MethodCall` is using the item
860                // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
861                //
862                // Note about method calls:
863                // - compiler automatically dereference references if the target type is a reference (works also for
864                //   function call)
865                // - `self` arguments in the case of `x.is_something()` are also automatically (de)referenced, and
866                //   no projection should be suggested
867                if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
868                    match &parent_expr.kind {
869                        // given expression is the self argument and will be handled completely by the compiler
870                        // i.e.: `|x| x.is_something()`
871                        ExprKind::MethodCall(_, self_expr, ..) if self_expr.hir_id == cmt.hir_id => {
872                            let _: fmt::Result = write!(self.suggestion_start, "{start_snip}{ident_str_with_proj}");
873                            self.next_pos = span.hi();
874                            return;
875                        },
876                        // item is used in a call
877                        // i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)`
878                        ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) => {
879                            let expr = self.cx.tcx.hir_expect_expr(cmt.hir_id);
880                            let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
881
882                            if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
883                                // suggest ampersand if call function is taking args by double reference
884                                let takes_arg_by_double_ref =
885                                    self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
886
887                                // compiler will automatically dereference field or index projection, so no need
888                                // to suggest ampersand, but full identifier that includes projection is required
889                                let has_field_or_index_projection =
890                                    cmt.place.projections.iter().any(|proj| {
891                                        matches!(proj.kind, ProjectionKind::Field(..) | ProjectionKind::Index)
892                                    });
893
894                                // no need to bind again if the function doesn't take arg by double ref
895                                // and if the item is already a double ref
896                                let ident_sugg = if !call_args.is_empty()
897                                    && !takes_arg_by_double_ref
898                                    && (self.closure_arg_is_type_annotated_double_ref || has_field_or_index_projection)
899                                {
900                                    let ident = if has_field_or_index_projection {
901                                        ident_str_with_proj
902                                    } else {
903                                        ident_str
904                                    };
905                                    format!("{start_snip}{ident}")
906                                } else {
907                                    format!("{start_snip}&{ident_str}")
908                                };
909                                self.suggestion_start.push_str(&ident_sugg);
910                                self.next_pos = span.hi();
911                                return;
912                            }
913
914                            self.applicability = Applicability::Unspecified;
915                        },
916                        _ => (),
917                    }
918                }
919
920                let mut replacement_str = ident_str;
921                let mut projections_handled = false;
922                cmt.place.projections.iter().enumerate().for_each(|(i, proj)| {
923                    match proj.kind {
924                        // Field projection like `|v| v.foo`
925                        // no adjustment needed here, as field projections are handled by the compiler
926                        ProjectionKind::Field(..) => match cmt.place.ty_before_projection(i).kind() {
927                            ty::Adt(..) | ty::Tuple(_) => {
928                                replacement_str.clone_from(&ident_str_with_proj);
929                                projections_handled = true;
930                            },
931                            _ => (),
932                        },
933                        // Index projection like `|x| foo[x]`
934                        // the index is dropped so we can't get it to build the suggestion,
935                        // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
936                        // instead of `span.lo()` (i.e.: `foo`)
937                        ProjectionKind::Index => {
938                            let start_span = Span::new(self.next_pos, span.hi(), span.ctxt(), None);
939                            start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
940                            replacement_str.clear();
941                            projections_handled = true;
942                        },
943                        // note: unable to trigger `Subslice` kind in tests
944                        ProjectionKind::Subslice |
945                        // Doesn't have surface syntax. Only occurs in patterns.
946                        ProjectionKind::OpaqueCast => (),
947                        ProjectionKind::Deref => {
948                            // Explicit derefs are typically handled later on, but
949                            // some items do not need explicit deref, such as array accesses,
950                            // so we mark them as already processed
951                            // i.e.: don't suggest `*sub[1..4].len()` for `|sub| sub[1..4].len() == 3`
952                            if let ty::Ref(_, inner, _) = cmt.place.ty_before_projection(i).kind() {
953                                if matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array()) {
954                                    projections_handled = true;
955                                }
956                            }
957                        },
958                    }
959                });
960
961                // handle `ProjectionKind::Deref` by removing one explicit deref
962                // if no special case was detected (i.e.: suggest `*x` instead of `**x`)
963                if !projections_handled {
964                    let last_deref = cmt
965                        .place
966                        .projections
967                        .iter()
968                        .rposition(|proj| proj.kind == ProjectionKind::Deref);
969
970                    if let Some(pos) = last_deref {
971                        let mut projections = cmt.place.projections.clone();
972                        projections.truncate(pos);
973
974                        for item in projections {
975                            if item.kind == ProjectionKind::Deref {
976                                replacement_str = format!("*{replacement_str}");
977                            }
978                        }
979                    }
980                }
981
982                let _: fmt::Result = write!(self.suggestion_start, "{start_snip}{replacement_str}");
983            }
984            self.next_pos = span.hi();
985        }
986    }
987
988    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
989
990    fn fake_read(&mut self, _: &PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
991}
992
993#[cfg(test)]
994mod test {
995    use super::Sugg;
996
997    use rustc_ast::util::parser::AssocOp;
998    use std::borrow::Cow;
999
1000    const SUGGESTION: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("function_call()"));
1001
1002    #[test]
1003    fn make_return_transform_sugg_into_a_return_call() {
1004        assert_eq!("return function_call()", SUGGESTION.make_return().to_string());
1005    }
1006
1007    #[test]
1008    fn blockify_transforms_sugg_into_a_block() {
1009        assert_eq!("{ function_call() }", SUGGESTION.blockify().to_string());
1010    }
1011
1012    #[test]
1013    fn binop_maybe_par() {
1014        let sugg = Sugg::BinOp(AssocOp::Add, "1".into(), "1".into());
1015        assert_eq!("(1 + 1)", sugg.maybe_par().to_string());
1016
1017        let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1)".into(), "(1 + 1)".into());
1018        assert_eq!("((1 + 1) + (1 + 1))", sugg.maybe_par().to_string());
1019    }
1020    #[test]
1021    fn not_op() {
1022        use AssocOp::{Add, Equal, Greater, GreaterEqual, LAnd, LOr, Less, LessEqual, NotEqual};
1023
1024        fn test_not(op: AssocOp, correct: &str) {
1025            let sugg = Sugg::BinOp(op, "x".into(), "y".into());
1026            assert_eq!((!sugg).to_string(), correct);
1027        }
1028
1029        // Invert the comparison operator.
1030        test_not(Equal, "x != y");
1031        test_not(NotEqual, "x == y");
1032        test_not(Less, "x >= y");
1033        test_not(LessEqual, "x > y");
1034        test_not(Greater, "x <= y");
1035        test_not(GreaterEqual, "x < y");
1036
1037        // Other operators are inverted like !(..).
1038        test_not(Add, "!(x + y)");
1039        test_not(LAnd, "!(x && y)");
1040        test_not(LOr, "!(x || y)");
1041    }
1042}