compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

   1 use super::FnCtxt;
   2
   3 use crate::errors::{AddReturnTypeSuggestion, ExpectedReturnTypeLabel};
   4 use rustc_ast::util::parser::{ExprPrecedence, PREC_POSTFIX};
   5 use rustc_errors::{Applicability, Diagnostic, MultiSpan};
   6 use rustc_hir as hir;
   7 use rustc_hir::def::{CtorOf, DefKind};
   8 use rustc_hir::lang_items::LangItem;
   9 use rustc_hir::{
  10     Expr, ExprKind, GenericBound, Node, Path, QPath, Stmt, StmtKind, TyKind, WherePredicate,
  11 };
  12 use rustc_hir_analysis::astconv::AstConv;
  13 use rustc_infer::infer::{self, TyCtxtInferExt};
  14 use rustc_infer::traits::{self, StatementAsExpression};
  15 use rustc_middle::lint::in_external_macro;
  16 use rustc_middle::ty::{self, Binder, DefIdTree, IsSuggestable, ToPredicate, Ty};
  17 use rustc_session::errors::ExprParenthesesNeeded;
  18 use rustc_span::symbol::sym;
  19 use rustc_span::Span;
  20 use rustc_trait_selection::infer::InferCtxtExt;
  21 use rustc_trait_selection::traits::error_reporting::DefIdOrName;
  22 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
  23
  24 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  25     pub(crate) fn body_fn_sig(&self) -> Option<ty::FnSig<'tcx>> {
  26         self.typeck_results
  27             .borrow()
  28             .liberated_fn_sigs()
  29             .get(self.tcx.hir().get_parent_node(self.body_id))
  30             .copied()
  31     }
  32
  33     pub(in super::super) fn suggest_semicolon_at_end(&self, span: Span, err: &mut Diagnostic) {
  34         err.span_suggestion_short(
  35             span.shrink_to_hi(),
  36             "consider using a semicolon here",
  37             ";",
  38             Applicability::MachineApplicable,
  39         );
  40     }
  41
  42     /// On implicit return expressions with mismatched types, provides the following suggestions:
  43     ///
  44     /// - Points out the method's return type as the reason for the expected type.
  45     /// - Possible missing semicolon.
  46     /// - Possible missing return type if the return type is the default, and not `fn main()`.
  47     pub fn suggest_mismatched_types_on_tail(
  48         &self,
  49         err: &mut Diagnostic,
  50         expr: &'tcx hir::Expr<'tcx>,
  51         expected: Ty<'tcx>,
  52         found: Ty<'tcx>,
  53         blk_id: hir::HirId,
  54     ) -> bool {
  55         let expr = expr.peel_drop_temps();
  56         self.suggest_missing_semicolon(err, expr, expected, false);
  57         let mut pointing_at_return_type = false;
  58         if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
  59             let fn_id = self.tcx.hir().get_return_block(blk_id).unwrap();
  60             pointing_at_return_type = self.suggest_missing_return_type(
  61                 err,
  62                 &fn_decl,
  63                 expected,
  64                 found,
  65                 can_suggest,
  66                 fn_id,
  67             );
  68             self.suggest_missing_break_or_return_expr(
  69                 err, expr, &fn_decl, expected, found, blk_id, fn_id,
  70             );
  71         }
  72         pointing_at_return_type
  73     }
  74
  75     /// When encountering an fn-like type, try accessing the output of the type
  76     /// and suggesting calling it if it satisfies a predicate (i.e. if the
  77     /// output has a method or a field):
  78     /// ```compile_fail,E0308
  79     /// fn foo(x: usize) -> usize { x }
  80     /// let x: usize = foo;  // suggest calling the `foo` function: `foo(42)`
  81     /// ```
  82     pub(crate) fn suggest_fn_call(
  83         &self,
  84         err: &mut Diagnostic,
  85         expr: &hir::Expr<'_>,
  86         found: Ty<'tcx>,
  87         can_satisfy: impl FnOnce(Ty<'tcx>) -> bool,
  88     ) -> bool {
  89         let Some((def_id_or_name, output, inputs)) = self.extract_callable_info(expr, found)
  90             else { return false; };
  91         if can_satisfy(output) {
  92             let (sugg_call, mut applicability) = match inputs.len() {
  93                 0 => ("".to_string(), Applicability::MachineApplicable),
  94                 1..=4 => (
  95                     inputs
  96                         .iter()
  97                         .map(|ty| {
  98                             if ty.is_suggestable(self.tcx, false) {
  99                                 format!("/* {ty} */")
 100                             } else {
 101                                 "/* value */".to_string()
 102                             }
 103                         })
 104                         .collect::<Vec<_>>()
 105                         .join(", "),
 106                     Applicability::HasPlaceholders,
 107                 ),
 108                 _ => ("/* ... */".to_string(), Applicability::HasPlaceholders),
 109             };
 110
 111             let msg = match def_id_or_name {
 112                 DefIdOrName::DefId(def_id) => match self.tcx.def_kind(def_id) {
 113                     DefKind::Ctor(CtorOf::Struct, _) => "construct this tuple struct".to_string(),
 114                     DefKind::Ctor(CtorOf::Variant, _) => "construct this tuple variant".to_string(),
 115                     kind => format!("call this {}", kind.descr(def_id)),
 116                 },
 117                 DefIdOrName::Name(name) => format!("call this {name}"),
 118             };
 119
 120             let sugg = match expr.kind {
 121                 hir::ExprKind::Call(..)
 122                 | hir::ExprKind::Path(..)
 123                 | hir::ExprKind::Index(..)
 124                 | hir::ExprKind::Lit(..) => {
 125                     vec![(expr.span.shrink_to_hi(), format!("({sugg_call})"))]
 126                 }
 127                 hir::ExprKind::Closure { .. } => {
 128                     // Might be `{ expr } || { bool }`
 129                     applicability = Applicability::MaybeIncorrect;
 130                     vec![
 131                         (expr.span.shrink_to_lo(), "(".to_string()),
 132                         (expr.span.shrink_to_hi(), format!(")({sugg_call})")),
 133                     ]
 134                 }
 135                 _ => {
 136                     vec![
 137                         (expr.span.shrink_to_lo(), "(".to_string()),
 138                         (expr.span.shrink_to_hi(), format!(")({sugg_call})")),
 139                     ]
 140                 }
 141             };
 142
 143             err.multipart_suggestion_verbose(
 144                 format!("use parentheses to {msg}"),
 145                 sugg,
 146                 applicability,
 147             );
 148             return true;
 149         }
 150         false
 151     }
 152
 153     /// Extracts information about a callable type for diagnostics. This is a
 154     /// heuristic -- it doesn't necessarily mean that a type is always callable,
 155     /// because the callable type must also be well-formed to be called.
 156     pub(in super::super) fn extract_callable_info(
 157         &self,
 158         expr: &Expr<'_>,
 159         found: Ty<'tcx>,
 160     ) -> Option<(DefIdOrName, Ty<'tcx>, Vec<Ty<'tcx>>)> {
 161         // Autoderef is useful here because sometimes we box callables, etc.
 162         let Some((def_id_or_name, output, inputs)) = self.autoderef(expr.span, found).silence_errors().find_map(|(found, _)| {
 163             match *found.kind() {
 164                 ty::FnPtr(fn_sig) =>
 165                     Some((DefIdOrName::Name("function pointer"), fn_sig.output(), fn_sig.inputs())),
 166                 ty::FnDef(def_id, _) => {
 167                     let fn_sig = found.fn_sig(self.tcx);
 168                     Some((DefIdOrName::DefId(def_id), fn_sig.output(), fn_sig.inputs()))
 169                 }
 170                 ty::Closure(def_id, substs) => {
 171                     let fn_sig = substs.as_closure().sig();
 172                     Some((DefIdOrName::DefId(def_id), fn_sig.output(), fn_sig.inputs().map_bound(|inputs| &inputs[1..])))
 173                 }
 174                 ty::Opaque(def_id, substs) => {
 175                     self.tcx.bound_item_bounds(def_id).subst(self.tcx, substs).iter().find_map(|pred| {
 176                         if let ty::PredicateKind::Projection(proj) = pred.kind().skip_binder()
 177                         && Some(proj.projection_ty.item_def_id) == self.tcx.lang_items().fn_once_output()
 178                         // args tuple will always be substs[1]
 179                         && let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind()
 180                         {
 181                             Some((
 182                                 DefIdOrName::DefId(def_id),
 183                                 pred.kind().rebind(proj.term.ty().unwrap()),
 184                                 pred.kind().rebind(args.as_slice()),
 185                             ))
 186                         } else {
 187                             None
 188                         }
 189                     })
 190                 }
 191                 ty::Dynamic(data, _, ty::Dyn) => {
 192                     data.iter().find_map(|pred| {
 193                         if let ty::ExistentialPredicate::Projection(proj) = pred.skip_binder()
 194                         && Some(proj.item_def_id) == self.tcx.lang_items().fn_once_output()
 195                         // for existential projection, substs are shifted over by 1
 196                         && let ty::Tuple(args) = proj.substs.type_at(0).kind()
 197                         {
 198                             Some((
 199                                 DefIdOrName::Name("trait object"),
 200                                 pred.rebind(proj.term.ty().unwrap()),
 201                                 pred.rebind(args.as_slice()),
 202                             ))
 203                         } else {
 204                             None
 205                         }
 206                     })
 207                 }
 208                 ty::Param(param) => {
 209                     let def_id = self.tcx.generics_of(self.body_id.owner).type_param(&param, self.tcx).def_id;
 210                     self.tcx.predicates_of(self.body_id.owner).predicates.iter().find_map(|(pred, _)| {
 211                         if let ty::PredicateKind::Projection(proj) = pred.kind().skip_binder()
 212                         && Some(proj.projection_ty.item_def_id) == self.tcx.lang_items().fn_once_output()
 213                         && proj.projection_ty.self_ty() == found
 214                         // args tuple will always be substs[1]
 215                         && let ty::Tuple(args) = proj.projection_ty.substs.type_at(1).kind()
 216                         {
 217                             Some((
 218                                 DefIdOrName::DefId(def_id),
 219                                 pred.kind().rebind(proj.term.ty().unwrap()),
 220                                 pred.kind().rebind(args.as_slice()),
 221                             ))
 222                         } else {
 223                             None
 224                         }
 225                     })
 226                 }
 227                 _ => None,
 228             }
 229         }) else { return None; };
 230
 231         let output = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, output);
 232         let inputs = inputs
 233             .skip_binder()
 234             .iter()
 235             .map(|ty| {
 236                 self.replace_bound_vars_with_fresh_vars(
 237                     expr.span,
 238                     infer::FnCall,
 239                     inputs.rebind(*ty),
 240                 )
 241             })
 242             .collect();
 243
 244         // We don't want to register any extra obligations, which should be
 245         // implied by wf, but also because that would possibly result in
 246         // erroneous errors later on.
 247         let infer::InferOk { value: output, obligations: _ } =
 248             self.normalize_associated_types_in_as_infer_ok(expr.span, output);
 249
 250         if output.is_ty_var() { None } else { Some((def_id_or_name, output, inputs)) }
 251     }
 252
 253     pub fn suggest_two_fn_call(
 254         &self,
 255         err: &mut Diagnostic,
 256         lhs_expr: &'tcx hir::Expr<'tcx>,
 257         lhs_ty: Ty<'tcx>,
 258         rhs_expr: &'tcx hir::Expr<'tcx>,
 259         rhs_ty: Ty<'tcx>,
 260         can_satisfy: impl FnOnce(Ty<'tcx>, Ty<'tcx>) -> bool,
 261     ) -> bool {
 262         let Some((_, lhs_output_ty, lhs_inputs)) = self.extract_callable_info(lhs_expr, lhs_ty)
 263             else { return false; };
 264         let Some((_, rhs_output_ty, rhs_inputs)) = self.extract_callable_info(rhs_expr, rhs_ty)
 265             else { return false; };
 266
 267         if can_satisfy(lhs_output_ty, rhs_output_ty) {
 268             let mut sugg = vec![];
 269             let mut applicability = Applicability::MachineApplicable;
 270
 271             for (expr, inputs) in [(lhs_expr, lhs_inputs), (rhs_expr, rhs_inputs)] {
 272                 let (sugg_call, this_applicability) = match inputs.len() {
 273                     0 => ("".to_string(), Applicability::MachineApplicable),
 274                     1..=4 => (
 275                         inputs
 276                             .iter()
 277                             .map(|ty| {
 278                                 if ty.is_suggestable(self.tcx, false) {
 279                                     format!("/* {ty} */")
 280                                 } else {
 281                                     "/* value */".to_string()
 282                                 }
 283                             })
 284                             .collect::<Vec<_>>()
 285                             .join(", "),
 286                         Applicability::HasPlaceholders,
 287                     ),
 288                     _ => ("/* ... */".to_string(), Applicability::HasPlaceholders),
 289                 };
 290
 291                 applicability = applicability.max(this_applicability);
 292
 293                 match expr.kind {
 294                     hir::ExprKind::Call(..)
 295                     | hir::ExprKind::Path(..)
 296                     | hir::ExprKind::Index(..)
 297                     | hir::ExprKind::Lit(..) => {
 298                         sugg.extend([(expr.span.shrink_to_hi(), format!("({sugg_call})"))]);
 299                     }
 300                     hir::ExprKind::Closure { .. } => {
 301                         // Might be `{ expr } || { bool }`
 302                         applicability = Applicability::MaybeIncorrect;
 303                         sugg.extend([
 304                             (expr.span.shrink_to_lo(), "(".to_string()),
 305                             (expr.span.shrink_to_hi(), format!(")({sugg_call})")),
 306                         ]);
 307                     }
 308                     _ => {
 309                         sugg.extend([
 310                             (expr.span.shrink_to_lo(), "(".to_string()),
 311                             (expr.span.shrink_to_hi(), format!(")({sugg_call})")),
 312                         ]);
 313                     }
 314                 }
 315             }
 316
 317             err.multipart_suggestion_verbose(
 318                 format!("use parentheses to call these"),
 319                 sugg,
 320                 applicability,
 321             );
 322
 323             true
 324         } else {
 325             false
 326         }
 327     }
 328
 329     pub fn suggest_deref_ref_or_into(
 330         &self,
 331         err: &mut Diagnostic,
 332         expr: &hir::Expr<'tcx>,
 333         expected: Ty<'tcx>,
 334         found: Ty<'tcx>,
 335         expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
 336     ) -> bool {
 337         let expr = expr.peel_blocks();
 338         if let Some((sp, msg, suggestion, applicability, verbose, annotation)) =
 339             self.check_ref(expr, found, expected)
 340         {
 341             if verbose {
 342                 err.span_suggestion_verbose(sp, &msg, suggestion, applicability);
 343             } else {
 344                 err.span_suggestion(sp, &msg, suggestion, applicability);
 345             }
 346             if annotation {
 347                 let suggest_annotation = match expr.peel_drop_temps().kind {
 348                     hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Not, _) => "&",
 349                     hir::ExprKind::AddrOf(hir::BorrowKind::Ref, hir::Mutability::Mut, _) => "&mut ",
 350                     _ => return true,
 351                 };
 352                 let mut tuple_indexes = Vec::new();
 353                 let mut expr_id = expr.hir_id;
 354                 for (parent_id, node) in self.tcx.hir().parent_iter(expr.hir_id) {
 355                     match node {
 356                         Node::Expr(&Expr { kind: ExprKind::Tup(subs), .. }) => {
 357                             tuple_indexes.push(
 358                                 subs.iter()
 359                                     .enumerate()
 360                                     .find(|(_, sub_expr)| sub_expr.hir_id == expr_id)
 361                                     .unwrap()
 362                                     .0,
 363                             );
 364                             expr_id = parent_id;
 365                         }
 366                         Node::Local(local) => {
 367                             if let Some(mut ty) = local.ty {
 368                                 while let Some(index) = tuple_indexes.pop() {
 369                                     match ty.kind {
 370                                         TyKind::Tup(tys) => ty = &tys[index],
 371                                         _ => return true,
 372                                     }
 373                                 }
 374                                 let annotation_span = ty.span;
 375                                 err.span_suggestion(
 376                                     annotation_span.with_hi(annotation_span.lo()),
 377                                     "alternatively, consider changing the type annotation",
 378                                     suggest_annotation,
 379                                     Applicability::MaybeIncorrect,
 380                                 );
 381                             }
 382                             break;
 383                         }
 384                         _ => break,
 385                     }
 386                 }
 387             }
 388             return true;
 389         } else if self.suggest_else_fn_with_closure(err, expr, found, expected) {
 390             return true;
 391         } else if self.suggest_fn_call(err, expr, found, |output| self.can_coerce(output, expected))
 392             && let ty::FnDef(def_id, ..) = &found.kind()
 393             && let Some(sp) = self.tcx.hir().span_if_local(*def_id)
 394         {
 395             err.span_label(sp, format!("{found} defined here"));
 396             return true;
 397         } else if self.check_for_cast(err, expr, found, expected, expected_ty_expr) {
 398             return true;
 399         } else {
 400             let methods = self.get_conversion_methods(expr.span, expected, found, expr.hir_id);
 401             if !methods.is_empty() {
 402                 let mut suggestions = methods.iter()
 403                     .filter_map(|conversion_method| {
 404                         let receiver_method_ident = expr.method_ident();
 405                         if let Some(method_ident) = receiver_method_ident
 406                             && method_ident.name == conversion_method.name
 407                         {
 408                             return None // do not suggest code that is already there (#53348)
 409                         }
 410
 411                         let method_call_list = [sym::to_vec, sym::to_string];
 412                         let mut sugg = if let ExprKind::MethodCall(receiver_method, ..) = expr.kind
 413                             && receiver_method.ident.name == sym::clone
 414                             && method_call_list.contains(&conversion_method.name)
 415                             // If receiver is `.clone()` and found type has one of those methods,
 416                             // we guess that the user wants to convert from a slice type (`&[]` or `&str`)
 417                             // to an owned type (`Vec` or `String`).  These conversions clone internally,
 418                             // so we remove the user's `clone` call.
 419                         {
 420                             vec![(
 421                                 receiver_method.ident.span,
 422                                 conversion_method.name.to_string()
 423                             )]
 424                         } else if expr.precedence().order()
 425                             < ExprPrecedence::MethodCall.order()
 426                         {
 427                             vec![
 428                                 (expr.span.shrink_to_lo(), "(".to_string()),
 429                                 (expr.span.shrink_to_hi(), format!(").{}()", conversion_method.name)),
 430                             ]
 431                         } else {
 432                             vec![(expr.span.shrink_to_hi(), format!(".{}()", conversion_method.name))]
 433                         };
 434                         let struct_pat_shorthand_field = self.maybe_get_struct_pattern_shorthand_field(expr);
 435                         if let Some(name) = struct_pat_shorthand_field {
 436                             sugg.insert(
 437                                 0,
 438                                 (expr.span.shrink_to_lo(), format!("{}: ", name)),
 439                             );
 440                         }
 441                         Some(sugg)
 442                     })
 443                     .peekable();
 444                 if suggestions.peek().is_some() {
 445                     err.multipart_suggestions(
 446                         "try using a conversion method",
 447                         suggestions,
 448                         Applicability::MaybeIncorrect,
 449                     );
 450                     return true;
 451                 }
 452             } else if let ty::Adt(found_adt, found_substs) = found.kind()
 453                 && self.tcx.is_diagnostic_item(sym::Option, found_adt.did())
 454                 && let ty::Adt(expected_adt, expected_substs) = expected.kind()
 455                 && self.tcx.is_diagnostic_item(sym::Option, expected_adt.did())
 456                 && let ty::Ref(_, inner_ty, _) = expected_substs.type_at(0).kind()
 457                 && inner_ty.is_str()
 458             {
 459                 let ty = found_substs.type_at(0);
 460                 let mut peeled = ty;
 461                 let mut ref_cnt = 0;
 462                 while let ty::Ref(_, inner, _) = peeled.kind() {
 463                     peeled = *inner;
 464                     ref_cnt += 1;
 465                 }
 466                 if let ty::Adt(adt, _) = peeled.kind()
 467                     && Some(adt.did()) == self.tcx.lang_items().string()
 468                 {
 469                     err.span_suggestion_verbose(
 470                         expr.span.shrink_to_hi(),
 471                         "try converting the passed type into a `&str`",
 472                         format!(".map(|x| &*{}x)", "*".repeat(ref_cnt)),
 473                         Applicability::MaybeIncorrect,
 474                     );
 475                     return true;
 476                 }
 477             }
 478         }
 479
 480         false
 481     }
 482
 483     /// When encountering the expected boxed value allocated in the stack, suggest allocating it
 484     /// in the heap by calling `Box::new()`.
 485     pub(in super::super) fn suggest_boxing_when_appropriate(
 486         &self,
 487         err: &mut Diagnostic,
 488         expr: &hir::Expr<'_>,
 489         expected: Ty<'tcx>,
 490         found: Ty<'tcx>,
 491     ) -> bool {
 492         if self.tcx.hir().is_inside_const_context(expr.hir_id) {
 493             // Do not suggest `Box::new` in const context.
 494             return false;
 495         }
 496         if !expected.is_box() || found.is_box() {
 497             return false;
 498         }
 499         let boxed_found = self.tcx.mk_box(found);
 500         if self.can_coerce(boxed_found, expected) {
 501             err.multipart_suggestion(
 502                 "store this in the heap by calling `Box::new`",
 503                 vec![
 504                     (expr.span.shrink_to_lo(), "Box::new(".to_string()),
 505                     (expr.span.shrink_to_hi(), ")".to_string()),
 506                 ],
 507                 Applicability::MachineApplicable,
 508             );
 509             err.note(
 510                 "for more on the distinction between the stack and the heap, read \
 511                  https://doc.rust-lang.org/book/ch15-01-box.html, \
 512                  https://doc.rust-lang.org/rust-by-example/std/box.html, and \
 513                  https://doc.rust-lang.org/std/boxed/index.html",
 514             );
 515             true
 516         } else {
 517             false
 518         }
 519     }
 520
 521     /// When encountering a closure that captures variables, where a FnPtr is expected,
 522     /// suggest a non-capturing closure
 523     pub(in super::super) fn suggest_no_capture_closure(
 524         &self,
 525         err: &mut Diagnostic,
 526         expected: Ty<'tcx>,
 527         found: Ty<'tcx>,
 528     ) -> bool {
 529         if let (ty::FnPtr(_), ty::Closure(def_id, _)) = (expected.kind(), found.kind()) {
 530             if let Some(upvars) = self.tcx.upvars_mentioned(*def_id) {
 531                 // Report upto four upvars being captured to reduce the amount error messages
 532                 // reported back to the user.
 533                 let spans_and_labels = upvars
 534                     .iter()
 535                     .take(4)
 536                     .map(|(var_hir_id, upvar)| {
 537                         let var_name = self.tcx.hir().name(*var_hir_id).to_string();
 538                         let msg = format!("`{}` captured here", var_name);
 539                         (upvar.span, msg)
 540                     })
 541                     .collect::<Vec<_>>();
 542
 543                 let mut multi_span: MultiSpan =
 544                     spans_and_labels.iter().map(|(sp, _)| *sp).collect::<Vec<_>>().into();
 545                 for (sp, label) in spans_and_labels {
 546                     multi_span.push_span_label(sp, label);
 547                 }
 548                 err.span_note(
 549                     multi_span,
 550                     "closures can only be coerced to `fn` types if they do not capture any variables"
 551                 );
 552                 return true;
 553             }
 554         }
 555         false
 556     }
 557
 558     /// When encountering an `impl Future` where `BoxFuture` is expected, suggest `Box::pin`.
 559     #[instrument(skip(self, err))]
 560     pub(in super::super) fn suggest_calling_boxed_future_when_appropriate(
 561         &self,
 562         err: &mut Diagnostic,
 563         expr: &hir::Expr<'_>,
 564         expected: Ty<'tcx>,
 565         found: Ty<'tcx>,
 566     ) -> bool {
 567         // Handle #68197.
 568
 569         if self.tcx.hir().is_inside_const_context(expr.hir_id) {
 570             // Do not suggest `Box::new` in const context.
 571             return false;
 572         }
 573         let pin_did = self.tcx.lang_items().pin_type();
 574         // This guards the `unwrap` and `mk_box` below.
 575         if pin_did.is_none() || self.tcx.lang_items().owned_box().is_none() {
 576             return false;
 577         }
 578         let box_found = self.tcx.mk_box(found);
 579         let pin_box_found = self.tcx.mk_lang_item(box_found, LangItem::Pin).unwrap();
 580         let pin_found = self.tcx.mk_lang_item(found, LangItem::Pin).unwrap();
 581         match expected.kind() {
 582             ty::Adt(def, _) if Some(def.did()) == pin_did => {
 583                 if self.can_coerce(pin_box_found, expected) {
 584                     debug!("can coerce {:?} to {:?}, suggesting Box::pin", pin_box_found, expected);
 585                     match found.kind() {
 586                         ty::Adt(def, _) if def.is_box() => {
 587                             err.help("use `Box::pin`");
 588                         }
 589                         _ => {
 590                             err.multipart_suggestion(
 591                                 "you need to pin and box this expression",
 592                                 vec![
 593                                     (expr.span.shrink_to_lo(), "Box::pin(".to_string()),
 594                                     (expr.span.shrink_to_hi(), ")".to_string()),
 595                                 ],
 596                                 Applicability::MaybeIncorrect,
 597                             );
 598                         }
 599                     }
 600                     true
 601                 } else if self.can_coerce(pin_found, expected) {
 602                     match found.kind() {
 603                         ty::Adt(def, _) if def.is_box() => {
 604                             err.help("use `Box::pin`");
 605                             true
 606                         }
 607                         _ => false,
 608                     }
 609                 } else {
 610                     false
 611                 }
 612             }
 613             ty::Adt(def, _) if def.is_box() && self.can_coerce(box_found, expected) => {
 614                 // Check if the parent expression is a call to Pin::new.  If it
 615                 // is and we were expecting a Box, ergo Pin<Box<expected>>, we
 616                 // can suggest Box::pin.
 617                 let parent = self.tcx.hir().get_parent_node(expr.hir_id);
 618                 let Some(Node::Expr(Expr { kind: ExprKind::Call(fn_name, _), .. })) = self.tcx.hir().find(parent) else {
 619                     return false;
 620                 };
 621                 match fn_name.kind {
 622                     ExprKind::Path(QPath::TypeRelative(
 623                         hir::Ty {
 624                             kind: TyKind::Path(QPath::Resolved(_, Path { res: recv_ty, .. })),
 625                             ..
 626                         },
 627                         method,
 628                     )) if recv_ty.opt_def_id() == pin_did && method.ident.name == sym::new => {
 629                         err.span_suggestion(
 630                             fn_name.span,
 631                             "use `Box::pin` to pin and box this expression",
 632                             "Box::pin",
 633                             Applicability::MachineApplicable,
 634                         );
 635                         true
 636                     }
 637                     _ => false,
 638                 }
 639             }
 640             _ => false,
 641         }
 642     }
 643
 644     /// A common error is to forget to add a semicolon at the end of a block, e.g.,
 645     ///
 646     /// ```compile_fail,E0308
 647     /// # fn bar_that_returns_u32() -> u32 { 4 }
 648     /// fn foo() {
 649     ///     bar_that_returns_u32()
 650     /// }
 651     /// ```
 652     ///
 653     /// This routine checks if the return expression in a block would make sense on its own as a
 654     /// statement and the return type has been left as default or has been specified as `()`. If so,
 655     /// it suggests adding a semicolon.
 656     ///
 657     /// If the expression is the expression of a closure without block (`|| expr`), a
 658     /// block is needed to be added too (`|| { expr; }`). This is denoted by `needs_block`.
 659     pub fn suggest_missing_semicolon(
 660         &self,
 661         err: &mut Diagnostic,
 662         expression: &'tcx hir::Expr<'tcx>,
 663         expected: Ty<'tcx>,
 664         needs_block: bool,
 665     ) {
 666         if expected.is_unit() {
 667             // `BlockTailExpression` only relevant if the tail expr would be
 668             // useful on its own.
 669             match expression.kind {
 670                 ExprKind::Call(..)
 671                 | ExprKind::MethodCall(..)
 672                 | ExprKind::Loop(..)
 673                 | ExprKind::If(..)
 674                 | ExprKind::Match(..)
 675                 | ExprKind::Block(..)
 676                     if expression.can_have_side_effects()
 677                         // If the expression is from an external macro, then do not suggest
 678                         // adding a semicolon, because there's nowhere to put it.
 679                         // See issue #81943.
 680                         && !in_external_macro(self.tcx.sess, expression.span) =>
 681                 {
 682                     if needs_block {
 683                         err.multipart_suggestion(
 684                             "consider using a semicolon here",
 685                             vec![
 686                                 (expression.span.shrink_to_lo(), "{ ".to_owned()),
 687                                 (expression.span.shrink_to_hi(), "; }".to_owned()),
 688                             ],
 689                             Applicability::MachineApplicable,
 690                         );
 691                     } else {
 692                         err.span_suggestion(
 693                             expression.span.shrink_to_hi(),
 694                             "consider using a semicolon here",
 695                             ";",
 696                             Applicability::MachineApplicable,
 697                         );
 698                     }
 699                 }
 700                 _ => (),
 701             }
 702         }
 703     }
 704
 705     /// A possible error is to forget to add a return type that is needed:
 706     ///
 707     /// ```compile_fail,E0308
 708     /// # fn bar_that_returns_u32() -> u32 { 4 }
 709     /// fn foo() {
 710     ///     bar_that_returns_u32()
 711     /// }
 712     /// ```
 713     ///
 714     /// This routine checks if the return type is left as default, the method is not part of an
 715     /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
 716     /// type.
 717     pub(in super::super) fn suggest_missing_return_type(
 718         &self,
 719         err: &mut Diagnostic,
 720         fn_decl: &hir::FnDecl<'_>,
 721         expected: Ty<'tcx>,
 722         found: Ty<'tcx>,
 723         can_suggest: bool,
 724         fn_id: hir::HirId,
 725     ) -> bool {
 726         let found =
 727             self.resolve_numeric_literals_with_default(self.resolve_vars_if_possible(found));
 728         // Only suggest changing the return type for methods that
 729         // haven't set a return type at all (and aren't `fn main()` or an impl).
 730         match &fn_decl.output {
 731             &hir::FnRetTy::DefaultReturn(span) if expected.is_unit() && !can_suggest => {
 732                 // `fn main()` must return `()`, do not suggest changing return type
 733                 err.subdiagnostic(ExpectedReturnTypeLabel::Unit { span });
 734                 return true;
 735             }
 736             &hir::FnRetTy::DefaultReturn(span) if expected.is_unit() => {
 737                 if found.is_suggestable(self.tcx, false) {
 738                     err.subdiagnostic(AddReturnTypeSuggestion::Add { span, found: found.to_string() });
 739                     return true;
 740                 } else if let ty::Closure(_, substs) = found.kind()
 741                     // FIXME(compiler-errors): Get better at printing binders...
 742                     && let closure = substs.as_closure()
 743                     && closure.sig().is_suggestable(self.tcx, false)
 744                 {
 745                     err.subdiagnostic(AddReturnTypeSuggestion::Add { span, found: closure.print_as_impl_trait().to_string() });
 746                     return true;
 747                 } else {
 748                     // FIXME: if `found` could be `impl Iterator` we should suggest that.
 749                     err.subdiagnostic(AddReturnTypeSuggestion::MissingHere { span });
 750                     return true
 751                 }
 752             }
 753             &hir::FnRetTy::Return(ref ty) => {
 754                 // Only point to return type if the expected type is the return type, as if they
 755                 // are not, the expectation must have been caused by something else.
 756                 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
 757                 let span = ty.span;
 758                 let ty = <dyn AstConv<'_>>::ast_ty_to_ty(self, ty);
 759                 debug!("suggest_missing_return_type: return type {:?}", ty);
 760                 debug!("suggest_missing_return_type: expected type {:?}", ty);
 761                 let bound_vars = self.tcx.late_bound_vars(fn_id);
 762                 let ty = Binder::bind_with_vars(ty, bound_vars);
 763                 let ty = self.normalize_associated_types_in(span, ty);
 764                 let ty = self.tcx.erase_late_bound_regions(ty);
 765                 if self.can_coerce(expected, ty) {
 766                     err.subdiagnostic(ExpectedReturnTypeLabel::Other { span, expected });
 767                     self.try_suggest_return_impl_trait(err, expected, ty, fn_id);
 768                     return true;
 769                 }
 770             }
 771             _ => {}
 772         }
 773         false
 774     }
 775
 776     /// check whether the return type is a generic type with a trait bound
 777     /// only suggest this if the generic param is not present in the arguments
 778     /// if this is true, hint them towards changing the return type to `impl Trait`
 779     /// ```compile_fail,E0308
 780     /// fn cant_name_it<T: Fn() -> u32>() -> T {
 781     ///     || 3
 782     /// }
 783     /// ```
 784     fn try_suggest_return_impl_trait(
 785         &self,
 786         err: &mut Diagnostic,
 787         expected: Ty<'tcx>,
 788         found: Ty<'tcx>,
 789         fn_id: hir::HirId,
 790     ) {
 791         // Only apply the suggestion if:
 792         //  - the return type is a generic parameter
 793         //  - the generic param is not used as a fn param
 794         //  - the generic param has at least one bound
 795         //  - the generic param doesn't appear in any other bounds where it's not the Self type
 796         // Suggest:
 797         //  - Changing the return type to be `impl <all bounds>`
 798
 799         debug!("try_suggest_return_impl_trait, expected = {:?}, found = {:?}", expected, found);
 800
 801         let ty::Param(expected_ty_as_param) = expected.kind() else { return };
 802
 803         let fn_node = self.tcx.hir().find(fn_id);
 804
 805         let Some(hir::Node::Item(hir::Item {
 806             kind:
 807                 hir::ItemKind::Fn(
 808                     hir::FnSig { decl: hir::FnDecl { inputs: fn_parameters, output: fn_return, .. }, .. },
 809                     hir::Generics { params, predicates, .. },
 810                     _body_id,
 811                 ),
 812             ..
 813         })) = fn_node else { return };
 814
 815         if params.get(expected_ty_as_param.index as usize).is_none() {
 816             return;
 817         };
 818
 819         // get all where BoundPredicates here, because they are used in to cases below
 820         let where_predicates = predicates
 821             .iter()
 822             .filter_map(|p| match p {
 823                 WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
 824                     bounds,
 825                     bounded_ty,
 826                     ..
 827                 }) => {
 828                     // FIXME: Maybe these calls to `ast_ty_to_ty` can be removed (and the ones below)
 829                     let ty = <dyn AstConv<'_>>::ast_ty_to_ty(self, bounded_ty);
 830                     Some((ty, bounds))
 831                 }
 832                 _ => None,
 833             })
 834             .map(|(ty, bounds)| match ty.kind() {
 835                 ty::Param(param_ty) if param_ty == expected_ty_as_param => Ok(Some(bounds)),
 836                 // check whether there is any predicate that contains our `T`, like `Option<T>: Send`
 837                 _ => match ty.contains(expected) {
 838                     true => Err(()),
 839                     false => Ok(None),
 840                 },
 841             })
 842             .collect::<Result<Vec<_>, _>>();
 843
 844         let Ok(where_predicates) = where_predicates else { return };
 845
 846         // now get all predicates in the same types as the where bounds, so we can chain them
 847         let predicates_from_where =
 848             where_predicates.iter().flatten().flat_map(|bounds| bounds.iter());
 849
 850         // extract all bounds from the source code using their spans
 851         let all_matching_bounds_strs = predicates_from_where
 852             .filter_map(|bound| match bound {
 853                 GenericBound::Trait(_, _) => {
 854                     self.tcx.sess.source_map().span_to_snippet(bound.span()).ok()
 855                 }
 856                 _ => None,
 857             })
 858             .collect::<Vec<String>>();
 859
 860         if all_matching_bounds_strs.len() == 0 {
 861             return;
 862         }
 863
 864         let all_bounds_str = all_matching_bounds_strs.join(" + ");
 865
 866         let ty_param_used_in_fn_params = fn_parameters.iter().any(|param| {
 867                 let ty = <dyn AstConv<'_>>::ast_ty_to_ty(self, param);
 868                 matches!(ty.kind(), ty::Param(fn_param_ty_param) if expected_ty_as_param == fn_param_ty_param)
 869             });
 870
 871         if ty_param_used_in_fn_params {
 872             return;
 873         }
 874
 875         err.span_suggestion(
 876             fn_return.span(),
 877             "consider using an impl return type",
 878             format!("impl {}", all_bounds_str),
 879             Applicability::MaybeIncorrect,
 880         );
 881     }
 882
 883     pub(in super::super) fn suggest_missing_break_or_return_expr(
 884         &self,
 885         err: &mut Diagnostic,
 886         expr: &'tcx hir::Expr<'tcx>,
 887         fn_decl: &hir::FnDecl<'_>,
 888         expected: Ty<'tcx>,
 889         found: Ty<'tcx>,
 890         id: hir::HirId,
 891         fn_id: hir::HirId,
 892     ) {
 893         if !expected.is_unit() {
 894             return;
 895         }
 896         let found = self.resolve_vars_with_obligations(found);
 897
 898         let in_loop = self.is_loop(id)
 899             || self.tcx.hir().parent_iter(id).any(|(parent_id, _)| self.is_loop(parent_id));
 900
 901         let in_local_statement = self.is_local_statement(id)
 902             || self
 903                 .tcx
 904                 .hir()
 905                 .parent_iter(id)
 906                 .any(|(parent_id, _)| self.is_local_statement(parent_id));
 907
 908         if in_loop && in_local_statement {
 909             err.multipart_suggestion(
 910                 "you might have meant to break the loop with this value",
 911                 vec![
 912                     (expr.span.shrink_to_lo(), "break ".to_string()),
 913                     (expr.span.shrink_to_hi(), ";".to_string()),
 914                 ],
 915                 Applicability::MaybeIncorrect,
 916             );
 917             return;
 918         }
 919
 920         if let hir::FnRetTy::Return(ty) = fn_decl.output {
 921             let ty = <dyn AstConv<'_>>::ast_ty_to_ty(self, ty);
 922             let bound_vars = self.tcx.late_bound_vars(fn_id);
 923             let ty = self.tcx.erase_late_bound_regions(Binder::bind_with_vars(ty, bound_vars));
 924             let ty = self.normalize_associated_types_in(expr.span, ty);
 925             let ty = match self.tcx.asyncness(fn_id.owner) {
 926                 hir::IsAsync::Async => {
 927                     let infcx = self.tcx.infer_ctxt().build();
 928                     infcx
 929                         .get_impl_future_output_ty(ty)
 930                         .unwrap_or_else(|| {
 931                             span_bug!(
 932                                 fn_decl.output.span(),
 933                                 "failed to get output type of async function"
 934                             )
 935                         })
 936                         .skip_binder()
 937                 }
 938                 hir::IsAsync::NotAsync => ty,
 939             };
 940             if self.can_coerce(found, ty) {
 941                 err.multipart_suggestion(
 942                     "you might have meant to return this value",
 943                     vec![
 944                         (expr.span.shrink_to_lo(), "return ".to_string()),
 945                         (expr.span.shrink_to_hi(), ";".to_string()),
 946                     ],
 947                     Applicability::MaybeIncorrect,
 948                 );
 949             }
 950         }
 951     }
 952
 953     pub(in super::super) fn suggest_missing_parentheses(
 954         &self,
 955         err: &mut Diagnostic,
 956         expr: &hir::Expr<'_>,
 957     ) -> bool {
 958         let sp = self.tcx.sess.source_map().start_point(expr.span);
 959         if let Some(sp) = self.tcx.sess.parse_sess.ambiguous_block_expr_parse.borrow().get(&sp) {
 960             // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`
 961             err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
 962             true
 963         } else {
 964             false
 965         }
 966     }
 967
 968     /// Given an expression type mismatch, peel any `&` expressions until we get to
 969     /// a block expression, and then suggest replacing the braces with square braces
 970     /// if it was possibly mistaken array syntax.
 971     pub(crate) fn suggest_block_to_brackets_peeling_refs(
 972         &self,
 973         diag: &mut Diagnostic,
 974         mut expr: &hir::Expr<'_>,
 975         mut expr_ty: Ty<'tcx>,
 976         mut expected_ty: Ty<'tcx>,
 977     ) -> bool {
 978         loop {
 979             match (&expr.kind, expr_ty.kind(), expected_ty.kind()) {
 980                 (
 981                     hir::ExprKind::AddrOf(_, _, inner_expr),
 982                     ty::Ref(_, inner_expr_ty, _),
 983                     ty::Ref(_, inner_expected_ty, _),
 984                 ) => {
 985                     expr = *inner_expr;
 986                     expr_ty = *inner_expr_ty;
 987                     expected_ty = *inner_expected_ty;
 988                 }
 989                 (hir::ExprKind::Block(blk, _), _, _) => {
 990                     self.suggest_block_to_brackets(diag, *blk, expr_ty, expected_ty);
 991                     break true;
 992                 }
 993                 _ => break false,
 994             }
 995         }
 996     }
 997
 998     pub(crate) fn suggest_copied_or_cloned(
 999         &self,
1000         diag: &mut Diagnostic,
1001         expr: &hir::Expr<'_>,
1002         expr_ty: Ty<'tcx>,
1003         expected_ty: Ty<'tcx>,
1004     ) -> bool {
1005         let ty::Adt(adt_def, substs) = expr_ty.kind() else { return false; };
1006         let ty::Adt(expected_adt_def, expected_substs) = expected_ty.kind() else { return false; };
1007         if adt_def != expected_adt_def {
1008             return false;
1009         }
1010
1011         let mut suggest_copied_or_cloned = || {
1012             let expr_inner_ty = substs.type_at(0);
1013             let expected_inner_ty = expected_substs.type_at(0);
1014             if let ty::Ref(_, ty, hir::Mutability::Not) = expr_inner_ty.kind()
1015                 && self.can_eq(self.param_env, *ty, expected_inner_ty).is_ok()
1016             {
1017                 let def_path = self.tcx.def_path_str(adt_def.did());
1018                 if self.type_is_copy_modulo_regions(self.param_env, *ty, expr.span) {
1019                     diag.span_suggestion_verbose(
1020                         expr.span.shrink_to_hi(),
1021                         format!(
1022                             "use `{def_path}::copied` to copy the value inside the `{def_path}`"
1023                         ),
1024                         ".copied()",
1025                         Applicability::MachineApplicable,
1026                     );
1027                     return true;
1028                 } else if let Some(clone_did) = self.tcx.lang_items().clone_trait()
1029                     && rustc_trait_selection::traits::type_known_to_meet_bound_modulo_regions(
1030                         self,
1031                         self.param_env,
1032                         *ty,
1033                         clone_did,
1034                         expr.span
1035                     )
1036                 {
1037                     diag.span_suggestion_verbose(
1038                         expr.span.shrink_to_hi(),
1039                         format!(
1040                             "use `{def_path}::cloned` to clone the value inside the `{def_path}`"
1041                         ),
1042                         ".cloned()",
1043                         Applicability::MachineApplicable,
1044                     );
1045                     return true;
1046                 }
1047             }
1048             false
1049         };
1050
1051         if let Some(result_did) = self.tcx.get_diagnostic_item(sym::Result)
1052             && adt_def.did() == result_did
1053             // Check that the error types are equal
1054             && self.can_eq(self.param_env, substs.type_at(1), expected_substs.type_at(1)).is_ok()
1055         {
1056             return suggest_copied_or_cloned();
1057         } else if let Some(option_did) = self.tcx.get_diagnostic_item(sym::Option)
1058             && adt_def.did() == option_did
1059         {
1060             return suggest_copied_or_cloned();
1061         }
1062
1063         false
1064     }
1065
1066     pub(crate) fn suggest_into(
1067         &self,
1068         diag: &mut Diagnostic,
1069         expr: &hir::Expr<'_>,
1070         expr_ty: Ty<'tcx>,
1071         expected_ty: Ty<'tcx>,
1072     ) -> bool {
1073         let expr = expr.peel_blocks();
1074
1075         // We have better suggestions for scalar interconversions...
1076         if expr_ty.is_scalar() && expected_ty.is_scalar() {
1077             return false;
1078         }
1079
1080         // Don't suggest turning a block into another type (e.g. `{}.into()`)
1081         if matches!(expr.kind, hir::ExprKind::Block(..)) {
1082             return false;
1083         }
1084
1085         // We'll later suggest `.as_ref` when noting the type error,
1086         // so skip if we will suggest that instead.
1087         if self.err_ctxt().should_suggest_as_ref(expected_ty, expr_ty).is_some() {
1088             return false;
1089         }
1090
1091         if let Some(into_def_id) = self.tcx.get_diagnostic_item(sym::Into)
1092             && self.predicate_must_hold_modulo_regions(&traits::Obligation::new(
1093                 self.tcx,
1094                 self.misc(expr.span),
1095                 self.param_env,
1096                 ty::Binder::dummy(self.tcx.mk_trait_ref(
1097                     into_def_id,
1098                     [expr_ty, expected_ty]
1099                 ))
1100                 .to_poly_trait_predicate(),
1101             ))
1102         {
1103             let sugg = if expr.precedence().order() >= PREC_POSTFIX {
1104                 vec![(expr.span.shrink_to_hi(), ".into()".to_owned())]
1105             } else {
1106                 vec![(expr.span.shrink_to_lo(), "(".to_owned()), (expr.span.shrink_to_hi(), ").into()".to_owned())]
1107             };
1108             diag.multipart_suggestion(
1109                 format!("call `Into::into` on this expression to convert `{expr_ty}` into `{expected_ty}`"),
1110                 sugg,
1111                 Applicability::MaybeIncorrect
1112             );
1113             return true;
1114         }
1115
1116         false
1117     }
1118
1119     /// When expecting a `bool` and finding an `Option`, suggests using `let Some(..)` or `.is_some()`
1120     pub(crate) fn suggest_option_to_bool(
1121         &self,
1122         diag: &mut Diagnostic,
1123         expr: &hir::Expr<'_>,
1124         expr_ty: Ty<'tcx>,
1125         expected_ty: Ty<'tcx>,
1126     ) -> bool {
1127         if !expected_ty.is_bool() {
1128             return false;
1129         }
1130
1131         let ty::Adt(def, _) = expr_ty.peel_refs().kind() else { return false; };
1132         if !self.tcx.is_diagnostic_item(sym::Option, def.did()) {
1133             return false;
1134         }
1135
1136         let hir = self.tcx.hir();
1137         let cond_parent = hir.parent_iter(expr.hir_id).skip_while(|(_, node)| {
1138             matches!(node, hir::Node::Expr(hir::Expr { kind: hir::ExprKind::Binary(op, _, _), .. }) if op.node == hir::BinOpKind::And)
1139         }).next();
1140         // Don't suggest:
1141         //     `let Some(_) = a.is_some() && b`
1142         //                     ++++++++++
1143         // since the user probably just misunderstood how `let else`
1144         // and `&&` work together.
1145         if let Some((_, hir::Node::Local(local))) = cond_parent
1146             && let hir::PatKind::Path(qpath) | hir::PatKind::TupleStruct(qpath, _, _) = &local.pat.kind
1147             && let hir::QPath::Resolved(None, path) = qpath
1148             && let Some(did) = path.res.opt_def_id()
1149                 .and_then(|did| self.tcx.opt_parent(did))
1150                 .and_then(|did| self.tcx.opt_parent(did))
1151             && self.tcx.is_diagnostic_item(sym::Option, did)
1152         {
1153             return false;
1154         }
1155
1156         diag.span_suggestion(
1157             expr.span.shrink_to_hi(),
1158             "use `Option::is_some` to test if the `Option` has a value",
1159             ".is_some()",
1160             Applicability::MachineApplicable,
1161         );
1162
1163         true
1164     }
1165
1166     /// Suggest wrapping the block in square brackets instead of curly braces
1167     /// in case the block was mistaken array syntax, e.g. `{ 1 }` -> `[ 1 ]`.
1168     pub(crate) fn suggest_block_to_brackets(
1169         &self,
1170         diag: &mut Diagnostic,
1171         blk: &hir::Block<'_>,
1172         blk_ty: Ty<'tcx>,
1173         expected_ty: Ty<'tcx>,
1174     ) {
1175         if let ty::Slice(elem_ty) | ty::Array(elem_ty, _) = expected_ty.kind() {
1176             if self.can_coerce(blk_ty, *elem_ty)
1177                 && blk.stmts.is_empty()
1178                 && blk.rules == hir::BlockCheckMode::DefaultBlock
1179             {
1180                 let source_map = self.tcx.sess.source_map();
1181                 if let Ok(snippet) = source_map.span_to_snippet(blk.span) {
1182                     if snippet.starts_with('{') && snippet.ends_with('}') {
1183                         diag.multipart_suggestion_verbose(
1184                             "to create an array, use square brackets instead of curly braces",
1185                             vec![
1186                                 (
1187                                     blk.span
1188                                         .shrink_to_lo()
1189                                         .with_hi(rustc_span::BytePos(blk.span.lo().0 + 1)),
1190                                     "[".to_string(),
1191                                 ),
1192                                 (
1193                                     blk.span
1194                                         .shrink_to_hi()
1195                                         .with_lo(rustc_span::BytePos(blk.span.hi().0 - 1)),
1196                                     "]".to_string(),
1197                                 ),
1198                             ],
1199                             Applicability::MachineApplicable,
1200                         );
1201                     }
1202                 }
1203             }
1204         }
1205     }
1206
1207     #[instrument(skip(self, err))]
1208     pub(crate) fn suggest_floating_point_literal(
1209         &self,
1210         err: &mut Diagnostic,
1211         expr: &hir::Expr<'_>,
1212         expected_ty: Ty<'tcx>,
1213     ) -> bool {
1214         if !expected_ty.is_floating_point() {
1215             return false;
1216         }
1217         match expr.kind {
1218             ExprKind::Struct(QPath::LangItem(LangItem::Range, ..), [start, end], _) => {
1219                 err.span_suggestion_verbose(
1220                     start.span.shrink_to_hi().with_hi(end.span.lo()),
1221                     "remove the unnecessary `.` operator for a floating point literal",
1222                     '.',
1223                     Applicability::MaybeIncorrect,
1224                 );
1225                 true
1226             }
1227             ExprKind::Struct(QPath::LangItem(LangItem::RangeFrom, ..), [start], _) => {
1228                 err.span_suggestion_verbose(
1229                     expr.span.with_lo(start.span.hi()),
1230                     "remove the unnecessary `.` operator for a floating point literal",
1231                     '.',
1232                     Applicability::MaybeIncorrect,
1233                 );
1234                 true
1235             }
1236             ExprKind::Struct(QPath::LangItem(LangItem::RangeTo, ..), [end], _) => {
1237                 err.span_suggestion_verbose(
1238                     expr.span.until(end.span),
1239                     "remove the unnecessary `.` operator and add an integer part for a floating point literal",
1240                     "0.",
1241                     Applicability::MaybeIncorrect,
1242                 );
1243                 true
1244             }
1245             _ => false,
1246         }
1247     }
1248
1249     fn is_loop(&self, id: hir::HirId) -> bool {
1250         let node = self.tcx.hir().get(id);
1251         matches!(node, Node::Expr(Expr { kind: ExprKind::Loop(..), .. }))
1252     }
1253
1254     fn is_local_statement(&self, id: hir::HirId) -> bool {
1255         let node = self.tcx.hir().get(id);
1256         matches!(node, Node::Stmt(Stmt { kind: StmtKind::Local(..), .. }))
1257     }
1258
1259     /// Suggest that `&T` was cloned instead of `T` because `T` does not implement `Clone`,
1260     /// which is a side-effect of autoref.
1261     pub(crate) fn note_type_is_not_clone(
1262         &self,
1263         diag: &mut Diagnostic,
1264         expected_ty: Ty<'tcx>,
1265         found_ty: Ty<'tcx>,
1266         expr: &hir::Expr<'_>,
1267     ) {
1268         let hir::ExprKind::MethodCall(segment, callee_expr, &[], _) = expr.kind else { return; };
1269         let Some(clone_trait_did) = self.tcx.lang_items().clone_trait() else { return; };
1270         let ty::Ref(_, pointee_ty, _) = found_ty.kind() else { return };
1271         let results = self.typeck_results.borrow();
1272         // First, look for a `Clone::clone` call
1273         if segment.ident.name == sym::clone
1274             && results.type_dependent_def_id(expr.hir_id).map_or(
1275                 false,
1276                 |did| {
1277                     let assoc_item = self.tcx.associated_item(did);
1278                     assoc_item.container == ty::AssocItemContainer::TraitContainer
1279                         && assoc_item.container_id(self.tcx) == clone_trait_did
1280                 },
1281             )
1282             // If that clone call hasn't already dereferenced the self type (i.e. don't give this
1283             // diagnostic in cases where we have `(&&T).clone()` and we expect `T`).
1284             && !results.expr_adjustments(callee_expr).iter().any(|adj| matches!(adj.kind, ty::adjustment::Adjust::Deref(..)))
1285             // Check that we're in fact trying to clone into the expected type
1286             && self.can_coerce(*pointee_ty, expected_ty)
1287             // And the expected type doesn't implement `Clone`
1288             && !self.predicate_must_hold_considering_regions(&traits::Obligation {
1289                 cause: traits::ObligationCause::dummy(),
1290                 param_env: self.param_env,
1291                 recursion_depth: 0,
1292                 predicate: ty::Binder::dummy(ty::TraitRef {
1293                     def_id: clone_trait_did,
1294                     substs: self.tcx.mk_substs([expected_ty.into()].iter()),
1295                 })
1296                 .without_const()
1297                 .to_predicate(self.tcx),
1298             })
1299         {
1300             diag.span_note(
1301                 callee_expr.span,
1302                 &format!(
1303                     "`{expected_ty}` does not implement `Clone`, so `{found_ty}` was cloned instead"
1304                 ),
1305             );
1306         }
1307     }
1308
1309     /// A common error is to add an extra semicolon:
1310     ///
1311     /// ```compile_fail,E0308
1312     /// fn foo() -> usize {
1313     ///     22;
1314     /// }
1315     /// ```
1316     ///
1317     /// This routine checks if the final statement in a block is an
1318     /// expression with an explicit semicolon whose type is compatible
1319     /// with `expected_ty`. If so, it suggests removing the semicolon.
1320     pub(crate) fn consider_removing_semicolon(
1321         &self,
1322         blk: &'tcx hir::Block<'tcx>,
1323         expected_ty: Ty<'tcx>,
1324         err: &mut Diagnostic,
1325     ) -> bool {
1326         if let Some((span_semi, boxed)) = self.err_ctxt().could_remove_semicolon(blk, expected_ty) {
1327             if let StatementAsExpression::NeedsBoxing = boxed {
1328                 err.span_suggestion_verbose(
1329                     span_semi,
1330                     "consider removing this semicolon and boxing the expression",
1331                     "",
1332                     Applicability::HasPlaceholders,
1333                 );
1334             } else {
1335                 err.span_suggestion_short(
1336                     span_semi,
1337                     "remove this semicolon to return this value",
1338                     "",
1339                     Applicability::MachineApplicable,
1340                 );
1341             }
1342             true
1343         } else {
1344             false
1345         }
1346     }
1347 }