Struct rustc::infer::InferCtxt

pub struct InferCtxt<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
    pub tcx: TyCtxt<'a, 'gcx, 'tcx>,
    pub tables: InferTables<'a, 'gcx, 'tcx>,
    pub parameter_environment: ParameterEnvironment<'gcx>,
    pub selection_cache: SelectionCache<'tcx>,
    pub evaluation_cache: EvaluationCache<'tcx>,
    pub reported_trait_errors: RefCell<FnvHashSet<TraitErrorKey<'tcx>>>,
    // some fields omitted
}

Unstable (rustc_private)

Fields

tcx: TyCtxt<'a, 'gcx, 'tcx>

Unstable (rustc_private)

tables: InferTables<'a, 'gcx, 'tcx>

Unstable (rustc_private)

parameter_environment: ParameterEnvironment<'gcx>

Unstable (rustc_private)

selection_cache: SelectionCache<'tcx>

Unstable (rustc_private)

Caches the results of trait selection. This cache is used for things that have to do with the parameters in scope.

evaluation_cache: EvaluationCache<'tcx>

Unstable (rustc_private)

Caches the results of trait evaluation.

reported_trait_errors: RefCell<FnvHashSet<TraitErrorKey<'tcx>>>

Unstable (rustc_private)

Methods

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

fn super_combine_tys<R>(&self, relation: &mut R, a: Ty<'tcx>, b: Ty<'tcx>) -> RelateResult<'tcx, Ty<'tcx>> where R: TypeRelation<'a, 'gcx, 'tcx>

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

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

fn report_and_explain_type_error(&self, trace: TypeTrace<'tcx>, terr: &TypeError<'tcx>) -> DiagnosticBuilder<'tcx>

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

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

Unstable (rustc_private)

Replace all regions bound by binder with skolemized regions and return a map indicating which bound-region was replaced with what skolemized region. This is the first step of checking subtyping when higher-ranked things are involved. See README.md for more details.

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

Unstable (rustc_private)

Searches the region constriants created since snapshot was started and checks to determine whether any of the skolemized regions created in skol_map would "escape" -- meaning that they are related to other regions in some way. If so, the higher-ranked subtyping doesn't hold. See README.md for more details.

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

Unstable (rustc_private)

This code converts from skolemized regions back to late-bound regions. It works by replacing each region in the taint set of a skolemized region with a bound-region. The bound region will be bound by the outer-most binder in value; the caller must ensure that there is such a binder and it is the right place.

This routine is only intended to be used when the leak-check has passed; currently, it's used in the trait matching code to create a set of nested obligations frmo an impl that matches against something higher-ranked. More details can be found in librustc/middle/traits/README.md.

As a brief example, consider the obligation for<'a> Fn(&'a int) -> &'a int, and the impl:

impl<A,R> Fn<A,R> for SomethingOrOther
    where A : Clone
{ ... }

Here we will have replaced 'a with a skolemized region '0. This means that our substitution will be {A=>&'0 int, R=>&'0 int}.

When we apply the substitution to the bounds, we will wind up with &'0 int : Clone as a predicate. As a last step, we then go and replace '0 with a late-bound region 'a. The depth is matched to the depth of the predicate, in this case 1, so that the final predicate is for<'a> &'a int : Clone.

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

