Struct rustc_middle::ty::typeck_results::TypeckResults
source · pub struct TypeckResults<'tcx> {Show 24 fields
pub hir_owner: OwnerId,
type_dependent_defs: ItemLocalMap<Result<(DefKind, DefId), ErrorGuaranteed>>,
field_indices: ItemLocalMap<FieldIdx>,
node_types: ItemLocalMap<Ty<'tcx>>,
node_args: ItemLocalMap<GenericArgsRef<'tcx>>,
user_provided_types: ItemLocalMap<CanonicalUserType<'tcx>>,
pub user_provided_sigs: LocalDefIdMap<CanonicalPolyFnSig<'tcx>>,
adjustments: ItemLocalMap<Vec<Adjustment<'tcx>>>,
pat_binding_modes: ItemLocalMap<BindingMode>,
pat_adjustments: ItemLocalMap<Vec<Ty<'tcx>>>,
closure_kind_origins: ItemLocalMap<(Span, Place<'tcx>)>,
liberated_fn_sigs: ItemLocalMap<FnSig<'tcx>>,
fru_field_types: ItemLocalMap<Vec<Ty<'tcx>>>,
coercion_casts: ItemLocalSet,
pub used_trait_imports: UnordSet<LocalDefId>,
pub tainted_by_errors: Option<ErrorGuaranteed>,
pub concrete_opaque_types: FxIndexMap<OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>>,
pub closure_min_captures: MinCaptureInformationMap<'tcx>,
pub closure_fake_reads: LocalDefIdMap<Vec<(Place<'tcx>, FakeReadCause, HirId)>>,
pub rvalue_scopes: RvalueScopes,
pub generator_interior_predicates: LocalDefIdMap<Vec<(Predicate<'tcx>, ObligationCause<'tcx>)>>,
pub treat_byte_string_as_slice: ItemLocalSet,
pub closure_size_eval: LocalDefIdMap<ClosureSizeProfileData<'tcx>>,
offset_of_data: ItemLocalMap<(Ty<'tcx>, Vec<FieldIdx>)>,
}
Fields§
§hir_owner: OwnerId
The HirId::owner
all ItemLocalId
s in this table are relative to.
type_dependent_defs: ItemLocalMap<Result<(DefKind, DefId), ErrorGuaranteed>>
Resolved definitions for <T>::X
associated paths and
method calls, including those of overloaded operators.
field_indices: ItemLocalMap<FieldIdx>
Resolved field indices for field accesses in expressions (S { field }
, obj.field
)
or patterns (S { field }
). The index is often useful by itself, but to learn more
about the field you also need definition of the variant to which the field
belongs, but it may not exist if it’s a tuple field (tuple.0
).
node_types: ItemLocalMap<Ty<'tcx>>
Stores the types for various nodes in the AST. Note that this table is not guaranteed to be populated outside inference. See typeck::check::fn_ctxt for details.
node_args: ItemLocalMap<GenericArgsRef<'tcx>>
Stores the type parameters which were substituted to obtain the type of this node. This only applies to nodes that refer to entities parameterized by type parameters, such as generic fns, types, or other items.
user_provided_types: ItemLocalMap<CanonicalUserType<'tcx>>
This will either store the canonicalized types provided by the user
or the substitutions that the user explicitly gave (if any) attached
to id
. These will not include any inferred values. The canonical form
is used to capture things like _
or other unspecified values.
For example, if the user wrote foo.collect::<Vec<_>>()
, then the
canonical substitutions would include only for<X> { Vec<X> }
.
See also AscribeUserType
statement in MIR.
user_provided_sigs: LocalDefIdMap<CanonicalPolyFnSig<'tcx>>
Stores the canonicalized types provided by the user. See also
AscribeUserType
statement in MIR.
adjustments: ItemLocalMap<Vec<Adjustment<'tcx>>>
§pat_binding_modes: ItemLocalMap<BindingMode>
Stores the actual binding mode for all instances of hir::BindingAnnotation.
pat_adjustments: ItemLocalMap<Vec<Ty<'tcx>>>
Stores the types which were implicitly dereferenced in pattern binding modes for later usage in THIR lowering. For example,
match &&Some(5i32) {
Some(n) => {},
_ => {},
}
leads to a vec![&&Option<i32>, &Option<i32>]
. Empty vectors are not stored.
See: https://github.com/rust-lang/rfcs/blob/master/text/2005-match-ergonomics.md#definitions
closure_kind_origins: ItemLocalMap<(Span, Place<'tcx>)>
Records the reasons that we picked the kind of each closure; not all closures are present in the map.
liberated_fn_sigs: ItemLocalMap<FnSig<'tcx>>
For each fn, records the “liberated” types of its arguments and return type. Liberated means that all bound regions (including late-bound regions) are replaced with free equivalents. This table is not used in codegen (since regions are erased there) and hence is not serialized to metadata.
This table also contains the “revealed” values for any impl Trait
that appear in the signature and whose values are being inferred
by this function.
Example
fn foo(x: &u32) -> impl Debug { *x }
The function signature here would be:
for<'a> fn(&'a u32) -> Foo
where Foo
is an opaque type created for this function.
The liberated form of this would be
fn(&'a u32) -> u32
Note that 'a
is not bound (it would be an ReFree
) and
that the Foo
opaque type is replaced by its hidden type.
fru_field_types: ItemLocalMap<Vec<Ty<'tcx>>>
For each FRU expression, record the normalized types of the fields of the struct - this is needed because it is non-trivial to normalize while preserving regions. This table is used only in MIR construction and hence is not serialized to metadata.
coercion_casts: ItemLocalSet
For every coercion cast we add the HIR node ID of the cast expression to this set.
used_trait_imports: UnordSet<LocalDefId>
Set of trait imports actually used in the method resolution.
This is used for warning unused imports. During type
checking, this Lrc
should not be cloned: it must have a ref-count
of 1 so that we can insert things into the set mutably.
tainted_by_errors: Option<ErrorGuaranteed>
If any errors occurred while type-checking this body,
this field will be set to Some(ErrorGuaranteed)
.
concrete_opaque_types: FxIndexMap<OpaqueTypeKey<'tcx>, OpaqueHiddenType<'tcx>>
All the opaque types that have hidden types set by this function. We also store the type here, so that the compiler can use it as a hint for figuring out hidden types, even if they are only set in dead code (which doesn’t show up in MIR).
closure_min_captures: MinCaptureInformationMap<'tcx>
Tracks the minimum captures required for a closure;
see MinCaptureInformationMap
for more details.
closure_fake_reads: LocalDefIdMap<Vec<(Place<'tcx>, FakeReadCause, HirId)>>
Tracks the fake reads required for a closure and the reason for the fake read. When performing pattern matching for closures, there are times we don’t end up reading places that are mentioned in a closure (because of _ patterns). However, to ensure the places are initialized, we introduce fake reads. Consider these two examples:
let x: u8;
let c = || match x { _ => () };
In this example, we don’t need to actually read/borrow x
in c
, and so we don’t
want to capture it. However, we do still want an error here, because x
should have
to be initialized at the point where c is created. Therefore, we add a “fake read”
instead.
let c = || {
let (t1, t2) = t;
}
In the second example, we capture the disjoint fields of t
(t.0
& t.1
), but
we never capture t
. This becomes an issue when we build MIR as we require
information on t
in order to create place t.0
and t.1
. We can solve this
issue by fake reading t
.
rvalue_scopes: RvalueScopes
Tracks the rvalue scoping rules which defines finer scoping for rvalue expressions
by applying extended parameter rules.
Details may be find in rustc_hir_analysis::check::rvalue_scopes
.
generator_interior_predicates: LocalDefIdMap<Vec<(Predicate<'tcx>, ObligationCause<'tcx>)>>
Stores the predicates that apply on generator witness types. formatting modified file tests/ui/generator/retain-resume-ref.rs
treat_byte_string_as_slice: ItemLocalSet
We sometimes treat byte string literals (which are of type &[u8; N]
)
as &[u8]
, depending on the pattern in which they are used.
This hashset records all instances where we behave
like this to allow const_to_pat
to reliably handle this situation.
closure_size_eval: LocalDefIdMap<ClosureSizeProfileData<'tcx>>
Contains the data for evaluating the effect of feature capture_disjoint_fields
on closure size.
offset_of_data: ItemLocalMap<(Ty<'tcx>, Vec<FieldIdx>)>
Container types and field indices of offset_of!
expressions
Implementations§
source§impl<'tcx> TypeckResults<'tcx>
impl<'tcx> TypeckResults<'tcx>
pub fn new(hir_owner: OwnerId) -> TypeckResults<'tcx>
sourcepub fn qpath_res(&self, qpath: &QPath<'_>, id: HirId) -> Res
pub fn qpath_res(&self, qpath: &QPath<'_>, id: HirId) -> Res
Returns the final resolution of a QPath
in an Expr
or Pat
node.
pub fn type_dependent_defs( &self ) -> LocalTableInContext<'_, Result<(DefKind, DefId), ErrorGuaranteed>>
pub fn type_dependent_def(&self, id: HirId) -> Option<(DefKind, DefId)>
pub fn type_dependent_def_id(&self, id: HirId) -> Option<DefId>
pub fn type_dependent_defs_mut( &mut self ) -> LocalTableInContextMut<'_, Result<(DefKind, DefId), ErrorGuaranteed>>
pub fn field_indices(&self) -> LocalTableInContext<'_, FieldIdx>
pub fn field_indices_mut(&mut self) -> LocalTableInContextMut<'_, FieldIdx>
pub fn field_index(&self, id: HirId) -> FieldIdx
pub fn opt_field_index(&self, id: HirId) -> Option<FieldIdx>
pub fn user_provided_types( &self ) -> LocalTableInContext<'_, CanonicalUserType<'tcx>>
pub fn user_provided_types_mut( &mut self ) -> LocalTableInContextMut<'_, CanonicalUserType<'tcx>>
pub fn node_types(&self) -> LocalTableInContext<'_, Ty<'tcx>>
pub fn node_types_mut(&mut self) -> LocalTableInContextMut<'_, Ty<'tcx>>
pub fn node_type(&self, id: HirId) -> Ty<'tcx>
pub fn node_type_opt(&self, id: HirId) -> Option<Ty<'tcx>>
pub fn node_args_mut( &mut self ) -> LocalTableInContextMut<'_, GenericArgsRef<'tcx>>
pub fn node_args(&self, id: HirId) -> GenericArgsRef<'tcx>
pub fn node_args_opt(&self, id: HirId) -> Option<GenericArgsRef<'tcx>>
sourcepub fn pat_ty(&self, pat: &Pat<'_>) -> Ty<'tcx>
pub fn pat_ty(&self, pat: &Pat<'_>) -> Ty<'tcx>
Returns the type of a pattern as a monotype. Like expr_ty
, this function
doesn’t provide type parameter substitutions.
sourcepub fn expr_ty(&self, expr: &Expr<'_>) -> Ty<'tcx>
pub fn expr_ty(&self, expr: &Expr<'_>) -> Ty<'tcx>
Returns the type of an expression as a monotype.
NB (1): This is the PRE-ADJUSTMENT TYPE for the expression. That is, in
some cases, we insert Adjustment
annotations such as auto-deref or
auto-ref. The type returned by this function does not consider such
adjustments. See expr_ty_adjusted()
instead.
NB (2): This type doesn’t provide type parameter substitutions; e.g., if you
ask for the type of id
in id(3)
, it will return fn(&isize) -> isize
instead of fn(ty) -> T with T = isize
.
pub fn expr_ty_opt(&self, expr: &Expr<'_>) -> Option<Ty<'tcx>>
pub fn adjustments(&self) -> LocalTableInContext<'_, Vec<Adjustment<'tcx>>>
pub fn adjustments_mut( &mut self ) -> LocalTableInContextMut<'_, Vec<Adjustment<'tcx>>>
pub fn expr_adjustments(&self, expr: &Expr<'_>) -> &[Adjustment<'tcx>]
sourcepub fn expr_ty_adjusted(&self, expr: &Expr<'_>) -> Ty<'tcx>
pub fn expr_ty_adjusted(&self, expr: &Expr<'_>) -> Ty<'tcx>
Returns the type of expr
, considering any Adjustment
entry recorded for that expression.
pub fn expr_ty_adjusted_opt(&self, expr: &Expr<'_>) -> Option<Ty<'tcx>>
pub fn is_method_call(&self, expr: &Expr<'_>) -> bool
pub fn extract_binding_mode( &self, s: &Session, id: HirId, sp: Span ) -> Option<BindingMode>
pub fn pat_binding_modes(&self) -> LocalTableInContext<'_, BindingMode>
pub fn pat_binding_modes_mut( &mut self ) -> LocalTableInContextMut<'_, BindingMode>
pub fn pat_adjustments(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>>
pub fn pat_adjustments_mut( &mut self ) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>>
sourcepub fn closure_min_captures_flattened(
&self,
closure_def_id: LocalDefId
) -> impl Iterator<Item = &CapturedPlace<'tcx>>
pub fn closure_min_captures_flattened( &self, closure_def_id: LocalDefId ) -> impl Iterator<Item = &CapturedPlace<'tcx>>
For a given closure, returns the iterator of ty::CapturedPlace
s that are captured
by the closure.
pub fn closure_kind_origins( &self ) -> LocalTableInContext<'_, (Span, HirPlace<'tcx>)>
pub fn closure_kind_origins_mut( &mut self ) -> LocalTableInContextMut<'_, (Span, HirPlace<'tcx>)>
pub fn liberated_fn_sigs(&self) -> LocalTableInContext<'_, FnSig<'tcx>>
pub fn liberated_fn_sigs_mut( &mut self ) -> LocalTableInContextMut<'_, FnSig<'tcx>>
pub fn fru_field_types(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>>
pub fn fru_field_types_mut( &mut self ) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>>
pub fn is_coercion_cast(&self, hir_id: HirId) -> bool
pub fn set_coercion_cast(&mut self, id: ItemLocalId)
pub fn coercion_casts(&self) -> &ItemLocalSet
pub fn offset_of_data( &self ) -> LocalTableInContext<'_, (Ty<'tcx>, Vec<FieldIdx>)>
pub fn offset_of_data_mut( &mut self ) -> LocalTableInContextMut<'_, (Ty<'tcx>, Vec<FieldIdx>)>
Trait Implementations§
source§impl<'tcx> ArenaAllocatable<'tcx, IsNotCopy> for TypeckResults<'tcx>
impl<'tcx> ArenaAllocatable<'tcx, IsNotCopy> for TypeckResults<'tcx>
fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut Self
fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = Self> ) -> &'a mut [Self]
source§impl<'tcx> Debug for TypeckResults<'tcx>
impl<'tcx> Debug for TypeckResults<'tcx>
source§impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for TypeckResults<'tcx>
impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for TypeckResults<'tcx>
fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )
source§impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D> for TypeckResults<'tcx>
impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> RefDecodable<'tcx, D> for TypeckResults<'tcx>
fn decode(decoder: &mut D) -> &'tcx Self
Auto Trait Implementations§
impl<'tcx> !RefUnwindSafe for TypeckResults<'tcx>
impl<'tcx> !Send for TypeckResults<'tcx>
impl<'tcx> !Sync for TypeckResults<'tcx>
impl<'tcx> Unpin for TypeckResults<'tcx>
impl<'tcx> !UnwindSafe for TypeckResults<'tcx>
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T, R> CollectAndApply<T, R> for T
impl<T, R> CollectAndApply<T, R> for T
source§impl<Tcx, T> DepNodeParams<Tcx> for Twhere
Tcx: DepContext,
T: for<'a> HashStable<StableHashingContext<'a>> + Debug,
impl<Tcx, T> DepNodeParams<Tcx> for Twhere Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,
default fn fingerprint_style() -> FingerprintStyle
source§default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint
default fn to_debug_str(&self, _: Tcx) -> String
source§default fn recover(_: Tcx, _: &DepNode) -> Option<T>
default fn recover(_: Tcx, _: &DepNode) -> Option<T>
DepNode
,
something which is needed when forcing DepNode
s during red-green
evaluation. The query system will only call this method if
fingerprint_style()
is not FingerprintStyle::Opaque
.
It is always valid to return None
here, in which case incremental
compilation will treat the query as having changed instead of forcing it.source§impl<P> IntoQueryParam<P> for P
impl<P> IntoQueryParam<P> for P
fn into_query_param(self) -> P
source§impl<T> MaybeResult<T> for T
impl<T> MaybeResult<T> for T
source§impl<'tcx, T> ToPredicate<'tcx, T> for T
impl<'tcx, T> ToPredicate<'tcx, T> for T
fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> T
source§impl<Tcx, T> Value<Tcx> for Twhere
Tcx: DepContext,
impl<Tcx, T> Value<Tcx> for Twhere Tcx: DepContext,
default fn from_cycle_error( tcx: Tcx, cycle: &[QueryInfo], _guar: ErrorGuaranteed ) -> T
Layout§
Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...)
attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.
Size: 736 bytes