rustc_hir_typeck/
demand.rs

1use rustc_errors::{Applicability, Diag, MultiSpan, listify};
2use rustc_hir as hir;
3use rustc_hir::def::Res;
4use rustc_hir::intravisit::Visitor;
5use rustc_infer::infer::DefineOpaqueTypes;
6use rustc_middle::bug;
7use rustc_middle::ty::adjustment::AllowTwoPhase;
8use rustc_middle::ty::error::{ExpectedFound, TypeError};
9use rustc_middle::ty::print::with_no_trimmed_paths;
10use rustc_middle::ty::{self, AssocItem, BottomUpFolder, Ty, TypeFoldable, TypeVisitableExt};
11use rustc_span::{DUMMY_SP, Ident, Span, sym};
12use rustc_trait_selection::infer::InferCtxtExt;
13use rustc_trait_selection::traits::ObligationCause;
14use tracing::instrument;
15
16use super::method::probe;
17use crate::FnCtxt;
18
19impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
20    pub(crate) fn emit_type_mismatch_suggestions(
21        &self,
22        err: &mut Diag<'_>,
23        expr: &hir::Expr<'tcx>,
24        expr_ty: Ty<'tcx>,
25        expected: Ty<'tcx>,
26        expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
27        error: Option<TypeError<'tcx>>,
28    ) {
29        if expr_ty == expected {
30            return;
31        }
32        self.annotate_alternative_method_deref(err, expr, error);
33        self.explain_self_literal(err, expr, expected, expr_ty);
34
35        // Use `||` to give these suggestions a precedence
36        let suggested = self.suggest_missing_parentheses(err, expr)
37            || self.suggest_missing_unwrap_expect(err, expr, expected, expr_ty)
38            || self.suggest_remove_last_method_call(err, expr, expected)
39            || self.suggest_associated_const(err, expr, expected)
40            || self.suggest_semicolon_in_repeat_expr(err, expr, expr_ty)
41            || self.suggest_deref_ref_or_into(err, expr, expected, expr_ty, expected_ty_expr)
42            || self.suggest_option_to_bool(err, expr, expr_ty, expected)
43            || self.suggest_compatible_variants(err, expr, expected, expr_ty)
44            || self.suggest_non_zero_new_unwrap(err, expr, expected, expr_ty)
45            || self.suggest_calling_boxed_future_when_appropriate(err, expr, expected, expr_ty)
46            || self.suggest_no_capture_closure(err, expected, expr_ty)
47            || self.suggest_boxing_when_appropriate(
48                err,
49                expr.peel_blocks().span,
50                expr.hir_id,
51                expected,
52                expr_ty,
53            )
54            || self.suggest_block_to_brackets_peeling_refs(err, expr, expr_ty, expected)
55            || self.suggest_copied_cloned_or_as_ref(err, expr, expr_ty, expected)
56            || self.suggest_clone_for_ref(err, expr, expr_ty, expected)
57            || self.suggest_into(err, expr, expr_ty, expected)
58            || self.suggest_floating_point_literal(err, expr, expected)
59            || self.suggest_null_ptr_for_literal_zero_given_to_ptr_arg(err, expr, expected)
60            || self.suggest_coercing_result_via_try_operator(err, expr, expected, expr_ty)
61            || self.suggest_returning_value_after_loop(err, expr, expected);
62
63        if !suggested {
64            self.note_source_of_type_mismatch_constraint(
65                err,
66                expr,
67                TypeMismatchSource::Ty(expected),
68            );
69        }
70    }
71
72    pub(crate) fn emit_coerce_suggestions(
73        &self,
74        err: &mut Diag<'_>,
75        expr: &hir::Expr<'tcx>,
76        expr_ty: Ty<'tcx>,
77        expected: Ty<'tcx>,
78        expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
79        error: Option<TypeError<'tcx>>,
80    ) {
81        if expr_ty == expected {
82            return;
83        }
84
85        self.annotate_expected_due_to_let_ty(err, expr, error);
86        self.annotate_loop_expected_due_to_inference(err, expr, error);
87        if self.annotate_mut_binding_to_immutable_binding(err, expr, expr_ty, expected, error) {
88            return;
89        }
90
91        // FIXME(#73154): For now, we do leak check when coercing function
92        // pointers in typeck, instead of only during borrowck. This can lead
93        // to these `RegionsInsufficientlyPolymorphic` errors that aren't helpful.
94        if matches!(error, Some(TypeError::RegionsInsufficientlyPolymorphic(..))) {
95            return;
96        }
97
98        if self.is_destruct_assignment_desugaring(expr) {
99            return;
100        }
101        self.emit_type_mismatch_suggestions(err, expr, expr_ty, expected, expected_ty_expr, error);
102        self.note_type_is_not_clone(err, expected, expr_ty, expr);
103        self.note_internal_mutation_in_method(err, expr, Some(expected), expr_ty);
104        self.suggest_method_call_on_range_literal(err, expr, expr_ty, expected);
105        self.suggest_return_binding_for_missing_tail_expr(err, expr, expr_ty, expected);
106        self.note_wrong_return_ty_due_to_generic_arg(err, expr, expr_ty);
107    }
108
109    /// Really hacky heuristic to remap an `assert_eq!` error to the user
110    /// expressions provided to the macro.
111    fn adjust_expr_for_assert_eq_macro(
112        &self,
113        found_expr: &mut &'tcx hir::Expr<'tcx>,
114        expected_expr: &mut Option<&'tcx hir::Expr<'tcx>>,
115    ) {
116        let Some(expected_expr) = expected_expr else {
117            return;
118        };
119
120        if !found_expr.span.eq_ctxt(expected_expr.span) {
121            return;
122        }
123
124        if !found_expr
125            .span
126            .ctxt()
127            .outer_expn_data()
128            .macro_def_id
129            .is_some_and(|def_id| self.tcx.is_diagnostic_item(sym::assert_eq_macro, def_id))
130        {
131            return;
132        }
133
134        let hir::ExprKind::Unary(
135            hir::UnOp::Deref,
136            hir::Expr { kind: hir::ExprKind::Path(found_path), .. },
137        ) = found_expr.kind
138        else {
139            return;
140        };
141        let hir::ExprKind::Unary(
142            hir::UnOp::Deref,
143            hir::Expr { kind: hir::ExprKind::Path(expected_path), .. },
144        ) = expected_expr.kind
145        else {
146            return;
147        };
148
149        for (path, name, idx, var) in [
150            (expected_path, "left_val", 0, expected_expr),
151            (found_path, "right_val", 1, found_expr),
152        ] {
153            if let hir::QPath::Resolved(_, path) = path
154                && let [segment] = path.segments
155                && segment.ident.name.as_str() == name
156                && let Res::Local(hir_id) = path.res
157                && let Some((_, hir::Node::Expr(match_expr))) =
158                    self.tcx.hir_parent_iter(hir_id).nth(2)
159                && let hir::ExprKind::Match(scrutinee, _, _) = match_expr.kind
160                && let hir::ExprKind::Tup(exprs) = scrutinee.kind
161                && let hir::ExprKind::AddrOf(_, _, macro_arg) = exprs[idx].kind
162            {
163                *var = macro_arg;
164            }
165        }
166    }
167
168    /// Requires that the two types unify, and prints an error message if
169    /// they don't.
170    pub(crate) fn demand_suptype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
171        if let Err(e) = self.demand_suptype_diag(sp, expected, actual) {
172            e.emit();
173        }
174    }
175
176    pub(crate) fn demand_suptype_diag(
177        &'a self,
178        sp: Span,
179        expected: Ty<'tcx>,
180        actual: Ty<'tcx>,
181    ) -> Result<(), Diag<'a>> {
182        self.demand_suptype_with_origin(&self.misc(sp), expected, actual)
183    }
184
185    #[instrument(skip(self), level = "debug")]
186    pub(crate) fn demand_suptype_with_origin(
187        &'a self,
188        cause: &ObligationCause<'tcx>,
189        expected: Ty<'tcx>,
190        actual: Ty<'tcx>,
191    ) -> Result<(), Diag<'a>> {
192        self.at(cause, self.param_env)
193            .sup(DefineOpaqueTypes::Yes, expected, actual)
194            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
195            .map_err(|e| {
196                self.err_ctxt().report_mismatched_types(cause, self.param_env, expected, actual, e)
197            })
198    }
199
200    pub(crate) fn demand_eqtype(&self, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) {
201        if let Err(err) = self.demand_eqtype_diag(sp, expected, actual) {
202            err.emit();
203        }
204    }
205
206    pub(crate) fn demand_eqtype_diag(
207        &'a self,
208        sp: Span,
209        expected: Ty<'tcx>,
210        actual: Ty<'tcx>,
211    ) -> Result<(), Diag<'a>> {
212        self.demand_eqtype_with_origin(&self.misc(sp), expected, actual)
213    }
214
215    pub(crate) fn demand_eqtype_with_origin(
216        &'a self,
217        cause: &ObligationCause<'tcx>,
218        expected: Ty<'tcx>,
219        actual: Ty<'tcx>,
220    ) -> Result<(), Diag<'a>> {
221        self.at(cause, self.param_env)
222            .eq(DefineOpaqueTypes::Yes, expected, actual)
223            .map(|infer_ok| self.register_infer_ok_obligations(infer_ok))
224            .map_err(|e| {
225                self.err_ctxt().report_mismatched_types(cause, self.param_env, expected, actual, e)
226            })
227    }
228
229    pub(crate) fn demand_coerce(
230        &self,
231        expr: &'tcx hir::Expr<'tcx>,
232        checked_ty: Ty<'tcx>,
233        expected: Ty<'tcx>,
234        expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
235        allow_two_phase: AllowTwoPhase,
236    ) -> Ty<'tcx> {
237        match self.demand_coerce_diag(expr, checked_ty, expected, expected_ty_expr, allow_two_phase)
238        {
239            Ok(ty) => ty,
240            Err(err) => {
241                err.emit();
242                // Return the original type instead of an error type here, otherwise the type of `x` in
243                // `let x: u32 = ();` will be a type error, causing all subsequent usages of `x` to not
244                // report errors, even though `x` is definitely `u32`.
245                expected
246            }
247        }
248    }
249
250    /// Checks that the type of `expr` can be coerced to `expected`.
251    ///
252    /// N.B., this code relies on `self.diverges` to be accurate. In particular, assignments to `!`
253    /// will be permitted if the diverges flag is currently "always".
254    #[instrument(level = "debug", skip(self, expr, expected_ty_expr, allow_two_phase))]
255    pub(crate) fn demand_coerce_diag(
256        &'a self,
257        mut expr: &'tcx hir::Expr<'tcx>,
258        checked_ty: Ty<'tcx>,
259        expected: Ty<'tcx>,
260        mut expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
261        allow_two_phase: AllowTwoPhase,
262    ) -> Result<Ty<'tcx>, Diag<'a>> {
263        let expected = if self.next_trait_solver() {
264            expected
265        } else {
266            self.resolve_vars_with_obligations(expected)
267        };
268
269        let e = match self.coerce(expr, checked_ty, expected, allow_two_phase, None) {
270            Ok(ty) => return Ok(ty),
271            Err(e) => e,
272        };
273
274        self.adjust_expr_for_assert_eq_macro(&mut expr, &mut expected_ty_expr);
275
276        self.set_tainted_by_errors(self.dcx().span_delayed_bug(
277            expr.span,
278            "`TypeError` when attempting coercion but no error emitted",
279        ));
280        let expr = expr.peel_drop_temps();
281        let cause = self.misc(expr.span);
282        let expr_ty = self.resolve_vars_if_possible(checked_ty);
283        let mut err =
284            self.err_ctxt().report_mismatched_types(&cause, self.param_env, expected, expr_ty, e);
285
286        self.emit_coerce_suggestions(&mut err, expr, expr_ty, expected, expected_ty_expr, Some(e));
287
288        Err(err)
289    }
290
291    /// Notes the point at which a variable is constrained to some type incompatible
292    /// with some expectation given by `source`.
293    pub(crate) fn note_source_of_type_mismatch_constraint(
294        &self,
295        err: &mut Diag<'_>,
296        expr: &hir::Expr<'_>,
297        source: TypeMismatchSource<'tcx>,
298    ) -> bool {
299        let hir::ExprKind::Path(hir::QPath::Resolved(None, p)) = expr.kind else {
300            return false;
301        };
302        let [hir::PathSegment { ident, args: None, .. }] = p.segments else {
303            return false;
304        };
305        let hir::def::Res::Local(local_hir_id) = p.res else {
306            return false;
307        };
308        let hir::Node::Pat(pat) = self.tcx.hir_node(local_hir_id) else {
309            return false;
310        };
311        let (init_ty_hir_id, init) = match self.tcx.parent_hir_node(pat.hir_id) {
312            hir::Node::LetStmt(hir::LetStmt { ty: Some(ty), init, .. }) => (ty.hir_id, *init),
313            hir::Node::LetStmt(hir::LetStmt { init: Some(init), .. }) => (init.hir_id, Some(*init)),
314            _ => return false,
315        };
316        let Some(init_ty) = self.node_ty_opt(init_ty_hir_id) else {
317            return false;
318        };
319
320        // Locate all the usages of the relevant binding.
321        struct FindExprs<'tcx> {
322            hir_id: hir::HirId,
323            uses: Vec<&'tcx hir::Expr<'tcx>>,
324        }
325        impl<'tcx> Visitor<'tcx> for FindExprs<'tcx> {
326            fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
327                if let hir::ExprKind::Path(hir::QPath::Resolved(None, path)) = ex.kind
328                    && let hir::def::Res::Local(hir_id) = path.res
329                    && hir_id == self.hir_id
330                {
331                    self.uses.push(ex);
332                }
333                hir::intravisit::walk_expr(self, ex);
334            }
335        }
336
337        let mut expr_finder = FindExprs { hir_id: local_hir_id, uses: init.into_iter().collect() };
338        let body = self.tcx.hir_body_owned_by(self.body_id);
339        expr_finder.visit_expr(body.value);
340
341        // Replaces all of the variables in the given type with a fresh inference variable.
342        let mut fudger = BottomUpFolder {
343            tcx: self.tcx,
344            ty_op: |ty| {
345                if let ty::Infer(infer) = ty.kind() {
346                    match infer {
347                        ty::TyVar(_) => self.next_ty_var(DUMMY_SP),
348                        ty::IntVar(_) => self.next_int_var(),
349                        ty::FloatVar(_) => self.next_float_var(),
350                        ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_) => {
351                            bug!("unexpected fresh ty outside of the trait solver")
352                        }
353                    }
354                } else {
355                    ty
356                }
357            },
358            lt_op: |_| self.tcx.lifetimes.re_erased,
359            ct_op: |ct| {
360                if let ty::ConstKind::Infer(_) = ct.kind() {
361                    self.next_const_var(DUMMY_SP)
362                } else {
363                    ct
364                }
365            },
366        };
367
368        let expected_ty = match source {
369            TypeMismatchSource::Ty(expected_ty) => expected_ty,
370            // Try to deduce what the possible value of `expr` would be if the
371            // incompatible arg were compatible. For example, given `Vec<i32>`
372            // and `vec.push(1u32)`, we ideally want to deduce that the type of
373            // `vec` *should* have been `Vec<u32>`. This will allow us to then
374            // run the subsequent code with this expectation, finding out exactly
375            // when this type diverged from our expectation.
376            TypeMismatchSource::Arg { call_expr, incompatible_arg: idx } => {
377                let hir::ExprKind::MethodCall(segment, _, args, _) = call_expr.kind else {
378                    return false;
379                };
380                let Some(arg_ty) = self.node_ty_opt(args[idx].hir_id) else {
381                    return false;
382                };
383                let possible_rcvr_ty = expr_finder.uses.iter().rev().find_map(|binding| {
384                    let possible_rcvr_ty = self.node_ty_opt(binding.hir_id)?;
385                    if possible_rcvr_ty.is_ty_var() {
386                        return None;
387                    }
388                    // Fudge the receiver, so we can do new inference on it.
389                    let possible_rcvr_ty = possible_rcvr_ty.fold_with(&mut fudger);
390                    let method = self
391                        .lookup_method_for_diagnostic(
392                            possible_rcvr_ty,
393                            segment,
394                            DUMMY_SP,
395                            call_expr,
396                            binding,
397                        )
398                        .ok()?;
399                    // Make sure we select the same method that we started with...
400                    if Some(method.def_id)
401                        != self.typeck_results.borrow().type_dependent_def_id(call_expr.hir_id)
402                    {
403                        return None;
404                    }
405                    // Unify the method signature with our incompatible arg, to
406                    // do inference in the *opposite* direction and to find out
407                    // what our ideal rcvr ty would look like.
408                    let _ = self
409                        .at(&ObligationCause::dummy(), self.param_env)
410                        .eq(DefineOpaqueTypes::Yes, method.sig.inputs()[idx + 1], arg_ty)
411                        .ok()?;
412                    self.select_obligations_where_possible(|errs| {
413                        // Yeet the errors, we're already reporting errors.
414                        errs.clear();
415                    });
416                    Some(self.resolve_vars_if_possible(possible_rcvr_ty))
417                });
418                if let Some(rcvr_ty) = possible_rcvr_ty {
419                    rcvr_ty
420                } else {
421                    return false;
422                }
423            }
424        };
425
426        // If our expected_ty does not equal init_ty, then it *began* as incompatible.
427        // No need to note in this case...
428        if !self.can_eq(self.param_env, expected_ty, init_ty.fold_with(&mut fudger)) {
429            return false;
430        }
431
432        for window in expr_finder.uses.windows(2) {
433            // Bindings always update their recorded type after the fact, so we
434            // need to look at the *following* usage's type to see when the
435            // binding became incompatible.
436            let [binding, next_usage] = *window else {
437                continue;
438            };
439
440            // Don't go past the binding (always gonna be a nonsense label if so)
441            if binding.hir_id == expr.hir_id {
442                break;
443            }
444
445            let Some(next_use_ty) = self.node_ty_opt(next_usage.hir_id) else {
446                continue;
447            };
448
449            // If the type is not constrained in a way making it not possible to
450            // equate with `expected_ty` by this point, skip.
451            if self.can_eq(self.param_env, expected_ty, next_use_ty.fold_with(&mut fudger)) {
452                continue;
453            }
454
455            if let hir::Node::Expr(parent_expr) = self.tcx.parent_hir_node(binding.hir_id)
456                && let hir::ExprKind::MethodCall(segment, rcvr, args, _) = parent_expr.kind
457                && rcvr.hir_id == binding.hir_id
458            {
459                // If our binding became incompatible while it was a receiver
460                // to a method call, we may be able to make a better guess to
461                // the source of a type mismatch.
462                let Some(rcvr_ty) = self.node_ty_opt(rcvr.hir_id) else {
463                    continue;
464                };
465                let rcvr_ty = rcvr_ty.fold_with(&mut fudger);
466                let Ok(method) = self.lookup_method_for_diagnostic(
467                    rcvr_ty,
468                    segment,
469                    DUMMY_SP,
470                    parent_expr,
471                    rcvr,
472                ) else {
473                    continue;
474                };
475                // Make sure we select the same method that we started with...
476                if Some(method.def_id)
477                    != self.typeck_results.borrow().type_dependent_def_id(parent_expr.hir_id)
478                {
479                    continue;
480                }
481
482                let ideal_rcvr_ty = rcvr_ty.fold_with(&mut fudger);
483                let ideal_method = self
484                    .lookup_method_for_diagnostic(
485                        ideal_rcvr_ty,
486                        segment,
487                        DUMMY_SP,
488                        parent_expr,
489                        rcvr,
490                    )
491                    .ok()
492                    .and_then(|method| {
493                        let _ = self
494                            .at(&ObligationCause::dummy(), self.param_env)
495                            .eq(DefineOpaqueTypes::Yes, ideal_rcvr_ty, expected_ty)
496                            .ok()?;
497                        Some(method)
498                    });
499
500                // Find what argument caused our rcvr to become incompatible
501                // with the expected ty.
502                for (idx, (expected_arg_ty, arg_expr)) in
503                    std::iter::zip(&method.sig.inputs()[1..], args).enumerate()
504                {
505                    let Some(arg_ty) = self.node_ty_opt(arg_expr.hir_id) else {
506                        continue;
507                    };
508                    let arg_ty = arg_ty.fold_with(&mut fudger);
509                    let _ =
510                        self.coerce(arg_expr, arg_ty, *expected_arg_ty, AllowTwoPhase::No, None);
511                    self.select_obligations_where_possible(|errs| {
512                        // Yeet the errors, we're already reporting errors.
513                        errs.clear();
514                    });
515                    // If our rcvr, after inference due to unifying the signature
516                    // with the expected argument type, is still compatible with
517                    // the rcvr, then it must've not been the source of blame.
518                    if self.can_eq(self.param_env, rcvr_ty, expected_ty) {
519                        continue;
520                    }
521                    err.span_label(arg_expr.span, format!("this argument has type `{arg_ty}`..."));
522                    err.span_label(
523                        binding.span,
524                        format!("... which causes `{ident}` to have type `{next_use_ty}`"),
525                    );
526                    // Using our "ideal" method signature, suggest a fix to this
527                    // blame arg, if possible. Don't do this if we're coming from
528                    // arg mismatch code, because we'll possibly suggest a mutually
529                    // incompatible fix at the original mismatch site.
530                    // HACK(compiler-errors): We don't actually consider the implications
531                    // of our inference guesses in `emit_type_mismatch_suggestions`, so
532                    // only suggest things when we know our type error is precisely due to
533                    // a type mismatch, and not via some projection or something. See #116155.
534                    if matches!(source, TypeMismatchSource::Ty(_))
535                        && let Some(ideal_method) = ideal_method
536                        && Some(ideal_method.def_id)
537                            == self
538                                .typeck_results
539                                .borrow()
540                                .type_dependent_def_id(parent_expr.hir_id)
541                        && let ideal_arg_ty =
542                            self.resolve_vars_if_possible(ideal_method.sig.inputs()[idx + 1])
543                        && !ideal_arg_ty.has_non_region_infer()
544                    {
545                        self.emit_type_mismatch_suggestions(
546                            err,
547                            arg_expr,
548                            arg_ty,
549                            ideal_arg_ty,
550                            None,
551                            None,
552                        );
553                    }
554                    return true;
555                }
556            }
557            err.span_label(
558                binding.span,
559                format!("here the type of `{ident}` is inferred to be `{next_use_ty}`"),
560            );
561            return true;
562        }
563
564        // We must've not found something that constrained the expr.
565        false
566    }
567
568    // When encountering a type error on the value of a `break`, try to point at the reason for the
569    // expected type.
570    pub(crate) fn annotate_loop_expected_due_to_inference(
571        &self,
572        err: &mut Diag<'_>,
573        expr: &hir::Expr<'_>,
574        error: Option<TypeError<'tcx>>,
575    ) {
576        let Some(TypeError::Sorts(ExpectedFound { expected, .. })) = error else {
577            return;
578        };
579        let mut parent_id = self.tcx.parent_hir_id(expr.hir_id);
580        let mut parent;
581        'outer: loop {
582            // Climb the HIR tree to see if the current `Expr` is part of a `break;` statement.
583            let (hir::Node::Stmt(&hir::Stmt { kind: hir::StmtKind::Semi(p), .. })
584            | hir::Node::Block(&hir::Block { expr: Some(p), .. })
585            | hir::Node::Expr(p)) = self.tcx.hir_node(parent_id)
586            else {
587                break;
588            };
589            parent = p;
590            parent_id = self.tcx.parent_hir_id(parent_id);
591            let hir::ExprKind::Break(destination, _) = parent.kind else {
592                continue;
593            };
594            let mut parent_id = parent_id;
595            let mut direct = false;
596            loop {
597                // Climb the HIR tree to find the (desugared) `loop` this `break` corresponds to.
598                let parent = match self.tcx.hir_node(parent_id) {
599                    hir::Node::Expr(parent) => {
600                        parent_id = self.tcx.parent_hir_id(parent.hir_id);
601                        parent
602                    }
603                    hir::Node::Stmt(hir::Stmt {
604                        hir_id,
605                        kind: hir::StmtKind::Semi(parent) | hir::StmtKind::Expr(parent),
606                        ..
607                    }) => {
608                        parent_id = self.tcx.parent_hir_id(*hir_id);
609                        parent
610                    }
611                    hir::Node::Block(_) => {
612                        parent_id = self.tcx.parent_hir_id(parent_id);
613                        parent
614                    }
615                    _ => break,
616                };
617                if let hir::ExprKind::Loop(..) = parent.kind {
618                    // When you have `'a: loop { break; }`, the `break` corresponds to the labeled
619                    // loop, so we need to account for that.
620                    direct = !direct;
621                }
622                if let hir::ExprKind::Loop(block, label, _, span) = parent.kind
623                    && (destination.label == label || direct)
624                {
625                    if let Some((reason_span, message)) =
626                        self.maybe_get_coercion_reason(parent_id, parent.span)
627                    {
628                        err.span_label(reason_span, message);
629                        err.span_label(
630                            span,
631                            format!("this loop is expected to be of type `{expected}`"),
632                        );
633                        break 'outer;
634                    } else {
635                        // Locate all other `break` statements within the same `loop` that might
636                        // have affected inference.
637                        struct FindBreaks<'tcx> {
638                            label: Option<rustc_ast::Label>,
639                            uses: Vec<&'tcx hir::Expr<'tcx>>,
640                            nest_depth: usize,
641                        }
642                        impl<'tcx> Visitor<'tcx> for FindBreaks<'tcx> {
643                            fn visit_expr(&mut self, ex: &'tcx hir::Expr<'tcx>) {
644                                let nest_depth = self.nest_depth;
645                                if let hir::ExprKind::Loop(_, label, _, _) = ex.kind {
646                                    if label == self.label {
647                                        // Account for `'a: loop { 'a: loop {...} }`.
648                                        return;
649                                    }
650                                    self.nest_depth += 1;
651                                }
652                                if let hir::ExprKind::Break(destination, _) = ex.kind
653                                    && (self.label == destination.label
654                                        // Account for `loop { 'a: loop { loop { break; } } }`.
655                                        || destination.label.is_none() && self.nest_depth == 0)
656                                {
657                                    self.uses.push(ex);
658                                }
659                                hir::intravisit::walk_expr(self, ex);
660                                self.nest_depth = nest_depth;
661                            }
662                        }
663                        let mut expr_finder = FindBreaks { label, uses: vec![], nest_depth: 0 };
664                        expr_finder.visit_block(block);
665                        let mut exit = false;
666                        for ex in expr_finder.uses {
667                            let hir::ExprKind::Break(_, val) = ex.kind else {
668                                continue;
669                            };
670                            let ty = match val {
671                                Some(val) => {
672                                    match self.typeck_results.borrow().expr_ty_adjusted_opt(val) {
673                                        None => continue,
674                                        Some(ty) => ty,
675                                    }
676                                }
677                                None => self.tcx.types.unit,
678                            };
679                            if self.can_eq(self.param_env, ty, expected) {
680                                err.span_label(ex.span, "expected because of this `break`");
681                                exit = true;
682                            }
683                        }
684                        if exit {
685                            break 'outer;
686                        }
687                    }
688                }
689            }
690        }
691    }
692
693    fn annotate_expected_due_to_let_ty(
694        &self,
695        err: &mut Diag<'_>,
696        expr: &hir::Expr<'_>,
697        error: Option<TypeError<'tcx>>,
698    ) {
699        match (self.tcx.parent_hir_node(expr.hir_id), error) {
700            (hir::Node::LetStmt(hir::LetStmt { ty: Some(ty), init: Some(init), .. }), _)
701                if init.hir_id == expr.hir_id =>
702            {
703                // Point at `let` assignment type.
704                err.span_label(ty.span, "expected due to this");
705            }
706            (
707                hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Assign(lhs, rhs, _), .. }),
708                Some(TypeError::Sorts(ExpectedFound { expected, .. })),
709            ) if rhs.hir_id == expr.hir_id && !expected.is_closure() => {
710                // We ignore closures explicitly because we already point at them elsewhere.
711                // Point at the assigned-to binding.
712                let mut primary_span = lhs.span;
713                let mut secondary_span = lhs.span;
714                let mut post_message = "";
715                match lhs.kind {
716                    hir::ExprKind::Path(hir::QPath::Resolved(
717                        None,
718                        hir::Path {
719                            res:
720                                hir::def::Res::Def(
721                                    hir::def::DefKind::Static { .. } | hir::def::DefKind::Const,
722                                    def_id,
723                                ),
724                            ..
725                        },
726                    )) => {
727                        if let Some(hir::Node::Item(hir::Item {
728                            kind:
729                                hir::ItemKind::Static(_, ident, ty, _)
730                                | hir::ItemKind::Const(ident, _, ty, _),
731                            ..
732                        })) = self.tcx.hir_get_if_local(*def_id)
733                        {
734                            primary_span = ty.span;
735                            secondary_span = ident.span;
736                            post_message = " type";
737                        }
738                    }
739                    hir::ExprKind::Path(hir::QPath::Resolved(
740                        None,
741                        hir::Path { res: hir::def::Res::Local(hir_id), .. },
742                    )) => {
743                        if let hir::Node::Pat(pat) = self.tcx.hir_node(*hir_id) {
744                            primary_span = pat.span;
745                            secondary_span = pat.span;
746                            match self.tcx.parent_hir_node(pat.hir_id) {
747                                hir::Node::LetStmt(hir::LetStmt { ty: Some(ty), .. }) => {
748                                    primary_span = ty.span;
749                                    post_message = " type";
750                                }
751                                hir::Node::LetStmt(hir::LetStmt { init: Some(init), .. }) => {
752                                    primary_span = init.span;
753                                    post_message = " value";
754                                }
755                                hir::Node::Param(hir::Param { ty_span, .. }) => {
756                                    primary_span = *ty_span;
757                                    post_message = " parameter type";
758                                }
759                                _ => {}
760                            }
761                        }
762                    }
763                    _ => {}
764                }
765
766                if primary_span != secondary_span
767                    && self
768                        .tcx
769                        .sess
770                        .source_map()
771                        .is_multiline(secondary_span.shrink_to_hi().until(primary_span))
772                {
773                    // We are pointing at the binding's type or initializer value, but it's pattern
774                    // is in a different line, so we point at both.
775                    err.span_label(secondary_span, "expected due to the type of this binding");
776                    err.span_label(primary_span, format!("expected due to this{post_message}"));
777                } else if post_message.is_empty() {
778                    // We are pointing at either the assignment lhs or the binding def pattern.
779                    err.span_label(primary_span, "expected due to the type of this binding");
780                } else {
781                    // We are pointing at the binding's type or initializer value.
782                    err.span_label(primary_span, format!("expected due to this{post_message}"));
783                }
784
785                if !lhs.is_syntactic_place_expr() {
786                    // We already emitted E0070 "invalid left-hand side of assignment", so we
787                    // silence this.
788                    err.downgrade_to_delayed_bug();
789                }
790            }
791            (
792                hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Binary(_, lhs, rhs), .. }),
793                Some(TypeError::Sorts(ExpectedFound { expected, .. })),
794            ) if rhs.hir_id == expr.hir_id
795                && self.typeck_results.borrow().expr_ty_adjusted_opt(lhs) == Some(expected) =>
796            {
797                err.span_label(lhs.span, format!("expected because this is `{expected}`"));
798            }
799            _ => {}
800        }
801    }
802
803    /// Detect the following case
804    ///
805    /// ```text
806    /// fn change_object(mut b: &Ty) {
807    ///     let a = Ty::new();
808    ///     b = a;
809    /// }
810    /// ```
811    ///
812    /// where the user likely meant to modify the value behind there reference, use `b` as an out
813    /// parameter, instead of mutating the local binding. When encountering this we suggest:
814    ///
815    /// ```text
816    /// fn change_object(b: &'_ mut Ty) {
817    ///     let a = Ty::new();
818    ///     *b = a;
819    /// }
820    /// ```
821    fn annotate_mut_binding_to_immutable_binding(
822        &self,
823        err: &mut Diag<'_>,
824        expr: &hir::Expr<'_>,
825        expr_ty: Ty<'tcx>,
826        expected: Ty<'tcx>,
827        error: Option<TypeError<'tcx>>,
828    ) -> bool {
829        if let Some(TypeError::Sorts(ExpectedFound { .. })) = error
830            && let ty::Ref(_, inner, hir::Mutability::Not) = expected.kind()
831
832            // The difference between the expected and found values is one level of borrowing.
833            && self.can_eq(self.param_env, *inner, expr_ty)
834
835            // We have an `ident = expr;` assignment.
836            && let hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Assign(lhs, rhs, _), .. }) =
837                self.tcx.parent_hir_node(expr.hir_id)
838            && rhs.hir_id == expr.hir_id
839
840            // We are assigning to some binding.
841            && let hir::ExprKind::Path(hir::QPath::Resolved(
842                None,
843                hir::Path { res: hir::def::Res::Local(hir_id), .. },
844            )) = lhs.kind
845            && let hir::Node::Pat(pat) = self.tcx.hir_node(*hir_id)
846
847            // The pattern we have is an fn argument.
848            && let hir::Node::Param(hir::Param { ty_span, .. }) =
849                self.tcx.parent_hir_node(pat.hir_id)
850            && let item = self.tcx.hir_get_parent_item(pat.hir_id)
851            && let item = self.tcx.hir_owner_node(item)
852            && let Some(fn_decl) = item.fn_decl()
853
854            // We have a mutable binding in the argument.
855            && let hir::PatKind::Binding(hir::BindingMode::MUT, _hir_id, ident, _) = pat.kind
856
857            // Look for the type corresponding to the argument pattern we have in the argument list.
858            && let Some(ty_ref) = fn_decl
859                .inputs
860                .iter()
861                .filter_map(|ty| match ty.kind {
862                    hir::TyKind::Ref(lt, mut_ty) if ty.span == *ty_span => Some((lt, mut_ty)),
863                    _ => None,
864                })
865                .next()
866        {
867            let mut sugg = if ty_ref.1.mutbl.is_mut() {
868                // Leave `&'name mut Ty` and `&mut Ty` as they are (#136028).
869                vec![]
870            } else {
871                // `&'name Ty` -> `&'name mut Ty` or `&Ty` -> `&mut Ty`
872                vec![(
873                    ty_ref.1.ty.span.shrink_to_lo(),
874                    format!("{}mut ", if ty_ref.0.ident.span.is_empty() { "" } else { " " },),
875                )]
876            };
877            sugg.extend([
878                (pat.span.until(ident.span), String::new()),
879                (lhs.span.shrink_to_lo(), "*".to_string()),
880            ]);
881            // We suggest changing the argument from `mut ident: &Ty` to `ident: &'_ mut Ty` and the
882            // assignment from `ident = val;` to `*ident = val;`.
883            err.multipart_suggestion_verbose(
884                "you might have meant to mutate the pointed at value being passed in, instead of \
885                changing the reference in the local binding",
886                sugg,
887                Applicability::MaybeIncorrect,
888            );
889            return true;
890        }
891        false
892    }
893
894    fn annotate_alternative_method_deref(
895        &self,
896        err: &mut Diag<'_>,
897        expr: &hir::Expr<'_>,
898        error: Option<TypeError<'tcx>>,
899    ) {
900        let Some(TypeError::Sorts(ExpectedFound { expected, .. })) = error else {
901            return;
902        };
903        let hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Assign(lhs, rhs, _), .. }) =
904            self.tcx.parent_hir_node(expr.hir_id)
905        else {
906            return;
907        };
908        if rhs.hir_id != expr.hir_id || expected.is_closure() {
909            return;
910        }
911        let hir::ExprKind::Unary(hir::UnOp::Deref, deref) = lhs.kind else {
912            return;
913        };
914        let hir::ExprKind::MethodCall(path, base, args, _) = deref.kind else {
915            return;
916        };
917        let Some(self_ty) = self.typeck_results.borrow().expr_ty_adjusted_opt(base) else {
918            return;
919        };
920
921        let Ok(pick) = self.lookup_probe_for_diagnostic(
922            path.ident,
923            self_ty,
924            deref,
925            probe::ProbeScope::TraitsInScope,
926            None,
927        ) else {
928            return;
929        };
930
931        let Ok(in_scope_methods) = self.probe_for_name_many(
932            probe::Mode::MethodCall,
933            path.ident,
934            Some(expected),
935            probe::IsSuggestion(true),
936            self_ty,
937            deref.hir_id,
938            probe::ProbeScope::TraitsInScope,
939        ) else {
940            return;
941        };
942
943        let other_methods_in_scope: Vec<_> =
944            in_scope_methods.iter().filter(|c| c.item.def_id != pick.item.def_id).collect();
945
946        let Ok(all_methods) = self.probe_for_name_many(
947            probe::Mode::MethodCall,
948            path.ident,
949            Some(expected),
950            probe::IsSuggestion(true),
951            self_ty,
952            deref.hir_id,
953            probe::ProbeScope::AllTraits,
954        ) else {
955            return;
956        };
957
958        let suggestions: Vec<_> = all_methods
959            .into_iter()
960            .filter(|c| c.item.def_id != pick.item.def_id)
961            .map(|c| {
962                let m = c.item;
963                let generic_args = ty::GenericArgs::for_item(self.tcx, m.def_id, |param, _| {
964                    self.var_for_def(deref.span, param)
965                });
966                let mutability =
967                    match self.tcx.fn_sig(m.def_id).skip_binder().input(0).skip_binder().kind() {
968                        ty::Ref(_, _, hir::Mutability::Mut) => "&mut ",
969                        ty::Ref(_, _, _) => "&",
970                        _ => "",
971                    };
972                vec![
973                    (
974                        deref.span.until(base.span),
975                        format!(
976                            "{}({}",
977                            with_no_trimmed_paths!(
978                                self.tcx.def_path_str_with_args(m.def_id, generic_args,)
979                            ),
980                            mutability,
981                        ),
982                    ),
983                    match &args {
984                        [] => (base.span.shrink_to_hi().with_hi(deref.span.hi()), ")".to_string()),
985                        [first, ..] => (base.span.between(first.span), ", ".to_string()),
986                    },
987                ]
988            })
989            .collect();
990        if suggestions.is_empty() {
991            return;
992        }
993        let mut path_span: MultiSpan = path.ident.span.into();
994        path_span.push_span_label(
995            path.ident.span,
996            with_no_trimmed_paths!(format!(
997                "refers to `{}`",
998                self.tcx.def_path_str(pick.item.def_id),
999            )),
1000        );
1001        let container_id = pick.item.container_id(self.tcx);
1002        let container = with_no_trimmed_paths!(self.tcx.def_path_str(container_id));
1003        for def_id in pick.import_ids {
1004            let hir_id = self.tcx.local_def_id_to_hir_id(def_id);
1005            path_span
1006                .push_span_label(self.tcx.hir_span(hir_id), format!("`{container}` imported here"));
1007        }
1008        let tail = with_no_trimmed_paths!(match &other_methods_in_scope[..] {
1009            [] => return,
1010            [candidate] => format!(
1011                "the method of the same name on {} `{}`",
1012                match candidate.kind {
1013                    probe::CandidateKind::InherentImplCandidate { .. } => "the inherent impl for",
1014                    _ => "trait",
1015                },
1016                self.tcx.def_path_str(candidate.item.container_id(self.tcx))
1017            ),
1018            _ if other_methods_in_scope.len() < 5 => {
1019                format!(
1020                    "the methods of the same name on {}",
1021                    listify(
1022                        &other_methods_in_scope[..other_methods_in_scope.len() - 1],
1023                        |c| format!("`{}`", self.tcx.def_path_str(c.item.container_id(self.tcx)))
1024                    )
1025                    .unwrap_or_default(),
1026                )
1027            }
1028            _ => format!(
1029                "the methods of the same name on {} other traits",
1030                other_methods_in_scope.len()
1031            ),
1032        });
1033        err.span_note(
1034            path_span,
1035            format!(
1036                "the `{}` call is resolved to the method in `{container}`, shadowing {tail}",
1037                path.ident,
1038            ),
1039        );
1040        if suggestions.len() > other_methods_in_scope.len() {
1041            err.note(format!(
1042                "additionally, there are {} other available methods that aren't in scope",
1043                suggestions.len() - other_methods_in_scope.len()
1044            ));
1045        }
1046        err.multipart_suggestions(
1047            format!(
1048                "you might have meant to call {}; you can use the fully-qualified path to call {} \
1049                 explicitly",
1050                if suggestions.len() == 1 {
1051                    "the other method"
1052                } else {
1053                    "one of the other methods"
1054                },
1055                if suggestions.len() == 1 { "it" } else { "one of them" },
1056            ),
1057            suggestions,
1058            Applicability::MaybeIncorrect,
1059        );
1060    }
1061
1062    pub(crate) fn get_conversion_methods_for_diagnostic(
1063        &self,
1064        span: Span,
1065        expected: Ty<'tcx>,
1066        checked_ty: Ty<'tcx>,
1067        hir_id: hir::HirId,
1068    ) -> Vec<AssocItem> {
1069        let methods = self.probe_for_return_type_for_diagnostic(
1070            span,
1071            probe::Mode::MethodCall,
1072            expected,
1073            checked_ty,
1074            hir_id,
1075            |m| {
1076                self.has_only_self_parameter(m)
1077                    && self
1078                        .tcx
1079                        // This special internal attribute is used to permit
1080                        // "identity-like" conversion methods to be suggested here.
1081                        //
1082                        // FIXME (#46459 and #46460): ideally
1083                        // `std::convert::Into::into` and `std::borrow:ToOwned` would
1084                        // also be `#[rustc_conversion_suggestion]`, if not for
1085                        // method-probing false-positives and -negatives (respectively).
1086                        //
1087                        // FIXME? Other potential candidate methods: `as_ref` and
1088                        // `as_mut`?
1089                        .has_attr(m.def_id, sym::rustc_conversion_suggestion)
1090            },
1091        );
1092
1093        methods
1094    }
1095
1096    /// This function checks whether the method is not static and does not accept other parameters than `self`.
1097    fn has_only_self_parameter(&self, method: &AssocItem) -> bool {
1098        method.is_method()
1099            && self.tcx.fn_sig(method.def_id).skip_binder().inputs().skip_binder().len() == 1
1100    }
1101
1102    /// If the given `HirId` corresponds to a block with a trailing expression, return that expression
1103    pub(crate) fn maybe_get_block_expr(
1104        &self,
1105        expr: &hir::Expr<'tcx>,
1106    ) -> Option<&'tcx hir::Expr<'tcx>> {
1107        match expr {
1108            hir::Expr { kind: hir::ExprKind::Block(block, ..), .. } => block.expr,
1109            _ => None,
1110        }
1111    }
1112
1113    /// Returns whether the given expression is a destruct assignment desugaring.
1114    /// For example, `(a, b) = (1, &2);`
1115    /// Here we try to find the pattern binding of the expression,
1116    /// `default_binding_modes` is false only for destruct assignment desugaring.
1117    pub(crate) fn is_destruct_assignment_desugaring(&self, expr: &hir::Expr<'_>) -> bool {
1118        if let hir::ExprKind::Path(hir::QPath::Resolved(
1119            _,
1120            hir::Path { res: hir::def::Res::Local(bind_hir_id), .. },
1121        )) = expr.kind
1122            && let bind = self.tcx.hir_node(*bind_hir_id)
1123            && let parent = self.tcx.parent_hir_node(*bind_hir_id)
1124            && let hir::Node::Pat(hir::Pat {
1125                kind: hir::PatKind::Binding(_, _hir_id, _, _), ..
1126            }) = bind
1127            && let hir::Node::Pat(hir::Pat { default_binding_modes: false, .. }) = parent
1128        {
1129            true
1130        } else {
1131            false
1132        }
1133    }
1134
1135    fn explain_self_literal(
1136        &self,
1137        err: &mut Diag<'_>,
1138        expr: &hir::Expr<'tcx>,
1139        expected: Ty<'tcx>,
1140        found: Ty<'tcx>,
1141    ) {
1142        match expr.peel_drop_temps().kind {
1143            hir::ExprKind::Struct(
1144                hir::QPath::Resolved(
1145                    None,
1146                    hir::Path { res: hir::def::Res::SelfTyAlias { alias_to, .. }, span, .. },
1147                ),
1148                ..,
1149            )
1150            | hir::ExprKind::Call(
1151                hir::Expr {
1152                    kind:
1153                        hir::ExprKind::Path(hir::QPath::Resolved(
1154                            None,
1155                            hir::Path {
1156                                res: hir::def::Res::SelfTyAlias { alias_to, .. },
1157                                span,
1158                                ..
1159                            },
1160                        )),
1161                    ..
1162                },
1163                ..,
1164            ) => {
1165                if let Some(hir::Node::Item(hir::Item {
1166                    kind: hir::ItemKind::Impl(hir::Impl { self_ty, .. }),
1167                    ..
1168                })) = self.tcx.hir_get_if_local(*alias_to)
1169                {
1170                    err.span_label(self_ty.span, "this is the type of the `Self` literal");
1171                }
1172                if let ty::Adt(e_def, e_args) = expected.kind()
1173                    && let ty::Adt(f_def, _f_args) = found.kind()
1174                    && e_def == f_def
1175                {
1176                    err.span_suggestion_verbose(
1177                        *span,
1178                        "use the type name directly",
1179                        self.tcx.value_path_str_with_args(e_def.did(), e_args),
1180                        Applicability::MaybeIncorrect,
1181                    );
1182                }
1183            }
1184            _ => {}
1185        }
1186    }
1187
1188    fn note_wrong_return_ty_due_to_generic_arg(
1189        &self,
1190        err: &mut Diag<'_>,
1191        expr: &hir::Expr<'_>,
1192        checked_ty: Ty<'tcx>,
1193    ) {
1194        let hir::Node::Expr(parent_expr) = self.tcx.parent_hir_node(expr.hir_id) else {
1195            return;
1196        };
1197        enum CallableKind {
1198            Function,
1199            Method,
1200            Constructor,
1201        }
1202        let mut maybe_emit_help = |def_id: hir::def_id::DefId,
1203                                   callable: Ident,
1204                                   args: &[hir::Expr<'_>],
1205                                   kind: CallableKind| {
1206            let arg_idx = args.iter().position(|a| a.hir_id == expr.hir_id).unwrap();
1207            let fn_ty = self.tcx.type_of(def_id).skip_binder();
1208            if !fn_ty.is_fn() {
1209                return;
1210            }
1211            let fn_sig = fn_ty.fn_sig(self.tcx).skip_binder();
1212            let Some(&arg) = fn_sig
1213                .inputs()
1214                .get(arg_idx + if matches!(kind, CallableKind::Method) { 1 } else { 0 })
1215            else {
1216                return;
1217            };
1218            if matches!(arg.kind(), ty::Param(_))
1219                && fn_sig.output().contains(arg)
1220                && self.node_ty(args[arg_idx].hir_id) == checked_ty
1221            {
1222                let mut multi_span: MultiSpan = parent_expr.span.into();
1223                multi_span.push_span_label(
1224                    args[arg_idx].span,
1225                    format!(
1226                        "this argument influences the {} of `{}`",
1227                        if matches!(kind, CallableKind::Constructor) {
1228                            "type"
1229                        } else {
1230                            "return type"
1231                        },
1232                        callable
1233                    ),
1234                );
1235                err.span_help(
1236                    multi_span,
1237                    format!(
1238                        "the {} `{}` due to the type of the argument passed",
1239                        match kind {
1240                            CallableKind::Function => "return type of this call is",
1241                            CallableKind::Method => "return type of this call is",
1242                            CallableKind::Constructor => "type constructed contains",
1243                        },
1244                        checked_ty
1245                    ),
1246                );
1247            }
1248        };
1249        match parent_expr.kind {
1250            hir::ExprKind::Call(fun, args) => {
1251                let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = fun.kind else {
1252                    return;
1253                };
1254                let hir::def::Res::Def(kind, def_id) = path.res else {
1255                    return;
1256                };
1257                let callable_kind = if matches!(kind, hir::def::DefKind::Ctor(_, _)) {
1258                    CallableKind::Constructor
1259                } else {
1260                    CallableKind::Function
1261                };
1262                maybe_emit_help(def_id, path.segments.last().unwrap().ident, args, callable_kind);
1263            }
1264            hir::ExprKind::MethodCall(method, _receiver, args, _span) => {
1265                let Some(def_id) =
1266                    self.typeck_results.borrow().type_dependent_def_id(parent_expr.hir_id)
1267                else {
1268                    return;
1269                };
1270                maybe_emit_help(def_id, method.ident, args, CallableKind::Method)
1271            }
1272            _ => return,
1273        }
1274    }
1275}
1276
1277pub(crate) enum TypeMismatchSource<'tcx> {
1278    /// Expected the binding to have the given type, but it was found to have
1279    /// a different type. Find out when that type first became incompatible.
1280    Ty(Ty<'tcx>),
1281    /// When we fail during method argument checking, try to find out if a previous
1282    /// expression has constrained the method's receiver in a way that makes the
1283    /// argument's type incompatible.
1284    Arg { call_expr: &'tcx hir::Expr<'tcx>, incompatible_arg: usize },
1285}