On type inference errors use the type argument name when possible
``` error[E0282]: type annotations needed in `std::result::Result<i32, E>` --> file7.rs:3:13 | 3 | let b = Ok(4); | - ^^ cannot infer type for `E` in `std::result::Result<i32, E>` | | | consider giving `b` a type` ```
This commit is contained in:
parent
65c2a7b18b
commit
74fb3bbee4
|
@ -15,7 +15,7 @@ struct FindLocalByTypeVisitor<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
|
|||
hir_map: &'a hir::map::Map<'gcx>,
|
||||
found_local_pattern: Option<&'gcx Pat>,
|
||||
found_arg_pattern: Option<&'gcx Pat>,
|
||||
found_ty: Option<String>,
|
||||
found_ty: Option<Ty<'tcx>>,
|
||||
}
|
||||
|
||||
impl<'a, 'gcx, 'tcx> FindLocalByTypeVisitor<'a, 'gcx, 'tcx> {
|
||||
|
@ -55,7 +55,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for FindLocalByTypeVisitor<'a, 'gcx, 'tcx> {
|
|||
fn visit_local(&mut self, local: &'gcx Local) {
|
||||
if let (None, Some(ty)) = (self.found_local_pattern, self.node_matches_type(local.hir_id)) {
|
||||
self.found_local_pattern = Some(&*local.pat);
|
||||
self.found_ty = Some(ty.to_string());
|
||||
self.found_ty = Some(ty);
|
||||
}
|
||||
intravisit::walk_local(self, local);
|
||||
}
|
||||
|
@ -67,7 +67,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for FindLocalByTypeVisitor<'a, 'gcx, 'tcx> {
|
|||
self.node_matches_type(argument.hir_id),
|
||||
) {
|
||||
self.found_arg_pattern = Some(&*argument.pat);
|
||||
self.found_ty = Some(ty.to_string());
|
||||
self.found_ty = Some(ty);
|
||||
}
|
||||
}
|
||||
intravisit::walk_body(self, body);
|
||||
|
@ -117,14 +117,43 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
|||
found_arg_pattern: None,
|
||||
found_ty: None,
|
||||
};
|
||||
let ty_to_string = |ty: Ty<'tcx>| -> String {
|
||||
let mut s = String::new();
|
||||
let mut printer = ty::print::FmtPrinter::new(self.tcx, &mut s, Namespace::TypeNS);
|
||||
let ty_vars = self.type_variables.borrow();
|
||||
let getter = move |ty_vid| {
|
||||
if let TypeVariableOrigin::TypeParameterDefinition(_, name) =
|
||||
*ty_vars.var_origin(ty_vid) {
|
||||
return Some(name.to_string());
|
||||
}
|
||||
None
|
||||
};
|
||||
printer.name_resolver = Some(Box::new(&getter));
|
||||
let _ = ty.print(printer);
|
||||
s
|
||||
};
|
||||
|
||||
if let Some(body_id) = body_id {
|
||||
let expr = self.tcx.hir().expect_expr_by_hir_id(body_id.hir_id);
|
||||
local_visitor.visit_expr(expr);
|
||||
}
|
||||
|
||||
// When `name` corresponds to a type argument, show the path of the full type we're
|
||||
// trying to infer. In the following example, `ty_msg` contains
|
||||
// " in `std::result::Result<i32, E>`":
|
||||
// ```
|
||||
// error[E0282]: type annotations needed in `std::result::Result<i32, E>`
|
||||
// --> file.rs:L:CC
|
||||
// |
|
||||
// L | let b = Ok(4);
|
||||
// | - ^^ cannot infer type for `E` in `std::result::Result<i32, E>`
|
||||
// | |
|
||||
// | consider giving `b` a type
|
||||
// ```
|
||||
let ty_msg = match &local_visitor.found_ty {
|
||||
Some(ty) if &ty[..] != "_" && ty != &name => format!(" in `{}`", ty),
|
||||
Some(ty) if &ty.to_string() != "_" && ty.to_string() != name => {
|
||||
format!(" in `{}`", ty_to_string(ty))
|
||||
}
|
||||
_ => String::new(),
|
||||
};
|
||||
let mut labels = vec![(span, InferCtxt::missing_type_msg(&name, &ty_msg))];
|
||||
|
@ -144,17 +173,20 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
|
|||
// After clearing, it looks something like this:
|
||||
// ```
|
||||
// let x = |_| { };
|
||||
// ^ consider giving this closure parameter a type
|
||||
// ^ consider giving this closure parameter the type `[_; 0]`
|
||||
// with the type parameter `_` specified
|
||||
// ```
|
||||
labels.clear();
|
||||
labels.push((pattern.span, format!(
|
||||
"consider giving this closure parameter {}",
|
||||
match &local_visitor.found_ty {
|
||||
Some(ty) if &ty[..] != "_" && ty != &name => format!(
|
||||
"the type `{}` with the type parameter `{}` specified",
|
||||
ty,
|
||||
name,
|
||||
),
|
||||
Some(ty) if &ty.to_string() != "_" && ty.to_string() != name => {
|
||||
format!(
|
||||
"the type `{}` with the type parameter `{}` specified",
|
||||
ty_to_string(ty),
|
||||
name,
|
||||
)
|
||||
}
|
||||
_ => "a type".to_owned(),
|
||||
},
|
||||
)));
|
||||
|
|
|
@ -483,7 +483,17 @@ pub trait PrettyPrinter<'gcx: 'tcx, 'tcx>:
|
|||
ty::FnPtr(ref bare_fn) => {
|
||||
p!(print(bare_fn))
|
||||
}
|
||||
ty::Infer(infer_ty) => p!(write("{}", infer_ty)),
|
||||
ty::Infer(infer_ty) => {
|
||||
if let ty::TyVar(ty_vid) = infer_ty {
|
||||
if let Some(name) = self.infer_ty_name(ty_vid) {
|
||||
p!(write("{}", name))
|
||||
} else {
|
||||
p!(write("{}", infer_ty))
|
||||
}
|
||||
} else {
|
||||
p!(write("{}", infer_ty))
|
||||
}
|
||||
},
|
||||
ty::Error => p!(write("[type error]")),
|
||||
ty::Param(ref param_ty) => p!(write("{}", param_ty)),
|
||||
ty::Bound(debruijn, bound_ty) => {
|
||||
|
@ -681,6 +691,10 @@ pub trait PrettyPrinter<'gcx: 'tcx, 'tcx>:
|
|||
Ok(self)
|
||||
}
|
||||
|
||||
fn infer_ty_name(&self, _: ty::TyVid) -> Option<String> {
|
||||
None
|
||||
}
|
||||
|
||||
fn pretty_print_dyn_existential(
|
||||
mut self,
|
||||
predicates: &'tcx ty::List<ty::ExistentialPredicate<'tcx>>,
|
||||
|
@ -931,6 +945,8 @@ pub struct FmtPrinterData<'a, 'gcx, 'tcx, F> {
|
|||
binder_depth: usize,
|
||||
|
||||
pub region_highlight_mode: RegionHighlightMode,
|
||||
|
||||
pub name_resolver: Option<Box<&'a dyn Fn(ty::sty::TyVid) -> Option<String>>>,
|
||||
}
|
||||
|
||||
impl<F> Deref for FmtPrinter<'a, 'gcx, 'tcx, F> {
|
||||
|
@ -957,6 +973,7 @@ impl<F> FmtPrinter<'a, 'gcx, 'tcx, F> {
|
|||
region_index: 0,
|
||||
binder_depth: 0,
|
||||
region_highlight_mode: RegionHighlightMode::default(),
|
||||
name_resolver: None,
|
||||
}))
|
||||
}
|
||||
}
|
||||
|
@ -1206,6 +1223,10 @@ impl<F: fmt::Write> Printer<'gcx, 'tcx> for FmtPrinter<'_, 'gcx, 'tcx, F> {
|
|||
}
|
||||
|
||||
impl<F: fmt::Write> PrettyPrinter<'gcx, 'tcx> for FmtPrinter<'_, 'gcx, 'tcx, F> {
|
||||
fn infer_ty_name(&self, id: ty::TyVid) -> Option<String> {
|
||||
self.0.name_resolver.as_ref().and_then(|func| func(id))
|
||||
}
|
||||
|
||||
fn print_value_path(
|
||||
mut self,
|
||||
def_id: DefId,
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error[E0282]: type annotations needed in `&_`
|
||||
error[E0282]: type annotations needed in `&T`
|
||||
--> $DIR/issue-12187-1.rs:6:10
|
||||
|
|
||||
LL | let &v = new();
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error[E0282]: type annotations needed in `&_`
|
||||
error[E0282]: type annotations needed in `&T`
|
||||
--> $DIR/issue-12187-2.rs:6:10
|
||||
|
|
||||
LL | let &v = new();
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
error[E0282]: type annotations needed in `B<_>`
|
||||
error[E0282]: type annotations needed in `B<T>`
|
||||
--> $DIR/issue-17551.rs:6:15
|
||||
|
|
||||
LL | let foo = B(marker::PhantomData);
|
||||
| --- ^ cannot infer type for `T` in `B<_>`
|
||||
| --- ^ cannot infer type for `T` in `B<T>`
|
||||
| |
|
||||
| consider giving `foo` a type
|
||||
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
error[E0282]: type annotations needed in `Expr<'_, _>`
|
||||
error[E0282]: type annotations needed in `Expr<'_, VAR>`
|
||||
--> $DIR/issue-23046.rs:17:15
|
||||
|
|
||||
LL | let ex = |x| {
|
||||
| ^ consider giving this closure parameter the type `Expr<'_, _>` with the type parameter `VAR` specified
|
||||
| ^ consider giving this closure parameter the type `Expr<'_, VAR>` with the type parameter `VAR` specified
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
@ -1,11 +1,11 @@
|
|||
error[E0282]: type annotations needed in `(std::sync::mpsc::Sender<Foo<_>>, std::sync::mpsc::Receiver<Foo<_>>)`
|
||||
error[E0282]: type annotations needed in `(std::sync::mpsc::Sender<Foo<T>>, std::sync::mpsc::Receiver<Foo<T>>)`
|
||||
--> $DIR/issue-25368.rs:11:17
|
||||
|
|
||||
LL | let (tx, rx) = channel();
|
||||
| -------- consider giving the pattern a type
|
||||
...
|
||||
LL | tx.send(Foo{ foo: PhantomData });
|
||||
| ^^^ cannot infer type for `T` in `(std::sync::mpsc::Sender<Foo<_>>, std::sync::mpsc::Receiver<Foo<_>>)`
|
||||
| ^^^ cannot infer type for `T` in `(std::sync::mpsc::Sender<Foo<T>>, std::sync::mpsc::Receiver<Foo<T>>)`
|
||||
|
||||
error: aborting due to previous error
|
||||
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
error[E0282]: type annotations needed in `std::vec::Vec<_>`
|
||||
error[E0282]: type annotations needed in `std::vec::Vec<T>`
|
||||
--> $DIR/method-ambig-one-trait-unknown-int-type.rs:24:17
|
||||
|
|
||||
LL | let mut x = Vec::new();
|
||||
| ----- ^^^^^^^^ cannot infer type for `T` in `std::vec::Vec<_>`
|
||||
| ----- ^^^^^^^^ cannot infer type for `T` in `std::vec::Vec<T>`
|
||||
| |
|
||||
| consider giving `x` a type
|
||||
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
error[E0282]: type annotations needed in `std::vec::Vec<_>`
|
||||
error[E0282]: type annotations needed in `std::vec::Vec<T>`
|
||||
--> $DIR/cannot_infer_local_or_vec.rs:2:13
|
||||
|
|
||||
LL | let x = vec![];
|
||||
| - ^^^^^^ cannot infer type for `T` in `std::vec::Vec<_>`
|
||||
| - ^^^^^^ cannot infer type for `T` in `std::vec::Vec<T>`
|
||||
| |
|
||||
| consider giving `x` a type
|
||||
|
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
error[E0282]: type annotations needed in `(std::vec::Vec<_>,)`
|
||||
error[E0282]: type annotations needed in `(std::vec::Vec<T>,)`
|
||||
--> $DIR/cannot_infer_local_or_vec_in_tuples.rs:2:18
|
||||
|
|
||||
LL | let (x, ) = (vec![], );
|
||||
| ----- ^^^^^^ cannot infer type for `T` in `(std::vec::Vec<_>,)`
|
||||
| ----- ^^^^^^ cannot infer type for `T` in `(std::vec::Vec<T>,)`
|
||||
| |
|
||||
| consider giving the pattern a type
|
||||
|
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
error[E0282]: type annotations needed in `std::option::Option<_>`
|
||||
error[E0282]: type annotations needed in `std::option::Option<T>`
|
||||
--> $DIR/unboxed-closures-failed-recursive-fn-2.rs:16:32
|
||||
|
|
||||
LL | let mut closure0 = None;
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
error[E0282]: type annotations needed in `std::vec::Vec<_>`
|
||||
error[E0282]: type annotations needed in `std::vec::Vec<T>`
|
||||
--> $DIR/vector-no-ann.rs:2:16
|
||||
|
|
||||
LL | let _foo = Vec::new();
|
||||
| ---- ^^^^^^^^ cannot infer type for `T` in `std::vec::Vec<_>`
|
||||
| ---- ^^^^^^^^ cannot infer type for `T` in `std::vec::Vec<T>`
|
||||
| |
|
||||
| consider giving `_foo` a type
|
||||
|
||||
|
|
Loading…
Reference in New Issue