Struct rustc_borrowck::type_check::TypeChecker
source · struct TypeChecker<'a, 'tcx> {
infcx: &'a BorrowckInferCtxt<'tcx>,
param_env: ParamEnv<'tcx>,
last_span: Span,
body: &'a Body<'tcx>,
user_type_annotations: &'a CanonicalUserTypeAnnotations<'tcx>,
region_bound_pairs: &'a RegionBoundPairs<'tcx>,
known_type_outlives_obligations: &'tcx [PolyTypeOutlivesPredicate<'tcx>],
implicit_region_bound: Region<'tcx>,
reported_errors: FxIndexSet<(Ty<'tcx>, Span)>,
borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>,
}
Expand description
The MIR type checker. Visits the MIR and enforces all the constraints needed for it to be valid and well-typed. Along the way, it accrues region constraints – these can later be used by NLL region checking.
Fields§
§infcx: &'a BorrowckInferCtxt<'tcx>
§param_env: ParamEnv<'tcx>
§last_span: Span
§body: &'a Body<'tcx>
§user_type_annotations: &'a CanonicalUserTypeAnnotations<'tcx>
User type annotations are shared between the main MIR and the MIR of all of the promoted items.
region_bound_pairs: &'a RegionBoundPairs<'tcx>
§known_type_outlives_obligations: &'tcx [PolyTypeOutlivesPredicate<'tcx>]
§implicit_region_bound: Region<'tcx>
§reported_errors: FxIndexSet<(Ty<'tcx>, Span)>
§borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>
Implementations§
source§impl<'a, 'tcx> TypeChecker<'a, 'tcx>
impl<'a, 'tcx> TypeChecker<'a, 'tcx>
sourcepub(super) fn fully_perform_op<R: Debug, Op>(
&mut self,
locations: Locations,
category: ConstraintCategory<'tcx>,
op: Op,
) -> Result<R, ErrorGuaranteed>
pub(super) fn fully_perform_op<R: Debug, Op>( &mut self, locations: Locations, category: ConstraintCategory<'tcx>, op: Op, ) -> Result<R, ErrorGuaranteed>
Given some operation op
that manipulates types, proves
predicates, or otherwise uses the inference context, executes
op
and then executes all the further obligations that op
returns. This will yield a set of outlives constraints amongst
regions which are extracted and stored as having occurred at
locations
.
Any rustc_infer::infer
operations that might generate region
constraints should occur within this method so that those
constraints can be properly localized!
pub(super) fn instantiate_canonical<T>(
&mut self,
span: Span,
canonical: &Canonical<'tcx, T>,
) -> Twhere
T: TypeFoldable<TyCtxt<'tcx>>,
pub(super) fn prove_trait_ref( &mut self, trait_ref: TraitRef<'tcx>, locations: Locations, category: ConstraintCategory<'tcx>, )
pub(super) fn normalize_and_prove_instantiated_predicates( &mut self, _def_id: DefId, instantiated_predicates: InstantiatedPredicates<'tcx>, locations: Locations, )
pub(super) fn prove_predicates( &mut self, predicates: impl IntoIterator<Item: Upcast<TyCtxt<'tcx>, Predicate<'tcx>> + Debug>, locations: Locations, category: ConstraintCategory<'tcx>, )
pub(super) fn prove_predicate( &mut self, predicate: impl Upcast<TyCtxt<'tcx>, Predicate<'tcx>> + Debug, locations: Locations, category: ConstraintCategory<'tcx>, )
pub(super) fn normalize<T>( &mut self, value: T, location: impl NormalizeLocation, ) -> T
pub(super) fn normalize_with_category<T>( &mut self, value: T, location: impl NormalizeLocation, category: ConstraintCategory<'tcx>, ) -> T
pub(super) fn struct_tail( &mut self, ty: Ty<'tcx>, location: impl NormalizeLocation, ) -> Ty<'tcx>
pub(super) fn ascribe_user_type( &mut self, mir_ty: Ty<'tcx>, user_ty: UserType<'tcx>, span: Span, )
sourcepub(super) fn ascribe_user_type_skip_wf(
&mut self,
mir_ty: Ty<'tcx>,
user_ty: UserType<'tcx>,
span: Span,
)
pub(super) fn ascribe_user_type_skip_wf( &mut self, mir_ty: Ty<'tcx>, user_ty: UserType<'tcx>, span: Span, )
Incorrectly skips the WF checks we normally do in ascribe_user_type
.
FIXME(#104478, #104477): This is a hack for backward-compatibility.
source§impl<'a, 'tcx> TypeChecker<'a, 'tcx>
impl<'a, 'tcx> TypeChecker<'a, 'tcx>
sourcepub(super) fn check_signature_annotation(&mut self, body: &Body<'tcx>)
pub(super) fn check_signature_annotation(&mut self, body: &Body<'tcx>)
Check explicit closure signature annotation,
e.g., |x: FxIndexMap<_, &'static u32>| ...
.
pub(super) fn equate_inputs_and_outputs( &mut self, body: &Body<'tcx>, universal_regions: &UniversalRegions<'tcx>, normalized_inputs_and_output: &[Ty<'tcx>], )
fn equate_normalized_input_or_output( &mut self, a: Ty<'tcx>, b: Ty<'tcx>, span: Span, )
source§impl<'a, 'tcx> TypeChecker<'a, 'tcx>
impl<'a, 'tcx> TypeChecker<'a, 'tcx>
sourcepub(super) fn relate_types(
&mut self,
a: Ty<'tcx>,
v: Variance,
b: Ty<'tcx>,
locations: Locations,
category: ConstraintCategory<'tcx>,
) -> Result<(), NoSolution>
pub(super) fn relate_types( &mut self, a: Ty<'tcx>, v: Variance, b: Ty<'tcx>, locations: Locations, category: ConstraintCategory<'tcx>, ) -> Result<(), NoSolution>
Adds sufficient constraints to ensure that a R b
where R
depends on v
:
- “Covariant”
a <: b
- “Invariant”
a == b
- “Contravariant”
a :> b
N.B., the type a
is permitted to have unresolved inference
variables, but not the type b
.
sourcepub(super) fn eq_args(
&mut self,
a: GenericArgsRef<'tcx>,
b: GenericArgsRef<'tcx>,
locations: Locations,
category: ConstraintCategory<'tcx>,
) -> Result<(), NoSolution>
pub(super) fn eq_args( &mut self, a: GenericArgsRef<'tcx>, b: GenericArgsRef<'tcx>, locations: Locations, category: ConstraintCategory<'tcx>, ) -> Result<(), NoSolution>
Add sufficient constraints to ensure a == b
. See also Self::relate_types.
source§impl<'a, 'tcx> TypeChecker<'a, 'tcx>
impl<'a, 'tcx> TypeChecker<'a, 'tcx>
fn new( infcx: &'a BorrowckInferCtxt<'tcx>, body: &'a Body<'tcx>, param_env: ParamEnv<'tcx>, region_bound_pairs: &'a RegionBoundPairs<'tcx>, known_type_outlives_obligations: &'tcx [PolyTypeOutlivesPredicate<'tcx>], implicit_region_bound: Region<'tcx>, borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>, ) -> Self
fn body(&self) -> &Body<'tcx>
fn unsized_feature_enabled(&self) -> bool
sourcefn check_user_type_annotations(&mut self)
fn check_user_type_annotations(&mut self)
Equate the inferred type and the annotated type for user type annotations
fn push_region_constraints( &mut self, locations: Locations, category: ConstraintCategory<'tcx>, data: &QueryRegionConstraints<'tcx>, )
sourcefn sub_types(
&mut self,
sub: Ty<'tcx>,
sup: Ty<'tcx>,
locations: Locations,
category: ConstraintCategory<'tcx>,
) -> Result<(), NoSolution>
fn sub_types( &mut self, sub: Ty<'tcx>, sup: Ty<'tcx>, locations: Locations, category: ConstraintCategory<'tcx>, ) -> Result<(), NoSolution>
Try to relate sub <: sup
fn eq_types( &mut self, expected: Ty<'tcx>, found: Ty<'tcx>, locations: Locations, category: ConstraintCategory<'tcx>, ) -> Result<(), NoSolution>
fn relate_type_and_user_type( &mut self, a: Ty<'tcx>, v: Variance, user_ty: &UserTypeProjection, locations: Locations, category: ConstraintCategory<'tcx>, ) -> Result<(), NoSolution>
fn check_inline_const( &mut self, inferred_ty: Ty<'tcx>, def_id: LocalDefId, args: UserArgs<'tcx>, span: Span, )
fn tcx(&self) -> TyCtxt<'tcx>
fn check_stmt( &mut self, body: &Body<'tcx>, stmt: &Statement<'tcx>, location: Location, )
fn check_terminator( &mut self, body: &Body<'tcx>, term: &Terminator<'tcx>, term_location: Location, )
fn check_call_dest( &mut self, body: &Body<'tcx>, term: &Terminator<'tcx>, sig: &FnSig<'tcx>, destination: Place<'tcx>, target: Option<BasicBlock>, term_location: Location, )
fn check_call_inputs( &mut self, body: &Body<'tcx>, term: &Terminator<'tcx>, func: &Operand<'tcx>, sig: &FnSig<'tcx>, args: &[Spanned<Operand<'tcx>>], term_location: Location, call_source: CallSource, )
fn check_iscleanup( &mut self, body: &Body<'tcx>, block_data: &BasicBlockData<'tcx>, )
fn assert_iscleanup( &mut self, body: &Body<'tcx>, ctxt: &dyn Debug, bb: BasicBlock, iscleanuppad: bool, )
fn assert_iscleanup_unwind( &mut self, body: &Body<'tcx>, ctxt: &dyn Debug, unwind: UnwindAction, is_cleanup: bool, )
fn check_local( &mut self, body: &Body<'tcx>, local: Local, local_decl: &LocalDecl<'tcx>, )
fn ensure_place_sized(&mut self, ty: Ty<'tcx>, span: Span)
fn aggregate_field_ty( &mut self, ak: &AggregateKind<'tcx>, field_index: FieldIdx, location: Location, ) -> Result<Ty<'tcx>, FieldAccessError>
fn check_operand(&mut self, op: &Operand<'tcx>, location: Location)
fn check_rvalue( &mut self, body: &Body<'tcx>, rvalue: &Rvalue<'tcx>, location: Location, )
sourcefn rvalue_user_ty(
&self,
rvalue: &Rvalue<'tcx>,
) -> Option<UserTypeAnnotationIndex>
fn rvalue_user_ty( &self, rvalue: &Rvalue<'tcx>, ) -> Option<UserTypeAnnotationIndex>
If this rvalue supports a user-given type annotation, then extract and return it. This represents the final type of the rvalue and will be unified with the inferred type.
fn check_aggregate_rvalue( &mut self, body: &Body<'tcx>, rvalue: &Rvalue<'tcx>, aggregate_kind: &AggregateKind<'tcx>, operands: &IndexSlice<FieldIdx, Operand<'tcx>>, location: Location, )
sourcefn add_reborrow_constraint(
&mut self,
body: &Body<'tcx>,
location: Location,
borrow_region: Region<'tcx>,
borrowed_place: &Place<'tcx>,
)
fn add_reborrow_constraint( &mut self, body: &Body<'tcx>, location: Location, borrow_region: Region<'tcx>, borrowed_place: &Place<'tcx>, )
Adds the constraints that arise from a borrow expression &'a P
at the location L
.
§Parameters
location
: the locationL
where the borrow expression occursborrow_region
: the region'a
associated with the borrowborrowed_place
: the placeP
being borrowed
fn prove_aggregate_predicates( &mut self, aggregate_kind: &AggregateKind<'tcx>, location: Location, )
fn prove_closure_bounds( &mut self, tcx: TyCtxt<'tcx>, def_id: LocalDefId, args: GenericArgsRef<'tcx>, locations: Locations, ) -> InstantiatedPredicates<'tcx>
fn typeck_mir(&mut self, body: &Body<'tcx>)
Auto Trait Implementations§
impl<'a, 'tcx> Freeze for TypeChecker<'a, 'tcx>
impl<'a, 'tcx> !RefUnwindSafe for TypeChecker<'a, 'tcx>
impl<'a, 'tcx> !Send for TypeChecker<'a, 'tcx>
impl<'a, 'tcx> !Sync for TypeChecker<'a, 'tcx>
impl<'a, 'tcx> Unpin for TypeChecker<'a, 'tcx>
impl<'a, 'tcx> !UnwindSafe for TypeChecker<'a, '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<T> Filterable for T
impl<T> Filterable for T
source§fn filterable(
self,
filter_name: &'static str,
) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
fn filterable( self, filter_name: &'static str, ) -> RequestFilterDataProvider<T, fn(_: DataRequest<'_>) -> bool>
source§impl<T> Instrument for T
impl<T> Instrument for T
source§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
source§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
source§impl<T> IntoEither for T
impl<T> IntoEither for T
source§fn into_either(self, into_left: bool) -> Either<Self, Self>
fn into_either(self, into_left: bool) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left
is true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
self
into a Left
variant of Either<Self, Self>
if into_left(&self)
returns true
.
Converts self
into a Right
variant of Either<Self, Self>
otherwise. Read moresource§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<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
impl<I, T, U> Upcast<I, U> for Twhere
U: UpcastFrom<I, T>,
source§impl<I, T> UpcastFrom<I, T> for T
impl<I, T> UpcastFrom<I, T> for T
fn upcast_from(from: T, _tcx: I) -> 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_error: &CycleError, _guar: ErrorGuaranteed, ) -> T
source§impl<T> WithSubscriber for T
impl<T> WithSubscriber for T
source§fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
source§fn with_current_subscriber(self) -> WithDispatch<Self>
fn with_current_subscriber(self) -> WithDispatch<Self>
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> ErasedDestructor for Twhere
T: 'static,
impl<T> MaybeSendSync for 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: 136 bytes