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                     (parent_name, Some(self.tcx.def_kind(parent_def_id).descr(parent_def_id)))
 211                 } else {
 212                     (None, None)
 213                 };
 214
 215                 if name != kw::SelfUpper {
 216                     return (
 217                         name.to_string(),
 218                         Some(var_origin.span),
 219                         "type parameter".into(),
 220                         parent_name,
 221                         parent_desc,
 222                     );
 223                 }
 224             }
 225         }
 226
 227         let mut s = String::new();
 228         let mut printer = ty::print::FmtPrinter::new(self.tcx, &mut s, Namespace::TypeNS);
 229         if let Some(highlight) = highlight {
 230             printer.region_highlight_mode = highlight;
 231         }
 232         let _ = ty.print(printer);
 233         (s, None, ty.prefix_string(), None, None)
 234     }
 235
 236     // FIXME(eddyb) generalize all of this to handle `ty::Const` inference variables as well.
 237     pub fn need_type_info_err(
 238         &self,
 239         body_id: Option<hir::BodyId>,
 240         span: Span,
 241         ty: Ty<'tcx>,
 242         error_code: TypeAnnotationNeeded,
 243     ) -> DiagnosticBuilder<'tcx> {
 244         let ty = self.resolve_vars_if_possible(&ty);
 245         let (name, name_sp, descr, parent_name, parent_descr) = self.extract_type_name(&ty, None);
 246
 247         let mut local_visitor = FindHirNodeVisitor::new(&self, ty.into(), span);
 248         let ty_to_string = |ty: Ty<'tcx>| -> String {
 249             let mut s = String::new();
 250             let mut printer = ty::print::FmtPrinter::new(self.tcx, &mut s, Namespace::TypeNS);
 251             let ty_vars = &self.inner.borrow().type_variables;
 252             let getter = move |ty_vid| {
 253                 let var_origin = ty_vars.var_origin(ty_vid);
 254                 if let TypeVariableOriginKind::TypeParameterDefinition(name, _) = var_origin.kind {
 255                     return Some(name.to_string());
 256                 }
 257                 None
 258             };
 259             printer.name_resolver = Some(Box::new(&getter));
 260             let _ = if let ty::FnDef(..) = ty.kind {
 261                 // We don't want the regular output for `fn`s because it includes its path in
 262                 // invalid pseduo-syntax, we want the `fn`-pointer output instead.
 263                 ty.fn_sig(self.tcx).print(printer)
 264             } else {
 265                 ty.print(printer)
 266             };
 267             s
 268         };
 269
 270         if let Some(body_id) = body_id {
 271             let expr = self.tcx.hir().expect_expr(body_id.hir_id);
 272             local_visitor.visit_expr(expr);
 273         }
 274         let err_span = if let Some(pattern) = local_visitor.found_arg_pattern {
 275             pattern.span
 276         } else if let Some(span) = name_sp {
 277             // `span` here lets us point at `sum` instead of the entire right hand side expr:
 278             // error[E0282]: type annotations needed
 279             //  --> file2.rs:3:15
 280             //   |
 281             // 3 |     let _ = x.sum() as f64;
 282             //   |               ^^^ cannot infer type for `S`
 283             span
 284         } else if let Some(ExprKind::MethodCall(_, call_span, _)) =
 285             local_visitor.found_method_call.map(|e| &e.kind)
 286         {
 287             // Point at the call instead of the whole expression:
 288             // error[E0284]: type annotations needed
 289             //  --> file.rs:2:5
 290             //   |
 291             // 2 |     vec![Ok(2)].into_iter().collect()?;
 292             //   |                             ^^^^^^^ cannot infer type
 293             //   |
 294             //   = note: cannot resolve `<_ as std::ops::Try>::Ok == _`
 295             if span.contains(*call_span) { *call_span } else { span }
 296         } else {
 297             span
 298         };
 299
 300         let is_named_and_not_impl_trait = |ty: Ty<'_>| {
 301             &ty.to_string() != "_" &&
 302                 // FIXME: Remove this check after `impl_trait_in_bindings` is stabilized. #63527
 303                 (!ty.is_impl_trait() || self.tcx.features().impl_trait_in_bindings)
 304         };
 305
 306         let ty_msg = match (local_visitor.found_node_ty, local_visitor.found_exact_method_call) {
 307             (_, Some(_)) => String::new(),
 308             (Some(ty::TyS { kind: ty::Closure(_, substs), .. }), _) => {
 309                 let fn_sig = substs.as_closure().sig();
 310                 let args = closure_args(&fn_sig);
 311                 let ret = fn_sig.output().skip_binder().to_string();
 312                 format!(" for the closure `fn({}) -> {}`", args, ret)
 313             }
 314             (Some(ty), _) if is_named_and_not_impl_trait(ty) => {
 315                 let ty = ty_to_string(ty);
 316                 format!(" for `{}`", ty)
 317             }
 318             _ => String::new(),
 319         };
 320
 321         // When `name` corresponds to a type argument, show the path of the full type we're
 322         // trying to infer. In the following example, `ty_msg` contains
 323         // " in `std::result::Result<i32, E>`":
 324         // ```
 325         // error[E0282]: type annotations needed for `std::result::Result<i32, E>`
 326         //  --> file.rs:L:CC
 327         //   |
 328         // L |     let b = Ok(4);
 329         //   |         -   ^^ cannot infer type for `E` in `std::result::Result<i32, E>`
 330         //   |         |
 331         //   |         consider giving `b` the explicit type `std::result::Result<i32, E>`, where
 332         //   |         the type parameter `E` is specified
 333         // ```
 334         let error_code = error_code.into();
 335         let mut err = self.tcx.sess.struct_span_err_with_code(
 336             err_span,
 337             &format!("type annotations needed{}", ty_msg),
 338             error_code,
 339         );
 340
 341         let suffix = match local_visitor.found_node_ty {
 342             Some(ty::TyS { kind: ty::Closure(_, substs), .. }) => {
 343                 let fn_sig = substs.as_closure().sig();
 344                 let ret = fn_sig.output().skip_binder().to_string();
 345
 346                 let closure_decl_and_body_id =
 347                     local_visitor.found_closure.and_then(|closure| match &closure.kind {
 348                         ExprKind::Closure(_, decl, body_id, ..) => Some((decl, *body_id)),
 349                         _ => None,
 350                     });
 351
 352                 if let Some((decl, body_id)) = closure_decl_and_body_id {
 353                     closure_return_type_suggestion(
 354                         span,
 355                         &mut err,
 356                         &decl.output,
 357                         self.tcx.hir().body(body_id),
 358                         &descr,
 359                         &name,
 360                         &ret,
 361                         parent_name,
 362                         parent_descr,
 363                     );
 364                     // We don't want to give the other suggestions when the problem is the
 365                     // closure return type.
 366                     return err;
 367                 }
 368
 369                 // This shouldn't be reachable, but just in case we leave a reasonable fallback.
 370                 let args = closure_args(&fn_sig);
 371                 // This suggestion is incomplete, as the user will get further type inference
 372                 // errors due to the `_` placeholders and the introduction of `Box`, but it does
 373                 // nudge them in the right direction.
 374                 format!("a boxed closure type like `Box<dyn Fn({}) -> {}>`", args, ret)
 375             }
 376             Some(ty) if is_named_and_not_impl_trait(ty) && name == "_" => {
 377                 let ty = ty_to_string(ty);
 378                 format!("the explicit type `{}`, with the type parameters specified", ty)
 379             }
 380             Some(ty) if is_named_and_not_impl_trait(ty) && ty.to_string() != name => {
 381                 let ty = ty_to_string(ty);
 382                 format!(
 383                     "the explicit type `{}`, where the type parameter `{}` is specified",
 384                     ty, name,
 385                 )
 386             }
 387             _ => "a type".to_string(),
 388         };
 389
 390         if let Some(e) = local_visitor.found_exact_method_call {
 391             if let ExprKind::MethodCall(segment, ..) = &e.kind {
 392                 // Suggest specifying type params or point out the return type of the call:
 393                 //
 394                 // error[E0282]: type annotations needed
 395                 //   --> $DIR/type-annotations-needed-expr.rs:2:39
 396                 //    |
 397                 // LL |     let _ = x.into_iter().sum() as f64;
 398                 //    |                           ^^^
 399                 //    |                           |
 400                 //    |                           cannot infer type for `S`
 401                 //    |                           help: consider specifying the type argument in
 402                 //    |                           the method call: `sum::<S>`
 403                 //    |
 404                 //    = note: type must be known at this point
 405                 //
 406                 // or
 407                 //
 408                 // error[E0282]: type annotations needed
 409                 //   --> $DIR/issue-65611.rs:59:20
 410                 //    |
 411                 // LL |     let x = buffer.last().unwrap().0.clone();
 412                 //    |             -------^^^^--
 413                 //    |             |      |
 414                 //    |             |      cannot infer type for `T`
 415                 //    |             this method call resolves to `std::option::Option<&T>`
 416                 //    |
 417                 //    = note: type must be known at this point
 418                 self.annotate_method_call(segment, e, &mut err);
 419             }
 420         } else if let Some(pattern) = local_visitor.found_arg_pattern {
 421             // We don't want to show the default label for closures.
 422             //
 423             // So, before clearing, the output would look something like this:
 424             // ```
 425             // let x = |_| {  };
 426             //          -  ^^^^ cannot infer type for `[_; 0]`
 427             //          |
 428             //          consider giving this closure parameter a type
 429             // ```
 430             //
 431             // After clearing, it looks something like this:
 432             // ```
 433             // let x = |_| {  };
 434             //          ^ consider giving this closure parameter the type `[_; 0]`
 435             //            with the type parameter `_` specified
 436             // ```
 437             err.span_label(
 438                 pattern.span,
 439                 format!("consider giving this closure parameter {}", suffix),
 440             );
 441         } else if let Some(pattern) = local_visitor.found_local_pattern {
 442             let msg = if let Some(simple_ident) = pattern.simple_ident() {
 443                 match pattern.span.desugaring_kind() {
 444                     None => format!("consider giving `{}` {}", simple_ident, suffix),
 445                     Some(DesugaringKind::ForLoop) => {
 446                         "the element type for this iterator is not specified".to_string()
 447                     }
 448                     _ => format!("this needs {}", suffix),
 449                 }
 450             } else {
 451                 format!("consider giving this pattern {}", suffix)
 452             };
 453             err.span_label(pattern.span, msg);
 454         } else if let Some(e) = local_visitor.found_method_call {
 455             if let ExprKind::MethodCall(segment, ..) = &e.kind {
 456                 // Suggest specifying type params or point out the return type of the call:
 457                 //
 458                 // error[E0282]: type annotations needed
 459                 //   --> $DIR/type-annotations-needed-expr.rs:2:39
 460                 //    |
 461                 // LL |     let _ = x.into_iter().sum() as f64;
 462                 //    |                           ^^^
 463                 //    |                           |
 464                 //    |                           cannot infer type for `S`
 465                 //    |                           help: consider specifying the type argument in
 466                 //    |                           the method call: `sum::<S>`
 467                 //    |
 468                 //    = note: type must be known at this point
 469                 //
 470                 // or
 471                 //
 472                 // error[E0282]: type annotations needed
 473                 //   --> $DIR/issue-65611.rs:59:20
 474                 //    |
 475                 // LL |     let x = buffer.last().unwrap().0.clone();
 476                 //    |             -------^^^^--
 477                 //    |             |      |
 478                 //    |             |      cannot infer type for `T`
 479                 //    |             this method call resolves to `std::option::Option<&T>`
 480                 //    |
 481                 //    = note: type must be known at this point
 482                 self.annotate_method_call(segment, e, &mut err);
 483             }
 484         }
 485         // Instead of the following:
 486         // error[E0282]: type annotations needed
 487         //  --> file2.rs:3:15
 488         //   |
 489         // 3 |     let _ = x.sum() as f64;
 490         //   |             --^^^--------- cannot infer type for `S`
 491         //   |
 492         //   = note: type must be known at this point
 493         // We want:
 494         // error[E0282]: type annotations needed
 495         //  --> file2.rs:3:15
 496         //   |
 497         // 3 |     let _ = x.sum() as f64;
 498         //   |               ^^^ cannot infer type for `S`
 499         //   |
 500         //   = note: type must be known at this point
 501         let span = name_sp.unwrap_or(err_span);
 502         if !err
 503             .span
 504             .span_labels()
 505             .iter()
 506             .any(|span_label| span_label.label.is_some() && span_label.span == span)
 507             && local_visitor.found_arg_pattern.is_none()
 508         {
 509             // Avoid multiple labels pointing at `span`.
 510             err.span_label(
 511                 span,
 512                 InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr),
 513             );
 514         }
 515
 516         err
 517     }
 518
 519     /// If the `FnSig` for the method call can be found and type arguments are identified as
 520     /// needed, suggest annotating the call, otherwise point out the resulting type of the call.
 521     fn annotate_method_call(
 522         &self,
 523         segment: &hir::PathSegment<'_>,
 524         e: &Expr<'_>,
 525         err: &mut DiagnosticBuilder<'_>,
 526     ) {
 527         if let (Some(tables), None) = (self.in_progress_tables, &segment.args) {
 528             let borrow = tables.borrow();
 529             if let Some((DefKind::AssocFn, did)) = borrow.type_dependent_def(e.hir_id) {
 530                 let generics = self.tcx.generics_of(did);
 531                 if !generics.params.is_empty() {
 532                     err.span_suggestion_verbose(
 533                         segment.ident.span.shrink_to_hi(),
 534                         &format!(
 535                             "consider specifying the type argument{} in the method call",
 536                             pluralize!(generics.params.len()),
 537                         ),
 538                         format!(
 539                             "::<{}>",
 540                             generics
 541                                 .params
 542                                 .iter()
 543                                 .map(|p| p.name.to_string())
 544                                 .collect::<Vec<String>>()
 545                                 .join(", ")
 546                         ),
 547                         Applicability::HasPlaceholders,
 548                     );
 549                 } else {
 550                     let sig = self.tcx.fn_sig(did);
 551                     let bound_output = sig.output();
 552                     let output = bound_output.skip_binder();
 553                     err.span_label(e.span, &format!("this method call resolves to `{:?}`", output));
 554                     let kind = &output.kind;
 555                     if let ty::Projection(proj) | ty::UnnormalizedProjection(proj) = kind {
 556                         if let Some(span) = self.tcx.hir().span_if_local(proj.item_def_id) {
 557                             err.span_label(span, &format!("`{:?}` defined here", output));
 558                         }
 559                     }
 560                 }
 561             }
 562         }
 563     }
 564
 565     pub fn need_type_info_err_in_generator(
 566         &self,
 567         kind: hir::GeneratorKind,
 568         span: Span,
 569         ty: Ty<'tcx>,
 570     ) -> DiagnosticBuilder<'tcx> {
 571         let ty = self.resolve_vars_if_possible(&ty);
 572         let (name, _, descr, parent_name, parent_descr) = self.extract_type_name(&ty, None);
 573
 574         let mut err = struct_span_err!(
 575             self.tcx.sess,
 576             span,
 577             E0698,
 578             "type inside {} must be known in this context",
 579             kind,
 580         );
 581         err.span_label(span, InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr));
 582         err
 583     }
 584
 585     fn missing_type_msg(
 586         type_name: &str,
 587         descr: &str,
 588         parent_name: Option<String>,
 589         parent_descr: Option<&str>,
 590     ) -> Cow<'static, str> {
 591         if type_name == "_" {
 592             "cannot infer type".into()
 593         } else {
 594             let parent_desc = if let Some(parent_name) = parent_name {
 595                 let parent_type_descr = if let Some(parent_descr) = parent_descr {
 596                     format!(" the {}", parent_descr)
 597                 } else {
 598                     "".into()
 599                 };
 600
 601                 format!(" declared on{} `{}`", parent_type_descr, parent_name)
 602             } else {
 603                 "".to_string()
 604             };
 605
 606             format!("cannot infer type for {} `{}`{}", descr, type_name, parent_desc).into()
 607         }
 608     }
 609 }