Struct rustc_typeck::check::Inherited
[−]
[src]
pub struct Inherited<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
// some fields omitted
}rustc_private)closures defined within the function. For example:
fn foo() { bar(move|| { ... }) }
Here, the function foo() and the closure passed to
bar() will each have their own FnCtxt, but they will
share the inherited fields.
Methods from Deref<Target=InferCtxt<'a, 'gcx, 'tcx>>
fn super_combine_tys<R>(&self, relation: &mut R, a: &'tcx TyS<'tcx>, b: &'tcx TyS<'tcx>) -> Result<&'tcx TyS<'tcx>, TypeError<'tcx>> where R: TypeRelation<'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>
fn skolemize_late_bound_regions<T>(&self, binder: &Binder<T>, snapshot: &CombinedSnapshot) -> (T, HashMap<BoundRegion, Region, BuildHasherDefault<FnvHasher>>) where T: TypeFoldable<'tcx>
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: &HashMap<BoundRegion, Region, BuildHasherDefault<FnvHasher>>, snapshot: &CombinedSnapshot) -> Result<(), TypeError<'tcx>>
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: HashMap<BoundRegion, Region, BuildHasherDefault<FnvHasher>>, snapshot: &CombinedSnapshot, value: &T) -> T where T: TypeFoldable<'tcx>
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.
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>
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>(&self, t: T) -> T where T: TypeFoldable<'tcx>
fn type_var_diverges(&'a self, ty: &TyS) -> bool
fn freshener(&'b self) -> TypeFreshener<'b, 'gcx, 'tcx>
fn type_is_unconstrained_numeric(&'a self, ty: &TyS) -> UnconstrainedNumeric
fn default(&self, ty: &'tcx TyS<'tcx>) -> Option<Default<'tcx>>
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<&'tcx TyS<'tcx>>
fn equate<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> Result<InferOk<'tcx, T>, TypeError<'tcx>> where T: Relate<'tcx>
fn sub<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> Result<InferOk<'tcx, T>, TypeError<'tcx>> where T: Relate<'tcx>
fn lub<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> Result<InferOk<'tcx, T>, TypeError<'tcx>> where T: Relate<'tcx>
fn glb<T>(&'a self, a_is_expected: bool, trace: TypeTrace<'tcx>, a: &T, b: &T) -> Result<InferOk<'tcx, T>, TypeError<'tcx>> where T: Relate<'tcx>
fn commit_unconditionally<R, F>(&self, f: F) -> R where F: FnOnce() -> R
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>
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>
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
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: &'tcx TyS<'tcx>, b: &'tcx TyS<'tcx>) -> Result<InferOk<'tcx, ()>, TypeError<'tcx>>
fn can_sub_types(&self, a: &'tcx TyS<'tcx>, b: &'tcx TyS<'tcx>) -> Result<(), TypeError<'tcx>>
fn eq_types(&self, a_is_expected: bool, origin: TypeOrigin, a: &'tcx TyS<'tcx>, b: &'tcx TyS<'tcx>) -> Result<InferOk<'tcx, ()>, TypeError<'tcx>>
fn eq_trait_refs(&self, a_is_expected: bool, origin: TypeOrigin, a: TraitRef<'tcx>, b: TraitRef<'tcx>) -> Result<InferOk<'tcx, ()>, TypeError<'tcx>>
fn eq_impl_headers(&self, a_is_expected: bool, origin: TypeOrigin, a: &ImplHeader<'tcx>, b: &ImplHeader<'tcx>) -> Result<InferOk<'tcx, ()>, TypeError<'tcx>>
fn sub_poly_trait_refs(&self, a_is_expected: bool, origin: TypeOrigin, a: Binder<TraitRef<'tcx>>, b: Binder<TraitRef<'tcx>>) -> Result<InferOk<'tcx, ()>, TypeError<'tcx>>
fn sub_regions(&self, origin: SubregionOrigin<'tcx>, a: Region, b: Region)
fn equality_predicate(&self, span: Span, predicate: &Binder<EquatePredicate<'tcx>>) -> Result<InferOk<'tcx, ()>, TypeError<'tcx>>
fn region_outlives_predicate(&self, span: Span, predicate: &Binder<OutlivesPredicate<Region, Region>>) -> Result<(), TypeError<'tcx>>
fn next_ty_var_id(&self, diverging: bool) -> TyVid
fn next_ty_var(&self) -> &'tcx TyS<'tcx>
fn next_ty_var_with_default(&self, default: Option<Default<'tcx>>) -> &'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 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>
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: &'tcx TyS<'tcx>) -> Substs<'tcx>
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>>) -> &'tcx TyS<'tcx>
rustc_private)Apply adjustment to the type of expr
fn is_tainted_by_errors(&self) -> bool
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)
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: u32) -> &'tcx TyS<'tcx>
fn expr_ty(&self, ex: &Expr) -> &'tcx TyS<'tcx>
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>
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>(&self, value: &T) -> Result<T, FixupError> where T: TypeFoldable<'tcx>
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<&'tcx TyS<'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<&'tcx TyS<'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: &'tcx TyS<'tcx>, err: Option<&TypeError<'tcx>>) where M: FnOnce(String) -> String
fn type_error_struct<M>(&self, sp: Span, mk_msg: M, actual_ty: &'tcx TyS<'tcx>, err: Option<&TypeError<'tcx>>) -> DiagnosticBuilder<'tcx> where M: FnOnce(String) -> String
fn report_mismatched_types(&self, origin: TypeOrigin, expected: &'tcx TyS<'tcx>, actual: &'tcx TyS<'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, HashMap<BoundRegion, Region, BuildHasherDefault<FnvHasher>>) where T: TypeFoldable<'tcx>
fn verify_generic_bound(&self, origin: SubregionOrigin<'tcx>, kind: GenericKind<'tcx>, a: Region, bound: VerifyBound)
rustc_private)See verify_generic_bound method in region_inference
fn can_equate<T>(&self, a: &T, b: &T) -> Result<(), TypeError<'tcx>> where T: Relate<'tcx> + Debug
fn node_ty(&self, id: u32) -> Result<&'tcx TyS<'tcx>, ()>
fn expr_ty_adjusted(&self, expr: &Expr) -> Result<&'tcx TyS<'tcx>, ()>
fn type_moves_by_default(&self, ty: &'tcx TyS<'tcx>, span: Span) -> bool
fn node_method_ty(&self, method_call: MethodCall) -> Option<&'tcx TyS<'tcx>>
fn node_method_id(&self, method_call: MethodCall) -> Option<DefId>
fn adjustments(&self) -> Ref<HashMap<u32, AutoAdjustment<'tcx>, BuildHasherDefault<FnvHasher>>>
fn is_method_call(&self, id: u32) -> bool
fn temporary_scope(&self, rvalue_id: u32) -> 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>
fn report_fulfillment_errors(&self, errors: &Vec<FulfillmentError<'tcx>>)
fn report_fulfillment_errors_as_warnings(&self, errors: &Vec<FulfillmentError<'tcx>>, node_id: u32)
fn report_overflow_error<T>(&self, obligation: &Obligation<'tcx, T>, suggest_increasing_limit: bool) -> ! where T: Display + TypeFoldable<'tcx>
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: &[Obligation<'tcx, Predicate<'tcx>>]) -> !
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: &Obligation<'tcx, Predicate<'tcx>>, error: &SelectionError<'tcx>, warning_node_id: Option<u32>)
fn outlives_components(&self, ty0: &'tcx TyS<'tcx>) -> Vec<Component<'tcx>>
rustc_private)Returns all the things that must outlive 'a for the condition
ty0: 'a to hold.