nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-01 06:51:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

review comments

Browse Source
This commit is contained in:
Esteban Küber 2022-12-13 11:36:43 -08:00
parent 7d1e47aeb0
commit 165efabbee
20 changed files with 96 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
compiler/rustc_error_messages/locales/en-US/infer.ftl
View File

@ -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] {""}
}

55
compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs
View File

@ -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<DefId>) -> 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::<Vec<_>>()
.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<Ident>,
ty: Ty<'tcx>,
is_collect: bool,
def_id: Option<DefId>,
},
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,
},
})
}

6
src/test/ui/array-slice-vec/infer_array_len.stderr
View File

@ -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

6
src/test/ui/closure-expected-type/expect-two-infer-vars-supply-ty-with-bound-region.stderr
View File

@ -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

6
src/test/ui/closures/issue-52437.stderr
View File

@ -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

6
src/test/ui/const-generics/issues/issue-83249.stderr
View File

@ -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

6
src/test/ui/impl-trait/issues/issue-86719.stderr
View File

@ -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

6
src/test/ui/inference/issue-72690.stderr
View File

@ -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

6
src/test/ui/issues/issue-18159.stderr
View File

@ -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

6
src/test/ui/issues/issue-2151.stderr
View File

@ -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

6
src/test/ui/issues/issue-24036.stderr
View File

@ -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

24
src/test/ui/lazy-type-alias-impl-trait/branches3.stderr
View File

@ -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

6
src/test/ui/match/match-unresolved-one-arm.stderr
View File

@ -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

6
src/test/ui/pattern/pat-tuple-bad-type.stderr
View File

@ -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

6
src/test/ui/pattern/rest-pat-semantic-disallowed.stderr
View File

@ -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

6
src/test/ui/resolve/issue-85348.stderr
View File

@ -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

12
src/test/ui/span/method-and-field-eager-resolution.stderr
View File

@ -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

12
src/test/ui/type-alias-impl-trait/closures_in_branches.stderr
View File

@ -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

6
src/test/ui/type/type-check/unknown_type_for_closure.stderr
View File

@ -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

6
src/test/ui/type/type-path-err-node-types.stderr
View File

@ -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