src/librustc_trait_selection/traits/error_reporting/suggestions.rs

   1 use super::{
   2     EvaluationResult, Obligation, ObligationCause, ObligationCauseCode, PredicateObligation,
   3     SelectionContext,
   4 };
   5
   6 use crate::autoderef::Autoderef;
   7 use crate::infer::InferCtxt;
   8 use crate::traits::normalize_projection_type;
   9
  10 use rustc_errors::{error_code, struct_span_err, Applicability, DiagnosticBuilder, Style};
  11 use rustc_hir as hir;
  12 use rustc_hir::def::DefKind;
  13 use rustc_hir::def_id::DefId;
  14 use rustc_hir::intravisit::Visitor;
  15 use rustc_hir::lang_items;
  16 use rustc_hir::{AsyncGeneratorKind, GeneratorKind, Node};
  17 use rustc_middle::ty::{
  18     self, suggest_constraining_type_param, AdtKind, DefIdTree, Infer, InferTy, ToPredicate, Ty,
  19     TyCtxt, TypeFoldable, WithConstness,
  20 };
  21 use rustc_middle::ty::{TypeAndMut, TypeckResults};
  22 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  23 use rustc_span::{MultiSpan, Span, DUMMY_SP};
  24 use std::fmt;
  25
  26 use super::InferCtxtPrivExt;
  27 use crate::traits::query::evaluate_obligation::InferCtxtExt as _;
  28
  29 #[derive(Debug)]
  30 pub enum GeneratorInteriorOrUpvar {
  31     // span of interior type
  32     Interior(Span),
  33     // span of upvar
  34     Upvar(Span),
  35 }
  36
  37 // This trait is public to expose the diagnostics methods to clippy.
  38 pub trait InferCtxtExt<'tcx> {
  39     fn suggest_restricting_param_bound(
  40         &self,
  41         err: &mut DiagnosticBuilder<'_>,
  42         trait_ref: ty::PolyTraitRef<'tcx>,
  43         body_id: hir::HirId,
  44     );
  45
  46     fn suggest_dereferences(
  47         &self,
  48         obligation: &PredicateObligation<'tcx>,
  49         err: &mut DiagnosticBuilder<'tcx>,
  50         trait_ref: &ty::PolyTraitRef<'tcx>,
  51         points_at_arg: bool,
  52     );
  53
  54     fn get_closure_name(
  55         &self,
  56         def_id: DefId,
  57         err: &mut DiagnosticBuilder<'_>,
  58         msg: &str,
  59     ) -> Option<String>;
  60
  61     fn suggest_fn_call(
  62         &self,
  63         obligation: &PredicateObligation<'tcx>,
  64         err: &mut DiagnosticBuilder<'_>,
  65         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
  66         points_at_arg: bool,
  67     );
  68
  69     fn suggest_add_reference_to_arg(
  70         &self,
  71         obligation: &PredicateObligation<'tcx>,
  72         err: &mut DiagnosticBuilder<'_>,
  73         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
  74         points_at_arg: bool,
  75         has_custom_message: bool,
  76     ) -> bool;
  77
  78     fn suggest_remove_reference(
  79         &self,
  80         obligation: &PredicateObligation<'tcx>,
  81         err: &mut DiagnosticBuilder<'_>,
  82         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
  83     );
  84
  85     fn suggest_change_mut(
  86         &self,
  87         obligation: &PredicateObligation<'tcx>,
  88         err: &mut DiagnosticBuilder<'_>,
  89         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
  90         points_at_arg: bool,
  91     );
  92
  93     fn suggest_semicolon_removal(
  94         &self,
  95         obligation: &PredicateObligation<'tcx>,
  96         err: &mut DiagnosticBuilder<'_>,
  97         span: Span,
  98         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
  99     );
 100
 101     fn return_type_span(&self, obligation: &PredicateObligation<'tcx>) -> Option<Span>;
 102
 103     fn suggest_impl_trait(
 104         &self,
 105         err: &mut DiagnosticBuilder<'_>,
 106         span: Span,
 107         obligation: &PredicateObligation<'tcx>,
 108         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 109     ) -> bool;
 110
 111     fn point_at_returns_when_relevant(
 112         &self,
 113         err: &mut DiagnosticBuilder<'_>,
 114         obligation: &PredicateObligation<'tcx>,
 115     );
 116
 117     fn report_closure_arg_mismatch(
 118         &self,
 119         span: Span,
 120         found_span: Option<Span>,
 121         expected_ref: ty::PolyTraitRef<'tcx>,
 122         found: ty::PolyTraitRef<'tcx>,
 123     ) -> DiagnosticBuilder<'tcx>;
 124
 125     fn suggest_fully_qualified_path(
 126         &self,
 127         err: &mut DiagnosticBuilder<'_>,
 128         def_id: DefId,
 129         span: Span,
 130         trait_ref: DefId,
 131     );
 132
 133     fn maybe_note_obligation_cause_for_async_await(
 134         &self,
 135         err: &mut DiagnosticBuilder<'_>,
 136         obligation: &PredicateObligation<'tcx>,
 137     ) -> bool;
 138
 139     fn note_obligation_cause_for_async_await(
 140         &self,
 141         err: &mut DiagnosticBuilder<'_>,
 142         interior_or_upvar_span: GeneratorInteriorOrUpvar,
 143         interior_extra_info: Option<(Option<Span>, Span, Option<hir::HirId>, Option<Span>)>,
 144         inner_generator_body: Option<&hir::Body<'tcx>>,
 145         outer_generator: Option<DefId>,
 146         trait_ref: ty::TraitRef<'tcx>,
 147         target_ty: Ty<'tcx>,
 148         typeck_results: &ty::TypeckResults<'tcx>,
 149         obligation: &PredicateObligation<'tcx>,
 150         next_code: Option<&ObligationCauseCode<'tcx>>,
 151     );
 152
 153     fn note_obligation_cause_code<T>(
 154         &self,
 155         err: &mut DiagnosticBuilder<'_>,
 156         predicate: &T,
 157         cause_code: &ObligationCauseCode<'tcx>,
 158         obligated_types: &mut Vec<&ty::TyS<'tcx>>,
 159     ) where
 160         T: fmt::Display;
 161
 162     fn suggest_new_overflow_limit(&self, err: &mut DiagnosticBuilder<'_>);
 163
 164     /// Suggest to await before try: future? => future.await?
 165     fn suggest_await_before_try(
 166         &self,
 167         err: &mut DiagnosticBuilder<'_>,
 168         obligation: &PredicateObligation<'tcx>,
 169         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 170         span: Span,
 171     );
 172 }
 173
 174 fn predicate_constraint(generics: &hir::Generics<'_>, pred: String) -> (Span, String) {
 175     (
 176         generics.where_clause.tail_span_for_suggestion(),
 177         format!(
 178             "{} {}",
 179             if !generics.where_clause.predicates.is_empty() { "," } else { " where" },
 180             pred,
 181         ),
 182     )
 183 }
 184
 185 /// Type parameter needs more bounds. The trivial case is `T` `where T: Bound`, but
 186 /// it can also be an `impl Trait` param that needs to be decomposed to a type
 187 /// param for cleaner code.
 188 fn suggest_restriction(
 189     tcx: TyCtxt<'tcx>,
 190     generics: &hir::Generics<'tcx>,
 191     msg: &str,
 192     err: &mut DiagnosticBuilder<'_>,
 193     fn_sig: Option<&hir::FnSig<'_>>,
 194     projection: Option<&ty::ProjectionTy<'_>>,
 195     trait_ref: ty::PolyTraitRef<'tcx>,
 196     super_traits: Option<(&Ident, &hir::GenericBounds<'_>)>,
 197 ) {
 198     // When we are dealing with a trait, `super_traits` will be `Some`:
 199     // Given `trait T: A + B + C {}`
 200     //              -  ^^^^^^^^^ GenericBounds
 201     //              |
 202     //              &Ident
 203     let span = generics.where_clause.span_for_predicates_or_empty_place();
 204     if span.from_expansion() || span.desugaring_kind().is_some() {
 205         return;
 206     }
 207     // Given `fn foo(t: impl Trait)` where `Trait` requires assoc type `A`...
 208     if let Some((bound_str, fn_sig)) =
 209         fn_sig.zip(projection).and_then(|(sig, p)| match p.self_ty().kind {
 210             // Shenanigans to get the `Trait` from the `impl Trait`.
 211             ty::Param(param) => {
 212                 // `fn foo(t: impl Trait)`
 213                 //                 ^^^^^ get this string
 214                 param.name.as_str().strip_prefix("impl").map(|s| (s.trim_start().to_string(), sig))
 215             }
 216             _ => None,
 217         })
 218     {
 219         // We know we have an `impl Trait` that doesn't satisfy a required projection.
 220
 221         // Find all of the ocurrences of `impl Trait` for `Trait` in the function arguments'
 222         // types. There should be at least one, but there might be *more* than one. In that
 223         // case we could just ignore it and try to identify which one needs the restriction,
 224         // but instead we choose to suggest replacing all instances of `impl Trait` with `T`
 225         // where `T: Trait`.
 226         let mut ty_spans = vec![];
 227         let impl_trait_str = format!("impl {}", bound_str);
 228         for input in fn_sig.decl.inputs {
 229             if let hir::TyKind::Path(hir::QPath::Resolved(
 230                 None,
 231                 hir::Path { segments: [segment], .. },
 232             )) = input.kind
 233             {
 234                 if segment.ident.as_str() == impl_trait_str.as_str() {
 235                     // `fn foo(t: impl Trait)`
 236                     //            ^^^^^^^^^^ get this to suggest `T` instead
 237
 238                     // There might be more than one `impl Trait`.
 239                     ty_spans.push(input.span);
 240                 }
 241             }
 242         }
 243
 244         let type_param_name = generics.params.next_type_param_name(Some(&bound_str));
 245         // The type param `T: Trait` we will suggest to introduce.
 246         let type_param = format!("{}: {}", type_param_name, bound_str);
 247
 248         // FIXME: modify the `trait_ref` instead of string shenanigans.
 249         // Turn `<impl Trait as Foo>::Bar: Qux` into `<T as Foo>::Bar: Qux`.
 250         let pred = trait_ref.without_const().to_predicate(tcx).to_string();
 251         let pred = pred.replace(&impl_trait_str, &type_param_name);
 252         let mut sugg = vec![
 253             match generics
 254                 .params
 255                 .iter()
 256                 .filter(|p| match p.kind {
 257                     hir::GenericParamKind::Type {
 258                         synthetic: Some(hir::SyntheticTyParamKind::ImplTrait),
 259                         ..
 260                     } => false,
 261                     _ => true,
 262                 })
 263                 .last()
 264             {
 265                 // `fn foo(t: impl Trait)`
 266                 //        ^ suggest `<T: Trait>` here
 267                 None => (generics.span, format!("<{}>", type_param)),
 268                 // `fn foo<A>(t: impl Trait)`
 269                 //        ^^^ suggest `<A, T: Trait>` here
 270                 Some(param) => (
 271                     param.bounds_span().unwrap_or(param.span).shrink_to_hi(),
 272                     format!(", {}", type_param),
 273                 ),
 274             },
 275             // `fn foo(t: impl Trait)`
 276             //                       ^ suggest `where <T as Trait>::A: Bound`
 277             predicate_constraint(generics, pred),
 278         ];
 279         sugg.extend(ty_spans.into_iter().map(|s| (s, type_param_name.to_string())));
 280
 281         // Suggest `fn foo<T: Trait>(t: T) where <T as Trait>::A: Bound`.
 282         // FIXME: once `#![feature(associated_type_bounds)]` is stabilized, we should suggest
 283         // `fn foo(t: impl Trait<A: Bound>)` instead.
 284         err.multipart_suggestion(
 285             "introduce a type parameter with a trait bound instead of using `impl Trait`",
 286             sugg,
 287             Applicability::MaybeIncorrect,
 288         );
 289     } else {
 290         // Trivial case: `T` needs an extra bound: `T: Bound`.
 291         let (sp, suggestion) = match super_traits {
 292             None => predicate_constraint(
 293                 generics,
 294                 trait_ref.without_const().to_predicate(tcx).to_string(),
 295             ),
 296             Some((ident, bounds)) => match bounds {
 297                 [.., bound] => (
 298                     bound.span().shrink_to_hi(),
 299                     format!(" + {}", trait_ref.print_only_trait_path().to_string()),
 300                 ),
 301                 [] => (
 302                     ident.span.shrink_to_hi(),
 303                     format!(": {}", trait_ref.print_only_trait_path().to_string()),
 304                 ),
 305             },
 306         };
 307
 308         err.span_suggestion_verbose(
 309             sp,
 310             &format!("consider further restricting {}", msg),
 311             suggestion,
 312             Applicability::MachineApplicable,
 313         );
 314     }
 315 }
 316
 317 impl<'a, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'a, 'tcx> {
 318     fn suggest_restricting_param_bound(
 319         &self,
 320         mut err: &mut DiagnosticBuilder<'_>,
 321         trait_ref: ty::PolyTraitRef<'tcx>,
 322         body_id: hir::HirId,
 323     ) {
 324         let self_ty = trait_ref.skip_binder().self_ty();
 325         let (param_ty, projection) = match &self_ty.kind {
 326             ty::Param(_) => (true, None),
 327             ty::Projection(projection) => (false, Some(projection)),
 328             _ => return,
 329         };
 330
 331         // FIXME: Add check for trait bound that is already present, particularly `?Sized` so we
 332         //        don't suggest `T: Sized + ?Sized`.
 333         let mut hir_id = body_id;
 334         while let Some(node) = self.tcx.hir().find(hir_id) {
 335             match node {
 336                 hir::Node::Item(hir::Item {
 337                     ident,
 338                     kind: hir::ItemKind::Trait(_, _, generics, bounds, _),
 339                     ..
 340                 }) if self_ty == self.tcx.types.self_param => {
 341                     assert!(param_ty);
 342                     // Restricting `Self` for a single method.
 343                     suggest_restriction(
 344                         self.tcx,
 345                         &generics,
 346                         "`Self`",
 347                         err,
 348                         None,
 349                         projection,
 350                         trait_ref,
 351                         Some((ident, bounds)),
 352                     );
 353                     return;
 354                 }
 355
 356                 hir::Node::TraitItem(hir::TraitItem {
 357                     generics,
 358                     kind: hir::TraitItemKind::Fn(..),
 359                     ..
 360                 }) if self_ty == self.tcx.types.self_param => {
 361                     assert!(param_ty);
 362                     // Restricting `Self` for a single method.
 363                     suggest_restriction(
 364                         self.tcx, &generics, "`Self`", err, None, projection, trait_ref, None,
 365                     );
 366                     return;
 367                 }
 368
 369                 hir::Node::TraitItem(hir::TraitItem {
 370                     generics,
 371                     kind: hir::TraitItemKind::Fn(fn_sig, ..),
 372                     ..
 373                 })
 374                 | hir::Node::ImplItem(hir::ImplItem {
 375                     generics,
 376                     kind: hir::ImplItemKind::Fn(fn_sig, ..),
 377                     ..
 378                 })
 379                 | hir::Node::Item(hir::Item {
 380                     kind: hir::ItemKind::Fn(fn_sig, generics, _), ..
 381                 }) if projection.is_some() => {
 382                     // Missing restriction on associated type of type parameter (unmet projection).
 383                     suggest_restriction(
 384                         self.tcx,
 385                         &generics,
 386                         "the associated type",
 387                         err,
 388                         Some(fn_sig),
 389                         projection,
 390                         trait_ref,
 391                         None,
 392                     );
 393                     return;
 394                 }
 395                 hir::Node::Item(hir::Item {
 396                     kind:
 397                         hir::ItemKind::Trait(_, _, generics, _, _)
 398                         | hir::ItemKind::Impl { generics, .. },
 399                     ..
 400                 }) if projection.is_some() => {
 401                     // Missing restriction on associated type of type parameter (unmet projection).
 402                     suggest_restriction(
 403                         self.tcx,
 404                         &generics,
 405                         "the associated type",
 406                         err,
 407                         None,
 408                         projection,
 409                         trait_ref,
 410                         None,
 411                     );
 412                     return;
 413                 }
 414
 415                 hir::Node::Item(hir::Item {
 416                     kind:
 417                         hir::ItemKind::Struct(_, generics)
 418                         | hir::ItemKind::Enum(_, generics)
 419                         | hir::ItemKind::Union(_, generics)
 420                         | hir::ItemKind::Trait(_, _, generics, ..)
 421                         | hir::ItemKind::Impl { generics, .. }
 422                         | hir::ItemKind::Fn(_, generics, _)
 423                         | hir::ItemKind::TyAlias(_, generics)
 424                         | hir::ItemKind::TraitAlias(generics, _)
 425                         | hir::ItemKind::OpaqueTy(hir::OpaqueTy { generics, .. }),
 426                     ..
 427                 })
 428                 | hir::Node::TraitItem(hir::TraitItem { generics, .. })
 429                 | hir::Node::ImplItem(hir::ImplItem { generics, .. })
 430                     if param_ty =>
 431                 {
 432                     // Missing generic type parameter bound.
 433                     let param_name = self_ty.to_string();
 434                     let constraint = trait_ref.print_only_trait_path().to_string();
 435                     if suggest_constraining_type_param(
 436                         self.tcx,
 437                         generics,
 438                         &mut err,
 439                         &param_name,
 440                         &constraint,
 441                         Some(trait_ref.def_id()),
 442                     ) {
 443                         return;
 444                     }
 445                 }
 446
 447                 hir::Node::Crate(..) => return,
 448
 449                 _ => {}
 450             }
 451
 452             hir_id = self.tcx.hir().get_parent_item(hir_id);
 453         }
 454     }
 455
 456     /// When after several dereferencing, the reference satisfies the trait
 457     /// binding. This function provides dereference suggestion for this
 458     /// specific situation.
 459     fn suggest_dereferences(
 460         &self,
 461         obligation: &PredicateObligation<'tcx>,
 462         err: &mut DiagnosticBuilder<'tcx>,
 463         trait_ref: &ty::PolyTraitRef<'tcx>,
 464         points_at_arg: bool,
 465     ) {
 466         // It only make sense when suggesting dereferences for arguments
 467         if !points_at_arg {
 468             return;
 469         }
 470         let param_env = obligation.param_env;
 471         let body_id = obligation.cause.body_id;
 472         let span = obligation.cause.span;
 473         let real_trait_ref = match &obligation.cause.code {
 474             ObligationCauseCode::ImplDerivedObligation(cause)
 475             | ObligationCauseCode::DerivedObligation(cause)
 476             | ObligationCauseCode::BuiltinDerivedObligation(cause) => &cause.parent_trait_ref,
 477             _ => trait_ref,
 478         };
 479         let real_ty = match real_trait_ref.self_ty().no_bound_vars() {
 480             Some(ty) => ty,
 481             None => return,
 482         };
 483
 484         if let ty::Ref(region, base_ty, mutbl) = real_ty.kind {
 485             let mut autoderef = Autoderef::new(self, param_env, body_id, span, base_ty);
 486             if let Some(steps) = autoderef.find_map(|(ty, steps)| {
 487                 // Re-add the `&`
 488                 let ty = self.tcx.mk_ref(region, TypeAndMut { ty, mutbl });
 489                 let obligation =
 490                     self.mk_trait_obligation_with_new_self_ty(param_env, real_trait_ref, ty);
 491                 Some(steps).filter(|_| self.predicate_may_hold(&obligation))
 492             }) {
 493                 if steps > 0 {
 494                     if let Ok(src) = self.tcx.sess.source_map().span_to_snippet(span) {
 495                         // Don't care about `&mut` because `DerefMut` is used less
 496                         // often and user will not expect autoderef happens.
 497                         if src.starts_with("&") && !src.starts_with("&mut ") {
 498                             let derefs = "*".repeat(steps);
 499                             err.span_suggestion(
 500                                 span,
 501                                 "consider adding dereference here",
 502                                 format!("&{}{}", derefs, &src[1..]),
 503                                 Applicability::MachineApplicable,
 504                             );
 505                         }
 506                     }
 507                 }
 508             }
 509         }
 510     }
 511
 512     /// Given a closure's `DefId`, return the given name of the closure.
 513     ///
 514     /// This doesn't account for reassignments, but it's only used for suggestions.
 515     fn get_closure_name(
 516         &self,
 517         def_id: DefId,
 518         err: &mut DiagnosticBuilder<'_>,
 519         msg: &str,
 520     ) -> Option<String> {
 521         let get_name =
 522             |err: &mut DiagnosticBuilder<'_>, kind: &hir::PatKind<'_>| -> Option<String> {
 523                 // Get the local name of this closure. This can be inaccurate because
 524                 // of the possibility of reassignment, but this should be good enough.
 525                 match &kind {
 526                     hir::PatKind::Binding(hir::BindingAnnotation::Unannotated, _, name, None) => {
 527                         Some(format!("{}", name))
 528                     }
 529                     _ => {
 530                         err.note(&msg);
 531                         None
 532                     }
 533                 }
 534             };
 535
 536         let hir = self.tcx.hir();
 537         let hir_id = hir.as_local_hir_id(def_id.as_local()?);
 538         let parent_node = hir.get_parent_node(hir_id);
 539         match hir.find(parent_node) {
 540             Some(hir::Node::Stmt(hir::Stmt { kind: hir::StmtKind::Local(local), .. })) => {
 541                 get_name(err, &local.pat.kind)
 542             }
 543             // Different to previous arm because one is `&hir::Local` and the other
 544             // is `P<hir::Local>`.
 545             Some(hir::Node::Local(local)) => get_name(err, &local.pat.kind),
 546             _ => None,
 547         }
 548     }
 549
 550     /// We tried to apply the bound to an `fn` or closure. Check whether calling it would
 551     /// evaluate to a type that *would* satisfy the trait binding. If it would, suggest calling
 552     /// it: `bar(foo)` → `bar(foo())`. This case is *very* likely to be hit if `foo` is `async`.
 553     fn suggest_fn_call(
 554         &self,
 555         obligation: &PredicateObligation<'tcx>,
 556         err: &mut DiagnosticBuilder<'_>,
 557         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 558         points_at_arg: bool,
 559     ) {
 560         let self_ty = match trait_ref.self_ty().no_bound_vars() {
 561             None => return,
 562             Some(ty) => ty,
 563         };
 564
 565         let (def_id, output_ty, callable) = match self_ty.kind {
 566             ty::Closure(def_id, substs) => (def_id, substs.as_closure().sig().output(), "closure"),
 567             ty::FnDef(def_id, _) => (def_id, self_ty.fn_sig(self.tcx).output(), "function"),
 568             _ => return,
 569         };
 570         let msg = format!("use parentheses to call the {}", callable);
 571
 572         // `mk_trait_obligation_with_new_self_ty` only works for types with no escaping bound
 573         // variables, so bail out if we have any.
 574         let output_ty = match output_ty.no_bound_vars() {
 575             Some(ty) => ty,
 576             None => return,
 577         };
 578
 579         let new_obligation =
 580             self.mk_trait_obligation_with_new_self_ty(obligation.param_env, trait_ref, output_ty);
 581
 582         match self.evaluate_obligation(&new_obligation) {
 583             Ok(
 584                 EvaluationResult::EvaluatedToOk
 585                 | EvaluationResult::EvaluatedToOkModuloRegions
 586                 | EvaluationResult::EvaluatedToAmbig,
 587             ) => {}
 588             _ => return,
 589         }
 590         let hir = self.tcx.hir();
 591         // Get the name of the callable and the arguments to be used in the suggestion.
 592         let (snippet, sugg) = match hir.get_if_local(def_id) {
 593             Some(hir::Node::Expr(hir::Expr {
 594                 kind: hir::ExprKind::Closure(_, decl, _, span, ..),
 595                 ..
 596             })) => {
 597                 err.span_label(*span, "consider calling this closure");
 598                 let name = match self.get_closure_name(def_id, err, &msg) {
 599                     Some(name) => name,
 600                     None => return,
 601                 };
 602                 let args = decl.inputs.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
 603                 let sugg = format!("({})", args);
 604                 (format!("{}{}", name, sugg), sugg)
 605             }
 606             Some(hir::Node::Item(hir::Item {
 607                 ident,
 608                 kind: hir::ItemKind::Fn(.., body_id),
 609                 ..
 610             })) => {
 611                 err.span_label(ident.span, "consider calling this function");
 612                 let body = hir.body(*body_id);
 613                 let args = body
 614                     .params
 615                     .iter()
 616                     .map(|arg| match &arg.pat.kind {
 617                         hir::PatKind::Binding(_, _, ident, None)
 618                         // FIXME: provide a better suggestion when encountering `SelfLower`, it
 619                         // should suggest a method call.
 620                         if ident.name != kw::SelfLower => ident.to_string(),
 621                         _ => "_".to_string(),
 622                     })
 623                     .collect::<Vec<_>>()
 624                     .join(", ");
 625                 let sugg = format!("({})", args);
 626                 (format!("{}{}", ident, sugg), sugg)
 627             }
 628             _ => return,
 629         };
 630         if points_at_arg {
 631             // When the obligation error has been ensured to have been caused by
 632             // an argument, the `obligation.cause.span` points at the expression
 633             // of the argument, so we can provide a suggestion. This is signaled
 634             // by `points_at_arg`. Otherwise, we give a more general note.
 635             err.span_suggestion_verbose(
 636                 obligation.cause.span.shrink_to_hi(),
 637                 &msg,
 638                 sugg,
 639                 Applicability::HasPlaceholders,
 640             );
 641         } else {
 642             err.help(&format!("{}: `{}`", msg, snippet));
 643         }
 644     }
 645
 646     fn suggest_add_reference_to_arg(
 647         &self,
 648         obligation: &PredicateObligation<'tcx>,
 649         err: &mut DiagnosticBuilder<'_>,
 650         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 651         points_at_arg: bool,
 652         has_custom_message: bool,
 653     ) -> bool {
 654         if !points_at_arg {
 655             return false;
 656         }
 657
 658         let span = obligation.cause.span;
 659         let param_env = obligation.param_env;
 660         let trait_ref = trait_ref.skip_binder();
 661
 662         if let ObligationCauseCode::ImplDerivedObligation(obligation) = &obligation.cause.code {
 663             // Try to apply the original trait binding obligation by borrowing.
 664             let self_ty = trait_ref.self_ty();
 665             let found = self_ty.to_string();
 666             let new_self_ty = self.tcx.mk_imm_ref(self.tcx.lifetimes.re_static, self_ty);
 667             let substs = self.tcx.mk_substs_trait(new_self_ty, &[]);
 668             let new_trait_ref = ty::TraitRef::new(obligation.parent_trait_ref.def_id(), substs);
 669             let new_obligation = Obligation::new(
 670                 ObligationCause::dummy(),
 671                 param_env,
 672                 new_trait_ref.without_const().to_predicate(self.tcx),
 673             );
 674
 675             if self.predicate_must_hold_modulo_regions(&new_obligation) {
 676                 if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
 677                     // We have a very specific type of error, where just borrowing this argument
 678                     // might solve the problem. In cases like this, the important part is the
 679                     // original type obligation, not the last one that failed, which is arbitrary.
 680                     // Because of this, we modify the error to refer to the original obligation and
 681                     // return early in the caller.
 682
 683                     let msg = format!(
 684                         "the trait bound `{}: {}` is not satisfied",
 685                         found,
 686                         obligation.parent_trait_ref.skip_binder().print_only_trait_path(),
 687                     );
 688                     if has_custom_message {
 689                         err.note(&msg);
 690                     } else {
 691                         err.message = vec![(msg, Style::NoStyle)];
 692                     }
 693                     if snippet.starts_with('&') {
 694                         // This is already a literal borrow and the obligation is failing
 695                         // somewhere else in the obligation chain. Do not suggest non-sense.
 696                         return false;
 697                     }
 698                     err.span_label(
 699                         span,
 700                         &format!(
 701                             "expected an implementor of trait `{}`",
 702                             obligation.parent_trait_ref.skip_binder().print_only_trait_path(),
 703                         ),
 704                     );
 705
 706                     // This if is to prevent a special edge-case
 707                     if !span.from_expansion() {
 708                         // We don't want a borrowing suggestion on the fields in structs,
 709                         // ```
 710                         // struct Foo {
 711                         //  the_foos: Vec<Foo>
 712                         // }
 713                         // ```
 714
 715                         err.span_suggestion(
 716                             span,
 717                             "consider borrowing here",
 718                             format!("&{}", snippet),
 719                             Applicability::MaybeIncorrect,
 720                         );
 721                     }
 722                     return true;
 723                 }
 724             }
 725         }
 726         false
 727     }
 728
 729     /// Whenever references are used by mistake, like `for (i, e) in &vec.iter().enumerate()`,
 730     /// suggest removing these references until we reach a type that implements the trait.
 731     fn suggest_remove_reference(
 732         &self,
 733         obligation: &PredicateObligation<'tcx>,
 734         err: &mut DiagnosticBuilder<'_>,
 735         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 736     ) {
 737         let span = obligation.cause.span;
 738
 739         if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
 740             let refs_number =
 741                 snippet.chars().filter(|c| !c.is_whitespace()).take_while(|c| *c == '&').count();
 742             if let Some('\'') = snippet.chars().filter(|c| !c.is_whitespace()).nth(refs_number) {
 743                 // Do not suggest removal of borrow from type arguments.
 744                 return;
 745             }
 746
 747             let mut suggested_ty = match trait_ref.self_ty().no_bound_vars() {
 748                 Some(ty) => ty,
 749                 None => return,
 750             };
 751
 752             for refs_remaining in 0..refs_number {
 753                 if let ty::Ref(_, inner_ty, _) = suggested_ty.kind {
 754                     suggested_ty = inner_ty;
 755
 756                     let new_obligation = self.mk_trait_obligation_with_new_self_ty(
 757                         obligation.param_env,
 758                         trait_ref,
 759                         suggested_ty,
 760                     );
 761
 762                     if self.predicate_may_hold(&new_obligation) {
 763                         let sp = self
 764                             .tcx
 765                             .sess
 766                             .source_map()
 767                             .span_take_while(span, |c| c.is_whitespace() || *c == '&');
 768
 769                         let remove_refs = refs_remaining + 1;
 770
 771                         let msg = if remove_refs == 1 {
 772                             "consider removing the leading `&`-reference".to_string()
 773                         } else {
 774                             format!("consider removing {} leading `&`-references", remove_refs)
 775                         };
 776
 777                         err.span_suggestion_short(
 778                             sp,
 779                             &msg,
 780                             String::new(),
 781                             Applicability::MachineApplicable,
 782                         );
 783                         break;
 784                     }
 785                 } else {
 786                     break;
 787                 }
 788             }
 789         }
 790     }
 791
 792     /// Check if the trait bound is implemented for a different mutability and note it in the
 793     /// final error.
 794     fn suggest_change_mut(
 795         &self,
 796         obligation: &PredicateObligation<'tcx>,
 797         err: &mut DiagnosticBuilder<'_>,
 798         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 799         points_at_arg: bool,
 800     ) {
 801         let span = obligation.cause.span;
 802         if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
 803             let refs_number =
 804                 snippet.chars().filter(|c| !c.is_whitespace()).take_while(|c| *c == '&').count();
 805             if let Some('\'') = snippet.chars().filter(|c| !c.is_whitespace()).nth(refs_number) {
 806                 // Do not suggest removal of borrow from type arguments.
 807                 return;
 808             }
 809             let trait_ref = self.resolve_vars_if_possible(trait_ref);
 810             if trait_ref.has_infer_types_or_consts() {
 811                 // Do not ICE while trying to find if a reborrow would succeed on a trait with
 812                 // unresolved bindings.
 813                 return;
 814             }
 815
 816             if let ty::Ref(region, t_type, mutability) = trait_ref.skip_binder().self_ty().kind {
 817                 if region.is_late_bound() || t_type.has_escaping_bound_vars() {
 818                     // Avoid debug assertion in `mk_obligation_for_def_id`.
 819                     //
 820                     // If the self type has escaping bound vars then it's not
 821                     // going to be the type of an expression, so the suggestion
 822                     // probably won't apply anyway.
 823                     return;
 824                 }
 825
 826                 let suggested_ty = match mutability {
 827                     hir::Mutability::Mut => self.tcx.mk_imm_ref(region, t_type),
 828                     hir::Mutability::Not => self.tcx.mk_mut_ref(region, t_type),
 829                 };
 830
 831                 let new_obligation = self.mk_trait_obligation_with_new_self_ty(
 832                     obligation.param_env,
 833                     &trait_ref,
 834                     suggested_ty,
 835                 );
 836                 let suggested_ty_would_satisfy_obligation = self
 837                     .evaluate_obligation_no_overflow(&new_obligation)
 838                     .must_apply_modulo_regions();
 839                 if suggested_ty_would_satisfy_obligation {
 840                     let sp = self
 841                         .tcx
 842                         .sess
 843                         .source_map()
 844                         .span_take_while(span, |c| c.is_whitespace() || *c == '&');
 845                     if points_at_arg && mutability == hir::Mutability::Not && refs_number > 0 {
 846                         err.span_suggestion_verbose(
 847                             sp,
 848                             "consider changing this borrow's mutability",
 849                             "&mut ".to_string(),
 850                             Applicability::MachineApplicable,
 851                         );
 852                     } else {
 853                         err.note(&format!(
 854                             "`{}` is implemented for `{:?}`, but not for `{:?}`",
 855                             trait_ref.print_only_trait_path(),
 856                             suggested_ty,
 857                             trait_ref.skip_binder().self_ty(),
 858                         ));
 859                     }
 860                 }
 861             }
 862         }
 863     }
 864
 865     fn suggest_semicolon_removal(
 866         &self,
 867         obligation: &PredicateObligation<'tcx>,
 868         err: &mut DiagnosticBuilder<'_>,
 869         span: Span,
 870         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 871     ) {
 872         let is_empty_tuple =
 873             |ty: ty::Binder<Ty<'_>>| ty.skip_binder().kind == ty::Tuple(ty::List::empty());
 874
 875         let hir = self.tcx.hir();
 876         let parent_node = hir.get_parent_node(obligation.cause.body_id);
 877         let node = hir.find(parent_node);
 878         if let Some(hir::Node::Item(hir::Item {
 879             kind: hir::ItemKind::Fn(sig, _, body_id), ..
 880         })) = node
 881         {
 882             let body = hir.body(*body_id);
 883             if let hir::ExprKind::Block(blk, _) = &body.value.kind {
 884                 if sig.decl.output.span().overlaps(span)
 885                     && blk.expr.is_none()
 886                     && is_empty_tuple(trait_ref.self_ty())
 887                 {
 888                     // FIXME(estebank): When encountering a method with a trait
 889                     // bound not satisfied in the return type with a body that has
 890                     // no return, suggest removal of semicolon on last statement.
 891                     // Once that is added, close #54771.
 892                     if let Some(ref stmt) = blk.stmts.last() {
 893                         let sp = self.tcx.sess.source_map().end_point(stmt.span);
 894                         err.span_label(sp, "consider removing this semicolon");
 895                     }
 896                 }
 897             }
 898         }
 899     }
 900
 901     fn return_type_span(&self, obligation: &PredicateObligation<'tcx>) -> Option<Span> {
 902         let hir = self.tcx.hir();
 903         let parent_node = hir.get_parent_node(obligation.cause.body_id);
 904         let sig = match hir.find(parent_node) {
 905             Some(hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(sig, ..), .. })) => sig,
 906             _ => return None,
 907         };
 908
 909         if let hir::FnRetTy::Return(ret_ty) = sig.decl.output { Some(ret_ty.span) } else { None }
 910     }
 911
 912     /// If all conditions are met to identify a returned `dyn Trait`, suggest using `impl Trait` if
 913     /// applicable and signal that the error has been expanded appropriately and needs to be
 914     /// emitted.
 915     fn suggest_impl_trait(
 916         &self,
 917         err: &mut DiagnosticBuilder<'_>,
 918         span: Span,
 919         obligation: &PredicateObligation<'tcx>,
 920         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
 921     ) -> bool {
 922         match obligation.cause.code.peel_derives() {
 923             // Only suggest `impl Trait` if the return type is unsized because it is `dyn Trait`.
 924             ObligationCauseCode::SizedReturnType => {}
 925             _ => return false,
 926         }
 927
 928         let hir = self.tcx.hir();
 929         let parent_node = hir.get_parent_node(obligation.cause.body_id);
 930         let node = hir.find(parent_node);
 931         let (sig, body_id) = if let Some(hir::Node::Item(hir::Item {
 932             kind: hir::ItemKind::Fn(sig, _, body_id),
 933             ..
 934         })) = node
 935         {
 936             (sig, body_id)
 937         } else {
 938             return false;
 939         };
 940         let body = hir.body(*body_id);
 941         let trait_ref = self.resolve_vars_if_possible(trait_ref);
 942         let ty = trait_ref.skip_binder().self_ty();
 943         let is_object_safe = match ty.kind {
 944             ty::Dynamic(predicates, _) => {
 945                 // If the `dyn Trait` is not object safe, do not suggest `Box<dyn Trait>`.
 946                 predicates
 947                     .principal_def_id()
 948                     .map_or(true, |def_id| self.tcx.object_safety_violations(def_id).is_empty())
 949             }
 950             // We only want to suggest `impl Trait` to `dyn Trait`s.
 951             // For example, `fn foo() -> str` needs to be filtered out.
 952             _ => return false,
 953         };
 954
 955         let ret_ty = if let hir::FnRetTy::Return(ret_ty) = sig.decl.output {
 956             ret_ty
 957         } else {
 958             return false;
 959         };
 960
 961         // Use `TypeVisitor` instead of the output type directly to find the span of `ty` for
 962         // cases like `fn foo() -> (dyn Trait, i32) {}`.
 963         // Recursively look for `TraitObject` types and if there's only one, use that span to
 964         // suggest `impl Trait`.
 965
 966         // Visit to make sure there's a single `return` type to suggest `impl Trait`,
 967         // otherwise suggest using `Box<dyn Trait>` or an enum.
 968         let mut visitor = ReturnsVisitor::default();
 969         visitor.visit_body(&body);
 970
 971         let typeck_results = self.in_progress_typeck_results.map(|t| t.borrow()).unwrap();
 972
 973         let mut ret_types = visitor
 974             .returns
 975             .iter()
 976             .filter_map(|expr| typeck_results.node_type_opt(expr.hir_id))
 977             .map(|ty| self.resolve_vars_if_possible(&ty));
 978         let (last_ty, all_returns_have_same_type, only_never_return) = ret_types.clone().fold(
 979             (None, true, true),
 980             |(last_ty, mut same, only_never_return): (std::option::Option<Ty<'_>>, bool, bool),
 981              ty| {
 982                 let ty = self.resolve_vars_if_possible(&ty);
 983                 same &=
 984                     !matches!(ty.kind, ty::Error(_))
 985                         && last_ty.map_or(true, |last_ty| {
 986                             // FIXME: ideally we would use `can_coerce` here instead, but `typeck` comes
 987                             // *after* in the dependency graph.
 988                             match (&ty.kind, &last_ty.kind) {
 989                                 (Infer(InferTy::IntVar(_)), Infer(InferTy::IntVar(_)))
 990                                 | (Infer(InferTy::FloatVar(_)), Infer(InferTy::FloatVar(_)))
 991                                 | (Infer(InferTy::FreshIntTy(_)), Infer(InferTy::FreshIntTy(_)))
 992                                 | (
 993                                     Infer(InferTy::FreshFloatTy(_)),
 994                                     Infer(InferTy::FreshFloatTy(_)),
 995                                 ) => true,
 996                                 _ => ty == last_ty,
 997                             }
 998                         });
 999                 (Some(ty), same, only_never_return && matches!(ty.kind, ty::Never))
1000             },
1001         );
1002         let all_returns_conform_to_trait =
1003             if let Some(ty_ret_ty) = typeck_results.node_type_opt(ret_ty.hir_id) {
1004                 match ty_ret_ty.kind {
1005                     ty::Dynamic(predicates, _) => {
1006                         let cause = ObligationCause::misc(ret_ty.span, ret_ty.hir_id);
1007                         let param_env = ty::ParamEnv::empty();
1008                         only_never_return
1009                             || ret_types.all(|returned_ty| {
1010                                 predicates.iter().all(|predicate| {
1011                                     let pred = predicate.with_self_ty(self.tcx, returned_ty);
1012                                     let obl = Obligation::new(cause.clone(), param_env, pred);
1013                                     self.predicate_may_hold(&obl)
1014                                 })
1015                             })
1016                     }
1017                     _ => false,
1018                 }
1019             } else {
1020                 true
1021             };
1022
1023         let sm = self.tcx.sess.source_map();
1024         let snippet = if let (true, hir::TyKind::TraitObject(..), Ok(snippet), true) = (
1025             // Verify that we're dealing with a return `dyn Trait`
1026             ret_ty.span.overlaps(span),
1027             &ret_ty.kind,
1028             sm.span_to_snippet(ret_ty.span),
1029             // If any of the return types does not conform to the trait, then we can't
1030             // suggest `impl Trait` nor trait objects: it is a type mismatch error.
1031             all_returns_conform_to_trait,
1032         ) {
1033             snippet
1034         } else {
1035             return false;
1036         };
1037         err.code(error_code!(E0746));
1038         err.set_primary_message("return type cannot have an unboxed trait object");
1039         err.children.clear();
1040         let impl_trait_msg = "for information on `impl Trait`, see \
1041             <https://doc.rust-lang.org/book/ch10-02-traits.html\
1042             #returning-types-that-implement-traits>";
1043         let trait_obj_msg = "for information on trait objects, see \
1044             <https://doc.rust-lang.org/book/ch17-02-trait-objects.html\
1045             #using-trait-objects-that-allow-for-values-of-different-types>";
1046         let has_dyn = snippet.split_whitespace().next().map_or(false, |s| s == "dyn");
1047         let trait_obj = if has_dyn { &snippet[4..] } else { &snippet[..] };
1048         if only_never_return {
1049             // No return paths, probably using `panic!()` or similar.
1050             // Suggest `-> T`, `-> impl Trait`, and if `Trait` is object safe, `-> Box<dyn Trait>`.
1051             suggest_trait_object_return_type_alternatives(
1052                 err,
1053                 ret_ty.span,
1054                 trait_obj,
1055                 is_object_safe,
1056             );
1057         } else if let (Some(last_ty), true) = (last_ty, all_returns_have_same_type) {
1058             // Suggest `-> impl Trait`.
1059             err.span_suggestion(
1060                 ret_ty.span,
1061                 &format!(
1062                     "use `impl {1}` as the return type, as all return paths are of type `{}`, \
1063                      which implements `{1}`",
1064                     last_ty, trait_obj,
1065                 ),
1066                 format!("impl {}", trait_obj),
1067                 Applicability::MachineApplicable,
1068             );
1069             err.note(impl_trait_msg);
1070         } else {
1071             if is_object_safe {
1072                 // Suggest `-> Box<dyn Trait>` and `Box::new(returned_value)`.
1073                 // Get all the return values and collect their span and suggestion.
1074                 if let Some(mut suggestions) = visitor
1075                     .returns
1076                     .iter()
1077                     .map(|expr| {
1078                         let snip = sm.span_to_snippet(expr.span).ok()?;
1079                         Some((expr.span, format!("Box::new({})", snip)))
1080                     })
1081                     .collect::<Option<Vec<_>>>()
1082                 {
1083                     // Add the suggestion for the return type.
1084                     suggestions.push((ret_ty.span, format!("Box<dyn {}>", trait_obj)));
1085                     err.multipart_suggestion(
1086                         "return a boxed trait object instead",
1087                         suggestions,
1088                         Applicability::MaybeIncorrect,
1089                     );
1090                 }
1091             } else {
1092                 // This is currently not possible to trigger because E0038 takes precedence, but
1093                 // leave it in for completeness in case anything changes in an earlier stage.
1094                 err.note(&format!(
1095                     "if trait `{}` was object safe, you could return a trait object",
1096                     trait_obj,
1097                 ));
1098             }
1099             err.note(trait_obj_msg);
1100             err.note(&format!(
1101                 "if all the returned values were of the same type you could use `impl {}` as the \
1102                  return type",
1103                 trait_obj,
1104             ));
1105             err.note(impl_trait_msg);
1106             err.note("you can create a new `enum` with a variant for each returned type");
1107         }
1108         true
1109     }
1110
1111     fn point_at_returns_when_relevant(
1112         &self,
1113         err: &mut DiagnosticBuilder<'_>,
1114         obligation: &PredicateObligation<'tcx>,
1115     ) {
1116         match obligation.cause.code.peel_derives() {
1117             ObligationCauseCode::SizedReturnType => {}
1118             _ => return,
1119         }
1120
1121         let hir = self.tcx.hir();
1122         let parent_node = hir.get_parent_node(obligation.cause.body_id);
1123         let node = hir.find(parent_node);
1124         if let Some(hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(_, _, body_id), .. })) =
1125             node
1126         {
1127             let body = hir.body(*body_id);
1128             // Point at all the `return`s in the function as they have failed trait bounds.
1129             let mut visitor = ReturnsVisitor::default();
1130             visitor.visit_body(&body);
1131             let typeck_results = self.in_progress_typeck_results.map(|t| t.borrow()).unwrap();
1132             for expr in &visitor.returns {
1133                 if let Some(returned_ty) = typeck_results.node_type_opt(expr.hir_id) {
1134                     let ty = self.resolve_vars_if_possible(&returned_ty);
1135                     err.span_label(expr.span, &format!("this returned value is of type `{}`", ty));
1136                 }
1137             }
1138         }
1139     }
1140
1141     fn report_closure_arg_mismatch(
1142         &self,
1143         span: Span,
1144         found_span: Option<Span>,
1145         expected_ref: ty::PolyTraitRef<'tcx>,
1146         found: ty::PolyTraitRef<'tcx>,
1147     ) -> DiagnosticBuilder<'tcx> {
1148         crate fn build_fn_sig_string<'tcx>(
1149             tcx: TyCtxt<'tcx>,
1150             trait_ref: ty::TraitRef<'tcx>,
1151         ) -> String {
1152             let inputs = trait_ref.substs.type_at(1);
1153             let sig = if let ty::Tuple(inputs) = inputs.kind {
1154                 tcx.mk_fn_sig(
1155                     inputs.iter().map(|k| k.expect_ty()),
1156                     tcx.mk_ty_infer(ty::TyVar(ty::TyVid { index: 0 })),
1157                     false,
1158                     hir::Unsafety::Normal,
1159                     ::rustc_target::spec::abi::Abi::Rust,
1160                 )
1161             } else {
1162                 tcx.mk_fn_sig(
1163                     ::std::iter::once(inputs),
1164                     tcx.mk_ty_infer(ty::TyVar(ty::TyVid { index: 0 })),
1165                     false,
1166                     hir::Unsafety::Normal,
1167                     ::rustc_target::spec::abi::Abi::Rust,
1168                 )
1169             };
1170             ty::Binder::bind(sig).to_string()
1171         }
1172
1173         let argument_is_closure = expected_ref.skip_binder().substs.type_at(0).is_closure();
1174         let mut err = struct_span_err!(
1175             self.tcx.sess,
1176             span,
1177             E0631,
1178             "type mismatch in {} arguments",
1179             if argument_is_closure { "closure" } else { "function" }
1180         );
1181
1182         let found_str = format!(
1183             "expected signature of `{}`",
1184             build_fn_sig_string(self.tcx, found.skip_binder())
1185         );
1186         err.span_label(span, found_str);
1187
1188         let found_span = found_span.unwrap_or(span);
1189         let expected_str = format!(
1190             "found signature of `{}`",
1191             build_fn_sig_string(self.tcx, expected_ref.skip_binder())
1192         );
1193         err.span_label(found_span, expected_str);
1194
1195         err
1196     }
1197
1198     fn suggest_fully_qualified_path(
1199         &self,
1200         err: &mut DiagnosticBuilder<'_>,
1201         def_id: DefId,
1202         span: Span,
1203         trait_ref: DefId,
1204     ) {
1205         if let Some(assoc_item) = self.tcx.opt_associated_item(def_id) {
1206             if let ty::AssocKind::Const | ty::AssocKind::Type = assoc_item.kind {
1207                 err.note(&format!(
1208                     "{}s cannot be accessed directly on a `trait`, they can only be \
1209                         accessed through a specific `impl`",
1210                     assoc_item.kind.as_def_kind().descr(def_id)
1211                 ));
1212                 err.span_suggestion(
1213                     span,
1214                     "use the fully qualified path to an implementation",
1215                     format!("<Type as {}>::{}", self.tcx.def_path_str(trait_ref), assoc_item.ident),
1216                     Applicability::HasPlaceholders,
1217                 );
1218             }
1219         }
1220     }
1221
1222     /// Adds an async-await specific note to the diagnostic when the future does not implement
1223     /// an auto trait because of a captured type.
1224     ///
1225     /// ```text
1226     /// note: future does not implement `Qux` as this value is used across an await
1227     ///   --> $DIR/issue-64130-3-other.rs:17:5
1228     ///    |
1229     /// LL |     let x = Foo;
1230     ///    |         - has type `Foo`
1231     /// LL |     baz().await;
1232     ///    |     ^^^^^^^^^^^ await occurs here, with `x` maybe used later
1233     /// LL | }
1234     ///    | - `x` is later dropped here
1235     /// ```
1236     ///
1237     /// When the diagnostic does not implement `Send` or `Sync` specifically, then the diagnostic
1238     /// is "replaced" with a different message and a more specific error.
1239     ///
1240     /// ```text
1241     /// error: future cannot be sent between threads safely
1242     ///   --> $DIR/issue-64130-2-send.rs:21:5
1243     ///    |
1244     /// LL | fn is_send<T: Send>(t: T) { }
1245     ///    |               ---- required by this bound in `is_send`
1246     /// ...
1247     /// LL |     is_send(bar());
1248     ///    |     ^^^^^^^ future returned by `bar` is not send
1249     ///    |
1250     ///    = help: within `impl std::future::Future`, the trait `std::marker::Send` is not
1251     ///            implemented for `Foo`
1252     /// note: future is not send as this value is used across an await
1253     ///   --> $DIR/issue-64130-2-send.rs:15:5
1254     ///    |
1255     /// LL |     let x = Foo;
1256     ///    |         - has type `Foo`
1257     /// LL |     baz().await;
1258     ///    |     ^^^^^^^^^^^ await occurs here, with `x` maybe used later
1259     /// LL | }
1260     ///    | - `x` is later dropped here
1261     /// ```
1262     ///
1263     /// Returns `true` if an async-await specific note was added to the diagnostic.
1264     fn maybe_note_obligation_cause_for_async_await(
1265         &self,
1266         err: &mut DiagnosticBuilder<'_>,
1267         obligation: &PredicateObligation<'tcx>,
1268     ) -> bool {
1269         debug!(
1270             "maybe_note_obligation_cause_for_async_await: obligation.predicate={:?} \
1271                 obligation.cause.span={:?}",
1272             obligation.predicate, obligation.cause.span
1273         );
1274         let hir = self.tcx.hir();
1275
1276         // Attempt to detect an async-await error by looking at the obligation causes, looking
1277         // for a generator to be present.
1278         //
1279         // When a future does not implement a trait because of a captured type in one of the
1280         // generators somewhere in the call stack, then the result is a chain of obligations.
1281         //
1282         // Given a `async fn` A that calls a `async fn` B which captures a non-send type and that
1283         // future is passed as an argument to a function C which requires a `Send` type, then the
1284         // chain looks something like this:
1285         //
1286         // - `BuiltinDerivedObligation` with a generator witness (B)
1287         // - `BuiltinDerivedObligation` with a generator (B)
1288         // - `BuiltinDerivedObligation` with `std::future::GenFuture` (B)
1289         // - `BuiltinDerivedObligation` with `impl std::future::Future` (B)
1290         // - `BuiltinDerivedObligation` with `impl std::future::Future` (B)
1291         // - `BuiltinDerivedObligation` with a generator witness (A)
1292         // - `BuiltinDerivedObligation` with a generator (A)
1293         // - `BuiltinDerivedObligation` with `std::future::GenFuture` (A)
1294         // - `BuiltinDerivedObligation` with `impl std::future::Future` (A)
1295         // - `BuiltinDerivedObligation` with `impl std::future::Future` (A)
1296         // - `BindingObligation` with `impl_send (Send requirement)
1297         //
1298         // The first obligation in the chain is the most useful and has the generator that captured
1299         // the type. The last generator (`outer_generator` below) has information about where the
1300         // bound was introduced. At least one generator should be present for this diagnostic to be
1301         // modified.
1302         let (mut trait_ref, mut target_ty) =
1303             match obligation.predicate.ignore_quantifiers().skip_binder().kind() {
1304                 ty::PredicateKind::Trait(p, _) => (Some(p.trait_ref), Some(p.self_ty())),
1305                 _ => (None, None),
1306             };
1307         let mut generator = None;
1308         let mut outer_generator = None;
1309         let mut next_code = Some(&obligation.cause.code);
1310         while let Some(code) = next_code {
1311             debug!("maybe_note_obligation_cause_for_async_await: code={:?}", code);
1312             match code {
1313                 ObligationCauseCode::DerivedObligation(derived_obligation)
1314                 | ObligationCauseCode::BuiltinDerivedObligation(derived_obligation)
1315                 | ObligationCauseCode::ImplDerivedObligation(derived_obligation) => {
1316                     let ty = derived_obligation.parent_trait_ref.skip_binder().self_ty();
1317                     debug!(
1318                         "maybe_note_obligation_cause_for_async_await: \
1319                             parent_trait_ref={:?} self_ty.kind={:?}",
1320                         derived_obligation.parent_trait_ref, ty.kind
1321                     );
1322
1323                     match ty.kind {
1324                         ty::Generator(did, ..) => {
1325                             generator = generator.or(Some(did));
1326                             outer_generator = Some(did);
1327                         }
1328                         ty::GeneratorWitness(..) => {}
1329                         _ if generator.is_none() => {
1330                             trait_ref = Some(derived_obligation.parent_trait_ref.skip_binder());
1331                             target_ty = Some(ty);
1332                         }
1333                         _ => {}
1334                     }
1335
1336                     next_code = Some(derived_obligation.parent_code.as_ref());
1337                 }
1338                 _ => break,
1339             }
1340         }
1341
1342         // Only continue if a generator was found.
1343         debug!(
1344             "maybe_note_obligation_cause_for_async_await: generator={:?} trait_ref={:?} \
1345                 target_ty={:?}",
1346             generator, trait_ref, target_ty
1347         );
1348         let (generator_did, trait_ref, target_ty) = match (generator, trait_ref, target_ty) {
1349             (Some(generator_did), Some(trait_ref), Some(target_ty)) => {
1350                 (generator_did, trait_ref, target_ty)
1351             }
1352             _ => return false,
1353         };
1354
1355         let span = self.tcx.def_span(generator_did);
1356
1357         // Do not ICE on closure typeck (#66868).
1358         if !generator_did.is_local() {
1359             return false;
1360         }
1361
1362         // Get the typeck results from the infcx if the generator is the function we are
1363         // currently type-checking; otherwise, get them by performing a query.
1364         // This is needed to avoid cycles.
1365         let in_progress_typeck_results = self.in_progress_typeck_results.map(|t| t.borrow());
1366         let generator_did_root = self.tcx.closure_base_def_id(generator_did);
1367         debug!(
1368             "maybe_note_obligation_cause_for_async_await: generator_did={:?} \
1369              generator_did_root={:?} in_progress_typeck_results.hir_owner={:?} span={:?}",
1370             generator_did,
1371             generator_did_root,
1372             in_progress_typeck_results.as_ref().map(|t| t.hir_owner),
1373             span
1374         );
1375         let query_typeck_results;
1376         let typeck_results: &TypeckResults<'tcx> = match &in_progress_typeck_results {
1377             Some(t) if t.hir_owner.to_def_id() == generator_did_root => t,
1378             _ => {
1379                 query_typeck_results = self.tcx.typeck(generator_did.expect_local());
1380                 &query_typeck_results
1381             }
1382         };
1383
1384         let generator_body = generator_did
1385             .as_local()
1386             .map(|def_id| hir.as_local_hir_id(def_id))
1387             .and_then(|hir_id| hir.maybe_body_owned_by(hir_id))
1388             .map(|body_id| hir.body(body_id));
1389         let mut visitor = AwaitsVisitor::default();
1390         if let Some(body) = generator_body {
1391             visitor.visit_body(body);
1392         }
1393         debug!("maybe_note_obligation_cause_for_async_await: awaits = {:?}", visitor.awaits);
1394
1395         // Look for a type inside the generator interior that matches the target type to get
1396         // a span.
1397         let target_ty_erased = self.tcx.erase_regions(&target_ty);
1398         let ty_matches = |ty| -> bool {
1399             // Careful: the regions for types that appear in the
1400             // generator interior are not generally known, so we
1401             // want to erase them when comparing (and anyway,
1402             // `Send` and other bounds are generally unaffected by
1403             // the choice of region).  When erasing regions, we
1404             // also have to erase late-bound regions. This is
1405             // because the types that appear in the generator
1406             // interior generally contain "bound regions" to
1407             // represent regions that are part of the suspended
1408             // generator frame. Bound regions are preserved by
1409             // `erase_regions` and so we must also call
1410             // `erase_late_bound_regions`.
1411             let ty_erased = self.tcx.erase_late_bound_regions(&ty::Binder::bind(ty));
1412             let ty_erased = self.tcx.erase_regions(&ty_erased);
1413             let eq = ty::TyS::same_type(ty_erased, target_ty_erased);
1414             debug!(
1415                 "maybe_note_obligation_cause_for_async_await: ty_erased={:?} \
1416                     target_ty_erased={:?} eq={:?}",
1417                 ty_erased, target_ty_erased, eq
1418             );
1419             eq
1420         };
1421
1422         let mut interior_or_upvar_span = None;
1423         let mut interior_extra_info = None;
1424
1425         if let Some(upvars) = self.tcx.upvars_mentioned(generator_did) {
1426             interior_or_upvar_span = upvars.iter().find_map(|(upvar_id, upvar)| {
1427                 let upvar_ty = typeck_results.node_type(*upvar_id);
1428                 let upvar_ty = self.resolve_vars_if_possible(&upvar_ty);
1429                 if ty_matches(&upvar_ty) {
1430                     Some(GeneratorInteriorOrUpvar::Upvar(upvar.span))
1431                 } else {
1432                     None
1433                 }
1434             });
1435         };
1436
1437         typeck_results
1438             .generator_interior_types
1439             .iter()
1440             .find(|ty::GeneratorInteriorTypeCause { ty, .. }| ty_matches(ty))
1441             .map(|cause| {
1442                 // Check to see if any awaited expressions have the target type.
1443                 let from_awaited_ty = visitor
1444                     .awaits
1445                     .into_iter()
1446                     .map(|id| hir.expect_expr(id))
1447                     .find(|await_expr| {
1448                         let ty = typeck_results.expr_ty_adjusted(&await_expr);
1449                         debug!(
1450                             "maybe_note_obligation_cause_for_async_await: await_expr={:?}",
1451                             await_expr
1452                         );
1453                         ty_matches(ty)
1454                     })
1455                     .map(|expr| expr.span);
1456                 let ty::GeneratorInteriorTypeCause { span, scope_span, yield_span, expr, .. } =
1457                     cause;
1458
1459                 interior_or_upvar_span = Some(GeneratorInteriorOrUpvar::Interior(*span));
1460                 interior_extra_info = Some((*scope_span, *yield_span, *expr, from_awaited_ty));
1461             });
1462
1463         debug!(
1464             "maybe_note_obligation_cause_for_async_await: interior_or_upvar={:?} \
1465                 generator_interior_types={:?}",
1466             interior_or_upvar_span, typeck_results.generator_interior_types
1467         );
1468         if let Some(interior_or_upvar_span) = interior_or_upvar_span {
1469             self.note_obligation_cause_for_async_await(
1470                 err,
1471                 interior_or_upvar_span,
1472                 interior_extra_info,
1473                 generator_body,
1474                 outer_generator,
1475                 trait_ref,
1476                 target_ty,
1477                 typeck_results,
1478                 obligation,
1479                 next_code,
1480             );
1481             true
1482         } else {
1483             false
1484         }
1485     }
1486
1487     /// Unconditionally adds the diagnostic note described in
1488     /// `maybe_note_obligation_cause_for_async_await`'s documentation comment.
1489     fn note_obligation_cause_for_async_await(
1490         &self,
1491         err: &mut DiagnosticBuilder<'_>,
1492         interior_or_upvar_span: GeneratorInteriorOrUpvar,
1493         interior_extra_info: Option<(Option<Span>, Span, Option<hir::HirId>, Option<Span>)>,
1494         inner_generator_body: Option<&hir::Body<'tcx>>,
1495         outer_generator: Option<DefId>,
1496         trait_ref: ty::TraitRef<'tcx>,
1497         target_ty: Ty<'tcx>,
1498         typeck_results: &ty::TypeckResults<'tcx>,
1499         obligation: &PredicateObligation<'tcx>,
1500         next_code: Option<&ObligationCauseCode<'tcx>>,
1501     ) {
1502         let source_map = self.tcx.sess.source_map();
1503
1504         let is_async = inner_generator_body
1505             .and_then(|body| body.generator_kind())
1506             .map(|generator_kind| matches!(generator_kind, hir::GeneratorKind::Async(..)))
1507             .unwrap_or(false);
1508         let (await_or_yield, an_await_or_yield) =
1509             if is_async { ("await", "an await") } else { ("yield", "a yield") };
1510         let future_or_generator = if is_async { "future" } else { "generator" };
1511
1512         // Special case the primary error message when send or sync is the trait that was
1513         // not implemented.
1514         let is_send = self.tcx.is_diagnostic_item(sym::send_trait, trait_ref.def_id);
1515         let is_sync = self.tcx.is_diagnostic_item(sym::sync_trait, trait_ref.def_id);
1516         let hir = self.tcx.hir();
1517         let trait_explanation = if is_send || is_sync {
1518             let (trait_name, trait_verb) =
1519                 if is_send { ("`Send`", "sent") } else { ("`Sync`", "shared") };
1520
1521             err.clear_code();
1522             err.set_primary_message(format!(
1523                 "{} cannot be {} between threads safely",
1524                 future_or_generator, trait_verb
1525             ));
1526
1527             let original_span = err.span.primary_span().unwrap();
1528             let mut span = MultiSpan::from_span(original_span);
1529
1530             let message = outer_generator
1531                 .and_then(|generator_did| {
1532                     Some(match self.tcx.generator_kind(generator_did).unwrap() {
1533                         GeneratorKind::Gen => format!("generator is not {}", trait_name),
1534                         GeneratorKind::Async(AsyncGeneratorKind::Fn) => self
1535                             .tcx
1536                             .parent(generator_did)
1537                             .and_then(|parent_did| parent_did.as_local())
1538                             .map(|parent_did| hir.as_local_hir_id(parent_did))
1539                             .and_then(|parent_hir_id| hir.opt_name(parent_hir_id))
1540                             .map(|name| {
1541                                 format!("future returned by `{}` is not {}", name, trait_name)
1542                             })?,
1543                         GeneratorKind::Async(AsyncGeneratorKind::Block) => {
1544                             format!("future created by async block is not {}", trait_name)
1545                         }
1546                         GeneratorKind::Async(AsyncGeneratorKind::Closure) => {
1547                             format!("future created by async closure is not {}", trait_name)
1548                         }
1549                     })
1550                 })
1551                 .unwrap_or_else(|| format!("{} is not {}", future_or_generator, trait_name));
1552
1553             span.push_span_label(original_span, message);
1554             err.set_span(span);
1555
1556             format!("is not {}", trait_name)
1557         } else {
1558             format!("does not implement `{}`", trait_ref.print_only_trait_path())
1559         };
1560
1561         let mut explain_yield = |interior_span: Span,
1562                                  yield_span: Span,
1563                                  scope_span: Option<Span>| {
1564             let mut span = MultiSpan::from_span(yield_span);
1565             if let Ok(snippet) = source_map.span_to_snippet(interior_span) {
1566                 span.push_span_label(
1567                     yield_span,
1568                     format!("{} occurs here, with `{}` maybe used later", await_or_yield, snippet),
1569                 );
1570                 // If available, use the scope span to annotate the drop location.
1571                 if let Some(scope_span) = scope_span {
1572                     span.push_span_label(
1573                         source_map.end_point(scope_span),
1574                         format!("`{}` is later dropped here", snippet),
1575                     );
1576                 }
1577             }
1578             span.push_span_label(
1579                 interior_span,
1580                 format!("has type `{}` which {}", target_ty, trait_explanation),
1581             );
1582
1583             err.span_note(
1584                 span,
1585                 &format!(
1586                     "{} {} as this value is used across {}",
1587                     future_or_generator, trait_explanation, an_await_or_yield
1588                 ),
1589             );
1590         };
1591         match interior_or_upvar_span {
1592             GeneratorInteriorOrUpvar::Interior(interior_span) => {
1593                 if let Some((scope_span, yield_span, expr, from_awaited_ty)) = interior_extra_info {
1594                     if let Some(await_span) = from_awaited_ty {
1595                         // The type causing this obligation is one being awaited at await_span.
1596                         let mut span = MultiSpan::from_span(await_span);
1597                         span.push_span_label(
1598                             await_span,
1599                             format!(
1600                                 "await occurs here on type `{}`, which {}",
1601                                 target_ty, trait_explanation
1602                             ),
1603                         );
1604                         err.span_note(
1605                             span,
1606                             &format!(
1607                                 "future {not_trait} as it awaits another future which {not_trait}",
1608                                 not_trait = trait_explanation
1609                             ),
1610                         );
1611                     } else {
1612                         // Look at the last interior type to get a span for the `.await`.
1613                         debug!(
1614                             "note_obligation_cause_for_async_await generator_interior_types: {:#?}",
1615                             typeck_results.generator_interior_types
1616                         );
1617                         explain_yield(interior_span, yield_span, scope_span);
1618                     }
1619
1620                     if let Some(expr_id) = expr {
1621                         let expr = hir.expect_expr(expr_id);
1622                         debug!("target_ty evaluated from {:?}", expr);
1623
1624                         let parent = hir.get_parent_node(expr_id);
1625                         if let Some(hir::Node::Expr(e)) = hir.find(parent) {
1626                             let parent_span = hir.span(parent);
1627                             let parent_did = parent.owner.to_def_id();
1628                             // ```rust
1629                             // impl T {
1630                             //     fn foo(&self) -> i32 {}
1631                             // }
1632                             // T.foo();
1633                             // ^^^^^^^ a temporary `&T` created inside this method call due to `&self`
1634                             // ```
1635                             //
1636                             let is_region_borrow = typeck_results
1637                                 .expr_adjustments(expr)
1638                                 .iter()
1639                                 .any(|adj| adj.is_region_borrow());
1640
1641                             // ```rust
1642                             // struct Foo(*const u8);
1643                             // bar(Foo(std::ptr::null())).await;
1644                             //     ^^^^^^^^^^^^^^^^^^^^^ raw-ptr `*T` created inside this struct ctor.
1645                             // ```
1646                             debug!("parent_def_kind: {:?}", self.tcx.def_kind(parent_did));
1647                             let is_raw_borrow_inside_fn_like_call =
1648                                 match self.tcx.def_kind(parent_did) {
1649                                     DefKind::Fn | DefKind::Ctor(..) => target_ty.is_unsafe_ptr(),
1650                                     _ => false,
1651                                 };
1652
1653                             if (typeck_results.is_method_call(e) && is_region_borrow)
1654                                 || is_raw_borrow_inside_fn_like_call
1655                             {
1656                                 err.span_help(
1657                                     parent_span,
1658                                     "consider moving this into a `let` \
1659                         binding to create a shorter lived borrow",
1660                                 );
1661                             }
1662                         }
1663                     }
1664                 }
1665             }
1666             GeneratorInteriorOrUpvar::Upvar(upvar_span) => {
1667                 let mut span = MultiSpan::from_span(upvar_span);
1668                 span.push_span_label(
1669                     upvar_span,
1670                     format!("has type `{}` which {}", target_ty, trait_explanation),
1671                 );
1672                 err.span_note(span, &format!("captured value {}", trait_explanation));
1673             }
1674         }
1675
1676         // Add a note for the item obligation that remains - normally a note pointing to the
1677         // bound that introduced the obligation (e.g. `T: Send`).
1678         debug!("note_obligation_cause_for_async_await: next_code={:?}", next_code);
1679         self.note_obligation_cause_code(
1680             err,
1681             &obligation.predicate,
1682             next_code.unwrap(),
1683             &mut Vec::new(),
1684         );
1685     }
1686
1687     fn note_obligation_cause_code<T>(
1688         &self,
1689         err: &mut DiagnosticBuilder<'_>,
1690         predicate: &T,
1691         cause_code: &ObligationCauseCode<'tcx>,
1692         obligated_types: &mut Vec<&ty::TyS<'tcx>>,
1693     ) where
1694         T: fmt::Display,
1695     {
1696         let tcx = self.tcx;
1697         match *cause_code {
1698             ObligationCauseCode::ExprAssignable
1699             | ObligationCauseCode::MatchExpressionArm { .. }
1700             | ObligationCauseCode::Pattern { .. }
1701             | ObligationCauseCode::IfExpression { .. }
1702             | ObligationCauseCode::IfExpressionWithNoElse
1703             | ObligationCauseCode::MainFunctionType
1704             | ObligationCauseCode::StartFunctionType
1705             | ObligationCauseCode::IntrinsicType
1706             | ObligationCauseCode::MethodReceiver
1707             | ObligationCauseCode::ReturnNoExpression
1708             | ObligationCauseCode::UnifyReceiver(..)
1709             | ObligationCauseCode::MiscObligation => {}
1710             ObligationCauseCode::SliceOrArrayElem => {
1711                 err.note("slice and array elements must have `Sized` type");
1712             }
1713             ObligationCauseCode::TupleElem => {
1714                 err.note("only the last element of a tuple may have a dynamically sized type");
1715             }
1716             ObligationCauseCode::ProjectionWf(data) => {
1717                 err.note(&format!("required so that the projection `{}` is well-formed", data,));
1718             }
1719             ObligationCauseCode::ReferenceOutlivesReferent(ref_ty) => {
1720                 err.note(&format!(
1721                     "required so that reference `{}` does not outlive its referent",
1722                     ref_ty,
1723                 ));
1724             }
1725             ObligationCauseCode::ObjectTypeBound(object_ty, region) => {
1726                 err.note(&format!(
1727                     "required so that the lifetime bound of `{}` for `{}` is satisfied",
1728                     region, object_ty,
1729                 ));
1730             }
1731             ObligationCauseCode::ItemObligation(item_def_id) => {
1732                 let item_name = tcx.def_path_str(item_def_id);
1733                 let msg = format!("required by `{}`", item_name);
1734                 if let Some(sp) = tcx.hir().span_if_local(item_def_id) {
1735                     let sp = tcx.sess.source_map().guess_head_span(sp);
1736                     err.span_label(sp, &msg);
1737                 } else {
1738                     err.note(&msg);
1739                 }
1740             }
1741             ObligationCauseCode::BindingObligation(item_def_id, span) => {
1742                 let item_name = tcx.def_path_str(item_def_id);
1743                 let msg = format!("required by this bound in `{}`", item_name);
1744                 if let Some(ident) = tcx.opt_item_name(item_def_id) {
1745                     let sm = tcx.sess.source_map();
1746                     let same_line =
1747                         match (sm.lookup_line(ident.span.hi()), sm.lookup_line(span.lo())) {
1748                             (Ok(l), Ok(r)) => l.line == r.line,
1749                             _ => true,
1750                         };
1751                     if !ident.span.overlaps(span) && !same_line {
1752                         err.span_label(ident.span, "required by a bound in this");
1753                     }
1754                 }
1755                 if span != DUMMY_SP {
1756                     err.span_label(span, &msg);
1757                 } else {
1758                     err.note(&msg);
1759                 }
1760             }
1761             ObligationCauseCode::ObjectCastObligation(object_ty) => {
1762                 err.note(&format!(
1763                     "required for the cast to the object type `{}`",
1764                     self.ty_to_string(object_ty)
1765                 ));
1766             }
1767             ObligationCauseCode::Coercion { source: _, target } => {
1768                 err.note(&format!("required by cast to type `{}`", self.ty_to_string(target)));
1769             }
1770             ObligationCauseCode::RepeatVec(suggest_const_in_array_repeat_expressions) => {
1771                 err.note(
1772                     "the `Copy` trait is required because the repeated element will be copied",
1773                 );
1774                 if suggest_const_in_array_repeat_expressions {
1775                     err.note(
1776                         "this array initializer can be evaluated at compile-time, see issue \
1777                          #49147 <https://github.com/rust-lang/rust/issues/49147> \
1778                          for more information",
1779                     );
1780                     if tcx.sess.opts.unstable_features.is_nightly_build() {
1781                         err.help(
1782                             "add `#![feature(const_in_array_repeat_expressions)]` to the \
1783                              crate attributes to enable",
1784                         );
1785                     }
1786                 }
1787             }
1788             ObligationCauseCode::VariableType(hir_id) => {
1789                 let parent_node = self.tcx.hir().get_parent_node(hir_id);
1790                 match self.tcx.hir().find(parent_node) {
1791                     Some(Node::Local(hir::Local {
1792                         init: Some(hir::Expr { kind: hir::ExprKind::Index(_, _), span, .. }),
1793                         ..
1794                     })) => {
1795                         // When encountering an assignment of an unsized trait, like
1796                         // `let x = ""[..];`, provide a suggestion to borrow the initializer in
1797                         // order to use have a slice instead.
1798                         err.span_suggestion_verbose(
1799                             span.shrink_to_lo(),
1800                             "consider borrowing here",
1801                             "&".to_owned(),
1802                             Applicability::MachineApplicable,
1803                         );
1804                         err.note("all local variables must have a statically known size");
1805                     }
1806                     Some(Node::Param(param)) => {
1807                         err.span_suggestion_verbose(
1808                             param.ty_span.shrink_to_lo(),
1809                             "function arguments must have a statically known size, borrowed types \
1810                             always have a known size",
1811                             "&".to_owned(),
1812                             Applicability::MachineApplicable,
1813                         );
1814                     }
1815                     _ => {
1816                         err.note("all local variables must have a statically known size");
1817                     }
1818                 }
1819                 if !self.tcx.features().unsized_locals {
1820                     err.help("unsized locals are gated as an unstable feature");
1821                 }
1822             }
1823             ObligationCauseCode::SizedArgumentType(sp) => {
1824                 if let Some(span) = sp {
1825                     err.span_suggestion_verbose(
1826                         span.shrink_to_lo(),
1827                         "function arguments must have a statically known size, borrowed types \
1828                          always have a known size",
1829                         "&".to_string(),
1830                         Applicability::MachineApplicable,
1831                     );
1832                 } else {
1833                     err.note("all function arguments must have a statically known size");
1834                 }
1835                 if tcx.sess.opts.unstable_features.is_nightly_build()
1836                     && !self.tcx.features().unsized_locals
1837                 {
1838                     err.help("unsized locals are gated as an unstable feature");
1839                 }
1840             }
1841             ObligationCauseCode::SizedReturnType => {
1842                 err.note("the return type of a function must have a statically known size");
1843             }
1844             ObligationCauseCode::SizedYieldType => {
1845                 err.note("the yield type of a generator must have a statically known size");
1846             }
1847             ObligationCauseCode::AssignmentLhsSized => {
1848                 err.note("the left-hand-side of an assignment must have a statically known size");
1849             }
1850             ObligationCauseCode::TupleInitializerSized => {
1851                 err.note("tuples must have a statically known size to be initialized");
1852             }
1853             ObligationCauseCode::StructInitializerSized => {
1854                 err.note("structs must have a statically known size to be initialized");
1855             }
1856             ObligationCauseCode::FieldSized { adt_kind: ref item, last, span } => {
1857                 match *item {
1858                     AdtKind::Struct => {
1859                         if last {
1860                             err.note(
1861                                 "the last field of a packed struct may only have a \
1862                                 dynamically sized type if it does not need drop to be run",
1863                             );
1864                         } else {
1865                             err.note(
1866                                 "only the last field of a struct may have a dynamically sized type",
1867                             );
1868                         }
1869                     }
1870                     AdtKind::Union => {
1871                         err.note("no field of a union may have a dynamically sized type");
1872                     }
1873                     AdtKind::Enum => {
1874                         err.note("no field of an enum variant may have a dynamically sized type");
1875                     }
1876                 }
1877                 err.help("change the field's type to have a statically known size");
1878                 err.span_suggestion(
1879                     span.shrink_to_lo(),
1880                     "borrowed types always have a statically known size",
1881                     "&".to_string(),
1882                     Applicability::MachineApplicable,
1883                 );
1884                 err.multipart_suggestion(
1885                     "the `Box` type always has a statically known size and allocates its contents \
1886                      in the heap",
1887                     vec![
1888                         (span.shrink_to_lo(), "Box<".to_string()),
1889                         (span.shrink_to_hi(), ">".to_string()),
1890                     ],
1891                     Applicability::MachineApplicable,
1892                 );
1893             }
1894             ObligationCauseCode::ConstSized => {
1895                 err.note("constant expressions must have a statically known size");
1896             }
1897             ObligationCauseCode::InlineAsmSized => {
1898                 err.note("all inline asm arguments must have a statically known size");
1899             }
1900             ObligationCauseCode::ConstPatternStructural => {
1901                 err.note("constants used for pattern-matching must derive `PartialEq` and `Eq`");
1902             }
1903             ObligationCauseCode::SharedStatic => {
1904                 err.note("shared static variables must have a type that implements `Sync`");
1905             }
1906             ObligationCauseCode::BuiltinDerivedObligation(ref data) => {
1907                 let parent_trait_ref = self.resolve_vars_if_possible(&data.parent_trait_ref);
1908                 let ty = parent_trait_ref.skip_binder().self_ty();
1909                 err.note(&format!("required because it appears within the type `{}`", ty));
1910                 obligated_types.push(ty);
1911
1912                 let parent_predicate = parent_trait_ref.without_const().to_predicate(tcx);
1913                 if !self.is_recursive_obligation(obligated_types, &data.parent_code) {
1914                     self.note_obligation_cause_code(
1915                         err,
1916                         &parent_predicate,
1917                         &data.parent_code,
1918                         obligated_types,
1919                     );
1920                 }
1921             }
1922             ObligationCauseCode::ImplDerivedObligation(ref data) => {
1923                 let parent_trait_ref = self.resolve_vars_if_possible(&data.parent_trait_ref);
1924                 err.note(&format!(
1925                     "required because of the requirements on the impl of `{}` for `{}`",
1926                     parent_trait_ref.print_only_trait_path(),
1927                     parent_trait_ref.skip_binder().self_ty()
1928                 ));
1929                 let parent_predicate = parent_trait_ref.without_const().to_predicate(tcx);
1930                 self.note_obligation_cause_code(
1931                     err,
1932                     &parent_predicate,
1933                     &data.parent_code,
1934                     obligated_types,
1935                 );
1936             }
1937             ObligationCauseCode::DerivedObligation(ref data) => {
1938                 let parent_trait_ref = self.resolve_vars_if_possible(&data.parent_trait_ref);
1939                 let parent_predicate = parent_trait_ref.without_const().to_predicate(tcx);
1940                 self.note_obligation_cause_code(
1941                     err,
1942                     &parent_predicate,
1943                     &data.parent_code,
1944                     obligated_types,
1945                 );
1946             }
1947             ObligationCauseCode::CompareImplMethodObligation { .. } => {
1948                 err.note(&format!(
1949                     "the requirement `{}` appears on the impl method \
1950                      but not on the corresponding trait method",
1951                     predicate
1952                 ));
1953             }
1954             ObligationCauseCode::CompareImplTypeObligation { .. } => {
1955                 err.note(&format!(
1956                     "the requirement `{}` appears on the associated impl type \
1957                      but not on the corresponding associated trait type",
1958                     predicate
1959                 ));
1960             }
1961             ObligationCauseCode::CompareImplConstObligation => {
1962                 err.note(&format!(
1963                     "the requirement `{}` appears on the associated impl constant \
1964                      but not on the corresponding associated trait constant",
1965                     predicate
1966                 ));
1967             }
1968             ObligationCauseCode::ReturnType
1969             | ObligationCauseCode::ReturnValue(_)
1970             | ObligationCauseCode::BlockTailExpression(_) => (),
1971             ObligationCauseCode::TrivialBound => {
1972                 err.help("see issue #48214");
1973                 if tcx.sess.opts.unstable_features.is_nightly_build() {
1974                     err.help("add `#![feature(trivial_bounds)]` to the crate attributes to enable");
1975                 }
1976             }
1977         }
1978     }
1979
1980     fn suggest_new_overflow_limit(&self, err: &mut DiagnosticBuilder<'_>) {
1981         let current_limit = self.tcx.sess.recursion_limit();
1982         let suggested_limit = current_limit * 2;
1983         err.help(&format!(
1984             "consider adding a `#![recursion_limit=\"{}\"]` attribute to your crate (`{}`)",
1985             suggested_limit, self.tcx.crate_name,
1986         ));
1987     }
1988
1989     fn suggest_await_before_try(
1990         &self,
1991         err: &mut DiagnosticBuilder<'_>,
1992         obligation: &PredicateObligation<'tcx>,
1993         trait_ref: &ty::Binder<ty::TraitRef<'tcx>>,
1994         span: Span,
1995     ) {
1996         debug!(
1997             "suggest_await_before_try: obligation={:?}, span={:?}, trait_ref={:?}, trait_ref_self_ty={:?}",
1998             obligation,
1999             span,
2000             trait_ref,
2001             trait_ref.self_ty()
2002         );
2003         let body_hir_id = obligation.cause.body_id;
2004         let item_id = self.tcx.hir().get_parent_node(body_hir_id);
2005
2006         if let Some(body_id) = self.tcx.hir().maybe_body_owned_by(item_id) {
2007             let body = self.tcx.hir().body(body_id);
2008             if let Some(hir::GeneratorKind::Async(_)) = body.generator_kind {
2009                 let future_trait =
2010                     self.tcx.require_lang_item(lang_items::FutureTraitLangItem, None);
2011
2012                 let self_ty = self.resolve_vars_if_possible(&trait_ref.self_ty());
2013
2014                 // Do not check on infer_types to avoid panic in evaluate_obligation.
2015                 if self_ty.has_infer_types() {
2016                     return;
2017                 }
2018                 let self_ty = self.tcx.erase_regions(&self_ty);
2019
2020                 let impls_future = self.tcx.type_implements_trait((
2021                     future_trait,
2022                     self_ty.skip_binder(),
2023                     ty::List::empty(),
2024                     obligation.param_env,
2025                 ));
2026
2027                 let item_def_id = self
2028                     .tcx
2029                     .associated_items(future_trait)
2030                     .in_definition_order()
2031                     .next()
2032                     .unwrap()
2033                     .def_id;
2034                 // `<T as Future>::Output`
2035                 let projection_ty = ty::ProjectionTy {
2036                     // `T`
2037                     substs: self.tcx.mk_substs_trait(
2038                         trait_ref.self_ty().skip_binder(),
2039                         self.fresh_substs_for_item(span, item_def_id),
2040                     ),
2041                     // `Future::Output`
2042                     item_def_id,
2043                 };
2044
2045                 let mut selcx = SelectionContext::new(self);
2046
2047                 let mut obligations = vec![];
2048                 let normalized_ty = normalize_projection_type(
2049                     &mut selcx,
2050                     obligation.param_env,
2051                     projection_ty,
2052                     obligation.cause.clone(),
2053                     0,
2054                     &mut obligations,
2055                 );
2056
2057                 debug!(
2058                     "suggest_await_before_try: normalized_projection_type {:?}",
2059                     self.resolve_vars_if_possible(&normalized_ty)
2060                 );
2061                 let try_obligation = self.mk_trait_obligation_with_new_self_ty(
2062                     obligation.param_env,
2063                     trait_ref,
2064                     normalized_ty,
2065                 );
2066                 debug!("suggest_await_before_try: try_trait_obligation {:?}", try_obligation);
2067                 if self.predicate_may_hold(&try_obligation) && impls_future {
2068                     if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
2069                         if snippet.ends_with('?') {
2070                             err.span_suggestion(
2071                                 span,
2072                                 "consider using `.await` here",
2073                                 format!("{}.await?", snippet.trim_end_matches('?')),
2074                                 Applicability::MaybeIncorrect,
2075                             );
2076                         }
2077                     }
2078                 }
2079             }
2080         }
2081     }
2082 }
2083
2084 /// Collect all the returned expressions within the input expression.
2085 /// Used to point at the return spans when we want to suggest some change to them.
2086 #[derive(Default)]
2087 pub struct ReturnsVisitor<'v> {
2088     pub returns: Vec<&'v hir::Expr<'v>>,
2089     in_block_tail: bool,
2090 }
2091
2092 impl<'v> Visitor<'v> for ReturnsVisitor<'v> {
2093     type Map = hir::intravisit::ErasedMap<'v>;
2094
2095     fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
2096         hir::intravisit::NestedVisitorMap::None
2097     }
2098
2099     fn visit_expr(&mut self, ex: &'v hir::Expr<'v>) {
2100         // Visit every expression to detect `return` paths, either through the function's tail
2101         // expression or `return` statements. We walk all nodes to find `return` statements, but
2102         // we only care about tail expressions when `in_block_tail` is `true`, which means that
2103         // they're in the return path of the function body.
2104         match ex.kind {
2105             hir::ExprKind::Ret(Some(ex)) => {
2106                 self.returns.push(ex);
2107             }
2108             hir::ExprKind::Block(block, _) if self.in_block_tail => {
2109                 self.in_block_tail = false;
2110                 for stmt in block.stmts {
2111                     hir::intravisit::walk_stmt(self, stmt);
2112                 }
2113                 self.in_block_tail = true;
2114                 if let Some(expr) = block.expr {
2115                     self.visit_expr(expr);
2116                 }
2117             }
2118             hir::ExprKind::Match(_, arms, _) if self.in_block_tail => {
2119                 for arm in arms {
2120                     self.visit_expr(arm.body);
2121                 }
2122             }
2123             // We need to walk to find `return`s in the entire body.
2124             _ if !self.in_block_tail => hir::intravisit::walk_expr(self, ex),
2125             _ => self.returns.push(ex),
2126         }
2127     }
2128
2129     fn visit_body(&mut self, body: &'v hir::Body<'v>) {
2130         assert!(!self.in_block_tail);
2131         if body.generator_kind().is_none() {
2132             if let hir::ExprKind::Block(block, None) = body.value.kind {
2133                 if block.expr.is_some() {
2134                     self.in_block_tail = true;
2135                 }
2136             }
2137         }
2138         hir::intravisit::walk_body(self, body);
2139     }
2140 }
2141
2142 /// Collect all the awaited expressions within the input expression.
2143 #[derive(Default)]
2144 struct AwaitsVisitor {
2145     awaits: Vec<hir::HirId>,
2146 }
2147
2148 impl<'v> Visitor<'v> for AwaitsVisitor {
2149     type Map = hir::intravisit::ErasedMap<'v>;
2150
2151     fn nested_visit_map(&mut self) -> hir::intravisit::NestedVisitorMap<Self::Map> {
2152         hir::intravisit::NestedVisitorMap::None
2153     }
2154
2155     fn visit_expr(&mut self, ex: &'v hir::Expr<'v>) {
2156         if let hir::ExprKind::Yield(_, hir::YieldSource::Await { expr: Some(id) }) = ex.kind {
2157             self.awaits.push(id)
2158         }
2159         hir::intravisit::walk_expr(self, ex)
2160     }
2161 }
2162
2163 pub trait NextTypeParamName {
2164     fn next_type_param_name(&self, name: Option<&str>) -> String;
2165 }
2166
2167 impl NextTypeParamName for &[hir::GenericParam<'_>] {
2168     fn next_type_param_name(&self, name: Option<&str>) -> String {
2169         // This is the list of possible parameter names that we might suggest.
2170         let name = name.and_then(|n| n.chars().next()).map(|c| c.to_string().to_uppercase());
2171         let name = name.as_deref();
2172         let possible_names = [name.unwrap_or("T"), "T", "U", "V", "X", "Y", "Z", "A", "B", "C"];
2173         let used_names = self
2174             .iter()
2175             .filter_map(|p| match p.name {
2176                 hir::ParamName::Plain(ident) => Some(ident.name),
2177                 _ => None,
2178             })
2179             .collect::<Vec<_>>();
2180
2181         possible_names
2182             .iter()
2183             .find(|n| !used_names.contains(&Symbol::intern(n)))
2184             .unwrap_or(&"ParamName")
2185             .to_string()
2186     }
2187 }
2188
2189 fn suggest_trait_object_return_type_alternatives(
2190     err: &mut DiagnosticBuilder<'_>,
2191     ret_ty: Span,
2192     trait_obj: &str,
2193     is_object_safe: bool,
2194 ) {
2195     err.span_suggestion(
2196         ret_ty,
2197         "use some type `T` that is `T: Sized` as the return type if all return paths have the \
2198             same type",
2199         "T".to_string(),
2200         Applicability::MaybeIncorrect,
2201     );
2202     err.span_suggestion(
2203         ret_ty,
2204         &format!(
2205             "use `impl {}` as the return type if all return paths have the same type but you \
2206                 want to expose only the trait in the signature",
2207             trait_obj,
2208         ),
2209         format!("impl {}", trait_obj),
2210         Applicability::MaybeIncorrect,
2211     );
2212     if is_object_safe {
2213         err.span_suggestion(
2214             ret_ty,
2215             &format!(
2216                 "use a boxed trait object if all return paths implement trait `{}`",
2217                 trait_obj,
2218             ),
2219             format!("Box<dyn {}>", trait_obj),
2220             Applicability::MaybeIncorrect,
2221         );
2222     }
2223 }