use middle::ty::{TyVid, IntVid, FloatVid, RegionVid};
use middle::ty;
use middle::ty_fold;
-use middle::ty_fold::TypeFolder;
+use middle::ty_fold::{TypeFolder, TypeFoldable};
use middle::typeck::check::regionmanip::replace_late_bound_regions_in_fn_sig;
-use middle::typeck::infer::coercion::Coerce;
-use middle::typeck::infer::combine::{Combine, CombineFields};
-use middle::typeck::infer::region_inference::{RegionVarBindings,
- RegionSnapshot};
-use middle::typeck::infer::resolve::{resolver};
-use middle::typeck::infer::equate::Equate;
-use middle::typeck::infer::sub::Sub;
-use middle::typeck::infer::lub::Lub;
-use middle::typeck::infer::unify::{UnificationTable};
-use middle::typeck::infer::error_reporting::ErrorReporting;
use std::cell::{RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use util::common::indent;
use util::ppaux::{bound_region_to_string, ty_to_string, trait_ref_to_string, Repr};
+use self::coercion::Coerce;
+use self::combine::{Combine, CombineFields};
+use self::region_inference::{RegionVarBindings, RegionSnapshot};
+use self::resolve::{resolver};
+use self::equate::Equate;
+use self::sub::Sub;
+use self::lub::Lub;
+use self::unify::{UnificationTable, InferCtxtMethodsForSimplyUnifiableTypes};
+use self::error_reporting::ErrorReporting;
+
pub mod coercion;
pub mod combine;
pub mod doc;
/// Why did we require that the two types be related?
///
/// See `error_reporting.rs` for more details
-#[deriving(Clone)]
+#[deriving(Clone, Show)]
pub enum TypeOrigin {
// Not yet categorized in a better way
Misc(Span),
// Computing common supertype in an if expression
IfExpression(Span),
+
+ // Computing common supertype of an if expression with no else counter-part
+ IfExpressionWithNoElse(Span)
}
/// See `error_reporting.rs` for more details
-#[deriving(Clone)]
+#[deriving(Clone, Show)]
pub enum ValuePairs {
Types(ty::expected_found<ty::t>),
TraitRefs(ty::expected_found<Rc<ty::TraitRef>>),
/// encounter an error or subtyping constraint.
///
/// See `error_reporting.rs` for more details.
-#[deriving(Clone)]
+#[deriving(Clone, Show)]
pub struct TypeTrace {
origin: TypeOrigin,
values: ValuePairs,
/// The origin of a `r1 <= r2` constraint.
///
/// See `error_reporting.rs` for more details
-#[deriving(Clone)]
+#[deriving(Clone, Show)]
pub enum SubregionOrigin {
// Arose from a subtyping relation
Subtype(TypeTrace),
/// Reasons to create a region inference variable
///
/// See `error_reporting.rs` for more details
-#[deriving(Clone)]
+#[deriving(Clone, Show)]
pub enum RegionVariableOrigin {
// Region variables created for ill-categorized reasons,
// mostly indicates places in need of refactoring
}
impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
+ pub fn skolemize<T:TypeFoldable>(&self, t: T) -> T {
+ t.fold_with(&mut self.skolemizer())
+ }
+
pub fn skolemizer<'a>(&'a self) -> TypeSkolemizer<'a, 'tcx> {
skolemize::TypeSkolemizer::new(self)
}
-> ures
{
debug!("sub_types({} <: {})", a.repr(self.tcx), b.repr(self.tcx));
- let trace = TypeTrace {
- origin: origin,
- values: Types(expected_found(a_is_expected, a, b))
- };
- self.sub(a_is_expected, trace).tys(a, b).to_ures()
+ self.commit_if_ok(|| {
+ let trace = TypeTrace {
+ origin: origin,
+ values: Types(expected_found(a_is_expected, a, b))
+ };
+ self.sub(a_is_expected, trace).tys(a, b).to_ures()
+ })
}
pub fn eq_types(&self,
b: ty::t)
-> ures
{
- let trace = TypeTrace {
- origin: origin,
- values: Types(expected_found(a_is_expected, a, b))
- };
- self.equate(a_is_expected, trace).tys(a, b).to_ures()
+ self.commit_if_ok(|| {
+ let trace = TypeTrace {
+ origin: origin,
+ values: Types(expected_found(a_is_expected, a, b))
+ };
+ self.equate(a_is_expected, trace).tys(a, b).to_ures()
+ })
}
pub fn sub_trait_refs(&self,
debug!("sub_trait_refs({} <: {})",
a.repr(self.tcx),
b.repr(self.tcx));
- let trace = TypeTrace {
- origin: origin,
- values: TraitRefs(expected_found(a_is_expected,
- a.clone(), b.clone()))
- };
- let suber = self.sub(a_is_expected, trace);
- suber.trait_refs(&*a, &*b).to_ures()
+ self.commit_if_ok(|| {
+ let trace = TypeTrace {
+ origin: origin,
+ values: TraitRefs(expected_found(a_is_expected,
+ a.clone(), b.clone()))
+ };
+ self.sub(a_is_expected, trace).trait_refs(&*a, &*b).to_ures()
+ })
}
}
}
}
+ pub fn shallow_resolve(&self, typ: ty::t) -> ty::t {
+ match ty::get(typ).sty {
+ ty::ty_infer(ty::TyVar(v)) => {
+ self.type_variables.borrow()
+ .probe(v)
+ .unwrap_or(typ)
+ }
+
+ ty::ty_infer(ty::IntVar(v)) => {
+ self.probe_var(v)
+ .unwrap_or(typ)
+ }
+
+ ty::ty_infer(ty::FloatVar(v)) => {
+ self.probe_var(v)
+ .unwrap_or(typ)
+ }
+
+ _ => {
+ typ
+ }
+ }
+ }
+
pub fn resolve_type_vars_if_possible(&self, typ: ty::t) -> ty::t {
match resolve_type(self,
None,
expected_ty: Option<ty::t>,
actual_ty: String,
err: Option<&ty::type_err>) {
- debug!("hi! expected_ty = {:?}, actual_ty = {}", expected_ty, actual_ty);
+ debug!("hi! expected_ty = {}, actual_ty = {}", expected_ty, actual_ty);
let error_str = err.map_or("".to_string(), |t_err| {
format!(" ({})", ty::type_err_to_str(self.tcx, t_err))
replace_late_bound_regions_in_fn_sig(self.tcx, fsig, |br| {
let rvar = self.next_region_var(
BoundRegionInFnType(trace.origin.span(), br));
- debug!("Bound region {} maps to {:?}",
+ debug!("Bound region {} maps to {}",
bound_region_to_string(self.tcx, "", false, br),
rvar);
rvar
RelateOutputImplTypes(span) => span,
MatchExpressionArm(match_span, _) => match_span,
IfExpression(span) => span,
+ IfExpressionWithNoElse(span) => span
}
}
}
IfExpression(a) => {
format!("IfExpression({})", a.repr(tcx))
}
+ IfExpressionWithNoElse(a) => {
+ format!("IfExpressionWithNoElse({})", a.repr(tcx))
+ }
}
}
}
}
Reborrow(a) => format!("Reborrow({})", a.repr(tcx)),
ReborrowUpvar(a, b) => {
- format!("ReborrowUpvar({},{:?})", a.repr(tcx), b)
+ format!("ReborrowUpvar({},{})", a.repr(tcx), b)
}
ReferenceOutlivesReferent(_, a) => {
format!("ReferenceOutlivesReferent({})", a.repr(tcx))
projects / rust.git / blobdiff