Skip to content

Commit 5e2f37f

Browse files
borsbors
committed
Auto merge of #38057 - KiChjang:display-formal-type-param, r=nikomatsakis
Display better error messages for E0282 Fixes #36554.
2 parents 3db197a + d24028b commit 5e2f37f

28 files changed

+191
-76
lines changed

‎src/librustc/infer/glb.rs

+5
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ use super::InferCtxt;
1313
use super::lattice::{self, LatticeDir};
1414
use super::Subtype;
1515

16+
use traits::ObligationCause;
1617
use ty::{self, Ty, TyCtxt};
1718
use ty::relate::{Relate, RelateResult, TypeRelation};
1819

@@ -83,6 +84,10 @@ impl<'combine, 'infcx, 'gcx, 'tcx> LatticeDir<'infcx, 'gcx, 'tcx>
8384
self.fields.infcx
8485
}
8586

87+
fn cause(&self) -> &ObligationCause<'tcx> {
88+
&self.fields.trace.cause
89+
}
90+
8691
fn relate_bound(&mut self, v: Ty<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()> {
8792
let mut sub = self.fields.sub(self.a_is_expected);
8893
sub.relate(&v, &a)?;

‎src/librustc/infer/lattice.rs

+7-2
Original file line numberDiff line numberDiff line change
@@ -30,14 +30,18 @@
3030
//! a lattice.
3131
3232
use super::InferCtxt;
33+
use super::type_variable::TypeVariableOrigin;
3334

35+
use traits::ObligationCause;
3436
use ty::TyVar;
3537
use ty::{self, Ty};
3638
use ty::relate::{RelateResult, TypeRelation};
3739

3840
pub trait LatticeDir<'f, 'gcx: 'f+'tcx, 'tcx: 'f> : TypeRelation<'f, 'gcx, 'tcx> {
3941
fn infcx(&self) -> &'f InferCtxt<'f, 'gcx, 'tcx>;
4042

43+
fn cause(&self) -> &ObligationCause<'tcx>;
44+
4145
// Relates the type `v` to `a` and `b` such that `v` represents
4246
// the LUB/GLB of `a` and `b` as appropriate.
4347
fn relate_bound(&mut self, v: Ty<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()>;
@@ -64,14 +68,15 @@ pub fn super_lattice_tys<'a, 'gcx, 'tcx, L>(this: &mut L,
6468
match (&a.sty, &b.sty) {
6569
(&ty::TyInfer(TyVar(..)), &ty::TyInfer(TyVar(..)))
6670
if infcx.type_var_diverges(a) && infcx.type_var_diverges(b) => {
67-
let v = infcx.next_diverging_ty_var();
71+
let v = infcx.next_diverging_ty_var(
72+
TypeVariableOrigin::LatticeVariable(this.cause().span));
6873
this.relate_bound(v, a, b)?;
6974
Ok(v)
7075
}
7176

7277
(&ty::TyInfer(TyVar(..)), _) |
7378
(_, &ty::TyInfer(TyVar(..))) => {
74-
let v = infcx.next_ty_var();
79+
let v = infcx.next_ty_var(TypeVariableOrigin::LatticeVariable(this.cause().span));
7580
this.relate_bound(v, a, b)?;
7681
Ok(v)
7782
}

‎src/librustc/infer/lub.rs

+5
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ use super::InferCtxt;
1313
use super::lattice::{self, LatticeDir};
1414
use super::Subtype;
1515

16+
use traits::ObligationCause;
1617
use ty::{self, Ty, TyCtxt};
1718
use ty::relate::{Relate, RelateResult, TypeRelation};
1819

@@ -83,6 +84,10 @@ impl<'combine, 'infcx, 'gcx, 'tcx> LatticeDir<'infcx, 'gcx, 'tcx>
8384
self.fields.infcx
8485
}
8586

87+
fn cause(&self) -> &ObligationCause<'tcx> {
88+
&self.fields.trace.cause
89+
}
90+
8691
fn relate_bound(&mut self, v: Ty<'tcx>, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, ()> {
8792
let mut sub = self.fields.sub(self.a_is_expected);
8893
sub.relate(&a, &v)?;

‎src/librustc/infer/mod.rs

+11-8
Original file line numberDiff line numberDiff line change
@@ -45,6 +45,7 @@ use util::nodemap::{FxHashMap, FxHashSet, NodeMap};
4545
use self::combine::CombineFields;
4646
use self::higher_ranked::HrMatchResult;
4747
use self::region_inference::{RegionVarBindings, RegionSnapshot};
48+
use self::type_variable::TypeVariableOrigin;
4849
use self::unify_key::ToType;
4950

5051
mod bivariate;
@@ -114,7 +115,7 @@ pub struct InferCtxt<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
114115
// We instantiate UnificationTable with bounds<Ty> because the
115116
// types that might instantiate a general type variable have an
116117
// order, represented by its upper and lower bounds.
117-
type_variables: RefCell<type_variable::TypeVariableTable<'tcx>>,
118+
pub type_variables: RefCell<type_variable::TypeVariableTable<'tcx>>,
118119

119120
// Map from integral variable to the kind of integer it represents
120121
int_unification_table: RefCell<UnificationTable<ty::IntVid>>,
@@ -1054,18 +1055,18 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
10541055
})
10551056
}
10561057

