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 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 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 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 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 expected
246 }
247 }
248 }
249
250 #[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 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 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 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 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 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 if Some(method.def_id)
401 != self.typeck_results.borrow().type_dependent_def_id(call_expr.hir_id)
402 {
403 return None;
404 }
405 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 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 !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 let [binding, next_usage] = *window else {
437 continue;
438 };
439
440 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 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 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 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 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 errs.clear();
514 });
515 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 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 false
566 }
567
568 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 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 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 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 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 return;
649 }
650 self.nest_depth += 1;
651 }
652 if let hir::ExprKind::Break(destination, _) = ex.kind
653 && (self.label == destination.label
654 || 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 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 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 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 err.span_label(primary_span, "expected due to the type of this binding");
780 } else {
781 err.span_label(primary_span, format!("expected due to this{post_message}"));
783 }
784
785 if !lhs.is_syntactic_place_expr() {
786 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 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 && self.can_eq(self.param_env, *inner, expr_ty)
834
835 && 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 && 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 && 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 && let hir::PatKind::Binding(hir::BindingMode::MUT, _hir_id, ident, _) = pat.kind
856
857 && 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 vec![]
870 } else {
871 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 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 .has_attr(m.def_id, sym::rustc_conversion_suggestion)
1090 },
1091 );
1092
1093 methods
1094 }
1095
1096 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 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 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 Ty(Ty<'tcx>),
1281 Arg { call_expr: &'tcx hir::Expr<'tcx>, incompatible_arg: usize },
1285}