Struct rustc_borrowck::type_check::TypeChecker

struct TypeChecker<'a, 'tcx> {
    infcx: &'a BorrowckInferCtxt<'a, 'tcx>,
    param_env: ParamEnv<'tcx>,
    last_span: Span,
    body: &'a Body<'tcx>,
    user_type_annotations: &'a CanonicalUserTypeAnnotations<'tcx>,
    region_bound_pairs: &'a RegionBoundPairs<'tcx>,
    implicit_region_bound: Region<'tcx>,
    reported_errors: FxIndexSet<(Ty<'tcx>, Span)>,
    borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>,
}

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<'a, '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>

implicit_region_bound: Region<'tcx>

reported_errors: FxIndexSet<(Ty<'tcx>, Span)>

borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx>

Implementations

impl<'a, 'tcx> TypeChecker<'a, 'tcx>

pub(super) fn fully_perform_op<R: Debug, Op>( &mut self, locations: Locations, category: ConstraintCategory<'tcx>, op: Op ) -> Result<R, ErrorGuaranteed>where Op: TypeOp<'tcx, Output = R>, Op::ErrorInfo: ToUniverseInfo<'tcx>,

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_with_fresh_inference_vars<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: ToPredicate<'tcx> + Debug>, locations: Locations, category: ConstraintCategory<'tcx> )

pub(super) fn prove_predicate( &mut self, predicate: impl ToPredicate<'tcx> + Debug, locations: Locations, category: ConstraintCategory<'tcx> )

pub(super) fn normalize<T>( &mut self, value: T, location: impl NormalizeLocation ) -> Twhere T: Normalizable<'tcx> + Display + Copy + 'tcx,

pub(super) fn normalize_with_category<T>( &mut self, value: T, location: impl NormalizeLocation, category: ConstraintCategory<'tcx> ) -> Twhere T: Normalizable<'tcx> + Display + Copy + 'tcx,

pub(super) fn ascribe_user_type( &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.

impl<'a, 'tcx> TypeChecker<'a, '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 )

impl<'a, 'tcx> TypeChecker<'a, 'tcx>

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.

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.

impl<'a, 'tcx> TypeChecker<'a, 'tcx>

fn new( infcx: &'a BorrowckInferCtxt<'a, 'tcx>, body: &'a Body<'tcx>, param_env: ParamEnv<'tcx>, region_bound_pairs: &'a RegionBoundPairs<'tcx>, implicit_region_bound: Region<'tcx>, borrowck_context: &'a mut BorrowCheckContext<'a, 'tcx> ) -> Self

pub(crate) fn register_predefined_opaques_in_new_solver(&mut self)

fn body(&self) -> &Body<'tcx>

fn unsized_feature_enabled(&self) -> bool

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> )

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 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: &[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 )

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 )

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 location L where the borrow expression occurs
• borrow_region: the region 'a associated with the borrow
• borrowed_place: the place P 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>, location: Location ) -> InstantiatedPredicates<'tcx>

fn typeck_mir(&mut self, body: &Body<'tcx>)

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: 120 bytes