Struct rustc::middle::typeck::infer::InferCtxtExperimental [-]  [+] [src]

pub struct InferCtxt<'a, 'tcx> {
    pub tcx: &'a ctxt<'tcx>,
    // some fields omitted
}

Fields

tcx

Methods

impl<'a, 'tcx> InferCtxt<'a, 'tcx>

fn skolemize<T: TypeFoldable<'tcx>>(&self, t: T) -> T

fn type_var_diverges(&'a self, ty: Ty) -> bool

fn skolemizer<'a>(&'a self) -> TypeSkolemizer<'a, 'tcx>

fn combine_fields<'a>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> CombineFields<'a, 'tcx>

fn equate<'a>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> Equate<'a, 'tcx>

fn sub<'a>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> Sub<'a, 'tcx>

fn lub<'a>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> Lub<'a, 'tcx>

fn commit_unconditionally<R>(&self, f: || -> R) -> R

Execute f and commit the bindings

fn commit_if_ok<T, E>(&self, f: || -> Result<T, E>) -> Result<T, E>

Execute f and commit the bindings if successful

fn try<T, E>(&self, f: || -> Result<T, E>) -> Result<T, E>

Execute f, unroll bindings on panic

fn probe<R>(&self, f: || -> R) -> R

Execute f then unroll any bindings it creates

fn add_given(&self, sub: FreeRegion, sup: RegionVid)

fn sub_types(&self, a_is_expected: bool, origin: TypeOrigin, a: Ty<'tcx>, b: Ty<'tcx>) -> ures<'tcx>

fn eq_types(&self, a_is_expected: bool, origin: TypeOrigin, a: Ty<'tcx>, b: Ty<'tcx>) -> ures<'tcx>

fn sub_trait_refs(&self, a_is_expected: bool, origin: TypeOrigin, a: Rc<TraitRef<'tcx>>, b: Rc<TraitRef<'tcx>>) -> ures<'tcx>

impl<'a, 'tcx> InferCtxt<'a, 'tcx>

fn next_ty_var_id(&self, diverging: bool) -> TyVid

fn next_ty_var(&self) -> Ty<'tcx>

fn next_diverging_ty_var(&self) -> Ty<'tcx>

fn next_ty_vars(&self, n: uint) -> Vec<Ty<'tcx>>

fn next_int_var_id(&self) -> IntVid

fn next_float_var_id(&self) -> FloatVid

fn next_region_var(&self, origin: RegionVariableOrigin<'tcx>) -> Region

fn region_vars_for_defs(&self, span: Span, defs: &[RegionParameterDef]) -> Vec<Region>

fn fresh_substs_for_generics(&self, span: Span, generics: &Generics<'tcx>) -> Substs<'tcx>

Given a set of generics defined on a type or impl, returns a substitution mapping each type/region parameter to a fresh inference variable.

fn fresh_substs_for_trait(&self, span: Span, generics: &Generics<'tcx>, self_ty: Ty<'tcx>) -> Substs<'tcx>

Given a set of generics defined on a trait, returns a substitution mapping each output type/region parameter to a fresh inference variable, and mapping the self type to self_ty.

fn fresh_bound_region(&self, debruijn: DebruijnIndex) -> Region

fn resolve_regions_and_report_errors(&self)

fn ty_to_string(&self, t: Ty<'tcx>) -> String

fn tys_to_string(&self, ts: &[Ty<'tcx>]) -> String

fn trait_ref_to_string(&self, t: &Rc<TraitRef<'tcx>>) -> String

fn contains_unbound_type_variables(&self, typ: Ty<'tcx>) -> Ty<'tcx>

fn shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx>

fn resolve_type_vars_if_possible(&self, typ: Ty<'tcx>) -> Ty<'tcx>

fn resolve_type_vars_in_trait_ref_if_possible(&self, trait_ref: &TraitRef<'tcx>) -> TraitRef<'tcx>

fn type_error_message_str(&self, sp: Span, mk_msg: |Option<String>, String| -> String, actual_ty: String, err: Option<&type_err<'tcx>>)

fn type_error_message_str_with_expected(&self, sp: Span, mk_msg: |Option<String>, String| -> String, expected_ty: Option<Ty<'tcx>>, actual_ty: String, err: Option<&type_err<'tcx>>)

fn type_error_message(&self, sp: Span, mk_msg: |String| -> String, actual_ty: Ty<'tcx>, err: Option<&type_err<'tcx>>)

fn report_mismatched_types(&self, span: Span, expected: Ty<'tcx>, actual: Ty<'tcx>, err: &type_err<'tcx>)

fn replace_late_bound_regions_with_fresh_var<T>(&self, span: Span, lbrct: LateBoundRegionConversionTime, value: &T) -> (T, FnvHashMap<BoundRegion, Region>) where T: HigherRankedFoldable<'tcx>

Trait Implementations

impl<'a, 'tcx> RegionScope for InferCtxt<'a, 'tcx>

fn default_region_bound(&self, span: Span) -> Option<Region>

fn anon_regions(&self, span: Span, count: uint) -> Result<Vec<Region>, Option<Vec<(String, uint)>>>

impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx>

fn report_region_errors(&self, errors: &Vec<RegionResolutionError<'tcx>>)

fn process_errors(&self, errors: &Vec<RegionResolutionError<'tcx>>) -> Vec<RegionResolutionError<'tcx>>

fn report_type_error(&self, trace: TypeTrace<'tcx>, terr: &type_err<'tcx>)

fn report_and_explain_type_error(&self, trace: TypeTrace<'tcx>, terr: &type_err<'tcx>)

fn values_str(&self, values: &ValuePairs<'tcx>) -> Option<String>

Returns a string of the form "expected {}, found {}", or None if this is a derived error.

fn expected_found_str<T: UserString<'tcx> + Resolvable<'tcx>>(&self, exp_found: &expected_found<T>) -> Option<String>

fn report_param_bound_failure(&self, origin: SubregionOrigin<'tcx>, param_ty: ParamTy, sub: Region, _sups: Vec<Region>)

fn report_concrete_failure(&self, origin: SubregionOrigin<'tcx>, sub: Region, sup: Region)

fn report_sub_sup_conflict(&self, var_origin: RegionVariableOrigin, sub_origin: SubregionOrigin<'tcx>, sub_region: Region, sup_origin: SubregionOrigin<'tcx>, sup_region: Region)

fn report_sup_sup_conflict(&self, var_origin: RegionVariableOrigin, origin1: SubregionOrigin<'tcx>, region1: Region, origin2: SubregionOrigin<'tcx>, region2: Region)

fn report_processed_errors(&self, var_origins: &[RegionVariableOrigin], trace_origins: &[(TypeTrace<'tcx>, type_err<'tcx>)], same_regions: &[SameRegions])

fn give_suggestion(&self, same_regions: &[SameRegions])

impl<'a, 'tcx, V: SimplyUnifiable<'tcx>, K: UnifyKey<'tcx, Option<V>>> InferCtxtMethodsForSimplyUnifiableTypes<'tcx, V, K> for InferCtxt<'a, 'tcx>

fn simple_vars(&self, a_is_expected: bool, a_id: K, b_id: K) -> ures<'tcx>

Unifies two simple keys. Because simple keys do not have any subtyping relationships, if both keys have already been associated with a value, then those two values must be the same.

fn simple_var_t(&self, a_is_expected: bool, a_id: K, b: V) -> ures<'tcx>

Sets the value of the key a_id to b. Because simple keys do not have any subtyping relationships, if a_id already has a value, it must be the same as b.

fn probe_var(&self, a_id: K) -> Option<Ty<'tcx>>