diff --git a/src/librustc/middle/infer/error_reporting.rs b/src/librustc/middle/infer/error_reporting.rs index 111872f1784..1b118520339 100644 --- a/src/librustc/middle/infer/error_reporting.rs +++ b/src/librustc/middle/infer/error_reporting.rs @@ -78,7 +78,7 @@ use rustc_front::print::pprust; use middle::def; use middle::def_id::DefId; -use middle::infer; +use middle::infer::{self, TypeOrigin}; use middle::region; use middle::subst; use middle::ty::{self, Ty, HasTypeFlags}; @@ -474,7 +474,7 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> { self.check_and_note_conflicting_crates(terr, trace.origin.span()); match trace.origin { - infer::MatchExpressionArm(_, arm_span, source) => match source { + TypeOrigin::MatchExpressionArm(_, arm_span, source) => match source { hir::MatchSource::IfLetDesugar{..} => self.tcx.sess.span_note(arm_span, "`if let` arm with an incompatible type"), _ => self.tcx.sess.span_note(arm_span, "match arm with an incompatible type"), @@ -1602,38 +1602,38 @@ impl<'a, 'tcx> ErrorReportingHelpers<'tcx> for InferCtxt<'a, 'tcx> { } infer::Subtype(ref trace) => { let desc = match trace.origin { - infer::Misc(_) => { + TypeOrigin::Misc(_) => { "types are compatible" } - infer::MethodCompatCheck(_) => { + TypeOrigin::MethodCompatCheck(_) => { "method type is compatible with trait" } - infer::ExprAssignable(_) => { + TypeOrigin::ExprAssignable(_) => { "expression is assignable" } - infer::RelateTraitRefs(_) => { + TypeOrigin::RelateTraitRefs(_) => { "traits are compatible" } - infer::RelateSelfType(_) => { + TypeOrigin::RelateSelfType(_) => { "self type matches impl self type" } - infer::RelateOutputImplTypes(_) => { + TypeOrigin::RelateOutputImplTypes(_) => { "trait type parameters matches those \ specified on the impl" } - infer::MatchExpressionArm(_, _, _) => { + TypeOrigin::MatchExpressionArm(_, _, _) => { "match arms have compatible types" } - infer::IfExpression(_) => { + TypeOrigin::IfExpression(_) => { "if and else have compatible types" } - infer::IfExpressionWithNoElse(_) => { + TypeOrigin::IfExpressionWithNoElse(_) => { "if may be missing an else clause" } - infer::RangeExpression(_) => { + TypeOrigin::RangeExpression(_) => { "start and end of range have compatible types" } - infer::EquatePredicate(_) => { + TypeOrigin::EquatePredicate(_) => { "equality where clause is satisfied" } }; diff --git a/src/librustc/middle/infer/mod.rs b/src/librustc/middle/infer/mod.rs index d61029a2d2d..b39ddfe95c8 100644 --- a/src/librustc/middle/infer/mod.rs +++ b/src/librustc/middle/infer/mod.rs @@ -13,7 +13,6 @@ pub use self::LateBoundRegionConversionTime::*; pub use self::RegionVariableOrigin::*; pub use self::SubregionOrigin::*; -pub use self::TypeOrigin::*; pub use self::ValuePairs::*; pub use middle::ty::IntVarValue; pub use self::freshen::TypeFreshener; @@ -440,7 +439,7 @@ pub fn can_mk_subty<'a, 'tcx>(cx: &InferCtxt<'a, 'tcx>, debug!("can_mk_subty({:?} <: {:?})", a, b); cx.probe(|_| { let trace = TypeTrace { - origin: Misc(codemap::DUMMY_SP), + origin: TypeOrigin::Misc(codemap::DUMMY_SP), values: Types(expected_found(true, a, b)) }; cx.sub(true, trace).relate(&a, &b).map(|_| ()) @@ -950,7 +949,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { self.commit_if_ok(|snapshot| { let (ty::EquatePredicate(a, b), skol_map) = self.skolemize_late_bound_regions(predicate, snapshot); - let origin = EquatePredicate(span); + let origin = TypeOrigin::EquatePredicate(span); let () = try!(mk_eqty(self, false, origin, a, b)); self.leak_check(&skol_map, snapshot) }) @@ -1328,7 +1327,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { actual: Ty<'tcx>, err: &TypeError<'tcx>) { let trace = TypeTrace { - origin: Misc(span), + origin: TypeOrigin::Misc(span), values: Types(ExpectedFound { expected: expected, found: actual @@ -1342,7 +1341,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { expected: type_variable::Default<'tcx>, actual: type_variable::Default<'tcx>) { let trace = TypeTrace { - origin: Misc(span), + origin: TypeOrigin::Misc(span), values: Types(ExpectedFound { expected: expected.ty, found: actual.ty @@ -1393,8 +1392,10 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> { // generic so we don't have to do anything quite this // terrible. let e = self.tcx.types.err; - let trace = TypeTrace { origin: Misc(codemap::DUMMY_SP), - values: Types(expected_found(true, e, e)) }; + let trace = TypeTrace { + origin: TypeOrigin::Misc(codemap::DUMMY_SP), + values: Types(expected_found(true, e, e)) + }; self.equate(true, trace).relate(a, b) }).map(|_| ()) } @@ -1525,7 +1526,7 @@ impl<'tcx> TypeTrace<'tcx> { pub fn dummy(tcx: &ty::ctxt<'tcx>) -> TypeTrace<'tcx> { TypeTrace { - origin: Misc(codemap::DUMMY_SP), + origin: TypeOrigin::Misc(codemap::DUMMY_SP), values: Types(ExpectedFound { expected: tcx.types.err, found: tcx.types.err, @@ -1543,17 +1544,17 @@ impl<'tcx> fmt::Debug for TypeTrace<'tcx> { impl TypeOrigin { pub fn span(&self) -> Span { match *self { - MethodCompatCheck(span) => span, - ExprAssignable(span) => span, - Misc(span) => span, - RelateTraitRefs(span) => span, - RelateSelfType(span) => span, - RelateOutputImplTypes(span) => span, - MatchExpressionArm(match_span, _, _) => match_span, - IfExpression(span) => span, - IfExpressionWithNoElse(span) => span, - RangeExpression(span) => span, - EquatePredicate(span) => span, + TypeOrigin::MethodCompatCheck(span) => span, + TypeOrigin::ExprAssignable(span) => span, + TypeOrigin::Misc(span) => span, + TypeOrigin::RelateTraitRefs(span) => span, + TypeOrigin::RelateSelfType(span) => span, + TypeOrigin::RelateOutputImplTypes(span) => span, + TypeOrigin::MatchExpressionArm(match_span, _, _) => match_span, + TypeOrigin::IfExpression(span) => span, + TypeOrigin::IfExpressionWithNoElse(span) => span, + TypeOrigin::RangeExpression(span) => span, + TypeOrigin::EquatePredicate(span) => span, } } } diff --git a/src/librustc/middle/traits/coherence.rs b/src/librustc/middle/traits/coherence.rs index bf950ff6dc9..705cb97a898 100644 --- a/src/librustc/middle/traits/coherence.rs +++ b/src/librustc/middle/traits/coherence.rs @@ -21,7 +21,7 @@ use metadata::cstore::LOCAL_CRATE; use middle::def_id::DefId; use middle::subst::{Subst, Substs, TypeSpace}; use middle::ty::{self, Ty}; -use middle::infer::{self, InferCtxt}; +use middle::infer::{self, InferCtxt, TypeOrigin}; use syntax::codemap::{DUMMY_SP, Span}; #[derive(Copy, Clone)] @@ -70,7 +70,7 @@ fn overlap(selcx: &mut SelectionContext, // Do `a` and `b` unify? If not, no overlap. if let Err(_) = infer::mk_eq_trait_refs(selcx.infcx(), true, - infer::Misc(DUMMY_SP), + TypeOrigin::Misc(DUMMY_SP), a_trait_ref, b_trait_ref) { return false; diff --git a/src/librustc/middle/traits/project.rs b/src/librustc/middle/traits/project.rs index f49202eb6c8..8fbfd513c78 100644 --- a/src/librustc/middle/traits/project.rs +++ b/src/librustc/middle/traits/project.rs @@ -21,7 +21,7 @@ use super::VtableClosureData; use super::VtableImplData; use super::util; -use middle::infer; +use middle::infer::{self, TypeOrigin}; use middle::subst::Subst; use middle::ty::{self, ToPredicate, RegionEscape, HasTypeFlags, ToPolyTraitRef, Ty}; use middle::ty::fold::{TypeFoldable, TypeFolder}; @@ -138,7 +138,7 @@ fn project_and_unify_type<'cx,'tcx>( obligations); let infcx = selcx.infcx(); - let origin = infer::RelateOutputImplTypes(obligation.cause.span); + let origin = TypeOrigin::RelateOutputImplTypes(obligation.cause.span); match infer::mk_eqty(infcx, true, origin, normalized_ty, obligation.predicate.ty) { Ok(()) => Ok(Some(obligations)), Err(err) => Err(MismatchedProjectionTypes { err: err }), @@ -183,7 +183,7 @@ fn consider_unification_despite_ambiguity<'cx,'tcx>(selcx: &mut SelectionContext debug!("consider_unification_despite_ambiguity: ret_type={:?}", ret_type); - let origin = infer::RelateOutputImplTypes(obligation.cause.span); + let origin = TypeOrigin::RelateOutputImplTypes(obligation.cause.span); let obligation_ty = obligation.predicate.ty; match infer::mk_eqty(infcx, true, origin, obligation_ty, ret_type) { Ok(()) => { } @@ -645,7 +645,7 @@ fn assemble_candidates_from_predicates<'cx,'tcx,I>( let same_name = data.item_name() == obligation.predicate.item_name; let is_match = same_name && infcx.probe(|_| { - let origin = infer::Misc(obligation.cause.span); + let origin = TypeOrigin::Misc(obligation.cause.span); let data_poly_trait_ref = data.to_poly_trait_ref(); let obligation_poly_trait_ref = @@ -901,7 +901,7 @@ fn confirm_param_env_candidate<'cx,'tcx>( assert_eq!(projection.projection_ty.item_name, obligation.predicate.item_name); - let origin = infer::RelateOutputImplTypes(obligation.cause.span); + let origin = TypeOrigin::RelateOutputImplTypes(obligation.cause.span); match infcx.eq_trait_refs(false, origin, obligation.predicate.trait_ref.clone(), diff --git a/src/librustc/middle/traits/select.rs b/src/librustc/middle/traits/select.rs index cd08c4feb8d..e73f0cafb04 100644 --- a/src/librustc/middle/traits/select.rs +++ b/src/librustc/middle/traits/select.rs @@ -38,7 +38,7 @@ use super::util; use middle::def_id::DefId; use middle::infer; -use middle::infer::{InferCtxt, TypeFreshener}; +use middle::infer::{InferCtxt, TypeFreshener, TypeOrigin}; use middle::subst::{Subst, Substs, TypeSpace}; use middle::ty::{self, ToPredicate, RegionEscape, ToPolyTraitRef, Ty, HasTypeFlags}; use middle::ty::fast_reject; @@ -1155,7 +1155,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { -> bool { assert!(!skol_trait_ref.has_escaping_regions()); - let origin = infer::RelateOutputImplTypes(obligation.cause.span); + let origin = TypeOrigin::RelateOutputImplTypes(obligation.cause.span); match self.infcx.sub_poly_trait_refs(false, origin, trait_bound.clone(), @@ -2444,7 +2444,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { expected_trait_ref: ty::PolyTraitRef<'tcx>) -> Result<(), SelectionError<'tcx>> { - let origin = infer::RelateOutputImplTypes(obligation_cause.span); + let origin = TypeOrigin::RelateOutputImplTypes(obligation_cause.span); let obligation_trait_ref = obligation_trait_ref.clone(); match self.infcx.sub_poly_trait_refs(false, @@ -2483,7 +2483,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { }; let new_trait = tcx.mk_trait(data_a.principal.clone(), bounds); - let origin = infer::Misc(obligation.cause.span); + let origin = TypeOrigin::Misc(obligation.cause.span); if self.infcx.sub_types(false, origin, new_trait, target).is_err() { return Err(Unimplemented); } @@ -2548,7 +2548,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { // [T; n] -> [T]. (&ty::TyArray(a, _), &ty::TySlice(b)) => { - let origin = infer::Misc(obligation.cause.span); + let origin = TypeOrigin::Misc(obligation.cause.span); if self.infcx.sub_types(false, origin, a, b).is_err() { return Err(Unimplemented); } @@ -2606,7 +2606,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { new_substs.types.get_mut_slice(TypeSpace)[i] = param_b; } let new_struct = tcx.mk_struct(def, tcx.mk_substs(new_substs)); - let origin = infer::Misc(obligation.cause.span); + let origin = TypeOrigin::Misc(obligation.cause.span); if self.infcx.sub_types(false, origin, new_struct, target).is_err() { return Err(Unimplemented); } @@ -2694,7 +2694,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { impl_trait_ref, skol_obligation_trait_ref); - let origin = infer::RelateOutputImplTypes(obligation.cause.span); + let origin = TypeOrigin::RelateOutputImplTypes(obligation.cause.span); if let Err(e) = self.infcx.eq_trait_refs(false, origin, impl_trait_ref.value.clone(), @@ -2763,7 +2763,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { obligation, poly_trait_ref); - let origin = infer::RelateOutputImplTypes(obligation.cause.span); + let origin = TypeOrigin::RelateOutputImplTypes(obligation.cause.span); match self.infcx.sub_poly_trait_refs(false, origin, poly_trait_ref, diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index e33f5df4d3d..aa439e102eb 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -25,7 +25,7 @@ use rustc_typeck::middle::subst; use rustc_typeck::middle::subst::Subst; use rustc_typeck::middle::ty::{self, Ty, RegionEscape}; use rustc_typeck::middle::ty::relate::TypeRelation; -use rustc_typeck::middle::infer; +use rustc_typeck::middle::infer::{self, TypeOrigin}; use rustc_typeck::middle::infer::lub::Lub; use rustc_typeck::middle::infer::glb::Glb; use rustc_typeck::middle::infer::sub::Sub; @@ -230,7 +230,7 @@ impl<'a, 'tcx> Env<'a, 'tcx> { } pub fn make_subtype(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> bool { - match infer::mk_subty(self.infcx, true, infer::Misc(DUMMY_SP), a, b) { + match infer::mk_subty(self.infcx, true, TypeOrigin::Misc(DUMMY_SP), a, b) { Ok(_) => true, Err(ref e) => panic!("Encountered error: {}", e), } diff --git a/src/librustc_typeck/check/_match.rs b/src/librustc_typeck/check/_match.rs index aaaca486006..5ffe34d61bf 100644 --- a/src/librustc_typeck/check/_match.rs +++ b/src/librustc_typeck/check/_match.rs @@ -9,7 +9,7 @@ // except according to those terms. use middle::def; -use middle::infer; +use middle::infer::{self, TypeOrigin}; use middle::pat_util::{PatIdMap, pat_id_map, pat_is_binding}; use middle::pat_util::pat_is_resolved_const; use middle::privacy::{AllPublic, LastMod}; @@ -509,12 +509,12 @@ pub fn check_match<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, /* if-let construct without an else block */ hir::MatchSource::IfLetDesugar { contains_else_clause } if !contains_else_clause => ( - infer::IfExpressionWithNoElse(expr.span), + TypeOrigin::IfExpressionWithNoElse(expr.span), bty, result_ty, ), _ => ( - infer::MatchExpressionArm(expr.span, arm.body.span, match_src), + TypeOrigin::MatchExpressionArm(expr.span, arm.body.span, match_src), result_ty, bty, ), diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index 69efaa792fe..85f0aa3bbd3 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -62,7 +62,7 @@ use check::{autoderef, FnCtxt, UnresolvedTypeAction}; -use middle::infer::{self, Coercion}; +use middle::infer::{self, Coercion, TypeOrigin}; use middle::traits::{self, ObligationCause}; use middle::traits::{predicate_for_trait_def, report_selection_error}; use middle::ty::adjustment::{AutoAdjustment, AutoDerefRef, AdjustDerefRef}; @@ -444,7 +444,7 @@ pub fn mk_assignty<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, fcx.infcx().commit_if_ok(|_| { let coerce = Coerce { fcx: fcx, - origin: infer::ExprAssignable(expr.span), + origin: TypeOrigin::ExprAssignable(expr.span), unsizing_obligations: RefCell::new(vec![]) }; let adjustment = try!(coerce.coerce(expr, a, b)); diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs index c46f386af27..d28a673f748 100644 --- a/src/librustc_typeck/check/compare_method.rs +++ b/src/librustc_typeck/check/compare_method.rs @@ -9,7 +9,7 @@ // except according to those terms. use middle::free_region::FreeRegionMap; -use middle::infer; +use middle::infer::{self, TypeOrigin}; use middle::traits; use middle::ty::{self}; use middle::subst::{self, Subst, Substs, VecPerParamSpace}; @@ -282,7 +282,7 @@ pub fn compare_impl_method<'tcx>(tcx: &ty::ctxt<'tcx>, let trait_fty = trait_fty.subst(tcx, &trait_to_skol_substs); let err = infcx.commit_if_ok(|snapshot| { - let origin = infer::MethodCompatCheck(impl_m_span); + let origin = TypeOrigin::MethodCompatCheck(impl_m_span); let (impl_sig, _) = infcx.replace_late_bound_regions_with_fresh_var(impl_m_span, @@ -448,7 +448,7 @@ pub fn compare_const_impl<'tcx>(tcx: &ty::ctxt<'tcx>, let trait_ty = trait_c.ty.subst(tcx, &trait_to_skol_substs); let err = infcx.commit_if_ok(|_| { - let origin = infer::Misc(impl_c_span); + let origin = TypeOrigin::Misc(impl_c_span); // There is no "body" here, so just pass dummy id. let impl_ty = diff --git a/src/librustc_typeck/check/demand.rs b/src/librustc_typeck/check/demand.rs index fe822138c9b..63dac49b384 100644 --- a/src/librustc_typeck/check/demand.rs +++ b/src/librustc_typeck/check/demand.rs @@ -11,7 +11,7 @@ use check::{coercion, FnCtxt}; use middle::ty::{self, Ty}; -use middle::infer; +use middle::infer::{self, TypeOrigin}; use std::result::Result::{Err, Ok}; use syntax::codemap::Span; @@ -35,7 +35,7 @@ pub fn suptype_with_fn<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, F: FnOnce(Span, Ty<'tcx>, Ty<'tcx>, &ty::error::TypeError<'tcx>), { // n.b.: order of actual, expected is reversed - match infer::mk_subty(fcx.infcx(), b_is_expected, infer::Misc(sp), + match infer::mk_subty(fcx.infcx(), b_is_expected, TypeOrigin::Misc(sp), ty_b, ty_a) { Ok(()) => { /* ok */ } Err(ref err) => { @@ -46,7 +46,7 @@ pub fn suptype_with_fn<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, pub fn eqtype<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, sp: Span, expected: Ty<'tcx>, actual: Ty<'tcx>) { - match infer::mk_eqty(fcx.infcx(), false, infer::Misc(sp), actual, expected) { + match infer::mk_eqty(fcx.infcx(), false, TypeOrigin::Misc(sp), actual, expected) { Ok(()) => { /* ok */ } Err(ref err) => { fcx.report_mismatched_types(sp, expected, actual, err); } } diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index d038890b908..b2462a3612c 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -19,7 +19,7 @@ use middle::ty::{self, NoPreference, PreferMutLvalue, Ty}; use middle::ty::adjustment::{AdjustDerefRef, AutoDerefRef, AutoPtr}; use middle::ty::fold::TypeFoldable; use middle::infer; -use middle::infer::InferCtxt; +use middle::infer::{InferCtxt, TypeOrigin}; use syntax::codemap::Span; use rustc_front::hir; @@ -367,7 +367,7 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> { self_ty: Ty<'tcx>, method_self_ty: Ty<'tcx>) { - match self.fcx.mk_subty(false, infer::Misc(self.span), self_ty, method_self_ty) { + match self.fcx.mk_subty(false, TypeOrigin::Misc(self.span), self_ty, method_self_ty) { Ok(_) => {} Err(_) => { self.tcx().sess.span_bug( diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs index c63b081c73c..59790d72265 100644 --- a/src/librustc_typeck/check/method/probe.rs +++ b/src/librustc_typeck/check/method/probe.rs @@ -23,7 +23,7 @@ use middle::ty::{self, NoPreference, RegionEscape, Ty, ToPolyTraitRef, TraitRef} use middle::ty::HasTypeFlags; use middle::ty::fold::TypeFoldable; use middle::infer; -use middle::infer::InferCtxt; +use middle::infer::{InferCtxt, TypeOrigin}; use syntax::ast; use syntax::codemap::{Span, DUMMY_SP}; use rustc_front::hir; @@ -1136,7 +1136,7 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> { // MISCELLANY fn make_sub_ty(&self, sub: Ty<'tcx>, sup: Ty<'tcx>) -> infer::UnitResult<'tcx> { - self.infcx().sub_types(false, infer::Misc(DUMMY_SP), sub, sup) + self.infcx().sub_types(false, TypeOrigin::Misc(DUMMY_SP), sub, sup) } fn has_applicable_self(&self, item: &ty::ImplOrTraitItem) -> bool { diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index bac85e4b700..c375eb19a37 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -88,7 +88,7 @@ use middle::astconv_util::prohibit_type_params; use middle::def; use middle::def_id::DefId; use middle::infer; -use middle::infer::type_variable; +use middle::infer::{TypeOrigin, type_variable}; use middle::pat_util::{self, pat_id_map}; use middle::privacy::{AllPublic, LastMod}; use middle::subst::{self, Subst, Substs, VecPerParamSpace, ParamSpace, TypeSpace}; @@ -1610,7 +1610,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub fn mk_subty(&self, a_is_expected: bool, - origin: infer::TypeOrigin, + origin: TypeOrigin, sub: Ty<'tcx>, sup: Ty<'tcx>) -> Result<(), TypeError<'tcx>> { @@ -1619,7 +1619,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { pub fn mk_eqty(&self, a_is_expected: bool, - origin: infer::TypeOrigin, + origin: TypeOrigin, sub: Ty<'tcx>, sup: Ty<'tcx>) -> Result<(), TypeError<'tcx>> { @@ -1897,7 +1897,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let Some(default) = default_map.get(ty) { let default = default.clone(); match infer::mk_eqty(self.infcx(), false, - infer::Misc(default.origin_span), + TypeOrigin::Misc(default.origin_span), ty, default.ty) { Ok(()) => {} Err(_) => { @@ -1990,7 +1990,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> { if let Some(default) = default_map.get(ty) { let default = default.clone(); match infer::mk_eqty(self.infcx(), false, - infer::Misc(default.origin_span), + TypeOrigin::Misc(default.origin_span), ty, default.ty) { Ok(()) => {} Err(_) => { @@ -2784,7 +2784,7 @@ fn expected_types_for_fn_args<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, // return type (likely containing type variables if the function // is polymorphic) and the expected return type. // No argument expectations are produced if unification fails. - let origin = infer::Misc(call_span); + let origin = TypeOrigin::Misc(call_span); let ures = fcx.infcx().sub_types(false, origin, formal_ret_ty, ret_ty); // FIXME(#15760) can't use try! here, FromError doesn't default // to identity so the resulting type is not constrained. @@ -2898,14 +2898,14 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, check_expr_with_expectation(fcx, &**else_expr, expected); let else_ty = fcx.expr_ty(&**else_expr); infer::common_supertype(fcx.infcx(), - infer::IfExpression(sp), + TypeOrigin::IfExpression(sp), true, then_ty, else_ty) } None => { infer::common_supertype(fcx.infcx(), - infer::IfExpressionWithNoElse(sp), + TypeOrigin::IfExpressionWithNoElse(sp), false, then_ty, fcx.tcx().mk_nil()) @@ -3405,7 +3405,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ty::FnConverging(result_type) => { match *expr_opt { None => - if let Err(_) = fcx.mk_eqty(false, infer::Misc(expr.span), + if let Err(_) = fcx.mk_eqty(false, TypeOrigin::Misc(expr.span), result_type, fcx.tcx().mk_nil()) { span_err!(tcx.sess, expr.span, E0069, "`return;` in a function whose return type is \ @@ -3689,7 +3689,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } (Some(t_start), Some(t_end)) => { Some(infer::common_supertype(fcx.infcx(), - infer::RangeExpression(expr.span), + TypeOrigin::RangeExpression(expr.span), true, t_start, t_end)) @@ -4585,7 +4585,7 @@ pub fn instantiate_path<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, impl_scheme.generics.regions.len(subst::TypeSpace)); let impl_ty = fcx.instantiate_type_scheme(span, &substs, &impl_scheme.ty); - if fcx.mk_subty(false, infer::Misc(span), self_ty, impl_ty).is_err() { + if fcx.mk_subty(false, TypeOrigin::Misc(span), self_ty, impl_ty).is_err() { fcx.tcx().sess.span_bug(span, &format!( "instantiate_path: (UFCS) {:?} was a subtype of {:?} but now is not?", diff --git a/src/librustc_typeck/check/regionck.rs b/src/librustc_typeck/check/regionck.rs index 095dded7770..549824d22a4 100644 --- a/src/librustc_typeck/check/regionck.rs +++ b/src/librustc_typeck/check/regionck.rs @@ -93,7 +93,7 @@ use middle::region::CodeExtent; use middle::subst::Substs; use middle::traits; use middle::ty::{self, RegionEscape, ReScope, Ty, MethodCall, HasTypeFlags}; -use middle::infer::{self, GenericKind, InferCtxt, SubregionOrigin, VerifyBound}; +use middle::infer::{self, GenericKind, InferCtxt, SubregionOrigin, TypeOrigin, VerifyBound}; use middle::pat_util; use middle::ty::adjustment; use middle::ty::wf::ImpliedBound; @@ -1868,7 +1868,7 @@ fn declared_projection_bounds_from_trait<'a,'tcx>(rcx: &Rcx<'a, 'tcx>, outlives); // check whether this predicate applies to our current projection - match infer::mk_eqty(infcx, false, infer::Misc(span), ty, outlives.0) { + match infer::mk_eqty(infcx, false, TypeOrigin::Misc(span), ty, outlives.0) { Ok(()) => { Ok(outlives.1) } Err(_) => { Err(()) } } diff --git a/src/librustc_typeck/coherence/mod.rs b/src/librustc_typeck/coherence/mod.rs index b3614210eef..4c81c807ebd 100644 --- a/src/librustc_typeck/coherence/mod.rs +++ b/src/librustc_typeck/coherence/mod.rs @@ -33,7 +33,7 @@ use middle::ty::TyProjection; use middle::ty::util::CopyImplementationError; use middle::free_region::FreeRegionMap; use CrateCtxt; -use middle::infer::{self, InferCtxt, new_infer_ctxt}; +use middle::infer::{self, InferCtxt, TypeOrigin, new_infer_ctxt}; use std::cell::RefCell; use std::rc::Rc; use syntax::codemap::Span; @@ -406,7 +406,7 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> { return; } - let origin = infer::Misc(span); + let origin = TypeOrigin::Misc(span); let fields = &def_a.struct_variant().fields; let diff_fields = fields.iter().enumerate().filter_map(|(i, f)| { let (a, b) = (f.ty(tcx, substs_a), f.ty(tcx, substs_b)); diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs index 1b59aaa4c32..3d28a912179 100644 --- a/src/librustc_typeck/lib.rs +++ b/src/librustc_typeck/lib.rs @@ -106,7 +106,7 @@ pub use rustc::util; use front::map as hir_map; use middle::def; -use middle::infer; +use middle::infer::{self, TypeOrigin}; use middle::subst; use middle::ty::{self, Ty, HasTypeFlags}; use session::config; @@ -200,10 +200,10 @@ fn require_same_types<'a, 'tcx, M>(tcx: &ty::ctxt<'tcx>, let result = match maybe_infcx { None => { let infcx = infer::new_infer_ctxt(tcx, &tcx.tables, None, false); - infer::mk_eqty(&infcx, t1_is_expected, infer::Misc(span), t1, t2) + infer::mk_eqty(&infcx, t1_is_expected, TypeOrigin::Misc(span), t1, t2) } Some(infcx) => { - infer::mk_eqty(infcx, t1_is_expected, infer::Misc(span), t1, t2) + infer::mk_eqty(infcx, t1_is_expected, TypeOrigin::Misc(span), t1, t2) } };