fn drain_fulfillment_cx_or_panic<T>(&self, span: Span, fulfill_cx: &mut FulfillmentContext<'tcx>, result: &T) -> T::Lifted where T: TypeFoldable<'tcx> + Lift<'gcx>

fn drain_fulfillment_cx<T>(&self, fulfill_cx: &mut FulfillmentContext<'tcx>, result: &T) -> Result<T, Vec<FulfillmentError<'tcx>>> where T: TypeFoldable<'tcx>

Unstable (rustc_private)

Finishes processes any obligations that remain in the fulfillment context, and then "freshens" and returns result. This is primarily used during normalization and other cases where processing the obligations in fulfill_cx may cause type inference variables that appear in result to be unified, and hence we need to process those obligations to get the complete picture of the type.

fn projection_mode(&self) -> ProjectionMode

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, 'gcx, 'tcx>

fn type_is_unconstrained_numeric(&'a self, ty: Ty) -> UnconstrainedNumeric

fn default(&self, ty: Ty<'tcx>) -> Option<Default<'tcx>>

Unstable (rustc_private)

Returns a type variable's default fallback if any exists. A default must be attached to the variable when created, if it is created without a default, this will return None.

This code does not apply to integral or floating point variables, only to use declared defaults.

See new_ty_var_with_default to create a type variable with a default. See type_variable::Default for details about what a default entails.

fn unsolved_variables(&self) -> Vec<Ty<'tcx>>

fn equate<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> InferResult<'tcx, T> where T: Relate<'tcx>

fn sub<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> InferResult<'tcx, T> where T: Relate<'tcx>

fn lub<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> InferResult<'tcx, T> where T: Relate<'tcx>

fn glb<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> InferResult<'tcx, T> where T: Relate<'tcx>

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

Execute f and commit the bindings if closure f returns Ok(_)

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

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

Unstable (rustc_private)

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

Unstable (rustc_private)

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>) -> InferResult<'tcx, ()>

fn can_sub_types(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> UnitResult<'tcx>

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

fn eq_trait_refs(&self, a_is_expected: bool, origin: TypeOrigin, a: TraitRef<'tcx>, b: TraitRef<'tcx>) -> InferResult<'tcx, ()>

fn eq_impl_headers(&self, a_is_expected: bool, origin: TypeOrigin, a: &ImplHeader<'tcx>, b: &ImplHeader<'tcx>) -> InferResult<'tcx, ()>

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

fn sub_regions(&self, origin: SubregionOrigin<'tcx>, a: Region, b: Region)

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

fn region_outlives_predicate(&self, span: Span, predicate: &PolyRegionOutlivesPredicate) -> UnitResult<'tcx>

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

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

fn next_ty_var_with_default(&self, default: Option<Default<'tcx>>) -> Ty<'tcx>

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

fn next_ty_vars(&self, n: usize) -> Vec<Ty<'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 type_vars_for_defs(&self, span: Span, space: ParamSpace, substs: &mut Substs<'tcx>, defs: &[TypeParameterDef<'tcx>])

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

Unstable (rustc_private)

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>

Unstable (rustc_private)

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 adjust_expr_ty(&self, expr: &Expr, adjustment: Option<&AutoAdjustment<'tcx>>) -> Ty<'tcx>

Unstable (rustc_private)

Apply adjustment to the type of expr

fn is_tainted_by_errors(&self) -> bool

Unstable (rustc_private)

True if errors have been reported since this infcx was created. This is sometimes used as a heuristic to skip reporting errors that often occur as a result of earlier errors, but where it's hard to be 100% sure (e.g., unresolved inference variables, regionck errors).

fn set_tainted_by_errors(&self)

Unstable (rustc_private)

Set the "tainted by errors" flag to true. We call this when we observe an error from a prior pass.

fn node_type(&self, id: NodeId) -> Ty<'tcx>

fn expr_ty(&self, ex: &Expr) -> Ty<'tcx>

fn resolve_regions_and_report_errors(&self, free_regions: &FreeRegionMap, 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: &TraitRef<'tcx>) -> String

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

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

Unstable (rustc_private)

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 resolve_type_and_region_vars_if_possible<T>(&self, value: &T) -> T where T: TypeFoldable<'tcx>

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

Unstable (rustc_private)

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<&TypeError<'tcx>>) where M: FnOnce(Option<String>, String) -> String

fn type_error_struct_str<M>(&self, sp: Span, mk_msg: M, actual_ty: String, err: Option<&TypeError<'tcx>>) -> DiagnosticBuilder<'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<&TypeError<'tcx>>) where M: FnOnce(Option<String>, String) -> String

fn type_error_struct_str_with_expected<M>(&self, sp: Span, mk_msg: M, expected_ty: Option<Ty<'tcx>>, actual_ty: String, err: Option<&TypeError<'tcx>>) -> DiagnosticBuilder<'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<&TypeError<'tcx>>) where M: FnOnce(String) -> String

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

fn report_mismatched_types(&self, origin: TypeOrigin, expected: Ty<'tcx>, actual: Ty<'tcx>, err: TypeError<'tcx>)

fn report_conflicting_default_types(&self, span: Span, expected: Default<'tcx>, actual: Default<'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>

fn verify_generic_bound(&self, origin: SubregionOrigin<'tcx>, kind: GenericKind<'tcx>, a: Region, bound: VerifyBound)

Unstable (rustc_private)

See verify_generic_bound method in region_inference

fn can_equate<T>(&self, a: &T, b: &T) -> UnitResult<'tcx> where T: Relate<'tcx> + Debug

fn node_ty(&self, id: NodeId) -> McResult<Ty<'tcx>>

fn expr_ty_adjusted(&self, expr: &Expr) -> McResult<Ty<'tcx>>

fn type_moves_by_default(&self, ty: Ty<'tcx>, span: Span) -> bool

fn node_method_ty(&self, method_call: MethodCall) -> Option<Ty<'tcx>>

fn node_method_id(&self, method_call: MethodCall) -> Option<DefId>

fn adjustments(&self) -> Ref<NodeMap<AutoAdjustment<'tcx>>>

fn is_method_call(&self, id: NodeId) -> bool

fn temporary_scope(&self, rvalue_id: NodeId) -> Option<CodeExtent>

fn upvar_capture(&self, upvar_id: UpvarId) -> Option<UpvarCapture>

fn param_env(&self) -> &ParameterEnvironment<'gcx>

fn closure_kind(&self, def_id: DefId) -> Option<ClosureKind>

fn closure_type(&self, def_id: DefId, substs: ClosureSubsts<'tcx>) -> ClosureTy<'tcx>

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

fn report_fulfillment_errors(&self, errors: &Vec<FulfillmentError<'tcx>>)

fn report_fulfillment_errors_as_warnings(&self, errors: &Vec<FulfillmentError<'tcx>>, node_id: NodeId)

fn report_overflow_error<T>(&self, obligation: &Obligation<'tcx, T>, suggest_increasing_limit: bool) -> ! where T: Display + TypeFoldable<'tcx>

Unstable (rustc_private)

Reports that an overflow has occurred and halts compilation. We halt compilation unconditionally because it is important that overflows never be masked -- they basically represent computations whose result could not be truly determined and thus we can't say if the program type checks or not -- and they are unusual occurrences in any case.

fn report_overflow_error_cycle(&self, cycle: &[PredicateObligation<'tcx>]) -> !

Unstable (rustc_private)

Reports that a cycle was detected which led to overflow and halts compilation. This is equivalent to report_overflow_error except that we can give a more helpful error message (and, in particular, we do not suggest increasing the overflow limit, which is not going to help).

fn report_selection_error(&self, obligation: &PredicateObligation<'tcx>, error: &SelectionError<'tcx>, warning_node_id: Option<NodeId>)

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

fn outlives_components(&self, ty0: Ty<'tcx>) -> Vec<Component<'tcx>>

Unstable (rustc_private)

Returns all the things that must outlive 'a for the condition ty0: 'a to hold.