#![allow(non_camel_case_types)]
pub use middle::ty::IntVarValue;
-pub use middle::typeck::infer::resolve::resolve_and_force_all_but_regions;
-pub use middle::typeck::infer::resolve::{force_all, not_regions};
-pub use middle::typeck::infer::resolve::{force_ivar};
-pub use middle::typeck::infer::resolve::{force_tvar, force_rvar};
-pub use middle::typeck::infer::resolve::{resolve_ivar, resolve_all};
-pub use middle::typeck::infer::resolve::{resolve_nested_tvar};
-pub use middle::typeck::infer::resolve::{resolve_rvar};
+pub use self::resolve::resolve_and_force_all_but_regions;
+pub use self::resolve::{force_all, not_regions};
+pub use self::resolve::{force_ivar};
+pub use self::resolve::{force_tvar, force_rvar};
+pub use self::resolve::{resolve_ivar, resolve_all};
+pub use self::resolve::{resolve_nested_tvar};
+pub use self::resolve::{resolve_rvar};
+pub use self::skolemize::TypeSkolemizer;
use middle::subst;
use middle::subst::Substs;
use middle::ty::{TyVid, IntVid, FloatVid, RegionVid};
use middle::ty;
use middle::ty_fold;
-use middle::ty_fold::TypeFoldable;
-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;
pub type Bound<T> = Option<T>;
-#[deriving(PartialEq,Clone)]
-pub struct Bounds<T> {
- pub lb: Bound<T>,
- pub ub: Bound<T>
-}
-
pub type cres<T> = Result<T,ty::type_err>; // "combine result"
pub type ures = cres<()>; // "unify result"
pub type fres<T> = Result<T, fixup_err>; // "fixup result"
/// 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),
// An auto-borrow that does not enclose the expr where it occurs
AutoBorrow(Span),
-
- // Managed data cannot contain borrowed pointers.
- Managed(Span),
}
/// 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
pub enum fixup_err {
unresolved_int_ty(IntVid),
unresolved_float_ty(FloatVid),
- unresolved_ty(TyVid),
- unresolved_region(RegionVid),
- region_var_bound_by_region_var(RegionVid, RegionVid)
+ unresolved_ty(TyVid)
}
pub fn fixup_err_to_string(f: fixup_err) -> String {
the type explicitly".to_string()
}
unresolved_ty(_) => "unconstrained type".to_string(),
- unresolved_region(_) => "unconstrained region".to_string(),
- region_var_bound_by_region_var(r1, r2) => {
- format!("region var {:?} bound by another region var {:?}; \
- this is a bug in rustc", r1, r2)
- }
}
}
cx.region_vars.verify_param_bound(origin, param_ty, a, bs);
}
-pub fn skolemize<T:TypeFoldable+Repr>(cx: &InferCtxt, a: T) -> T {
- let mut skol = skolemize::TypeSkolemizer::new(cx);
- let b = a.fold_with(&mut skol);
- debug!("skol(a={}) -> {}", a.repr(cx.tcx), b.repr(cx.tcx));
- b
-}
-
pub fn mk_eqty(cx: &InferCtxt,
a_is_expected: bool,
origin: TypeOrigin,
}
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)
+ }
+
pub fn combine_fields<'a>(&'a self, a_is_expected: bool, trace: TypeTrace)
-> CombineFields<'a, 'tcx> {
CombineFields {infcx: 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))
+ }
}
}
}
CallReturn(a) => a,
AddrOf(a) => a,
AutoBorrow(a) => a,
- Managed(a) => a,
}
}
}
}
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))
CallReturn(a) => format!("CallReturn({})", a.repr(tcx)),
AddrOf(a) => format!("AddrOf({})", a.repr(tcx)),
AutoBorrow(a) => format!("AutoBorrow({})", a.repr(tcx)),
- Managed(a) => format!("Managed({})", a.repr(tcx)),
}
}
}