Struct RustItemCtxt

pub(crate) struct RustItemCtxt<'a, 'genv, 'tcx> {
    genv: GlobalEnv<'genv, 'tcx>,
    local_id_gen: IndexGen<ItemLocalId>,
    owner: MaybeExternId<OwnerId>,
    fn_sig_scope: Option<NodeId>,
    resolver_output: &'genv ResolverOutput,
    opaque_tys: Option<&'a mut Vec<&'genv OpaqueTy<'genv>>>,
    errors: Errors<'genv>,
}

Fields

genv: GlobalEnv<'genv, 'tcx>

local_id_gen: IndexGen<ItemLocalId>

owner: MaybeExternId<OwnerId>

fn_sig_scope: Option<NodeId>

resolver_output: &'genv ResolverOutput

opaque_tys: Option<&'a mut Vec<&'genv OpaqueTy<'genv>>>

errors: Errors<'genv>

Implementations

impl<'genv> RustItemCtxt<'_, 'genv, '_>

pub fn lift_generics(&mut self) -> Generics<'genv>

pub fn lift_generic_param( &mut self, param: &GenericParam<'_>, ) -> GenericParam<'genv>

fn lift_generics_inner(&mut self, generics: &Generics<'_>) -> Generics<'genv>

fn lift_generic_bound( &mut self, bound: &GenericBound<'_>, ) -> Result<GenericBound<'genv>, ErrorGuaranteed>

fn lift_poly_trait_ref( &mut self, poly_trait_ref: PolyTraitRef<'_>, ) -> Result<PolyTraitRef<'genv>, ErrorGuaranteed>

fn lift_opaque_ty( &mut self, opaque_ty: &OpaqueTy<'_>, ) -> Result<OpaqueTy<'genv>, ErrorGuaranteed>

pub fn lift_fn_header(&mut self) -> FnHeader

pub fn lift_fn_decl(&mut self) -> FnDecl<'genv>

fn lift_fn_decl_inner(&mut self, span: Span, decl: &FnDecl<'_>) -> FnDecl<'genv>

fn lift_fn_ret_ty(&mut self, ret_ty: &FnRetTy<'_>) -> Ty<'genv>

pub fn lift_type_alias(&mut self) -> Item<'genv>

pub fn lift_field_def(&mut self, field_def: &FieldDef<'_>) -> FieldDef<'genv>

pub fn lift_enum_variant(&mut self, variant: &Variant<'_>) -> VariantDef<'genv>

pub fn lift_variant_ret(&mut self) -> VariantRet<'genv>

fn lift_variant_ret_inner( &mut self, generics: &Generics<'_>, ) -> VariantRet<'genv>

pub fn lift_ty(&mut self, ty: &Ty<'_>) -> Ty<'genv>

fn lift_bare_fn( &mut self, span: Span, bare_fn: &BareFnTy<'_>, ) -> BareFnTy<'genv>

fn lift_lifetime(&self, lft: &Lifetime) -> Lifetime

fn lift_mut_ty(&mut self, mut_ty: MutTy<'_>) -> MutTy<'genv>

fn lift_qpath( &mut self, qpath: QPath<'_>, ) -> Result<QPath<'genv>, ErrorGuaranteed>

fn lift_path(&mut self, path: &Path<'_>) -> Result<Path<'genv>, ErrorGuaranteed>

fn lift_path_segment( &mut self, segment: &PathSegment<'_>, ) -> Result<PathSegment<'genv>, ErrorGuaranteed>

fn lift_generic_args( &mut self, args: &[GenericArg<'_>], ) -> Result<&'genv [GenericArg<'genv>], ErrorGuaranteed>

fn lift_assoc_item_constraints( &mut self, constraints: &[AssocItemConstraint<'_>], ) -> Result<&'genv [AssocItemConstraint<'genv>], ErrorGuaranteed>

fn lift_const_arg(&mut self, const_arg: &ConstArg<'_>) -> ConstArg

fn emit_unsupported(&self, note: &str) -> ErrorGuaranteed

fn next_fhir_id(&self) -> FhirId

fn local_id(&self) -> LocalDefId

fn lift_fn_sig(&mut self, fn_sig: FnSig<'_>) -> FnSig<'genv>

pub fn lift_foreign_item( &mut self, foreign_item: ForeignItem<'_>, ) -> Result<ForeignItem<'genv>, ErrorGuaranteed>

impl<'a, 'genv, 'tcx: 'genv> RustItemCtxt<'a, 'genv, 'tcx>

pub(crate) fn with<T>( genv: GlobalEnv<'genv, 'tcx>, owner: MaybeExternId<OwnerId>, resolver_output: &'genv ResolverOutput, opaque_tys: Option<&'a mut Vec<&'genv OpaqueTy<'genv>>>, f: impl FnOnce(&mut Self) -> Result<T, ErrorGuaranteed>, ) -> Result<T, ErrorGuaranteed>

pub(crate) fn desugar_trait(&mut self, trait_: &Trait) -> Item<'genv>

fn desugar_trait_assoc_refts( &mut self, assoc_refts: &[TraitAssocReft], ) -> &'genv [TraitAssocReft<'genv>]

pub(crate) fn desugar_impl(&mut self, impl_: &Impl) -> Item<'genv>

fn desugar_impl_assoc_refts( &mut self, assoc_refts: &[ImplAssocReft], ) -> &'genv [ImplAssocReft<'genv>]

pub(crate) fn desugar_generics( &mut self, generics: &Generics, ) -> Generics<'genv>

fn desugar_opt_generics( &mut self, generics: Option<&Generics>, ) -> Generics<'genv>

fn desugar_generic_predicates( &mut self, predicates: &[WhereBoundPredicate], ) -> &'genv [WhereBoundPredicate<'genv>]

fn desugar_generic_bounds( &mut self, bounds: &[TraitRef], ) -> GenericBounds<'genv>

fn desugar_trait_ref(&mut self, trait_ref: &TraitRef) -> PolyTraitRef<'genv>

fn desugar_refined_by(&mut self, refined_by: &RefineParams) -> RefinedBy<'genv>

pub(crate) fn desugar_struct_def( &mut self, struct_def: &StructDef, ) -> Item<'genv>

pub(crate) fn desugar_enum_def( &mut self, enum_def: &EnumDef, ) -> Result<Item<'genv>, ErrorGuaranteed>

fn desugar_enum_variant_def( &mut self, reflected: bool, variant_def: &Option<VariantDef>, hir_variant: &Variant<'_>, ) -> Result<VariantDef<'genv>, ErrorGuaranteed>

pub(crate) fn desugar_type_alias( &mut self, ty_alias: Option<&TyAlias>, ) -> Item<'genv>

pub(crate) fn desugar_trait_assoc_ty(&mut self) -> TraitItem<'genv>

pub(crate) fn desugar_impl_assoc_ty(&mut self) -> ImplItem<'genv>

pub(crate) fn desugar_foreign_item( &mut self, foreign_item: ForeignItem<'_>, ) -> Result<ForeignItem<'genv>, ErrorGuaranteed>

pub(crate) fn desugar_item_fn( &mut self, fn_spec: &FnSpec, ) -> Result<Item<'genv>, ErrorGuaranteed>

pub(crate) fn desugar_trait_fn( &mut self, fn_spec: &FnSpec, ) -> Result<TraitItem<'genv>, ErrorGuaranteed>

pub(crate) fn desugar_impl_fn( &mut self, fn_spec: &FnSpec, ) -> Result<ImplItem<'genv>, ErrorGuaranteed>

pub(crate) fn desugar_const(&mut self, const_info: &ConstantInfo) -> Item<'genv>

pub(crate) fn desugar_impl_const(&mut self) -> ImplItem<'genv>

pub(crate) fn desugar_trait_const(&mut self) -> TraitItem<'genv>

pub(crate) fn desugar_fn_spec( &mut self, fn_spec: &FnSpec, ) -> Result<(Generics<'genv>, FnSig<'genv>), ErrorGuaranteed>

fn desugar_fn_sig_refine_params( &mut self, fn_sig: &FnSig, ) -> &'genv [RefineParam<'genv>]

fn desugar_fn_output( &mut self, asyncness: Async, output: &FnOutput, ) -> Result<FnOutput<'genv>, ErrorGuaranteed>

fn desugar_ensures( &mut self, cstr: &Ensures, ) -> Result<Ensures<'genv>, ErrorGuaranteed>

fn desugar_fn_input(&mut self, input: &FnInput) -> Ty<'genv>

fn desugar_asyncness( &mut self, asyncness: Async, returns: &FnRetTy, ) -> Ty<'genv>

fn desugar_opaque_ty_for_async( &mut self, def_id: LocalDefId, returns: &FnRetTy, ) -> OpaqueTy<'genv>

fn make_lang_item_path( &mut self, lang_item: LangItem, span: Span, args: &'genv [GenericArg<'genv>], constraints: &'genv [AssocItemConstraint<'genv>], ) -> Path<'genv>

fn desugar_fn_ret_ty(&mut self, returns: &FnRetTy) -> Ty<'genv>

fn desugar_opaque_ty_for_impl_trait( &mut self, def_id: LocalDefId, bounds: &[TraitRef], ) -> OpaqueTy<'genv>

fn desugar_variant_ret( &mut self, ret: &VariantRet, ) -> Result<VariantRet<'genv>, ErrorGuaranteed>

fn check_variant_ret_path(&mut self, path: &Path) -> Option<DefId>

fn insert_opaque_ty( &mut self, opaque_ty: OpaqueTy<'genv>, ) -> &'genv OpaqueTy<'genv>

Trait Implementations

impl<'genv, 'tcx> DesugarCtxt<'genv, 'tcx> for RustItemCtxt<'_, 'genv, 'tcx>

fn next_fhir_id(&self) -> FhirId

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

fn resolver_output(&self) -> &'genv ResolverOutput

fn desugar_impl_trait( &mut self, node_id: NodeId, bounds: &[TraitRef], ) -> TyKind<'genv>

fn resolve_implicit_param( &self, node_id: NodeId, ) -> Option<(ParamId, ParamKind)>

fn desugar_epath(&self, path: &ExprPath) -> PathExpr<'genv>

fn desugar_loc( &self, ident: Ident, node_id: NodeId, ) -> Result<ExprRes, ErrorGuaranteed>

fn resolve_param(&self, node_id: NodeId) -> (ParamId, ParamKind)

fn resolve_implicit_params( &self, scope: NodeId, ) -> impl ExactSizeIterator<Item = (Ident, ParamId, ParamKind)>

fn implicit_params_to_params( &self, scope: NodeId, ) -> impl ExactSizeIterator<Item = RefineParam<'genv>>

fn desugar_refine_params( &mut self, params: &[RefineParam], ) -> &'genv [RefineParam<'genv>]

fn desugar_refine_params_iter( &mut self, params: &[RefineParam], ) -> impl ExactSizeIterator<Item = RefineParam<'genv>>

fn desugar_refine_param(&mut self, param: &RefineParam) -> RefineParam<'genv>

fn desugar_sort( &mut self, sort: &Sort, generic_id_to_var_idx: Option<&FxIndexSet<DefId>>, ) -> Sort<'genv>

fn desugar_base_sort( &mut self, sort: &BaseSort, generic_id_to_var_idx: Option<&FxIndexSet<DefId>>, ) -> Sort<'genv>

fn desugar_generic_args( &mut self, res: Res, args: &[GenericArg], ) -> (&'genv [GenericArg<'genv>], &'genv [AssocItemConstraint<'genv>])

fn desugar_ty(&mut self, ty: &Ty) -> Ty<'genv>

This is the mega desugaring function surface::Ty -> fhir::Ty. These are both similar representations. The most important difference is that fhir::Ty has explicit refinement parameters and surface::Ty does not. Refinements are implicitly scoped in surface.

fn desugar_const_arg(const_arg: &ConstArg) -> ConstArg

fn desugar_bty(&mut self, bty: &BaseTy) -> BaseTy<'genv>

fn desugar_path_to_bty( &mut self, qself: Option<&Ty>, path: &Path, ) -> BaseTy<'genv>

fn desugar_qpath(&mut self, qself: Option<&Ty>, path: &Path) -> QPath<'genv>

fn desugar_path_segment(&mut self, segment: &PathSegment) -> PathSegment<'genv>

fn ty_path(&self, qpath: QPath<'genv>) -> Ty<'genv>

fn mk_lft_hole(&self) -> Lifetime

fn desugar_indices(&mut self, idxs: &Indices) -> Expr<'genv>

fn desugar_refine_arg(&mut self, arg: &RefineArg) -> Expr<'genv>

fn implicit_param_into_refine_arg( &self, ident: Ident, node_id: NodeId, ) -> Option<Expr<'genv>>

fn desugar_expr(&mut self, expr: &Expr) -> Expr<'genv>

fn desugar_call(&mut self, callee: &Expr, args: &[Expr]) -> ExprKind<'genv>

fn desugar_constructor( &mut self, path: Option<&ExprPath>, args: &[ConstructorArg], ) -> ExprKind<'genv>

fn desugar_exprs(&mut self, exprs: &[Expr]) -> &'genv [Expr<'genv>]

fn try_parse_int_lit( &self, span: Span, s: &str, ) -> Result<u128, ErrorGuaranteed>

fn desugar_lit(&self, span: Span, lit: Lit) -> ExprKind<'genv>

Desugar surface literal

impl ErrorCollector<ErrorGuaranteed> for RustItemCtxt<'_, '_, '_>

type Result = Result<(), ErrorGuaranteed>

fn collect(&mut self, err: ErrorGuaranteed)

fn into_result(self) -> Self::Result

impl ErrorEmitter for RustItemCtxt<'_, '_, '_>

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