1#![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#[derive(Clone, Debug, PartialEq)]
24pub enum Sugg<'a> {
25 NonParen(Cow<'a, str>),
27 MaybeParen(Cow<'a, str>),
29 BinOp(AssocOp, Cow<'a, str>, Cow<'a, str>),
32}
33
34pub const ZERO: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("0"));
36pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1"));
38pub 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)] impl<'a> Sugg<'a> {
52 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 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 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 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 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 ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::Cast, get_snippet(lhs.span), get_snippet(ty.span)),
168 }
169 }
170
171 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 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 pub fn and(self, rhs: &Self) -> Sugg<'static> {
260 make_binop(ast::BinOpKind::And, &self, rhs)
261 }
262
263 pub fn bit_and(self, rhs: &Self) -> Sugg<'static> {
265 make_binop(ast::BinOpKind::BitAnd, &self, rhs)
266 }
267
268 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 pub fn addr(self) -> Sugg<'static> {
275 make_unop("&", self)
276 }
277
278 pub fn mut_addr(self) -> Sugg<'static> {
280 make_unop("&mut ", self)
281 }
282
283 pub fn deref(self) -> Sugg<'static> {
285 make_unop("*", self)
286 }
287
288 pub fn addr_deref(self) -> Sugg<'static> {
292 make_unop("&*", self)
293 }
294
295 pub fn mut_addr_deref(self) -> Sugg<'static> {
299 make_unop("&mut *", self)
300 }
301
302 pub fn make_return(self) -> Sugg<'static> {
304 Sugg::NonParen(Cow::Owned(format!("return {self}")))
305 }
306
307 pub fn blockify(self) -> Sugg<'static> {
310 Sugg::NonParen(Cow::Owned(format!("{{ {self} }}")))
311 }
312
313 pub fn asyncify(self) -> Sugg<'static> {
316 Sugg::NonParen(Cow::Owned(format!("async {self}")))
317 }
318
319 pub fn range(self, end: &Self, limits: ast::RangeLimits) -> Sugg<'static> {
322 make_assoc(AssocOp::Range(limits), &self, end)
323 }
324
325 #[must_use]
329 pub fn maybe_par(self) -> Self {
330 match self {
331 Sugg::NonParen(..) => self,
332 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
355fn 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
366pub 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
387macro_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
466struct ParenHelper<T> {
468 paren: bool,
470 wrapped: T,
472}
473
474impl<T> ParenHelper<T> {
475 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
491pub fn make_unop(op: &str, expr: Sugg<'_>) -> Sugg<'static> {
497 Sugg::MaybeParen(format!("{op}{}", expr.maybe_par()).into())
498}
499
500pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
506 fn is_shift(op: AssocOp) -> bool {
508 matches!(op, AssocOp::Binary(ast::BinOpKind::Shl | ast::BinOpKind::Shr))
509 }
510
511 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 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
554pub 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)]
560enum Associativity {
562 Both,
564 Left,
566 None,
568 Right,
570}
571
572#[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
594fn 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 )
600 .and_then(|line| {
601 if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
602 if lo.col == CharPos(pos) {
604 Some(line[..pos].into())
605 } else {
606 None
607 }
608 } else {
609 None
610 }
611 })
612}
613
614pub trait DiagExt<T: LintContext> {
616 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 fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability);
647
648 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
716pub struct DerefClosure {
719 pub applicability: Applicability,
721 pub suggestion: String,
723}
724
725pub 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 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
768struct DerefDelegate<'a, 'tcx> {
771 cx: &'a LateContext<'tcx>,
773 closure_span: Span,
775 closure_arg_is_type_annotated_double_ref: bool,
777 next_pos: BytePos,
779 suggestion_start: String,
781 applicability: Applicability,
783}
784
785impl<'tcx> DerefDelegate<'_, 'tcx> {
786 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 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 let ident_str = self.cx.tcx.hir_name(id).to_string();
851 let ident_str_with_proj = snippet(self.cx, span, "..").to_string();
853
854 if cmt.place.projections.is_empty() {
855 let _: fmt::Result = write!(self.suggestion_start, "{start_snip}&{ident_str}");
858 } else {
859 if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
868 match &parent_expr.kind {
869 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 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 let takes_arg_by_double_ref =
885 self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
886
887 let has_field_or_index_projection =
890 cmt.place.projections.iter().any(|proj| {
891 matches!(proj.kind, ProjectionKind::Field(..) | ProjectionKind::Index)
892 });
893
894 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 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 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 ProjectionKind::Subslice |
945 ProjectionKind::OpaqueCast => (),
947 ProjectionKind::Deref => {
948 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 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 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 test_not(Add, "!(x + y)");
1039 test_not(LAnd, "!(x && y)");
1040 test_not(LOr, "!(x || y)");
1041 }
1042}