src/librustc_infer/infer/error_reporting/need_type_info.rs

   1 use crate::infer::type_variable::TypeVariableOriginKind;
   2 use crate::infer::InferCtxt;
   3 use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticBuilder};
   4 use rustc_hir as hir;
   5 use rustc_hir::def::{DefKind, Namespace};
   6 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
   7 use rustc_hir::{Body, Expr, ExprKind, FnRetTy, HirId, Local, Pat};
   8 use rustc_middle::hir::map::Map;
   9 use rustc_middle::ty::print::Print;
  10 use rustc_middle::ty::subst::{GenericArg, GenericArgKind};
  11 use rustc_middle::ty::{self, DefIdTree, Ty};
  12 use rustc_span::source_map::DesugaringKind;
  13 use rustc_span::symbol::kw;
  14 use rustc_span::Span;
  15 use std::borrow::Cow;
  16
  17 struct FindHirNodeVisitor<'a, 'tcx> {
  18     infcx: &'a InferCtxt<'a, 'tcx>,
  19     target: GenericArg<'tcx>,
  20     target_span: Span,
  21     found_node_ty: Option<Ty<'tcx>>,
  22     found_local_pattern: Option<&'tcx Pat<'tcx>>,
  23     found_arg_pattern: Option<&'tcx Pat<'tcx>>,
  24     found_closure: Option<&'tcx Expr<'tcx>>,
  25     found_method_call: Option<&'tcx Expr<'tcx>>,
  26     found_exact_method_call: Option<&'tcx Expr<'tcx>>,
  27 }
  28
  29 impl<'a, 'tcx> FindHirNodeVisitor<'a, 'tcx> {
  30     fn new(infcx: &'a InferCtxt<'a, 'tcx>, target: GenericArg<'tcx>, target_span: Span) -> Self {
  31         Self {
  32             infcx,
  33             target,
  34             target_span,
  35             found_node_ty: None,
  36             found_local_pattern: None,
  37             found_arg_pattern: None,
  38             found_closure: None,
  39             found_method_call: None,
  40             found_exact_method_call: None,
  41         }
  42     }
  43
  44     fn node_ty_contains_target(&mut self, hir_id: HirId) -> Option<Ty<'tcx>> {
  45         let ty_opt =
  46             self.infcx.in_progress_tables.and_then(|tables| tables.borrow().node_type_opt(hir_id));
  47         match ty_opt {
  48             Some(ty) => {
  49                 let ty = self.infcx.resolve_vars_if_possible(&ty);
  50                 if ty.walk().any(|inner| {
  51                     inner == self.target
  52                         || match (inner.unpack(), self.target.unpack()) {
  53                             (GenericArgKind::Type(inner_ty), GenericArgKind::Type(target_ty)) => {
  54                                 match (&inner_ty.kind, &target_ty.kind) {
  55                                     (
  56                                         &ty::Infer(ty::TyVar(a_vid)),
  57                                         &ty::Infer(ty::TyVar(b_vid)),
  58                                     ) => self
  59                                         .infcx
  60                                         .inner
  61                                         .borrow_mut()
  62                                         .type_variables
  63                                         .sub_unified(a_vid, b_vid),
  64                                     _ => false,
  65                                 }
  66                             }
  67                             _ => false,
  68                         }
  69                 }) {
  70                     Some(ty)
  71                 } else {
  72                     None
  73                 }
  74             }
  75             None => None,
  76         }
  77     }
  78 }
  79
  80 impl<'a, 'tcx> Visitor<'tcx> for FindHirNodeVisitor<'a, 'tcx> {
  81     type Map = Map<'tcx>;
  82
  83     fn nested_visit_map(&mut self) -> NestedVisitorMap<Self::Map> {
  84         NestedVisitorMap::OnlyBodies(self.infcx.tcx.hir())
  85     }
  86
  87     fn visit_local(&mut self, local: &'tcx Local<'tcx>) {
  88         if let (None, Some(ty)) =
  89             (self.found_local_pattern, self.node_ty_contains_target(local.hir_id))
  90         {
  91             self.found_local_pattern = Some(&*local.pat);
  92             self.found_node_ty = Some(ty);
  93         }
  94         intravisit::walk_local(self, local);
  95     }
  96
  97     fn visit_body(&mut self, body: &'tcx Body<'tcx>) {
  98         for param in body.params {
  99             if let (None, Some(ty)) =
 100                 (self.found_arg_pattern, self.node_ty_contains_target(param.hir_id))
 101             {
 102                 self.found_arg_pattern = Some(&*param.pat);
 103                 self.found_node_ty = Some(ty);
 104             }
 105         }
 106         intravisit::walk_body(self, body);
 107     }
 108
 109     fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) {
 110         if let ExprKind::MethodCall(_, call_span, exprs) = expr.kind {
 111             if call_span == self.target_span
 112                 && Some(self.target)
 113                     == self.infcx.in_progress_tables.and_then(|tables| {
 114                         tables.borrow().node_type_opt(exprs.first().unwrap().hir_id).map(Into::into)
 115                     })
 116             {
 117                 self.found_exact_method_call = Some(&expr);
 118                 return;
 119             }
 120         }
 121         if self.node_ty_contains_target(expr.hir_id).is_some() {
 122             match expr.kind {
 123                 ExprKind::Closure(..) => self.found_closure = Some(&expr),
 124                 ExprKind::MethodCall(..) => self.found_method_call = Some(&expr),
 125                 _ => {}
 126             }
 127         }
 128         intravisit::walk_expr(self, expr);
 129     }
 130 }
 131
 132 /// Suggest giving an appropriate return type to a closure expression.
 133 fn closure_return_type_suggestion(
 134     span: Span,
 135     err: &mut DiagnosticBuilder<'_>,
 136     output: &FnRetTy<'_>,
 137     body: &Body<'_>,
 138     descr: &str,
 139     name: &str,
 140     ret: &str,
 141     parent_name: Option<String>,
 142     parent_descr: Option<&str>,
 143 ) {
 144     let (arrow, post) = match output {
 145         FnRetTy::DefaultReturn(_) => ("-> ", " "),
 146         _ => ("", ""),
 147     };
 148     let suggestion = match body.value.kind {
 149         ExprKind::Block(..) => vec![(output.span(), format!("{}{}{}", arrow, ret, post))],
 150         _ => vec![
 151             (output.span(), format!("{}{}{}{{ ", arrow, ret, post)),
 152             (body.value.span.shrink_to_hi(), " }".to_string()),
 153         ],
 154     };
 155     err.multipart_suggestion(
 156         "give this closure an explicit return type without `_` placeholders",
 157         suggestion,
 158         Applicability::HasPlaceholders,
 159     );
 160     err.span_label(span, InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr));
 161 }
 162
 163 /// Given a closure signature, return a `String` containing a list of all its argument types.
 164 fn closure_args(fn_sig: &ty::PolyFnSig<'_>) -> String {
 165     fn_sig
 166         .inputs()
 167         .skip_binder()
 168         .iter()
 169         .next()
 170         .map(|args| args.tuple_fields().map(|arg| arg.to_string()).collect::<Vec<_>>().join(", "))
 171         .unwrap_or_default()
 172 }
 173
 174 pub enum TypeAnnotationNeeded {
 175     E0282,
 176     E0283,
 177     E0284,
 178 }
 179
 180 impl Into<rustc_errors::DiagnosticId> for TypeAnnotationNeeded {
 181     fn into(self) -> rustc_errors::DiagnosticId {
 182         match self {
 183             Self::E0282 => rustc_errors::error_code!(E0282),
 184             Self::E0283 => rustc_errors::error_code!(E0283),
 185             Self::E0284 => rustc_errors::error_code!(E0284),
 186         }
 187     }
 188 }
 189
 190 impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
 191     pub fn extract_type_name(
 192         &self,
 193         ty: Ty<'tcx>,
 194         highlight: Option<ty::print::RegionHighlightMode>,
 195     ) -> (String, Option<Span>, Cow<'static, str>, Option<String>, Option<&'static str>) {
 196         if let ty::Infer(ty::TyVar(ty_vid)) = ty.kind {
 197             let ty_vars = &self.inner.borrow().type_variables;
 198             let var_origin = ty_vars.var_origin(ty_vid);
 199             if let TypeVariableOriginKind::TypeParameterDefinition(name, def_id) = var_origin.kind {
 200                 let parent_def_id = def_id.and_then(|def_id| self.tcx.parent(def_id));
 201                 let (parent_name, parent_desc) = if let Some(parent_def_id) = parent_def_id {
 202                     let parent_name = self
 203                         .tcx
 204                         .def_key(parent_def_id)
 205                         .disambiguated_data
 206                         .data
 207                         .get_opt_name()
 208                         .map(|parent_symbol| parent_symbol.to_string());
 209
 210                     let type_parent_desc = self
 211                         .tcx
 212                         .def_kind(parent_def_id)
 213                         .map(|parent_def_kind| parent_def_kind.descr(parent_def_id));
 214
 215                     (parent_name, type_parent_desc)
 216                 } else {
 217                     (None, None)
 218                 };
 219
 220                 if name != kw::SelfUpper {
 221                     return (
 222                         name.to_string(),
 223                         Some(var_origin.span),
 224                         "type parameter".into(),
 225                         parent_name,
 226                         parent_desc,
 227                     );
 228                 }
 229             }
 230         }
 231
 232         let mut s = String::new();
 233         let mut printer = ty::print::FmtPrinter::new(self.tcx, &mut s, Namespace::TypeNS);
 234         if let Some(highlight) = highlight {
 235             printer.region_highlight_mode = highlight;
 236         }
 237         let _ = ty.print(printer);
 238         (s, None, ty.prefix_string(), None, None)
 239     }
 240
 241     // FIXME(eddyb) generalize all of this to handle `ty::Const` inference variables as well.
 242     pub fn need_type_info_err(
 243         &self,
 244         body_id: Option<hir::BodyId>,
 245         span: Span,
 246         ty: Ty<'tcx>,
 247         error_code: TypeAnnotationNeeded,
 248     ) -> DiagnosticBuilder<'tcx> {
 249         let ty = self.resolve_vars_if_possible(&ty);
 250         let (name, name_sp, descr, parent_name, parent_descr) = self.extract_type_name(&ty, None);
 251
 252         let mut local_visitor = FindHirNodeVisitor::new(&self, ty.into(), span);
 253         let ty_to_string = |ty: Ty<'tcx>| -> String {
 254             let mut s = String::new();
 255             let mut printer = ty::print::FmtPrinter::new(self.tcx, &mut s, Namespace::TypeNS);
 256             let ty_vars = &self.inner.borrow().type_variables;
 257             let getter = move |ty_vid| {
 258                 let var_origin = ty_vars.var_origin(ty_vid);
 259                 if let TypeVariableOriginKind::TypeParameterDefinition(name, _) = var_origin.kind {
 260                     return Some(name.to_string());
 261                 }
 262                 None
 263             };
 264             printer.name_resolver = Some(Box::new(&getter));
 265             let _ = ty.print(printer);
 266             s
 267         };
 268
 269         if let Some(body_id) = body_id {
 270             let expr = self.tcx.hir().expect_expr(body_id.hir_id);
 271             local_visitor.visit_expr(expr);
 272         }
 273         let err_span = if let Some(pattern) = local_visitor.found_arg_pattern {
 274             pattern.span
 275         } else if let Some(span) = name_sp {
 276             // `span` here lets us point at `sum` instead of the entire right hand side expr:
 277             // error[E0282]: type annotations needed
 278             //  --> file2.rs:3:15
 279             //   |
 280             // 3 |     let _ = x.sum() as f64;
 281             //   |               ^^^ cannot infer type for `S`
 282             span
 283         } else if let Some(ExprKind::MethodCall(_, call_span, _)) =
 284             local_visitor.found_method_call.map(|e| &e.kind)
 285         {
 286             // Point at the call instead of the whole expression:
 287             // error[E0284]: type annotations needed
 288             //  --> file.rs:2:5
 289             //   |
 290             // 2 |     vec![Ok(2)].into_iter().collect()?;
 291             //   |                             ^^^^^^^ cannot infer type
 292             //   |
 293             //   = note: cannot resolve `<_ as std::ops::Try>::Ok == _`
 294             if span.contains(*call_span) { *call_span } else { span }
 295         } else {
 296             span
 297         };
 298
 299         let is_named_and_not_impl_trait = |ty: Ty<'_>| {
 300             &ty.to_string() != "_" &&
 301                 // FIXME: Remove this check after `impl_trait_in_bindings` is stabilized. #63527
 302                 (!ty.is_impl_trait() || self.tcx.features().impl_trait_in_bindings)
 303         };
 304
 305         let ty_msg = match (local_visitor.found_node_ty, local_visitor.found_exact_method_call) {
 306             (_, Some(_)) => String::new(),
 307             (Some(ty::TyS { kind: ty::Closure(_, substs), .. }), _) => {
 308                 let fn_sig = substs.as_closure().sig();
 309                 let args = closure_args(&fn_sig);
 310                 let ret = fn_sig.output().skip_binder().to_string();
 311                 format!(" for the closure `fn({}) -> {}`", args, ret)
 312             }
 313             (Some(ty), _) if is_named_and_not_impl_trait(ty) => {
 314                 let ty = ty_to_string(ty);
 315                 format!(" for `{}`", ty)
 316             }
 317             _ => String::new(),
 318         };
 319
 320         // When `name` corresponds to a type argument, show the path of the full type we're
 321         // trying to infer. In the following example, `ty_msg` contains
 322         // " in `std::result::Result<i32, E>`":
 323         // ```
 324         // error[E0282]: type annotations needed for `std::result::Result<i32, E>`
 325         //  --> file.rs:L:CC
 326         //   |
 327         // L |     let b = Ok(4);
 328         //   |         -   ^^ cannot infer type for `E` in `std::result::Result<i32, E>`
 329         //   |         |
 330         //   |         consider giving `b` the explicit type `std::result::Result<i32, E>`, where
 331         //   |         the type parameter `E` is specified
 332         // ```
 333         let error_code = error_code.into();
 334         let mut err = self.tcx.sess.struct_span_err_with_code(
 335             err_span,
 336             &format!("type annotations needed{}", ty_msg),
 337             error_code,
 338         );
 339
 340         let suffix = match local_visitor.found_node_ty {
 341             Some(ty::TyS { kind: ty::Closure(_, substs), .. }) => {
 342                 let fn_sig = substs.as_closure().sig();
 343                 let ret = fn_sig.output().skip_binder().to_string();
 344
 345                 let closure_decl_and_body_id =
 346                     local_visitor.found_closure.and_then(|closure| match &closure.kind {
 347                         ExprKind::Closure(_, decl, body_id, ..) => Some((decl, *body_id)),
 348                         _ => None,
 349                     });
 350
 351                 if let Some((decl, body_id)) = closure_decl_and_body_id {
 352                     closure_return_type_suggestion(
 353                         span,
 354                         &mut err,
 355                         &decl.output,
 356                         self.tcx.hir().body(body_id),
 357                         &descr,
 358                         &name,
 359                         &ret,
 360                         parent_name,
 361                         parent_descr,
 362                     );
 363                     // We don't want to give the other suggestions when the problem is the
 364                     // closure return type.
 365                     return err;
 366                 }
 367
 368                 // This shouldn't be reachable, but just in case we leave a reasonable fallback.
 369                 let args = closure_args(&fn_sig);
 370                 // This suggestion is incomplete, as the user will get further type inference
 371                 // errors due to the `_` placeholders and the introduction of `Box`, but it does
 372                 // nudge them in the right direction.
 373                 format!("a boxed closure type like `Box<dyn Fn({}) -> {}>`", args, ret)
 374             }
 375             Some(ty) if is_named_and_not_impl_trait(ty) && name == "_" => {
 376                 let ty = ty_to_string(ty);
 377                 format!("the explicit type `{}`, with the type parameters specified", ty)
 378             }
 379             Some(ty) if is_named_and_not_impl_trait(ty) && ty.to_string() != name => {
 380                 let ty = ty_to_string(ty);
 381                 format!(
 382                     "the explicit type `{}`, where the type parameter `{}` is specified",
 383                     ty, name,
 384                 )
 385             }
 386             _ => "a type".to_string(),
 387         };
 388
 389         if let Some(e) = local_visitor.found_exact_method_call {
 390             if let ExprKind::MethodCall(segment, ..) = &e.kind {
 391                 // Suggest specifying type params or point out the return type of the call:
 392                 //
 393                 // error[E0282]: type annotations needed
 394                 //   --> $DIR/type-annotations-needed-expr.rs:2:39
 395                 //    |
 396                 // LL |     let _ = x.into_iter().sum() as f64;
 397                 //    |                           ^^^
 398                 //    |                           |
 399                 //    |                           cannot infer type for `S`
 400                 //    |                           help: consider specifying the type argument in
 401                 //    |                           the method call: `sum::<S>`
 402                 //    |
 403                 //    = note: type must be known at this point
 404                 //
 405                 // or
 406                 //
 407                 // error[E0282]: type annotations needed
 408                 //   --> $DIR/issue-65611.rs:59:20
 409                 //    |
 410                 // LL |     let x = buffer.last().unwrap().0.clone();
 411                 //    |             -------^^^^--
 412                 //    |             |      |
 413                 //    |             |      cannot infer type for `T`
 414                 //    |             this method call resolves to `std::option::Option<&T>`
 415                 //    |
 416                 //    = note: type must be known at this point
 417                 self.annotate_method_call(segment, e, &mut err);
 418             }
 419         } else if let Some(pattern) = local_visitor.found_arg_pattern {
 420             // We don't want to show the default label for closures.
 421             //
 422             // So, before clearing, the output would look something like this:
 423             // ```
 424             // let x = |_| {  };
 425             //          -  ^^^^ cannot infer type for `[_; 0]`
 426             //          |
 427             //          consider giving this closure parameter a type
 428             // ```
 429             //
 430             // After clearing, it looks something like this:
 431             // ```
 432             // let x = |_| {  };
 433             //          ^ consider giving this closure parameter the type `[_; 0]`
 434             //            with the type parameter `_` specified
 435             // ```
 436             err.span_label(
 437                 pattern.span,
 438                 format!("consider giving this closure parameter {}", suffix),
 439             );
 440         } else if let Some(pattern) = local_visitor.found_local_pattern {
 441             let msg = if let Some(simple_ident) = pattern.simple_ident() {
 442                 match pattern.span.desugaring_kind() {
 443                     None => format!("consider giving `{}` {}", simple_ident, suffix),
 444                     Some(DesugaringKind::ForLoop) => {
 445                         "the element type for this iterator is not specified".to_string()
 446                     }
 447                     _ => format!("this needs {}", suffix),
 448                 }
 449             } else {
 450                 format!("consider giving this pattern {}", suffix)
 451             };
 452             err.span_label(pattern.span, msg);
 453         } else if let Some(e) = local_visitor.found_method_call {
 454             if let ExprKind::MethodCall(segment, ..) = &e.kind {
 455                 // Suggest specifying type params or point out the return type of the call:
 456                 //
 457                 // error[E0282]: type annotations needed
 458                 //   --> $DIR/type-annotations-needed-expr.rs:2:39
 459                 //    |
 460                 // LL |     let _ = x.into_iter().sum() as f64;
 461                 //    |                           ^^^
 462                 //    |                           |
 463                 //    |                           cannot infer type for `S`
 464                 //    |                           help: consider specifying the type argument in
 465                 //    |                           the method call: `sum::<S>`
 466                 //    |
 467                 //    = note: type must be known at this point
 468                 //
 469                 // or
 470                 //
 471                 // error[E0282]: type annotations needed
 472                 //   --> $DIR/issue-65611.rs:59:20
 473                 //    |
 474                 // LL |     let x = buffer.last().unwrap().0.clone();
 475                 //    |             -------^^^^--
 476                 //    |             |      |
 477                 //    |             |      cannot infer type for `T`
 478                 //    |             this method call resolves to `std::option::Option<&T>`
 479                 //    |
 480                 //    = note: type must be known at this point
 481                 self.annotate_method_call(segment, e, &mut err);
 482             }
 483         }
 484         // Instead of the following:
 485         // error[E0282]: type annotations needed
 486         //  --> file2.rs:3:15
 487         //   |
 488         // 3 |     let _ = x.sum() as f64;
 489         //   |             --^^^--------- cannot infer type for `S`
 490         //   |
 491         //   = note: type must be known at this point
 492         // We want:
 493         // error[E0282]: type annotations needed
 494         //  --> file2.rs:3:15
 495         //   |
 496         // 3 |     let _ = x.sum() as f64;
 497         //   |               ^^^ cannot infer type for `S`
 498         //   |
 499         //   = note: type must be known at this point
 500         let span = name_sp.unwrap_or(err_span);
 501         if !err
 502             .span
 503             .span_labels()
 504             .iter()
 505             .any(|span_label| span_label.label.is_some() && span_label.span == span)
 506             && local_visitor.found_arg_pattern.is_none()
 507         {
 508             // Avoid multiple labels pointing at `span`.
 509             err.span_label(
 510                 span,
 511                 InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr),
 512             );
 513         }
 514
 515         err
 516     }
 517
 518     /// If the `FnSig` for the method call can be found and type arguments are identified as
 519     /// needed, suggest annotating the call, otherwise point out the resulting type of the call.
 520     fn annotate_method_call(
 521         &self,
 522         segment: &hir::PathSegment<'_>,
 523         e: &Expr<'_>,
 524         err: &mut DiagnosticBuilder<'_>,
 525     ) {
 526         if let (Some(tables), None) = (self.in_progress_tables, &segment.args) {
 527             let borrow = tables.borrow();
 528             if let Some((DefKind::AssocFn, did)) = borrow.type_dependent_def(e.hir_id) {
 529                 let generics = self.tcx.generics_of(did);
 530                 if !generics.params.is_empty() {
 531                     err.span_suggestion_verbose(
 532                         segment.ident.span.shrink_to_hi(),
 533                         &format!(
 534                             "consider specifying the type argument{} in the method call",
 535                             pluralize!(generics.params.len()),
 536                         ),
 537                         format!(
 538                             "::<{}>",
 539                             generics
 540                                 .params
 541                                 .iter()
 542                                 .map(|p| p.name.to_string())
 543                                 .collect::<Vec<String>>()
 544                                 .join(", ")
 545                         ),
 546                         Applicability::HasPlaceholders,
 547                     );
 548                 } else {
 549                     let sig = self.tcx.fn_sig(did);
 550                     let bound_output = sig.output();
 551                     let output = bound_output.skip_binder();
 552                     err.span_label(e.span, &format!("this method call resolves to `{:?}`", output));
 553                     let kind = &output.kind;
 554                     if let ty::Projection(proj) | ty::UnnormalizedProjection(proj) = kind {
 555                         if let Some(span) = self.tcx.hir().span_if_local(proj.item_def_id) {
 556                             err.span_label(span, &format!("`{:?}` defined here", output));
 557                         }
 558                     }
 559                 }
 560             }
 561         }
 562     }
 563
 564     pub fn need_type_info_err_in_generator(
 565         &self,
 566         kind: hir::GeneratorKind,
 567         span: Span,
 568         ty: Ty<'tcx>,
 569     ) -> DiagnosticBuilder<'tcx> {
 570         let ty = self.resolve_vars_if_possible(&ty);
 571         let (name, _, descr, parent_name, parent_descr) = self.extract_type_name(&ty, None);
 572
 573         let mut err = struct_span_err!(
 574             self.tcx.sess,
 575             span,
 576             E0698,
 577             "type inside {} must be known in this context",
 578             kind,
 579         );
 580         err.span_label(span, InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr));
 581         err
 582     }
 583
 584     fn missing_type_msg(
 585         type_name: &str,
 586         descr: &str,
 587         parent_name: Option<String>,
 588         parent_descr: Option<&str>,
 589     ) -> Cow<'static, str> {
 590         if type_name == "_" {
 591             "cannot infer type".into()
 592         } else {
 593             let parent_desc = if let Some(parent_name) = parent_name {
 594                 let parent_type_descr = if let Some(parent_descr) = parent_descr {
 595                     format!(" the {}", parent_descr)
 596                 } else {
 597                     "".into()
 598                 };
 599
 600                 format!(" declared on{} `{}`", parent_type_descr, parent_name)
 601             } else {
 602                 "".to_string()
 603             };
 604
 605             format!("cannot infer type for {} `{}`{}", descr, type_name, parent_desc).into()
 606         }
 607     }
 608 }