Struct rustc::middle::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 freshen<T: TypeFoldable<'tcx>>(&self, t: T) -> T

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

fn freshener<'b>(&'b self) -> TypeFreshener<'b, 'tcx>

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

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

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

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

fn commit_unconditionally<R, F>(&self, f: F) -> R where F: FnOnce() -> R

Execute f and commit the bindings

fn commit_if_ok<T, E, F>(&self, f: F) -> Result<T, E> where F: FnOnce() -> Result<T, E>

Execute f and commit the bindings if successful

fn try<T, E, F>(&self, f: F) -> Result<T, E> where F: FnOnce(&CombinedSnapshot) -> Result<T, E>

Execute f, unroll bindings on panic

fn probe<R, F>(&self, f: F) -> R where F: FnOnce(&CombinedSnapshot) -> 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>

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

fn skolemize_late_bound_regions<T>(&self, value: &Binder<T>, snapshot: &CombinedSnapshot) -> (T, SkolemizationMap) where T: TypeFoldable<'tcx> + Repr<'tcx>

See higher_ranked::skolemize_late_bound_regions

fn leak_check(&self, skol_map: &SkolemizationMap, snapshot: &CombinedSnapshot) -> ures<'tcx>

See higher_ranked::leak_check

fn plug_leaks<T>(&self, skol_map: SkolemizationMap, snapshot: &CombinedSnapshot, value: &T) -> T where T: TypeFoldable<'tcx> + Repr<'tcx>

See higher_ranked::plug_leaks

fn equality_predicate(&self, span: Span, predicate: &PolyEquatePredicate<'tcx>) -> ures<'tcx>

fn region_outlives_predicate(&self, span: Span, predicate: &PolyRegionOutlivesPredicate) -> ures<'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, subject_node_id: NodeId)

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 shallow_resolve(&self, typ: Ty<'tcx>) -> Ty<'tcx>

fn resolve_type_vars_if_possible<T: TypeFoldable<'tcx>>(&self, value: &T) -> T

Where possible, replaces type/int/float variables in value with their final value. Note that region variables are unaffected. If a type variable has not been unified, it is left as is. This is an idempotent operation that does not affect inference state in any way and so you can do it at will.

fn fully_resolve<T: TypeFoldable<'tcx>>(&self, value: &T) -> fres<T>

Attempts to resolve all type/region variables in value. Region inference must have been run already (e.g., by calling resolve_regions_and_report_errors). If some variable was never unified, an Err results.

This method is idempotent, but it not typically not invoked except during the writeback phase.

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

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

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

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: &Binder<T>) -> (T, FnvHashMap<BoundRegion, Region>) where T: TypeFoldable<'tcx> + Repr<'tcx>

Trait Implementations

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>>