compiler/rustc_typeck/src/check/fn_ctxt/suggestions.rs

   1 use super::FnCtxt;
   2 use crate::astconv::AstConv;
   3
   4 use rustc_ast::util::parser::ExprPrecedence;
   5 use rustc_span::{self, MultiSpan, Span};
   6
   7 use rustc_errors::{Applicability, DiagnosticBuilder};
   8 use rustc_hir as hir;
   9 use rustc_hir::def::{CtorOf, DefKind};
  10 use rustc_hir::lang_items::LangItem;
  11 use rustc_hir::{Expr, ExprKind, ItemKind, Node, Stmt, StmtKind};
  12 use rustc_infer::infer;
  13 use rustc_middle::lint::in_external_macro;
  14 use rustc_middle::ty::{self, Binder, Ty};
  15 use rustc_span::symbol::kw;
  16
  17 use std::iter;
  18
  19 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  20     pub(in super::super) fn suggest_semicolon_at_end(
  21         &self,
  22         span: Span,
  23         err: &mut DiagnosticBuilder<'_>,
  24     ) {
  25         err.span_suggestion_short(
  26             span.shrink_to_hi(),
  27             "consider using a semicolon here",
  28             ";".to_string(),
  29             Applicability::MachineApplicable,
  30         );
  31     }
  32
  33     /// On implicit return expressions with mismatched types, provides the following suggestions:
  34     ///
  35     /// - Points out the method's return type as the reason for the expected type.
  36     /// - Possible missing semicolon.
  37     /// - Possible missing return type if the return type is the default, and not `fn main()`.
  38     pub fn suggest_mismatched_types_on_tail(
  39         &self,
  40         err: &mut DiagnosticBuilder<'_>,
  41         expr: &'tcx hir::Expr<'tcx>,
  42         expected: Ty<'tcx>,
  43         found: Ty<'tcx>,
  44         blk_id: hir::HirId,
  45     ) -> bool {
  46         let expr = expr.peel_drop_temps();
  47         // If the expression is from an external macro, then do not suggest
  48         // adding a semicolon, because there's nowhere to put it.
  49         // See issue #81943.
  50         if expr.can_have_side_effects() && !in_external_macro(self.tcx.sess, expr.span) {
  51             self.suggest_missing_semicolon(err, expr, expected);
  52         }
  53         let mut pointing_at_return_type = false;
  54         if let Some((fn_decl, can_suggest)) = self.get_fn_decl(blk_id) {
  55             let fn_id = self.tcx.hir().get_return_block(blk_id).unwrap();
  56             pointing_at_return_type = self.suggest_missing_return_type(
  57                 err,
  58                 &fn_decl,
  59                 expected,
  60                 found,
  61                 can_suggest,
  62                 fn_id,
  63             );
  64             self.suggest_missing_break_or_return_expr(
  65                 err, expr, &fn_decl, expected, found, blk_id, fn_id,
  66             );
  67         }
  68         pointing_at_return_type
  69     }
  70
  71     /// When encountering an fn-like ctor that needs to unify with a value, check whether calling
  72     /// the ctor would successfully solve the type mismatch and if so, suggest it:
  73     /// ```
  74     /// fn foo(x: usize) -> usize { x }
  75     /// let x: usize = foo;  // suggest calling the `foo` function: `foo(42)`
  76     /// ```
  77     fn suggest_fn_call(
  78         &self,
  79         err: &mut DiagnosticBuilder<'_>,
  80         expr: &hir::Expr<'_>,
  81         expected: Ty<'tcx>,
  82         found: Ty<'tcx>,
  83     ) -> bool {
  84         let hir = self.tcx.hir();
  85         let (def_id, sig) = match *found.kind() {
  86             ty::FnDef(def_id, _) => (def_id, found.fn_sig(self.tcx)),
  87             ty::Closure(def_id, substs) => (def_id, substs.as_closure().sig()),
  88             _ => return false,
  89         };
  90
  91         let sig = self.replace_bound_vars_with_fresh_vars(expr.span, infer::FnCall, sig).0;
  92         let sig = self.normalize_associated_types_in(expr.span, sig);
  93         if self.can_coerce(sig.output(), expected) {
  94             let (mut sugg_call, applicability) = if sig.inputs().is_empty() {
  95                 (String::new(), Applicability::MachineApplicable)
  96             } else {
  97                 ("...".to_string(), Applicability::HasPlaceholders)
  98             };
  99             let mut msg = "call this function";
 100             match hir.get_if_local(def_id) {
 101                 Some(
 102                     Node::Item(hir::Item { kind: ItemKind::Fn(.., body_id), .. })
 103                     | Node::ImplItem(hir::ImplItem {
 104                         kind: hir::ImplItemKind::Fn(_, body_id), ..
 105                     })
 106                     | Node::TraitItem(hir::TraitItem {
 107                         kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Provided(body_id)),
 108                         ..
 109                     }),
 110                 ) => {
 111                     let body = hir.body(*body_id);
 112                     sugg_call = body
 113                         .params
 114                         .iter()
 115                         .map(|param| match &param.pat.kind {
 116                             hir::PatKind::Binding(_, _, ident, None)
 117                                 if ident.name != kw::SelfLower =>
 118                             {
 119                                 ident.to_string()
 120                             }
 121                             _ => "_".to_string(),
 122                         })
 123                         .collect::<Vec<_>>()
 124                         .join(", ");
 125                 }
 126                 Some(Node::Expr(hir::Expr {
 127                     kind: ExprKind::Closure(_, _, body_id, _, _),
 128                     span: full_closure_span,
 129                     ..
 130                 })) => {
 131                     if *full_closure_span == expr.span {
 132                         return false;
 133                     }
 134                     msg = "call this closure";
 135                     let body = hir.body(*body_id);
 136                     sugg_call = body
 137                         .params
 138                         .iter()
 139                         .map(|param| match &param.pat.kind {
 140                             hir::PatKind::Binding(_, _, ident, None)
 141                                 if ident.name != kw::SelfLower =>
 142                             {
 143                                 ident.to_string()
 144                             }
 145                             _ => "_".to_string(),
 146                         })
 147                         .collect::<Vec<_>>()
 148                         .join(", ");
 149                 }
 150                 Some(Node::Ctor(hir::VariantData::Tuple(fields, _))) => {
 151                     sugg_call = fields.iter().map(|_| "_").collect::<Vec<_>>().join(", ");
 152                     match def_id.as_local().map(|def_id| hir.def_kind(def_id)) {
 153                         Some(DefKind::Ctor(hir::def::CtorOf::Variant, _)) => {
 154                             msg = "instantiate this tuple variant";
 155                         }
 156                         Some(DefKind::Ctor(CtorOf::Struct, _)) => {
 157                             msg = "instantiate this tuple struct";
 158                         }
 159                         _ => {}
 160                     }
 161                 }
 162                 Some(Node::ForeignItem(hir::ForeignItem {
 163                     kind: hir::ForeignItemKind::Fn(_, idents, _),
 164                     ..
 165                 })) => {
 166                     sugg_call = idents
 167                         .iter()
 168                         .map(|ident| {
 169                             if ident.name != kw::SelfLower {
 170                                 ident.to_string()
 171                             } else {
 172                                 "_".to_string()
 173                             }
 174                         })
 175                         .collect::<Vec<_>>()
 176                         .join(", ")
 177                 }
 178                 Some(Node::TraitItem(hir::TraitItem {
 179                     kind: hir::TraitItemKind::Fn(.., hir::TraitFn::Required(idents)),
 180                     ..
 181                 })) => {
 182                     sugg_call = idents
 183                         .iter()
 184                         .map(|ident| {
 185                             if ident.name != kw::SelfLower {
 186                                 ident.to_string()
 187                             } else {
 188                                 "_".to_string()
 189                             }
 190                         })
 191                         .collect::<Vec<_>>()
 192                         .join(", ")
 193                 }
 194                 _ => {}
 195             }
 196             err.span_suggestion_verbose(
 197                 expr.span.shrink_to_hi(),
 198                 &format!("use parentheses to {}", msg),
 199                 format!("({})", sugg_call),
 200                 applicability,
 201             );
 202             return true;
 203         }
 204         false
 205     }
 206
 207     pub fn suggest_deref_ref_or_into(
 208         &self,
 209         err: &mut DiagnosticBuilder<'_>,
 210         expr: &hir::Expr<'_>,
 211         expected: Ty<'tcx>,
 212         found: Ty<'tcx>,
 213         expected_ty_expr: Option<&'tcx hir::Expr<'tcx>>,
 214     ) {
 215         let expr = expr.peel_blocks();
 216         if let Some((sp, msg, suggestion, applicability, verbose)) =
 217             self.check_ref(expr, found, expected)
 218         {
 219             if verbose {
 220                 err.span_suggestion_verbose(sp, msg, suggestion, applicability);
 221             } else {
 222                 err.span_suggestion(sp, msg, suggestion, applicability);
 223             }
 224         } else if let (ty::FnDef(def_id, ..), true) =
 225             (&found.kind(), self.suggest_fn_call(err, expr, expected, found))
 226         {
 227             if let Some(sp) = self.tcx.hir().span_if_local(*def_id) {
 228                 let sp = self.sess().source_map().guess_head_span(sp);
 229                 err.span_label(sp, &format!("{} defined here", found));
 230             }
 231         } else if !self.check_for_cast(err, expr, found, expected, expected_ty_expr) {
 232             let is_struct_pat_shorthand_field =
 233                 self.is_hir_id_from_struct_pattern_shorthand_field(expr.hir_id, expr.span);
 234             let methods = self.get_conversion_methods(expr.span, expected, found, expr.hir_id);
 235             if let Ok(expr_text) = self.sess().source_map().span_to_snippet(expr.span) {
 236                 let mut suggestions = iter::zip(iter::repeat(&expr_text), &methods)
 237                     .filter_map(|(receiver, method)| {
 238                         let method_call = format!(".{}()", method.ident);
 239                         if receiver.ends_with(&method_call) {
 240                             None // do not suggest code that is already there (#53348)
 241                         } else {
 242                             let method_call_list = [".to_vec()", ".to_string()"];
 243                             let mut sugg = if receiver.ends_with(".clone()")
 244                                 && method_call_list.contains(&method_call.as_str())
 245                             {
 246                                 let max_len = receiver.rfind('.').unwrap();
 247                                 vec![(
 248                                     expr.span,
 249                                     format!("{}{}", &receiver[..max_len], method_call),
 250                                 )]
 251                             } else {
 252                                 if expr.precedence().order() < ExprPrecedence::MethodCall.order() {
 253                                     vec![
 254                                         (expr.span.shrink_to_lo(), "(".to_string()),
 255                                         (expr.span.shrink_to_hi(), format!("){}", method_call)),
 256                                     ]
 257                                 } else {
 258                                     vec![(expr.span.shrink_to_hi(), method_call)]
 259                                 }
 260                             };
 261                             if is_struct_pat_shorthand_field {
 262                                 sugg.insert(
 263                                     0,
 264                                     (expr.span.shrink_to_lo(), format!("{}: ", receiver)),
 265                                 );
 266                             }
 267                             Some(sugg)
 268                         }
 269                     })
 270                     .peekable();
 271                 if suggestions.peek().is_some() {
 272                     err.multipart_suggestions(
 273                         "try using a conversion method",
 274                         suggestions,
 275                         Applicability::MaybeIncorrect,
 276                     );
 277                 }
 278             }
 279         }
 280     }
 281
 282     /// When encountering the expected boxed value allocated in the stack, suggest allocating it
 283     /// in the heap by calling `Box::new()`.
 284     pub(in super::super) fn suggest_boxing_when_appropriate(
 285         &self,
 286         err: &mut DiagnosticBuilder<'_>,
 287         expr: &hir::Expr<'_>,
 288         expected: Ty<'tcx>,
 289         found: Ty<'tcx>,
 290     ) {
 291         if self.tcx.hir().is_inside_const_context(expr.hir_id) {
 292             // Do not suggest `Box::new` in const context.
 293             return;
 294         }
 295         if !expected.is_box() || found.is_box() {
 296             return;
 297         }
 298         let boxed_found = self.tcx.mk_box(found);
 299         if self.can_coerce(boxed_found, expected) {
 300             err.multipart_suggestion(
 301                 "store this in the heap by calling `Box::new`",
 302                 vec![
 303                     (expr.span.shrink_to_lo(), "Box::new(".to_string()),
 304                     (expr.span.shrink_to_hi(), ")".to_string()),
 305                 ],
 306                 Applicability::MachineApplicable,
 307             );
 308             err.note(
 309                 "for more on the distinction between the stack and the heap, read \
 310                  https://doc.rust-lang.org/book/ch15-01-box.html, \
 311                  https://doc.rust-lang.org/rust-by-example/std/box.html, and \
 312                  https://doc.rust-lang.org/std/boxed/index.html",
 313             );
 314         }
 315     }
 316
 317     /// When encountering a closure that captures variables, where a FnPtr is expected,
 318     /// suggest a non-capturing closure
 319     pub(in super::super) fn suggest_no_capture_closure(
 320         &self,
 321         err: &mut DiagnosticBuilder<'_>,
 322         expected: Ty<'tcx>,
 323         found: Ty<'tcx>,
 324     ) {
 325         if let (ty::FnPtr(_), ty::Closure(def_id, _)) = (expected.kind(), found.kind()) {
 326             if let Some(upvars) = self.tcx.upvars_mentioned(*def_id) {
 327                 // Report upto four upvars being captured to reduce the amount error messages
 328                 // reported back to the user.
 329                 let spans_and_labels = upvars
 330                     .iter()
 331                     .take(4)
 332                     .map(|(var_hir_id, upvar)| {
 333                         let var_name = self.tcx.hir().name(*var_hir_id).to_string();
 334                         let msg = format!("`{}` captured here", var_name);
 335                         (upvar.span, msg)
 336                     })
 337                     .collect::<Vec<_>>();
 338
 339                 let mut multi_span: MultiSpan =
 340                     spans_and_labels.iter().map(|(sp, _)| *sp).collect::<Vec<_>>().into();
 341                 for (sp, label) in spans_and_labels {
 342                     multi_span.push_span_label(sp, label);
 343                 }
 344                 err.span_note(multi_span, "closures can only be coerced to `fn` types if they do not capture any variables");
 345             }
 346         }
 347     }
 348
 349     /// When encountering an `impl Future` where `BoxFuture` is expected, suggest `Box::pin`.
 350     pub(in super::super) fn suggest_calling_boxed_future_when_appropriate(
 351         &self,
 352         err: &mut DiagnosticBuilder<'_>,
 353         expr: &hir::Expr<'_>,
 354         expected: Ty<'tcx>,
 355         found: Ty<'tcx>,
 356     ) -> bool {
 357         // Handle #68197.
 358
 359         if self.tcx.hir().is_inside_const_context(expr.hir_id) {
 360             // Do not suggest `Box::new` in const context.
 361             return false;
 362         }
 363         let pin_did = self.tcx.lang_items().pin_type();
 364         match expected.kind() {
 365             ty::Adt(def, _) if Some(def.did) != pin_did => return false,
 366             // This guards the `unwrap` and `mk_box` below.
 367             _ if pin_did.is_none() || self.tcx.lang_items().owned_box().is_none() => return false,
 368             _ => {}
 369         }
 370         let boxed_found = self.tcx.mk_box(found);
 371         let new_found = self.tcx.mk_lang_item(boxed_found, LangItem::Pin).unwrap();
 372         if self.can_coerce(new_found, expected) {
 373             match found.kind() {
 374                 ty::Adt(def, _) if def.is_box() => {
 375                     err.help("use `Box::pin`");
 376                 }
 377                 _ => {
 378                     err.multipart_suggestion(
 379                         "you need to pin and box this expression",
 380                         vec![
 381                             (expr.span.shrink_to_lo(), "Box::pin(".to_string()),
 382                             (expr.span.shrink_to_hi(), ")".to_string()),
 383                         ],
 384                         Applicability::MachineApplicable,
 385                     );
 386                 }
 387             }
 388             true
 389         } else {
 390             false
 391         }
 392     }
 393
 394     /// A common error is to forget to add a semicolon at the end of a block, e.g.,
 395     ///
 396     /// ```
 397     /// fn foo() {
 398     ///     bar_that_returns_u32()
 399     /// }
 400     /// ```
 401     ///
 402     /// This routine checks if the return expression in a block would make sense on its own as a
 403     /// statement and the return type has been left as default or has been specified as `()`. If so,
 404     /// it suggests adding a semicolon.
 405     fn suggest_missing_semicolon(
 406         &self,
 407         err: &mut DiagnosticBuilder<'_>,
 408         expression: &'tcx hir::Expr<'tcx>,
 409         expected: Ty<'tcx>,
 410     ) {
 411         if expected.is_unit() {
 412             // `BlockTailExpression` only relevant if the tail expr would be
 413             // useful on its own.
 414             match expression.kind {
 415                 ExprKind::Call(..)
 416                 | ExprKind::MethodCall(..)
 417                 | ExprKind::Loop(..)
 418                 | ExprKind::If(..)
 419                 | ExprKind::Match(..)
 420                 | ExprKind::Block(..)
 421                     if expression.can_have_side_effects() =>
 422                 {
 423                     err.span_suggestion(
 424                         expression.span.shrink_to_hi(),
 425                         "consider using a semicolon here",
 426                         ";".to_string(),
 427                         Applicability::MachineApplicable,
 428                     );
 429                 }
 430                 _ => (),
 431             }
 432         }
 433     }
 434
 435     /// A possible error is to forget to add a return type that is needed:
 436     ///
 437     /// ```
 438     /// fn foo() {
 439     ///     bar_that_returns_u32()
 440     /// }
 441     /// ```
 442     ///
 443     /// This routine checks if the return type is left as default, the method is not part of an
 444     /// `impl` block and that it isn't the `main` method. If so, it suggests setting the return
 445     /// type.
 446     pub(in super::super) fn suggest_missing_return_type(
 447         &self,
 448         err: &mut DiagnosticBuilder<'_>,
 449         fn_decl: &hir::FnDecl<'_>,
 450         expected: Ty<'tcx>,
 451         found: Ty<'tcx>,
 452         can_suggest: bool,
 453         fn_id: hir::HirId,
 454     ) -> bool {
 455         // Only suggest changing the return type for methods that
 456         // haven't set a return type at all (and aren't `fn main()` or an impl).
 457         match (&fn_decl.output, found.is_suggestable(), can_suggest, expected.is_unit()) {
 458             (&hir::FnRetTy::DefaultReturn(span), true, true, true) => {
 459                 err.span_suggestion(
 460                     span,
 461                     "try adding a return type",
 462                     format!("-> {} ", self.resolve_vars_with_obligations(found)),
 463                     Applicability::MachineApplicable,
 464                 );
 465                 true
 466             }
 467             (&hir::FnRetTy::DefaultReturn(span), false, true, true) => {
 468                 err.span_label(span, "possibly return type missing here?");
 469                 true
 470             }
 471             (&hir::FnRetTy::DefaultReturn(span), _, false, true) => {
 472                 // `fn main()` must return `()`, do not suggest changing return type
 473                 err.span_label(span, "expected `()` because of default return type");
 474                 true
 475             }
 476             // expectation was caused by something else, not the default return
 477             (&hir::FnRetTy::DefaultReturn(_), _, _, false) => false,
 478             (&hir::FnRetTy::Return(ref ty), _, _, _) => {
 479                 // Only point to return type if the expected type is the return type, as if they
 480                 // are not, the expectation must have been caused by something else.
 481                 debug!("suggest_missing_return_type: return type {:?} node {:?}", ty, ty.kind);
 482                 let sp = ty.span;
 483                 let ty = <dyn AstConv<'_>>::ast_ty_to_ty(self, ty);
 484                 debug!("suggest_missing_return_type: return type {:?}", ty);
 485                 debug!("suggest_missing_return_type: expected type {:?}", ty);
 486                 let bound_vars = self.tcx.late_bound_vars(fn_id);
 487                 let ty = self.tcx.erase_late_bound_regions(Binder::bind_with_vars(ty, bound_vars));
 488                 let ty = self.normalize_associated_types_in(sp, ty);
 489                 if self.can_coerce(expected, ty) {
 490                     err.span_label(sp, format!("expected `{}` because of return type", expected));
 491                     return true;
 492                 }
 493                 false
 494             }
 495         }
 496     }
 497
 498     pub(in super::super) fn suggest_missing_break_or_return_expr(
 499         &self,
 500         err: &mut DiagnosticBuilder<'_>,
 501         expr: &'tcx hir::Expr<'tcx>,
 502         fn_decl: &hir::FnDecl<'_>,
 503         expected: Ty<'tcx>,
 504         found: Ty<'tcx>,
 505         id: hir::HirId,
 506         fn_id: hir::HirId,
 507     ) {
 508         if !expected.is_unit() {
 509             return;
 510         }
 511         let found = self.resolve_vars_with_obligations(found);
 512
 513         let in_loop = self.is_loop(id)
 514             || self.tcx.hir().parent_iter(id).any(|(parent_id, _)| self.is_loop(parent_id));
 515
 516         let in_local_statement = self.is_local_statement(id)
 517             || self
 518                 .tcx
 519                 .hir()
 520                 .parent_iter(id)
 521                 .any(|(parent_id, _)| self.is_local_statement(parent_id));
 522
 523         if in_loop && in_local_statement {
 524             err.multipart_suggestion(
 525                 "you might have meant to break the loop with this value",
 526                 vec![
 527                     (expr.span.shrink_to_lo(), "break ".to_string()),
 528                     (expr.span.shrink_to_hi(), ";".to_string()),
 529                 ],
 530                 Applicability::MaybeIncorrect,
 531             );
 532             return;
 533         }
 534
 535         if let hir::FnRetTy::Return(ty) = fn_decl.output {
 536             let ty = <dyn AstConv<'_>>::ast_ty_to_ty(self, ty);
 537             let bound_vars = self.tcx.late_bound_vars(fn_id);
 538             let ty = self.tcx.erase_late_bound_regions(Binder::bind_with_vars(ty, bound_vars));
 539             let ty = self.normalize_associated_types_in(expr.span, ty);
 540             if self.can_coerce(found, ty) {
 541                 err.multipart_suggestion(
 542                     "you might have meant to return this value",
 543                     vec![
 544                         (expr.span.shrink_to_lo(), "return ".to_string()),
 545                         (expr.span.shrink_to_hi(), ";".to_string()),
 546                     ],
 547                     Applicability::MaybeIncorrect,
 548                 );
 549             }
 550         }
 551     }
 552
 553     pub(in super::super) fn suggest_missing_parentheses(
 554         &self,
 555         err: &mut DiagnosticBuilder<'_>,
 556         expr: &hir::Expr<'_>,
 557     ) {
 558         let sp = self.tcx.sess.source_map().start_point(expr.span);
 559         if let Some(sp) = self.tcx.sess.parse_sess.ambiguous_block_expr_parse.borrow().get(&sp) {
 560             // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`
 561             self.tcx.sess.parse_sess.expr_parentheses_needed(err, *sp);
 562         }
 563     }
 564
 565     fn is_loop(&self, id: hir::HirId) -> bool {
 566         let node = self.tcx.hir().get(id);
 567         matches!(node, Node::Expr(Expr { kind: ExprKind::Loop(..), .. }))
 568     }
 569
 570     fn is_local_statement(&self, id: hir::HirId) -> bool {
 571         let node = self.tcx.hir().get(id);
 572         matches!(node, Node::Stmt(Stmt { kind: StmtKind::Local(..), .. }))
 573     }
 574 }