Skip to content
Permalink
Browse files

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`
```
  • Loading branch information...
estebank committed May 30, 2019
1 parent 65c2a7b commit 74fb3bbee45d54e1680832ba064fa1af8d344bc0
@@ -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

0 comments on commit 74fb3bb

Please sign in to comment.
You can’t perform that action at this time.