Struct rustc_trans::middle::infer::InferCtxt
[−]
[src]
pub struct InferCtxt<'a, 'tcx> where 'tcx: 'a {
pub tcx: &'a ctxt<'tcx>,
// some fields omitted
}Fields
tcx | Unstable |
Methods
impl<'a, 'tcx> InferCtxt<'a, 'tcx>
fn freshen<T>(&self, t: T) -> T where T: TypeFoldable<'tcx>
fn type_var_diverges(&'a self, ty: &TyS) -> bool
fn freshener(&'b self) -> TypeFreshener<'b, 'tcx>
fn type_is_unconstrained_numeric(&'a self, ty: &TyS) -> UnconstrainedNumeric
fn equate(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> Equate<'a, 'tcx>
fn sub(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> Sub<'a, 'tcx>
fn lub(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> Lub<'a, 'tcx>
fn glb(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>) -> Glb<'a, '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(&CombinedSnapshot) -> Result<T, E>
Execute f and commit the bindings if closure f returns Ok(_)
fn commit_regions_if_ok<T, E, F>(&self, f: F) -> Result<T, E> where F: FnOnce() -> Result<T, E>
Execute f and commit only the region bindings if successful.
The function f must be very careful not to leak any non-region
variables that get created.
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: &'tcx TyS<'tcx>, b: &'tcx TyS<'tcx>) -> Result<(), type_err<'tcx>>
fn eq_types(&self, a_is_expected: bool, origin: TypeOrigin, a: &'tcx TyS<'tcx>, b: &'tcx TyS<'tcx>) -> Result<(), type_err<'tcx>>
fn sub_trait_refs(&self, a_is_expected: bool, origin: TypeOrigin, a: TraitRef<'tcx>, b: TraitRef<'tcx>) -> Result<(), type_err<'tcx>>
fn sub_poly_trait_refs(&self, a_is_expected: bool, origin: TypeOrigin, a: Binder<TraitRef<'tcx>>, b: Binder<TraitRef<'tcx>>) -> Result<(), type_err<'tcx>>
fn construct_skolemized_subst(&self, generics: &Generics<'tcx>, snapshot: &CombinedSnapshot) -> (Substs<'tcx>, HashMap<BoundRegion, Region, DefaultState<FnvHasher>>)
See higher_ranked::construct_skolemized_subst
fn skolemize_late_bound_regions<T>(&self, value: &Binder<T>, snapshot: &CombinedSnapshot) -> (T, HashMap<BoundRegion, Region, DefaultState<FnvHasher>>) where T: TypeFoldable<'tcx> + Repr<'tcx>
See higher_ranked::skolemize_late_bound_regions
fn leak_check(&self, skol_map: &HashMap<BoundRegion, Region, DefaultState<FnvHasher>>, snapshot: &CombinedSnapshot) -> Result<(), type_err<'tcx>>
See higher_ranked::leak_check
fn plug_leaks<T>(&self, skol_map: HashMap<BoundRegion, Region, DefaultState<FnvHasher>>, snapshot: &CombinedSnapshot, value: &T) -> T where T: TypeFoldable<'tcx> + Repr<'tcx>
See higher_ranked::plug_leaks
fn equality_predicate(&self, span: Span, predicate: &Binder<EquatePredicate<'tcx>>) -> Result<(), type_err<'tcx>>
fn region_outlives_predicate(&self, span: Span, predicate: &Binder<OutlivesPredicate<Region, Region>>) -> Result<(), type_err<'tcx>>
fn next_ty_var_id(&self, diverging: bool) -> TyVid
fn next_ty_var(&self) -> &'tcx TyS<'tcx>
fn next_diverging_ty_var(&self) -> &'tcx TyS<'tcx>
fn next_ty_vars(&self, n: usize) -> Vec<&'tcx TyS<'tcx>>
fn next_int_var_id(&self) -> IntVid
fn next_float_var_id(&self) -> FloatVid
fn next_region_var(&self, origin: RegionVariableOrigin) -> 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: &'tcx TyS<'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, free_regions: &FreeRegionMap, subject_node_id: u32)
fn ty_to_string(&self, t: &'tcx TyS<'tcx>) -> String
fn tys_to_string(&self, ts: &[&'tcx TyS<'tcx>]) -> String
fn trait_ref_to_string(&self, t: &TraitRef<'tcx>) -> String
fn shallow_resolve(&self, typ: &'tcx TyS<'tcx>) -> &'tcx TyS<'tcx>
fn resolve_type_vars_if_possible<T>(&self, value: &T) -> T where T: TypeFoldable<'tcx>
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>(&self, value: &T) -> Result<T, fixup_err> where T: TypeFoldable<'tcx>
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<&'tcx TyS<'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: &'tcx TyS<'tcx>, err: Option<&type_err<'tcx>>) where M: FnOnce(String) -> String
fn report_mismatched_types(&self, span: Span, expected: &'tcx TyS<'tcx>, actual: &'tcx TyS<'tcx>, err: &type_err<'tcx>)
fn replace_late_bound_regions_with_fresh_var<T>(&self, span: Span, lbrct: LateBoundRegionConversionTime, value: &Binder<T>) -> (T, HashMap<BoundRegion, Region, DefaultState<FnvHasher>>) where T: TypeFoldable<'tcx> + Repr<'tcx>
fn verify_generic_bound(&self, origin: SubregionOrigin<'tcx>, kind: GenericKind<'tcx>, a: Region, bs: Vec<Region>)
See verify_generic_bound method in region_inference