1057-
pub fn next_ty_var_id(&self, diverging: bool) -> TyVid {
1058+
pub fn next_ty_var_id(&self, diverging: bool, origin: TypeVariableOrigin) -> TyVid {
10581059
self.type_variables
10591060
.borrow_mut()
1060-
.new_var(diverging, None)
1061+
.new_var(diverging, origin, None)
10611062
}
10621063

1063-
pub fn next_ty_var(&self) -> Ty<'tcx> {
1064-
self.tcx.mk_var(self.next_ty_var_id(false))
1064+
pub fn next_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
1065+
self.tcx.mk_var(self.next_ty_var_id(false, origin))
10651066
}
10661067

1067-
pub fn next_diverging_ty_var(&self) -> Ty<'tcx> {
1068-
self.tcx.mk_var(self.next_ty_var_id(true))
1068+
pub fn next_diverging_ty_var(&self, origin: TypeVariableOrigin) -> Ty<'tcx> {
1069+
self.tcx.mk_var(self.next_ty_var_id(true, origin))
10691070
}
10701071

10711072
pub fn next_int_var_id(&self) -> IntVid {
@@ -1118,7 +1119,9 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
11181119

11191120
let ty_var_id = self.type_variables
11201121
.borrow_mut()
1121-
.new_var(false, default);
1122+
.new_var(false,
1123+
TypeVariableOrigin::TypeParameterDefinition(span, def.name),
1124+
default);
11221125

11231126
self.tcx.mk_var(ty_var_id)
11241127
}

‎src/librustc/infer/type_variable.rs

+24-1
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,7 @@ use self::TypeVariableValue::*;
1313
use self::UndoEntry::*;
1414
use hir::def_id::{DefId};
1515
use syntax::util::small_vector::SmallVector;
16+
use syntax::ast;
1617
use syntax_pos::Span;
1718
use ty::{self, Ty};
1819

@@ -28,8 +29,24 @@ pub struct TypeVariableTable<'tcx> {
2829
eq_relations: ut::UnificationTable<ty::TyVid>,
2930
}
3031

32+
/// Reasons to create a type inference variable
33+
pub enum TypeVariableOrigin {
34+
MiscVariable(Span),
35+
NormalizeProjectionType(Span),
36+
TypeInference(Span),
37+
TypeParameterDefinition(Span, ast::Name),
38+
TransformedUpvar(Span),
39+
SubstitutionPlaceholder(Span),
40+
AutoDeref(Span),
41+
AdjustmentType(Span),
42+
DivergingStmt(Span),
43+
DivergingBlockExpr(Span),
44+
LatticeVariable(Span),
45+
}
46+
3147
struct TypeVariableData<'tcx> {
3248
value: TypeVariableValue<'tcx>,
49+
origin: TypeVariableOrigin,
3350
diverging: bool
3451
}
3552

