From 165efabbee6e2ea997bdbd7aee67f92554a83f80 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Esteban=20K=C3=BCber?= Date: Tue, 13 Dec 2022 11:36:43 -0800 Subject: [PATCH] review comments --- .../locales/en-US/infer.ftl | 1 - .../infer/error_reporting/need_type_info.rs | 55 +++++++++---------- .../ui/array-slice-vec/infer_array_len.stderr | 6 +- ...er-vars-supply-ty-with-bound-region.stderr | 6 +- src/test/ui/closures/issue-52437.stderr | 6 +- .../const-generics/issues/issue-83249.stderr | 6 +- .../ui/impl-trait/issues/issue-86719.stderr | 6 +- src/test/ui/inference/issue-72690.stderr | 6 +- src/test/ui/issues/issue-18159.stderr | 6 +- src/test/ui/issues/issue-2151.stderr | 6 +- src/test/ui/issues/issue-24036.stderr | 6 +- .../branches3.stderr | 24 ++++---- .../ui/match/match-unresolved-one-arm.stderr | 6 +- src/test/ui/pattern/pat-tuple-bad-type.stderr | 6 +- .../rest-pat-semantic-disallowed.stderr | 6 +- src/test/ui/resolve/issue-85348.stderr | 6 +- .../method-and-field-eager-resolution.stderr | 12 ++-- .../closures_in_branches.stderr | 12 ++-- .../unknown_type_for_closure.stderr | 6 +- .../ui/type/type-path-err-node-types.stderr | 6 +- 20 files changed, 96 insertions(+), 98 deletions(-) diff --git a/compiler/rustc_error_messages/locales/en-US/infer.ftl b/compiler/rustc_error_messages/locales/en-US/infer.ftl index fbef2da7cb98..c9d83746d545 100644 --- a/compiler/rustc_error_messages/locales/en-US/infer.ftl +++ b/compiler/rustc_error_messages/locales/en-US/infer.ftl @@ -34,7 +34,6 @@ infer_source_kind_subdiag_let = {$kind -> [const] the value of the constant } `{$arg_name}` is specified [underscore] , where the placeholders `_` are specified - [anon] , where the placeholder `Type` is specified *[empty] {""} } diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs index 38655492244b..858ca6deedcb 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs @@ -77,11 +77,9 @@ impl InferenceDiagnosticsData { !(self.name == "_" && matches!(self.kind, UnderspecifiedArgKind::Type { .. })) } - fn where_x_is_kind(&self, in_type: Ty<'_>, is_collect: bool) -> &'static str { - if is_collect { - "empty" - } else if in_type.is_ty_infer() { - "anon" + fn where_x_is_kind(&self, in_type: Ty<'_>) -> &'static str { + if in_type.is_ty_infer() { + "" } else if self.name == "_" { // FIXME: Consider specializing this message if there is a single `_` // in the type. @@ -185,14 +183,20 @@ fn fmt_printer<'a, 'tcx>(infcx: &'a InferCtxt<'tcx>, ns: Namespace) -> FmtPrinte printer } -fn ty_to_string<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>) -> String { +fn ty_to_string<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>, def_id: Option) -> String { let printer = fmt_printer(infcx, Namespace::TypeNS); let ty = infcx.resolve_vars_if_possible(ty); - match ty.kind() { + match (ty.kind(), def_id) { // We don't want the regular output for `fn`s because it includes its path in // invalid pseudo-syntax, we want the `fn`-pointer output instead. - ty::FnDef(..) => ty.fn_sig(infcx.tcx).print(printer).unwrap().into_buffer(), - _ if ty.is_ty_infer() => "Type".to_string(), + (ty::FnDef(..), _) => ty.fn_sig(infcx.tcx).print(printer).unwrap().into_buffer(), + (_, Some(def_id)) + if ty.is_ty_infer() + && infcx.tcx.get_diagnostic_item(sym::iterator_collect_fn) == Some(def_id) => + { + "Vec<_>".to_string() + } + _ if ty.is_ty_infer() => "/* Type */".to_string(), // FIXME: The same thing for closures, but this only works when the closure // does not capture anything. // @@ -216,7 +220,7 @@ fn closure_as_fn_str<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>) -> String { .map(|args| { args.tuple_fields() .iter() - .map(|arg| ty_to_string(infcx, arg)) + .map(|arg| ty_to_string(infcx, arg, None)) .collect::>() .join(", ") }) @@ -224,7 +228,7 @@ fn closure_as_fn_str<'tcx>(infcx: &InferCtxt<'tcx>, ty: Ty<'tcx>) -> String { let ret = if fn_sig.output().skip_binder().is_unit() { String::new() } else { - format!(" -> {}", ty_to_string(infcx, fn_sig.output().skip_binder())) + format!(" -> {}", ty_to_string(infcx, fn_sig.output().skip_binder(), None)) }; format!("fn({}){}", args, ret) } @@ -410,32 +414,28 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { let mut infer_subdiags = Vec::new(); let mut multi_suggestions = Vec::new(); match kind { - InferSourceKind::LetBinding { insert_span, pattern_name, ty, is_collect } => { + InferSourceKind::LetBinding { insert_span, pattern_name, ty, def_id } => { infer_subdiags.push(SourceKindSubdiag::LetLike { span: insert_span, name: pattern_name.map(|name| name.to_string()).unwrap_or_else(String::new), - x_kind: arg_data.where_x_is_kind(ty, is_collect), + x_kind: arg_data.where_x_is_kind(ty), prefix_kind: arg_data.kind.clone(), prefix: arg_data.kind.try_get_prefix().unwrap_or_default(), arg_name: arg_data.name, kind: if pattern_name.is_some() { "with_pattern" } else { "other" }, - type_name: if is_collect { - "Vec<_>".to_string() - } else { - ty_to_string(self, ty) - }, + type_name: ty_to_string(self, ty, def_id), }); } InferSourceKind::ClosureArg { insert_span, ty } => { infer_subdiags.push(SourceKindSubdiag::LetLike { span: insert_span, name: String::new(), - x_kind: arg_data.where_x_is_kind(ty, false), + x_kind: arg_data.where_x_is_kind(ty), prefix_kind: arg_data.kind.clone(), prefix: arg_data.kind.try_get_prefix().unwrap_or_default(), arg_name: arg_data.name, kind: "closure", - type_name: ty_to_string(self, ty), + type_name: ty_to_string(self, ty, None), }); } InferSourceKind::GenericArg { @@ -534,7 +534,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { )); } InferSourceKind::ClosureReturn { ty, data, should_wrap_expr } => { - let ty_info = ty_to_string(self, ty); + let ty_info = ty_to_string(self, ty, None); multi_suggestions.push(SourceKindMultiSuggestion::new_closure_return( ty_info, data, @@ -622,7 +622,7 @@ enum InferSourceKind<'tcx> { insert_span: Span, pattern_name: Option, ty: Ty<'tcx>, - is_collect: bool, + def_id: Option, }, ClosureArg { insert_span: Span, @@ -677,7 +677,7 @@ impl<'tcx> InferSourceKind<'tcx> { if ty.is_closure() { ("closure", closure_as_fn_str(infcx, ty)) } else if !ty.is_ty_infer() { - ("normal", ty_to_string(infcx, ty)) + ("normal", ty_to_string(infcx, ty, None)) } else { ("other", String::new()) } @@ -807,14 +807,13 @@ impl<'a, 'tcx> FindInferSourceVisitor<'a, 'tcx> { let cost = self.source_cost(&new_source) + self.attempt; debug!(?cost); self.attempt += 1; - if let Some(InferSource { kind: InferSourceKind::GenericArg { def_id, ..}, .. }) = self.infer_source - && self.infcx.tcx.get_diagnostic_item(sym::iterator_collect_fn) == Some(def_id) - && let InferSourceKind::LetBinding { ref ty, ref mut is_collect, ..} = new_source.kind + if let Some(InferSource { kind: InferSourceKind::GenericArg { def_id: did, ..}, .. }) = self.infer_source + && let InferSourceKind::LetBinding { ref ty, ref mut def_id, ..} = new_source.kind && ty.is_ty_infer() { // Customize the output so we talk about `let x: Vec<_> = iter.collect();` instead of // `let x: _ = iter.collect();`, as this is a very common case. - *is_collect = true; + *def_id = Some(did); } if cost < self.infer_source_cost { self.infer_source_cost = cost; @@ -1113,7 +1112,7 @@ impl<'a, 'tcx> Visitor<'tcx> for FindInferSourceVisitor<'a, 'tcx> { insert_span: local.pat.span.shrink_to_hi(), pattern_name: local.pat.simple_ident(), ty, - is_collect: false, + def_id: None, }, }) } diff --git a/src/test/ui/array-slice-vec/infer_array_len.stderr b/src/test/ui/array-slice-vec/infer_array_len.stderr index 11a07164e8c6..c2a509a19634 100644 --- a/src/test/ui/array-slice-vec/infer_array_len.stderr +++ b/src/test/ui/array-slice-vec/infer_array_len.stderr @@ -4,10 +4,10 @@ error[E0282]: type annotations needed LL | let [_, _] = a.into(); | ^^^^^^ | -help: consider giving this pattern a type, where the placeholder `Type` is specified +help: consider giving this pattern a type | -LL | let [_, _]: Type = a.into(); - | ++++++ +LL | let [_, _]: /* Type */ = a.into(); + | ++++++++++++ error: aborting due to previous error diff --git a/src/test/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr b/src/test/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr index 9e5705ba00b8..7a04ed7381e6 100644 --- a/src/test/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr +++ b/src/test/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr @@ -4,10 +4,10 @@ error[E0282]: type annotations needed LL | with_closure(|x: u32, y| {}); | ^ | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | with_closure(|x: u32, y: Type| {}); - | ++++++ +LL | with_closure(|x: u32, y: /* Type */| {}); + | ++++++++++++ error: aborting due to previous error diff --git a/src/test/ui/closures/issue-52437.stderr b/src/test/ui/closures/issue-52437.stderr index c635e7432932..9ba24c7a8869 100644 --- a/src/test/ui/closures/issue-52437.stderr +++ b/src/test/ui/closures/issue-52437.stderr @@ -10,10 +10,10 @@ error[E0282]: type annotations needed LL | [(); &(&'static: loop { |x| {}; }) as *const _ as usize] | ^ | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | [(); &(&'static: loop { |x: Type| {}; }) as *const _ as usize] - | ++++++ +LL | [(); &(&'static: loop { |x: /* Type */| {}; }) as *const _ as usize] + | ++++++++++++ error: aborting due to 2 previous errors diff --git a/src/test/ui/const-generics/issues/issue-83249.stderr b/src/test/ui/const-generics/issues/issue-83249.stderr index f148cb7699ef..7491fdc8a693 100644 --- a/src/test/ui/const-generics/issues/issue-83249.stderr +++ b/src/test/ui/const-generics/issues/issue-83249.stderr @@ -4,10 +4,10 @@ error[E0282]: type annotations needed LL | let _ = foo([0; 1]); | ^ | -help: consider giving this pattern a type, where the placeholder `Type` is specified +help: consider giving this pattern a type | -LL | let _: Type = foo([0; 1]); - | ++++++ +LL | let _: /* Type */ = foo([0; 1]); + | ++++++++++++ error: aborting due to previous error diff --git a/src/test/ui/impl-trait/issues/issue-86719.stderr b/src/test/ui/impl-trait/issues/issue-86719.stderr index 30bad841d150..7592418fdfd6 100644 --- a/src/test/ui/impl-trait/issues/issue-86719.stderr +++ b/src/test/ui/impl-trait/issues/issue-86719.stderr @@ -18,10 +18,10 @@ error[E0282]: type annotations needed LL | |_| true | ^ | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |_: Type| true - | ++++++ +LL | |_: /* Type */| true + | ++++++++++++ error: aborting due to 3 previous errors diff --git a/src/test/ui/inference/issue-72690.stderr b/src/test/ui/inference/issue-72690.stderr index 37daeb6441f2..8eda71ec09bd 100644 --- a/src/test/ui/inference/issue-72690.stderr +++ b/src/test/ui/inference/issue-72690.stderr @@ -30,10 +30,10 @@ error[E0282]: type annotations needed LL | |x| String::from("x".as_ref()); | ^ | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |x: Type| String::from("x".as_ref()); - | ++++++ +LL | |x: /* Type */| String::from("x".as_ref()); + | ++++++++++++ error[E0283]: type annotations needed --> $DIR/issue-72690.rs:12:26 diff --git a/src/test/ui/issues/issue-18159.stderr b/src/test/ui/issues/issue-18159.stderr index 1cfb0e415044..5e0589eed435 100644 --- a/src/test/ui/issues/issue-18159.stderr +++ b/src/test/ui/issues/issue-18159.stderr @@ -4,10 +4,10 @@ error[E0282]: type annotations needed LL | let x; | ^ | -help: consider giving `x` an explicit type, where the placeholder `Type` is specified +help: consider giving `x` an explicit type | -LL | let x: Type; - | ++++++ +LL | let x: /* Type */; + | ++++++++++++ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-2151.stderr b/src/test/ui/issues/issue-2151.stderr index f689afd4ea72..c75038b6169c 100644 --- a/src/test/ui/issues/issue-2151.stderr +++ b/src/test/ui/issues/issue-2151.stderr @@ -6,10 +6,10 @@ LL | let x = panic!(); LL | x.clone(); | - type must be known at this point | -help: consider giving `x` an explicit type, where the placeholder `Type` is specified +help: consider giving `x` an explicit type | -LL | let x: Type = panic!(); - | ++++++ +LL | let x: /* Type */ = panic!(); + | ++++++++++++ error: aborting due to previous error diff --git a/src/test/ui/issues/issue-24036.stderr b/src/test/ui/issues/issue-24036.stderr index 2413db2cadab..0e73a51faed9 100644 --- a/src/test/ui/issues/issue-24036.stderr +++ b/src/test/ui/issues/issue-24036.stderr @@ -17,10 +17,10 @@ error[E0282]: type annotations needed LL | 1 => |c| c + 1, | ^ | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | 1 => |c: Type| c + 1, - | ++++++ +LL | 1 => |c: /* Type */| c + 1, + | ++++++++++++ error: aborting due to 2 previous errors diff --git a/src/test/ui/lazy-type-alias-impl-trait/branches3.stderr b/src/test/ui/lazy-type-alias-impl-trait/branches3.stderr index d14cad4d71c7..fe2631f94742 100644 --- a/src/test/ui/lazy-type-alias-impl-trait/branches3.stderr +++ b/src/test/ui/lazy-type-alias-impl-trait/branches3.stderr @@ -4,10 +4,10 @@ error[E0282]: type annotations needed LL | |s| s.len() | ^ - type must be known at this point | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |s: Type| s.len() - | ++++++ +LL | |s: /* Type */| s.len() + | ++++++++++++ error[E0282]: type annotations needed --> $DIR/branches3.rs:15:10 @@ -15,10 +15,10 @@ error[E0282]: type annotations needed LL | |s| s.len() | ^ - type must be known at this point | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |s: Type| s.len() - | ++++++ +LL | |s: /* Type */| s.len() + | ++++++++++++ error[E0282]: type annotations needed --> $DIR/branches3.rs:23:10 @@ -26,10 +26,10 @@ error[E0282]: type annotations needed LL | |s| s.len() | ^ - type must be known at this point | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |s: Type| s.len() - | ++++++ +LL | |s: /* Type */| s.len() + | ++++++++++++ error[E0282]: type annotations needed --> $DIR/branches3.rs:30:10 @@ -37,10 +37,10 @@ error[E0282]: type annotations needed LL | |s| s.len() | ^ - type must be known at this point | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |s: Type| s.len() - | ++++++ +LL | |s: /* Type */| s.len() + | ++++++++++++ error: aborting due to 4 previous errors diff --git a/src/test/ui/match/match-unresolved-one-arm.stderr b/src/test/ui/match/match-unresolved-one-arm.stderr index 0ebd56cb0642..e3b501b2fd55 100644 --- a/src/test/ui/match/match-unresolved-one-arm.stderr +++ b/src/test/ui/match/match-unresolved-one-arm.stderr @@ -4,10 +4,10 @@ error[E0282]: type annotations needed LL | let x = match () { | ^ | -help: consider giving `x` an explicit type, where the placeholder `Type` is specified +help: consider giving `x` an explicit type | -LL | let x: Type = match () { - | ++++++ +LL | let x: /* Type */ = match () { + | ++++++++++++ error: aborting due to previous error diff --git a/src/test/ui/pattern/pat-tuple-bad-type.stderr b/src/test/ui/pattern/pat-tuple-bad-type.stderr index ff45e9fb7a32..da369d33397f 100644 --- a/src/test/ui/pattern/pat-tuple-bad-type.stderr +++ b/src/test/ui/pattern/pat-tuple-bad-type.stderr @@ -7,10 +7,10 @@ LL | let x; LL | (..) => {} | ---- type must be known at this point | -help: consider giving `x` an explicit type, where the placeholder `Type` is specified +help: consider giving `x` an explicit type | -LL | let x: Type; - | ++++++ +LL | let x: /* Type */; + | ++++++++++++ error[E0308]: mismatched types --> $DIR/pat-tuple-bad-type.rs:10:9 diff --git a/src/test/ui/pattern/rest-pat-semantic-disallowed.stderr b/src/test/ui/pattern/rest-pat-semantic-disallowed.stderr index df0aa942fed4..beba7def96f5 100644 --- a/src/test/ui/pattern/rest-pat-semantic-disallowed.stderr +++ b/src/test/ui/pattern/rest-pat-semantic-disallowed.stderr @@ -191,10 +191,10 @@ error[E0282]: type annotations needed LL | let x @ ..; | ^^^^^^ | -help: consider giving this pattern a type, where the placeholder `Type` is specified +help: consider giving this pattern a type | -LL | let x @ ..: Type; - | ++++++ +LL | let x @ ..: /* Type */; + | ++++++++++++ error: aborting due to 23 previous errors diff --git a/src/test/ui/resolve/issue-85348.stderr b/src/test/ui/resolve/issue-85348.stderr index 2cbc109055f0..42b43f825d10 100644 --- a/src/test/ui/resolve/issue-85348.stderr +++ b/src/test/ui/resolve/issue-85348.stderr @@ -19,10 +19,10 @@ error[E0282]: type annotations needed LL | let mut N; | ^^^^^ | -help: consider giving `N` an explicit type, where the placeholder `Type` is specified +help: consider giving `N` an explicit type | -LL | let mut N: Type; - | ++++++ +LL | let mut N: /* Type */; + | ++++++++++++ error: aborting due to 3 previous errors diff --git a/src/test/ui/span/method-and-field-eager-resolution.stderr b/src/test/ui/span/method-and-field-eager-resolution.stderr index 554a2580c945..f6efbe40bc23 100644 --- a/src/test/ui/span/method-and-field-eager-resolution.stderr +++ b/src/test/ui/span/method-and-field-eager-resolution.stderr @@ -7,10 +7,10 @@ LL | LL | x.0; | - type must be known at this point | -help: consider giving `x` an explicit type, where the placeholder `Type` is specified +help: consider giving `x` an explicit type | -LL | let mut x: Type = Default::default(); - | ++++++ +LL | let mut x: /* Type */ = Default::default(); + | ++++++++++++ error[E0282]: type annotations needed --> $DIR/method-and-field-eager-resolution.rs:11:9 @@ -21,10 +21,10 @@ LL | LL | x[0]; | - type must be known at this point | -help: consider giving `x` an explicit type, where the placeholder `Type` is specified +help: consider giving `x` an explicit type | -LL | let mut x: Type = Default::default(); - | ++++++ +LL | let mut x: /* Type */ = Default::default(); + | ++++++++++++ error: aborting due to 2 previous errors diff --git a/src/test/ui/type-alias-impl-trait/closures_in_branches.stderr b/src/test/ui/type-alias-impl-trait/closures_in_branches.stderr index 0d7341bfb910..9cc15f14a991 100644 --- a/src/test/ui/type-alias-impl-trait/closures_in_branches.stderr +++ b/src/test/ui/type-alias-impl-trait/closures_in_branches.stderr @@ -4,10 +4,10 @@ error[E0282]: type annotations needed LL | |x| x.len() | ^ - type must be known at this point | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |x: Type| x.len() - | ++++++ +LL | |x: /* Type */| x.len() + | ++++++++++++ error[E0282]: type annotations needed --> $DIR/closures_in_branches.rs:21:10 @@ -15,10 +15,10 @@ error[E0282]: type annotations needed LL | |x| x.len() | ^ - type must be known at this point | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | |x: Type| x.len() - | ++++++ +LL | |x: /* Type */| x.len() + | ++++++++++++ error: aborting due to 2 previous errors diff --git a/src/test/ui/type/type-check/unknown_type_for_closure.stderr b/src/test/ui/type/type-check/unknown_type_for_closure.stderr index 01e053ccd513..e5e29aabf374 100644 --- a/src/test/ui/type/type-check/unknown_type_for_closure.stderr +++ b/src/test/ui/type/type-check/unknown_type_for_closure.stderr @@ -10,10 +10,10 @@ error[E0282]: type annotations needed LL | let x = |_| {}; | ^ | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | let x = |_: Type| {}; - | ++++++ +LL | let x = |_: /* Type */| {}; + | ++++++++++++ error[E0282]: type annotations needed --> $DIR/unknown_type_for_closure.rs:10:14 diff --git a/src/test/ui/type/type-path-err-node-types.stderr b/src/test/ui/type/type-path-err-node-types.stderr index 51077dedbbe5..1aed1dbe4bab 100644 --- a/src/test/ui/type/type-path-err-node-types.stderr +++ b/src/test/ui/type/type-path-err-node-types.stderr @@ -28,10 +28,10 @@ error[E0282]: type annotations needed LL | let _ = |a, b: _| -> _ { 0 }; | ^ | -help: consider giving this closure parameter an explicit type, where the placeholder `Type` is specified +help: consider giving this closure parameter an explicit type | -LL | let _ = |a: Type, b: _| -> _ { 0 }; - | ++++++ +LL | let _ = |a: /* Type */, b: _| -> _ { 0 }; + | ++++++++++++ error: aborting due to 5 previous errors