src/tools/clippy/clippy_lints/src/copies.rs

   1 use clippy_utils::diagnostics::{span_lint_and_note, span_lint_and_then};
   2 use clippy_utils::source::{first_line_of_span, indent_of, reindent_multiline, snippet, snippet_opt};
   3 use clippy_utils::{
   4     both, count_eq, eq_expr_value, get_enclosing_block, get_parent_expr, if_sequence, is_else_clause, is_lint_allowed,
   5     search_same, ContainsName, SpanlessEq, SpanlessHash,
   6 };
   7 use if_chain::if_chain;
   8 use rustc_data_structures::fx::FxHashSet;
   9 use rustc_errors::{Applicability, DiagnosticBuilder};
  10 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
  11 use rustc_hir::{Block, Expr, ExprKind, HirId};
  12 use rustc_lint::{LateContext, LateLintPass, LintContext};
  13 use rustc_middle::hir::map::Map;
  14 use rustc_session::{declare_lint_pass, declare_tool_lint};
  15 use rustc_span::{source_map::Span, symbol::Symbol, BytePos};
  16 use std::borrow::Cow;
  17
  18 declare_clippy_lint! {
  19     /// ### What it does
  20     /// Checks for consecutive `if`s with the same condition.
  21     ///
  22     /// ### Why is this bad?
  23     /// This is probably a copy & paste error.
  24     ///
  25     /// ### Example
  26     /// ```ignore
  27     /// if a == b {
  28     ///     …
  29     /// } else if a == b {
  30     ///     …
  31     /// }
  32     /// ```
  33     ///
  34     /// Note that this lint ignores all conditions with a function call as it could
  35     /// have side effects:
  36     ///
  37     /// ```ignore
  38     /// if foo() {
  39     ///     …
  40     /// } else if foo() { // not linted
  41     ///     …
  42     /// }
  43     /// ```
  44     #[clippy::version = "pre 1.29.0"]
  45     pub IFS_SAME_COND,
  46     correctness,
  47     "consecutive `if`s with the same condition"
  48 }
  49
  50 declare_clippy_lint! {
  51     /// ### What it does
  52     /// Checks for consecutive `if`s with the same function call.
  53     ///
  54     /// ### Why is this bad?
  55     /// This is probably a copy & paste error.
  56     /// Despite the fact that function can have side effects and `if` works as
  57     /// intended, such an approach is implicit and can be considered a "code smell".
  58     ///
  59     /// ### Example
  60     /// ```ignore
  61     /// if foo() == bar {
  62     ///     …
  63     /// } else if foo() == bar {
  64     ///     …
  65     /// }
  66     /// ```
  67     ///
  68     /// This probably should be:
  69     /// ```ignore
  70     /// if foo() == bar {
  71     ///     …
  72     /// } else if foo() == baz {
  73     ///     …
  74     /// }
  75     /// ```
  76     ///
  77     /// or if the original code was not a typo and called function mutates a state,
  78     /// consider move the mutation out of the `if` condition to avoid similarity to
  79     /// a copy & paste error:
  80     ///
  81     /// ```ignore
  82     /// let first = foo();
  83     /// if first == bar {
  84     ///     …
  85     /// } else {
  86     ///     let second = foo();
  87     ///     if second == bar {
  88     ///     …
  89     ///     }
  90     /// }
  91     /// ```
  92     #[clippy::version = "1.41.0"]
  93     pub SAME_FUNCTIONS_IN_IF_CONDITION,
  94     pedantic,
  95     "consecutive `if`s with the same function call"
  96 }
  97
  98 declare_clippy_lint! {
  99     /// ### What it does
 100     /// Checks for `if/else` with the same body as the *then* part
 101     /// and the *else* part.
 102     ///
 103     /// ### Why is this bad?
 104     /// This is probably a copy & paste error.
 105     ///
 106     /// ### Example
 107     /// ```ignore
 108     /// let foo = if … {
 109     ///     42
 110     /// } else {
 111     ///     42
 112     /// };
 113     /// ```
 114     #[clippy::version = "pre 1.29.0"]
 115     pub IF_SAME_THEN_ELSE,
 116     correctness,
 117     "`if` with the same `then` and `else` blocks"
 118 }
 119
 120 declare_clippy_lint! {
 121     /// ### What it does
 122     /// Checks if the `if` and `else` block contain shared code that can be
 123     /// moved out of the blocks.
 124     ///
 125     /// ### Why is this bad?
 126     /// Duplicate code is less maintainable.
 127     ///
 128     /// ### Known problems
 129     /// * The lint doesn't check if the moved expressions modify values that are beeing used in
 130     ///   the if condition. The suggestion can in that case modify the behavior of the program.
 131     ///   See [rust-clippy#7452](https://github.com/rust-lang/rust-clippy/issues/7452)
 132     ///
 133     /// ### Example
 134     /// ```ignore
 135     /// let foo = if … {
 136     ///     println!("Hello World");
 137     ///     13
 138     /// } else {
 139     ///     println!("Hello World");
 140     ///     42
 141     /// };
 142     /// ```
 143     ///
 144     /// Could be written as:
 145     /// ```ignore
 146     /// println!("Hello World");
 147     /// let foo = if … {
 148     ///     13
 149     /// } else {
 150     ///     42
 151     /// };
 152     /// ```
 153     #[clippy::version = "1.53.0"]
 154     pub BRANCHES_SHARING_CODE,
 155     nursery,
 156     "`if` statement with shared code in all blocks"
 157 }
 158
 159 declare_lint_pass!(CopyAndPaste => [
 160     IFS_SAME_COND,
 161     SAME_FUNCTIONS_IN_IF_CONDITION,
 162     IF_SAME_THEN_ELSE,
 163     BRANCHES_SHARING_CODE
 164 ]);
 165
 166 impl<'tcx> LateLintPass<'tcx> for CopyAndPaste {
 167     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
 168         if !expr.span.from_expansion() {
 169             if let ExprKind::If(_, _, _) = expr.kind {
 170                 // skip ifs directly in else, it will be checked in the parent if
 171                 if let Some(&Expr {
 172                     kind: ExprKind::If(_, _, Some(else_expr)),
 173                     ..
 174                 }) = get_parent_expr(cx, expr)
 175                 {
 176                     if else_expr.hir_id == expr.hir_id {
 177                         return;
 178                     }
 179                 }
 180
 181                 let (conds, blocks) = if_sequence(expr);
 182                 // Conditions
 183                 lint_same_cond(cx, &conds);
 184                 lint_same_fns_in_if_cond(cx, &conds);
 185                 // Block duplication
 186                 lint_same_then_else(cx, &blocks, conds.len() == blocks.len(), expr);
 187             }
 188         }
 189     }
 190 }
 191
 192 /// Implementation of `BRANCHES_SHARING_CODE` and `IF_SAME_THEN_ELSE` if the blocks are equal.
 193 fn lint_same_then_else<'tcx>(
 194     cx: &LateContext<'tcx>,
 195     blocks: &[&Block<'tcx>],
 196     has_conditional_else: bool,
 197     expr: &'tcx Expr<'_>,
 198 ) {
 199     // We only lint ifs with multiple blocks
 200     if blocks.len() < 2 || is_else_clause(cx.tcx, expr) {
 201         return;
 202     }
 203
 204     // Check if each block has shared code
 205     let has_expr = blocks[0].expr.is_some();
 206
 207     let (start_eq, mut end_eq, expr_eq) = if let Some(block_eq) = scan_block_for_eq(cx, blocks) {
 208         (block_eq.start_eq, block_eq.end_eq, block_eq.expr_eq)
 209     } else {
 210         return;
 211     };
 212
 213     // BRANCHES_SHARING_CODE prerequisites
 214     if has_conditional_else || (start_eq == 0 && end_eq == 0 && (has_expr && !expr_eq)) {
 215         return;
 216     }
 217
 218     // Only the start is the same
 219     if start_eq != 0 && end_eq == 0 && (!has_expr || !expr_eq) {
 220         let block = blocks[0];
 221         let start_stmts = block.stmts.split_at(start_eq).0;
 222
 223         let mut start_walker = UsedValueFinderVisitor::new(cx);
 224         for stmt in start_stmts {
 225             intravisit::walk_stmt(&mut start_walker, stmt);
 226         }
 227
 228         emit_branches_sharing_code_lint(
 229             cx,
 230             start_eq,
 231             0,
 232             false,
 233             check_for_warn_of_moved_symbol(cx, &start_walker.def_symbols, expr),
 234             blocks,
 235             expr,
 236         );
 237     } else if end_eq != 0 || (has_expr && expr_eq) {
 238         let block = blocks[blocks.len() - 1];
 239         let (start_stmts, block_stmts) = block.stmts.split_at(start_eq);
 240         let (block_stmts, end_stmts) = block_stmts.split_at(block_stmts.len() - end_eq);
 241
 242         // Scan start
 243         let mut start_walker = UsedValueFinderVisitor::new(cx);
 244         for stmt in start_stmts {
 245             intravisit::walk_stmt(&mut start_walker, stmt);
 246         }
 247         let mut moved_syms = start_walker.def_symbols;
 248
 249         // Scan block
 250         let mut block_walker = UsedValueFinderVisitor::new(cx);
 251         for stmt in block_stmts {
 252             intravisit::walk_stmt(&mut block_walker, stmt);
 253         }
 254         let mut block_defs = block_walker.defs;
 255
 256         // Scan moved stmts
 257         let mut moved_start: Option<usize> = None;
 258         let mut end_walker = UsedValueFinderVisitor::new(cx);
 259         for (index, stmt) in end_stmts.iter().enumerate() {
 260             intravisit::walk_stmt(&mut end_walker, stmt);
 261
 262             for value in &end_walker.uses {
 263                 // Well we can't move this and all prev statements. So reset
 264                 if block_defs.contains(value) {
 265                     moved_start = Some(index + 1);
 266                     end_walker.defs.drain().for_each(|x| {
 267                         block_defs.insert(x);
 268                     });
 269
 270                     end_walker.def_symbols.clear();
 271                 }
 272             }
 273
 274             end_walker.uses.clear();
 275         }
 276
 277         if let Some(moved_start) = moved_start {
 278             end_eq -= moved_start;
 279         }
 280
 281         let end_linable = block.expr.map_or_else(
 282             || end_eq != 0,
 283             |expr| {
 284                 intravisit::walk_expr(&mut end_walker, expr);
 285                 end_walker.uses.iter().any(|x| !block_defs.contains(x))
 286             },
 287         );
 288
 289         if end_linable {
 290             end_walker.def_symbols.drain().for_each(|x| {
 291                 moved_syms.insert(x);
 292             });
 293         }
 294
 295         emit_branches_sharing_code_lint(
 296             cx,
 297             start_eq,
 298             end_eq,
 299             end_linable,
 300             check_for_warn_of_moved_symbol(cx, &moved_syms, expr),
 301             blocks,
 302             expr,
 303         );
 304     }
 305 }
 306
 307 struct BlockEqual {
 308     /// The amount statements that are equal from the start
 309     start_eq: usize,
 310     /// The amount statements that are equal from the end
 311     end_eq: usize,
 312     ///  An indication if the block expressions are the same. This will also be true if both are
 313     /// `None`
 314     expr_eq: bool,
 315 }
 316
 317 /// This function can also trigger the `IF_SAME_THEN_ELSE` in which case it'll return `None` to
 318 /// abort any further processing and avoid duplicate lint triggers.
 319 fn scan_block_for_eq(cx: &LateContext<'_>, blocks: &[&Block<'_>]) -> Option<BlockEqual> {
 320     let mut start_eq = usize::MAX;
 321     let mut end_eq = usize::MAX;
 322     let mut expr_eq = true;
 323     let mut iter = blocks.windows(2);
 324     while let Some(&[win0, win1]) = iter.next() {
 325         let l_stmts = win0.stmts;
 326         let r_stmts = win1.stmts;
 327
 328         // `SpanlessEq` now keeps track of the locals and is therefore context sensitive clippy#6752.
 329         // The comparison therefore needs to be done in a way that builds the correct context.
 330         let mut evaluator = SpanlessEq::new(cx);
 331         let mut evaluator = evaluator.inter_expr();
 332
 333         let current_start_eq = count_eq(&mut l_stmts.iter(), &mut r_stmts.iter(), |l, r| evaluator.eq_stmt(l, r));
 334
 335         let current_end_eq = {
 336             // We skip the middle statements which can't be equal
 337             let end_comparison_count = l_stmts.len().min(r_stmts.len()) - current_start_eq;
 338             let it1 = l_stmts.iter().skip(l_stmts.len() - end_comparison_count);
 339             let it2 = r_stmts.iter().skip(r_stmts.len() - end_comparison_count);
 340             it1.zip(it2)
 341                 .fold(0, |acc, (l, r)| if evaluator.eq_stmt(l, r) { acc + 1 } else { 0 })
 342         };
 343         let block_expr_eq = both(&win0.expr, &win1.expr, |l, r| evaluator.eq_expr(l, r));
 344
 345         // IF_SAME_THEN_ELSE
 346         if_chain! {
 347             if block_expr_eq;
 348             if l_stmts.len() == r_stmts.len();
 349             if l_stmts.len() == current_start_eq;
 350             if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win0.hir_id);
 351             if !is_lint_allowed(cx, IF_SAME_THEN_ELSE, win1.hir_id);
 352             then {
 353                 span_lint_and_note(
 354                     cx,
 355                     IF_SAME_THEN_ELSE,
 356                     win0.span,
 357                     "this `if` has identical blocks",
 358                     Some(win1.span),
 359                     "same as this",
 360                 );
 361
 362                 return None;
 363             }
 364         }
 365
 366         start_eq = start_eq.min(current_start_eq);
 367         end_eq = end_eq.min(current_end_eq);
 368         expr_eq &= block_expr_eq;
 369     }
 370
 371     if !expr_eq {
 372         end_eq = 0;
 373     }
 374
 375     // Check if the regions are overlapping. Set `end_eq` to prevent the overlap
 376     let min_block_size = blocks.iter().map(|x| x.stmts.len()).min().unwrap();
 377     if (start_eq + end_eq) > min_block_size {
 378         end_eq = min_block_size - start_eq;
 379     }
 380
 381     Some(BlockEqual {
 382         start_eq,
 383         end_eq,
 384         expr_eq,
 385     })
 386 }
 387
 388 fn check_for_warn_of_moved_symbol(cx: &LateContext<'_>, symbols: &FxHashSet<Symbol>, if_expr: &Expr<'_>) -> bool {
 389     get_enclosing_block(cx, if_expr.hir_id).map_or(false, |block| {
 390         let ignore_span = block.span.shrink_to_lo().to(if_expr.span);
 391
 392         symbols
 393             .iter()
 394             .filter(|sym| !sym.as_str().starts_with('_'))
 395             .any(move |sym| {
 396                 let mut walker = ContainsName {
 397                     name: *sym,
 398                     result: false,
 399                 };
 400
 401                 // Scan block
 402                 block
 403                     .stmts
 404                     .iter()
 405                     .filter(|stmt| !ignore_span.overlaps(stmt.span))
 406                     .for_each(|stmt| intravisit::walk_stmt(&mut walker, stmt));
 407
 408                 if let Some(expr) = block.expr {
 409                     intravisit::walk_expr(&mut walker, expr);
 410                 }
 411
 412                 walker.result
 413             })
 414     })
 415 }
 416
 417 fn emit_branches_sharing_code_lint(
 418     cx: &LateContext<'_>,
 419     start_stmts: usize,
 420     end_stmts: usize,
 421     lint_end: bool,
 422     warn_about_moved_symbol: bool,
 423     blocks: &[&Block<'_>],
 424     if_expr: &Expr<'_>,
 425 ) {
 426     if start_stmts == 0 && !lint_end {
 427         return;
 428     }
 429
 430     // (help, span, suggestion)
 431     let mut suggestions: Vec<(&str, Span, String)> = vec![];
 432     let mut add_expr_note = false;
 433
 434     // Construct suggestions
 435     let sm = cx.sess().source_map();
 436     if start_stmts > 0 {
 437         let block = blocks[0];
 438         let span_start = first_line_of_span(cx, if_expr.span).shrink_to_lo();
 439         let span_end = sm.stmt_span(block.stmts[start_stmts - 1].span, block.span);
 440
 441         let cond_span = first_line_of_span(cx, if_expr.span).until(block.span);
 442         let cond_snippet = reindent_multiline(snippet(cx, cond_span, "_"), false, None);
 443         let cond_indent = indent_of(cx, cond_span);
 444         let moved_span = block.stmts[0].span.source_callsite().to(span_end);
 445         let moved_snippet = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
 446         let suggestion = moved_snippet.to_string() + "\n" + &cond_snippet + "{";
 447         let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, cond_indent);
 448
 449         let span = span_start.to(span_end);
 450         suggestions.push(("start", span, suggestion.to_string()));
 451     }
 452
 453     if lint_end {
 454         let block = blocks[blocks.len() - 1];
 455         let span_end = block.span.shrink_to_hi();
 456
 457         let moved_start = if end_stmts == 0 && block.expr.is_some() {
 458             block.expr.unwrap().span.source_callsite()
 459         } else {
 460             sm.stmt_span(block.stmts[block.stmts.len() - end_stmts].span, block.span)
 461         };
 462         let moved_end = block.expr.map_or_else(
 463             || sm.stmt_span(block.stmts[block.stmts.len() - 1].span, block.span),
 464             |expr| expr.span.source_callsite(),
 465         );
 466
 467         let moved_span = moved_start.to(moved_end);
 468         let moved_snipped = reindent_multiline(snippet(cx, moved_span, "_"), true, None);
 469         let indent = indent_of(cx, if_expr.span.shrink_to_hi());
 470         let suggestion = "}\n".to_string() + &moved_snipped;
 471         let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, indent);
 472
 473         let mut span = moved_start.to(span_end);
 474         // Improve formatting if the inner block has indention (i.e. normal Rust formatting)
 475         let test_span = Span::new(span.lo() - BytePos(4), span.lo(), span.ctxt(), span.parent());
 476         if snippet_opt(cx, test_span)
 477             .map(|snip| snip == "    ")
 478             .unwrap_or_default()
 479         {
 480             span = span.with_lo(test_span.lo());
 481         }
 482
 483         suggestions.push(("end", span, suggestion.to_string()));
 484         add_expr_note = !cx.typeck_results().expr_ty(if_expr).is_unit();
 485     }
 486
 487     let add_optional_msgs = |diag: &mut DiagnosticBuilder<'_>| {
 488         if add_expr_note {
 489             diag.note("The end suggestion probably needs some adjustments to use the expression result correctly");
 490         }
 491
 492         if warn_about_moved_symbol {
 493             diag.warn("Some moved values might need to be renamed to avoid wrong references");
 494         }
 495     };
 496
 497     // Emit lint
 498     if suggestions.len() == 1 {
 499         let (place_str, span, sugg) = suggestions.pop().unwrap();
 500         let msg = format!("all if blocks contain the same code at the {}", place_str);
 501         let help = format!("consider moving the {} statements out like this", place_str);
 502         span_lint_and_then(cx, BRANCHES_SHARING_CODE, span, msg.as_str(), |diag| {
 503             diag.span_suggestion(span, help.as_str(), sugg, Applicability::Unspecified);
 504
 505             add_optional_msgs(diag);
 506         });
 507     } else if suggestions.len() == 2 {
 508         let (_, end_span, end_sugg) = suggestions.pop().unwrap();
 509         let (_, start_span, start_sugg) = suggestions.pop().unwrap();
 510         span_lint_and_then(
 511             cx,
 512             BRANCHES_SHARING_CODE,
 513             start_span,
 514             "all if blocks contain the same code at the start and the end. Here at the start",
 515             move |diag| {
 516                 diag.span_note(end_span, "and here at the end");
 517
 518                 diag.span_suggestion(
 519                     start_span,
 520                     "consider moving the start statements out like this",
 521                     start_sugg,
 522                     Applicability::Unspecified,
 523                 );
 524
 525                 diag.span_suggestion(
 526                     end_span,
 527                     "and consider moving the end statements out like this",
 528                     end_sugg,
 529                     Applicability::Unspecified,
 530                 );
 531
 532                 add_optional_msgs(diag);
 533             },
 534         );
 535     }
 536 }
 537
 538 /// This visitor collects `HirId`s and Symbols of defined symbols and `HirId`s of used values.
 539 struct UsedValueFinderVisitor<'a, 'tcx> {
 540     cx: &'a LateContext<'tcx>,
 541
 542     /// The `HirId`s of defined values in the scanned statements
 543     defs: FxHashSet<HirId>,
 544
 545     /// The Symbols of the defined symbols in the scanned statements
 546     def_symbols: FxHashSet<Symbol>,
 547
 548     /// The `HirId`s of the used values
 549     uses: FxHashSet<HirId>,
 550 }
 551
 552 impl<'a, 'tcx> UsedValueFinderVisitor<'a, 'tcx> {
 553     fn new(cx: &'a LateContext<'tcx>) -> Self {
 554         UsedValueFinderVisitor {
 555             cx,
 556             defs: FxHashSet::default(),
 557             def_symbols: FxHashSet::default(),
 558             uses: FxHashSet::default(),
 559         }
 560     }
 561 }
 562
 563 impl<'a, 'tcx> Visitor<'tcx> for UsedValueFinderVisitor<'a, 'tcx> {
 564     type Map = Map<'tcx>;
 565
 566     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
 567         NestedVisitorMap::All(self.cx.tcx.hir())
 568     }
 569
 570     fn visit_local(&mut self, l: &'tcx rustc_hir::Local<'tcx>) {
 571         let local_id = l.pat.hir_id;
 572         self.defs.insert(local_id);
 573
 574         if let Some(sym) = l.pat.simple_ident() {
 575             self.def_symbols.insert(sym.name);
 576         }
 577
 578         if let Some(expr) = l.init {
 579             intravisit::walk_expr(self, expr);
 580         }
 581     }
 582
 583     fn visit_qpath(&mut self, qpath: &'tcx rustc_hir::QPath<'tcx>, id: HirId, _span: rustc_span::Span) {
 584         if let rustc_hir::QPath::Resolved(_, path) = *qpath {
 585             if path.segments.len() == 1 {
 586                 if let rustc_hir::def::Res::Local(var) = self.cx.qpath_res(qpath, id) {
 587                     self.uses.insert(var);
 588                 }
 589             }
 590         }
 591     }
 592 }
 593
 594 /// Implementation of `IFS_SAME_COND`.
 595 fn lint_same_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
 596     let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
 597         let mut h = SpanlessHash::new(cx);
 598         h.hash_expr(expr);
 599         h.finish()
 600     };
 601
 602     let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool { eq_expr_value(cx, lhs, rhs) };
 603
 604     for (i, j) in search_same(conds, hash, eq) {
 605         span_lint_and_note(
 606             cx,
 607             IFS_SAME_COND,
 608             j.span,
 609             "this `if` has the same condition as a previous `if`",
 610             Some(i.span),
 611             "same as this",
 612         );
 613     }
 614 }
 615
 616 /// Implementation of `SAME_FUNCTIONS_IN_IF_CONDITION`.
 617 fn lint_same_fns_in_if_cond(cx: &LateContext<'_>, conds: &[&Expr<'_>]) {
 618     let hash: &dyn Fn(&&Expr<'_>) -> u64 = &|expr| -> u64 {
 619         let mut h = SpanlessHash::new(cx);
 620         h.hash_expr(expr);
 621         h.finish()
 622     };
 623
 624     let eq: &dyn Fn(&&Expr<'_>, &&Expr<'_>) -> bool = &|&lhs, &rhs| -> bool {
 625         // Do not lint if any expr originates from a macro
 626         if lhs.span.from_expansion() || rhs.span.from_expansion() {
 627             return false;
 628         }
 629         // Do not spawn warning if `IFS_SAME_COND` already produced it.
 630         if eq_expr_value(cx, lhs, rhs) {
 631             return false;
 632         }
 633         SpanlessEq::new(cx).eq_expr(lhs, rhs)
 634     };
 635
 636     for (i, j) in search_same(conds, hash, eq) {
 637         span_lint_and_note(
 638             cx,
 639             SAME_FUNCTIONS_IN_IF_CONDITION,
 640             j.span,
 641             "this `if` has the same function call as a previous `if`",
 642             Some(i.span),
 643             "same as this",
 644         );
 645     }
 646 }