Struct ConvCtxt

#[repr(transparent)]
pub struct ConvCtxt<P>(P);

Wrapper over a type implementing ConvPhase. We have this to implement most functionality as inherent methods instead of defining them as default implementation in the trait definition.

Tuple Fields

0: P

Implementations

impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P>

Delegate methods to P

fn genv(&self) -> GlobalEnv<'genv, 'tcx>

fn tcx(&self) -> TyCtxt<'tcx>

fn owner(&self) -> FluxOwnerId

fn results(&self) -> &P::Results

fn next_sort_vid(&mut self) -> SortVid

fn next_type_vid(&mut self) -> TyVid

fn next_region_vid(&mut self) -> RegionVid

fn next_const_vid(&mut self) -> ConstVid

impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P>

Conversion of definitions

pub(crate) fn conv_enum_variants( &mut self, enum_id: MaybeExternId, enum_def: &EnumDef<'_>, ) -> QueryResult<Vec<PolyVariant>>

fn conv_enum_variant( &mut self, enum_id: MaybeExternId, variant: &VariantDef<'_>, ) -> QueryResult<PolyVariant>

pub(crate) fn conv_struct_variant( &mut self, struct_id: MaybeExternId, struct_def: &StructDef<'_>, ) -> QueryResult<Opaqueness<PolyVariant>>

pub(crate) fn conv_type_alias( &mut self, ty_alias_id: MaybeExternId, ty_alias: &TyAlias<'_>, ) -> QueryResult<TyCtor>

pub(crate) fn conv_fn_sig( &mut self, fn_id: MaybeExternId, fn_sig: &FnSig<'_>, ) -> QueryResult<PolyFnSig>

pub(crate) fn conv_generic_predicates( &mut self, def_id: MaybeExternId, generics: &Generics<'_>, ) -> QueryResult<EarlyBinder<GenericPredicates>>

pub(crate) fn conv_opaque_ty( &mut self, opaque_ty: &OpaqueTy<'_>, ) -> QueryResult<Clauses>

pub(crate) fn conv_assoc_reft_body( &mut self, params: &[RefineParam<'_>], body: &Expr<'_>, output: &Sort<'_>, ) -> QueryResult<Lambda>

impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P>

Conversion of sorts

pub(crate) fn conv_sort(&mut self, sort: &Sort<'_>) -> QueryResult<Sort>

fn conv_poly_func_sort( &mut self, sort: &PolyFuncSort<'_>, ) -> QueryResult<PolyFuncSort>

fn conv_func_sort(&mut self, fsort: &FuncSort<'_>) -> QueryResult<FuncSort>

fn conv_sort_path(&mut self, path: &SortPath<'_>) -> QueryResult<Sort>

fn check_prim_sort_generics( &mut self, path: &SortPath<'_>, prim_sort: PrimSort, ) -> QueryResult

impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P>

Conversion of types

fn conv_fn_decl( &mut self, env: &mut Env, safety: Safety, abi: Abi, decl: &FnDecl<'_>, ) -> QueryResult<FnSig>

fn conv_requires( &mut self, env: &mut Env, requires: &Requires<'_>, ) -> QueryResult<Expr>

fn conv_ensures( &mut self, env: &mut Env, ensures: &Ensures<'_>, ) -> QueryResult<Ensures>

fn conv_fn_output( &mut self, env: &mut Env, output: &FnOutput<'_>, ) -> QueryResult<Binder<FnOutput>>

fn conv_generic_bounds( &mut self, env: &mut Env, bounded_ty_span: Span, bounded_ty: Ty, bounds: GenericBounds<'_>, ) -> QueryResult<Vec<Clause>>

fn conv_poly_trait_ref( &mut self, env: &mut Env, span: Span, bounded_ty: &Ty, poly_trait_ref: &PolyTraitRef<'_>, clauses: &mut Vec<Clause>, ) -> QueryResult

Converts a T: Trait<T0, ..., A0 = S0, ...> bound

fn conv_assoc_item_constraint( &mut self, env: &mut Env, poly_trait_ref: &PolyTraitRef, constraint: &AssocItemConstraint<'_>, clauses: &mut Vec<Clause>, ) -> QueryResult

fn trait_defines_associated_item_named( &self, trait_def_id: DefId, assoc_kind: AssocKind, assoc_name: Ident, ) -> Option<&'tcx AssocItem>

fn conv_ty(&mut self, env: &mut Env, ty: &Ty<'_>) -> QueryResult<Ty>

fn conv_opaque_def( &mut self, env: &mut Env, opaque_ty: &OpaqueTy<'_>, ) -> QueryResult<Ty>

Code adapted from https://github.com/rust-lang/rust/blob/b5723af3457b9cd3795eeb97e9af2d34964854f2/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs#L2099

fn conv_trait_object( &mut self, env: &mut Env, trait_bounds: &[PolyTraitRef<'_>], lifetime: Lifetime, ) -> QueryResult<Ty>

pub(crate) fn conv_bty( &mut self, env: &mut Env, bty: &BaseTy<'_>, ) -> QueryResult<TyOrCtor>

fn conv_type_relative_path( &mut self, env: &mut Env, qself_span: Span, qself_res: Res, assoc_segment: &PathSegment<'_>, ) -> QueryResult<AliasTy>

fn refiner(&self) -> QueryResult<Refiner<'genv, 'tcx>>

Return the generics of the containing owner item

fn probe_type_param_bounds( &self, param_id: DefId, assoc_ident: Ident, ) -> EarlyBinder<'tcx, &'tcx [(Clause<'tcx>, Span)]>

fn probe_single_bound_for_assoc_item<I>( &self, all_candidates: impl Fn() -> I, assoc_ident: Ident, ) -> Result<PolyTraitRef<'tcx>, ErrorGuaranteed>

where I: Iterator<Item = PolyTraitRef<'tcx>>,

fn conv_lifetime(&mut self, env: &Env, lft: Lifetime) -> Region

fn conv_resolved_lifetime(&mut self, env: &Env, res: ResolvedArg) -> Region

fn conv_const_arg(&mut self, cst: ConstArg) -> Const

fn conv_qpath( &mut self, env: &mut Env, qself: Option<&Ty<'_>>, path: &Path<'_>, ) -> QueryResult<TyOrCtor>

fn param_as_bound_var( &mut self, param: &GenericParam<'_>, ) -> QueryResult<BoundVariableKind>

fn conv_generic_args( &mut self, env: &mut Env, def_id: DefId, segment: &PathSegment<'_>, ) -> QueryResult<Vec<GenericArg>>

fn conv_generic_args_into( &mut self, env: &mut Env, def_id: DefId, segment: &PathSegment<'_>, into: &mut Vec<GenericArg>, ) -> QueryResult

fn check_generic_arg_count( &mut self, generics: &Generics, def_id: DefId, segment: &PathSegment<'_>, ) -> QueryResult

fn fill_generic_args_defaults( &mut self, def_id: DefId, into: &mut Vec<GenericArg>, ) -> QueryResult

fn conv_ty_to_generic_arg( &mut self, env: &mut Env, param: &GenericParamDef, ty: &Ty<'_>, ) -> QueryResult<GenericArg>

fn try_to_ty_or_base( &mut self, kind: GenericParamDefKind, span: Span, ty: &Ty, ) -> QueryResult<TyOrBase>

fn ty_to_subset_ty_ctor( &mut self, span: Span, ty: &Ty, ) -> QueryResult<SubsetTyCtor>

fn emit(&self, err: impl Diagnostic<'genv>) -> ErrorGuaranteed

impl<'genv, 'tcx: 'genv, P: ConvPhase<'genv, 'tcx>> ConvCtxt<P>

Conversion of expressions

fn conv_expr(&mut self, env: &mut Env, expr: &Expr<'_>) -> QueryResult<Expr>

fn conv_constructor_exprs( &mut self, struct_def_id: DefId, env: &mut Env, exprs: &[FieldExpr<'_>], spread: &Option<&Spread<'_>>, ) -> QueryResult<List<Expr>>

fn conv_exprs( &mut self, env: &mut Env, exprs: &[Expr<'_>], ) -> QueryResult<List<Expr>>

fn conv_bin_op(&self, op: BinOp, fhir_id: FhirId) -> BinOp

fn add_coercions(&self, expr: Expr, fhir_id: FhirId) -> Expr

fn conv_func(&self, env: &Env, func: &PathExpr<'_>) -> Expr

fn conv_alias_reft( &mut self, env: &mut Env, fhir_id: FhirId, alias: &AliasReft<'_>, ) -> QueryResult<AliasReft>

fn conv_invariants( &mut self, env: &mut Env, invariants: &[Expr<'_>], ) -> QueryResult<Vec<Invariant>>

fn conv_invariant( &mut self, env: &mut Env, invariant: &Expr<'_>, ) -> QueryResult<Invariant>