@@ -107,6 +124,10 @@ impl<'tcx> TypeVariableTable<'tcx> {
107124
self.values.get(vid.index as usize).diverging
108125
}
109126

127+
pub fn var_origin(&self, vid: ty::TyVid) -> &TypeVariableOrigin {
128+
&self.values.get(vid.index as usize).origin
129+
}
130+
110131
/// Records that `a <: b`, `a :> b`, or `a == b`, depending on `dir`.
111132
///
112133
/// Precondition: neither `a` nor `b` are known.
@@ -173,10 +194,12 @@ impl<'tcx> TypeVariableTable<'tcx> {
173194

174195
pub fn new_var(&mut self,
175196
diverging: bool,
176-
default: Option<Default<'tcx>>) -> ty::TyVid {
197+
origin: TypeVariableOrigin,
198+
default: Option<Default<'tcx>>,) -> ty::TyVid {
177199
self.eq_relations.new_key(());
178200
let index = self.values.push(TypeVariableData {
179201
value: Bounded { relations: vec![], default: default },
202+
origin: origin,
180203
diverging: diverging
181204
});
182205
let v = ty::TyVid { index: index as u32 };

‎src/librustc/traits/error_reporting.rs

+23-6
Original file line numberDiff line numberDiff line change
@@ -27,6 +27,7 @@ use super::{
2727
use fmt_macros::{Parser, Piece, Position};
2828
use hir::def_id::DefId;
2929
use infer::{self, InferCtxt};
30+
use infer::type_variable::TypeVariableOrigin;
3031
use rustc::lint::builtin::EXTRA_REQUIREMENT_IN_IMPL;
3132
use ty::{self, AdtKind, ToPredicate, ToPolyTraitRef, Ty, TyCtxt, TypeFoldable};
3233
use ty::error::ExpectedFound;
@@ -38,7 +39,7 @@ use util::nodemap::{FxHashMap, FxHashSet};
3839
use std::cmp;
3940
use std::fmt;
4041
use syntax::ast;
41-
use syntax_pos::Span;
42+
use syntax_pos::{DUMMY_SP, Span};
4243
use errors::DiagnosticBuilder;
4344

4445
#[derive(Debug, PartialEq, Eq, Hash)]
@@ -790,9 +791,11 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
790791
fn tcx<'b>(&'b self) -> TyCtxt<'b, 'gcx, 'tcx> { self.infcx.tcx }
791792

792793
fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> {
793-
if let ty::TyParam(..) = ty.sty {
794+
if let ty::TyParam(ty::ParamTy {name, ..}) = ty.sty {
794795
let infcx = self.infcx;
795-
self.var_map.entry(ty).or_insert_with(|| infcx.next_ty_var())
796+
self.var_map.entry(ty).or_insert_with(||
797+
infcx.next_ty_var(
798+
TypeVariableOrigin::TypeParameterDefinition(DUMMY_SP, name)))
796799
} else {
797800
ty.super_fold_with(self)
798801
}
@@ -824,12 +827,26 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
824827

825828

826829
fn need_type_info(&self, span: Span, ty: Ty<'tcx>) {
830+
let ty = self.resolve_type_vars_if_possible(&ty);
831+
let name = if let ty::TyInfer(ty::TyVar(ty_vid)) = ty.sty {
832+
let ty_vars = self.type_variables.borrow();
833+
if let TypeVariableOrigin::TypeParameterDefinition(_, name) =
834+
*ty_vars.var_origin(ty_vid)
835+
{
836+
name.to_string()
837+
} else {
838+
ty.to_string()
839+
}
840+
} else {
841+
ty.to_string()
842+
};
843+
827844
let mut err = struct_span_err!(self.tcx.sess, span, E0282,
828845
"unable to infer enough type information about `{}`",
829-
ty);
846+
name);
830847
err.note("type annotations or generic parameter binding required");
831-
err.span_label(span, &format!("cannot infer type for `{}`", ty));
832-
err.emit()
848+
err.span_label(span, &format!("cannot infer type for `{}`", name));
849+
err.emit();
833850
}
834851

835852
fn note_obligation_cause<T>(&self,

‎src/librustc/traits/project.rs

+13-2
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@ use super::util;
2525

2626
use hir::def_id::DefId;
2727
use infer::InferOk;
28+
use infer::type_variable::TypeVariableOrigin;
2829
use rustc_data_structures::snapshot_map::{Snapshot, SnapshotMap};
2930
use syntax::ast;
3031
use syntax::symbol::Symbol;
@@ -382,7 +383,12 @@ pub fn normalize_projection_type<'a, 'b, 'gcx, 'tcx>(
382383
// and a deferred predicate to resolve this when more type
383384
// information is available.
384385

385-
let ty_var = selcx.infcx().next_ty_var();
386+
let tcx = selcx.infcx().tcx;
387+
let def_id = tcx.associated_items(projection_ty.trait_ref.def_id).find(|i|
388+
i.name == projection_ty.item_name && i.kind == ty::AssociatedKind::Type
389+
).map(|i| i.def_id).unwrap();
390+
let ty_var = selcx.infcx().next_ty_var(
391+
TypeVariableOrigin::NormalizeProjectionType(tcx.def_span(def_id)));
386392
let projection = ty::Binder(ty::ProjectionPredicate {
387393
projection_ty: projection_ty,
388394
ty: ty_var
@@ -596,7 +602,12 @@ fn normalize_to_error<'a, 'gcx, 'tcx>(selcx: &mut SelectionContext<'a, 'gcx, 'tc
596602
let trait_obligation = Obligation { cause: cause,
597603
recursion_depth: depth,
598604
predicate: trait_ref.to_predicate() };
599-
let new_value = selcx.infcx().next_ty_var();
605+
let tcx = selcx.infcx().tcx;
606+
let def_id = tcx.associated_items(projection_ty.trait_ref.def_id).find(|i|
607+
i.name == projection_ty.item_name && i.kind == ty::AssociatedKind::Type
608+
).map(|i| i.def_id).unwrap();
609+
let new_value = selcx.infcx().next_ty_var(
610+
TypeVariableOrigin::NormalizeProjectionType(tcx.def_span(def_id)));
600611
Normalized {
601612
value: new_value,
602613
obligations: vec![trait_obligation]

‎src/librustc_driver/test.rs

+5-3
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,7 @@ use rustc::ty::subst::{Kind, Subst};
2424
use rustc::traits::{ObligationCause, Reveal};
2525
use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
2626
use rustc::infer::{self, InferOk, InferResult};
27+
use rustc::infer::type_variable::TypeVariableOrigin;
2728
use rustc_metadata::cstore::CStore;
2829
use rustc::hir::map as hir_map;
2930
use rustc::session::{self, config};
@@ -36,6 +37,7 @@ use errors::emitter::Emitter;
3637
use errors::{Level, DiagnosticBuilder};
3738
use syntax::feature_gate::UnstableFeatures;
3839
use syntax::symbol::Symbol;
40+
use syntax_pos::DUMMY_SP;
3941

4042
use rustc::hir;
4143

@@ -489,7 +491,7 @@ fn sub_free_bound_false_infer() {
489491
//! does NOT hold for any instantiation of `_#1`.
490492
491493
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
492-
let t_infer1 = env.infcx.next_ty_var();
494+
let t_infer1 = env.infcx.next_ty_var(TypeVariableOrigin::MiscVariable(DUMMY_SP));
493495
let t_rptr_bound1 = env.t_rptr_late_bound(1);
494496
env.check_not_sub(env.t_fn(&[t_infer1], env.tcx().types.isize),
495497
env.t_fn(&[t_rptr_bound1], env.tcx().types.isize));
@@ -508,7 +510,7 @@ fn lub_free_bound_infer() {
508510
509511
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
510512
env.create_simple_region_hierarchy();
511-
let t_infer1 = env.infcx.next_ty_var();
513+
let t_infer1 = env.infcx.next_ty_var(TypeVariableOrigin::MiscVariable(DUMMY_SP));
512514
let t_rptr_bound1 = env.t_rptr_late_bound(1);
513515
let t_rptr_free1 = env.t_rptr_free(1, 1);
514516
env.check_lub(env.t_fn(&[t_infer1], env.tcx().types.isize),
@@ -628,7 +630,7 @@ fn glb_bound_free() {
628630
fn glb_bound_free_infer() {
629631
test_env(EMPTY_SOURCE_STR, errors(&[]), |env| {
630632
let t_rptr_bound1 = env.t_rptr_late_bound(1);
631-
let t_infer1 = env.infcx.next_ty_var();
633+
let t_infer1 = env.infcx.next_ty_var(TypeVariableOrigin::MiscVariable(DUMMY_SP));
632634

633635
// compute GLB(fn(_) -> isize, for<'b> fn(&'b isize) -> isize),
634636
// which should yield for<'b> fn(&'b isize) -> isize

‎src/librustc_typeck/check/_match.rs

+11-5
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ use rustc::hir::{self, PatKind};
1212
use rustc::hir::def::{Def, CtorKind};
1313
use rustc::hir::pat_util::EnumerateAndAdjustIterator;
1414
use rustc::infer;
15+
use rustc::infer::type_variable::TypeVariableOrigin;
1516
use rustc::traits::ObligationCauseCode;
1617
use rustc::ty::{self, Ty, TypeFoldable, LvaluePreference};
1718
use check::{FnCtxt, Expectation, Diverges};
@@ -162,7 +163,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
162163
}
163164
let max_len = cmp::max(expected_len, elements.len());
164165

165-
let element_tys_iter = (0..max_len).map(|_| self.next_ty_var());
166+
let element_tys_iter = (0..max_len).map(|_| self.next_ty_var(
167+
// FIXME: MiscVariable for now, obtaining the span and name information
168+
// from all tuple elements isn't trivial.
169+
TypeVariableOrigin::TypeInference(pat.span)));
166170
let element_tys = tcx.mk_type_list(element_tys_iter);
167171
let pat_ty = tcx.mk_ty(ty::TyTuple(element_tys));
168172
self.demand_eqtype(pat.span, expected, pat_ty);
@@ -172,7 +176,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
172176
pat_ty
173177
}
174178
PatKind::Box(ref inner) => {
175-
let inner_ty = self.next_ty_var();
179+
let inner_ty = self.next_ty_var(TypeVariableOrigin::TypeInference(inner.span));
176180
let uniq_ty = tcx.mk_box(inner_ty);
177181

178182
if self.check_dereferencable(pat.span, expected, &inner) {
@@ -203,7 +207,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
203207
(expected, mt.ty)
204208
}
205209
_ => {
206-
let inner_ty = self.next_ty_var();
210+
let inner_ty = self.next_ty_var(
211+
TypeVariableOrigin::TypeInference(inner.span));
207212
let mt = ty::TypeAndMut { ty: inner_ty, mutbl: mutbl };
208213
let region = self.next_region_var(infer::PatternRegion(pat.span));
209214
let rptr_ty = tcx.mk_ref(region, mt);
@@ -379,7 +384,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
379384
// ...but otherwise we want to use any supertype of the
380385
// discriminant. This is sort of a workaround, see note (*) in
381386
// `check_pat` for some details.
382-
discrim_ty = self.next_ty_var();
387+
discrim_ty = self.next_ty_var(TypeVariableOrigin::TypeInference(discrim.span));
383388
self.check_expr_has_type(discrim, discrim_ty);
384389
};
385390
let discrim_diverges = self.diverges.get();
@@ -407,7 +412,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
407412
// of execution reach it, we will panic, so bottom is an appropriate
408413
// type in that case)
409414
let expected = expected.adjust_for_branches(self);
410-
let mut result_ty = self.next_diverging_ty_var();
415+
let mut result_ty = self.next_diverging_ty_var(
416+
TypeVariableOrigin::DivergingBlockExpr(expr.span));
411417
let mut all_arms_diverge = Diverges::WarnedAlways;
412418
let coerce_first = match expected {
413419
// We don't coerce to `()` so that if the match expression is a

0 commit comments

Comments
 (0)