pub(crate) struct LoweringContext<'a, 'hir> {
Show 24 fields pub(crate) tcx: TyCtxt<'hir>, pub(crate) resolver: &'a mut ResolverAstLowering, pub(crate) arena: &'hir Arena<'hir>, pub(crate) bodies: Vec<(ItemLocalId, &'hir Body<'hir>)>, pub(crate) attrs: SortedMap<ItemLocalId, &'hir [Attribute]>, pub(crate) children: Vec<(LocalDefId, MaybeOwner<&'hir OwnerInfo<'hir>>)>, pub(crate) generator_kind: Option<GeneratorKind>, pub(crate) task_context: Option<HirId>, pub(crate) current_item: Option<Span>, pub(crate) catch_scope: Option<NodeId>, pub(crate) loop_scope: Option<NodeId>, pub(crate) is_in_loop_condition: bool, pub(crate) is_in_trait_impl: bool, pub(crate) is_in_dyn_type: bool, pub(crate) current_hir_id_owner: OwnerId, pub(crate) item_local_id_counter: ItemLocalId, pub(crate) trait_map: FxHashMap<ItemLocalId, Box<[TraitCandidate]>>, pub(crate) impl_trait_defs: Vec<GenericParam<'hir>>, pub(crate) impl_trait_bounds: Vec<WherePredicate<'hir>>, pub(crate) node_id_to_local_id: FxHashMap<NodeId, ItemLocalId>, pub(crate) allow_try_trait: Option<Lrc<[Symbol]>>, pub(crate) allow_gen_future: Option<Lrc<[Symbol]>>, pub(crate) generics_def_id_map: Vec<FxHashMap<LocalDefId, LocalDefId>>, pub(crate) host_param_id: Option<LocalDefId>,
}

Fields§

§tcx: TyCtxt<'hir>§resolver: &'a mut ResolverAstLowering§arena: &'hir Arena<'hir>

Used to allocate HIR nodes.

§bodies: Vec<(ItemLocalId, &'hir Body<'hir>)>

Bodies inside the owner being lowered.

§attrs: SortedMap<ItemLocalId, &'hir [Attribute]>

Attributes inside the owner being lowered.

§children: Vec<(LocalDefId, MaybeOwner<&'hir OwnerInfo<'hir>>)>

Collect items that were created by lowering the current owner.

§generator_kind: Option<GeneratorKind>§task_context: Option<HirId>

When inside an async context, this is the HirId of the task_context local bound to the resume argument of the generator.

§current_item: Option<Span>

Used to get the current fn’s def span to point to when using await outside of an async fn.

§catch_scope: Option<NodeId>§loop_scope: Option<NodeId>§is_in_loop_condition: bool§is_in_trait_impl: bool§is_in_dyn_type: bool§current_hir_id_owner: OwnerId§item_local_id_counter: ItemLocalId§trait_map: FxHashMap<ItemLocalId, Box<[TraitCandidate]>>§impl_trait_defs: Vec<GenericParam<'hir>>§impl_trait_bounds: Vec<WherePredicate<'hir>>§node_id_to_local_id: FxHashMap<NodeId, ItemLocalId>

NodeIds that are lowered inside the current HIR owner.

§allow_try_trait: Option<Lrc<[Symbol]>>§allow_gen_future: Option<Lrc<[Symbol]>>§generics_def_id_map: Vec<FxHashMap<LocalDefId, LocalDefId>>

Mapping from generics def_ids to TAIT generics def_ids. For each captured lifetime (e.g., ’a), we create a new lifetime parameter that is a generic defined on the TAIT, so we have type Foo<’a1> = … and we establish a mapping in this field from the original parameter ’a to the new parameter ’a1.

§host_param_id: Option<LocalDefId>

Implementations§

source§

impl<'a, 'hir> LoweringContext<'a, 'hir>

source

pub(crate) fn lower_inline_asm( &mut self, sp: Span, asm: &InlineAsm ) -> &'hir InlineAsm<'hir>

source§

impl<'a, 'hir> LoweringContext<'a, 'hir>

source

pub(crate) fn lower_block( &mut self, b: &Block, targeted_by_break: bool ) -> &'hir Block<'hir>

source

pub(crate) fn lower_block_noalloc( &mut self, b: &Block, targeted_by_break: bool ) -> Block<'hir>

source

fn lower_stmts( &mut self, ast_stmts: &[Stmt] ) -> (&'hir [Stmt<'hir>], Option<&'hir Expr<'hir>>)

source

fn lower_local(&mut self, l: &Local) -> &'hir Local<'hir>

source

fn lower_block_check_mode(&mut self, b: &BlockCheckMode) -> BlockCheckMode

source§

impl<'hir> LoweringContext<'_, 'hir>

source

fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [Expr<'hir>]

source

pub(crate) fn lower_expr(&mut self, e: &Expr) -> &'hir Expr<'hir>

source

pub(crate) fn lower_expr_mut(&mut self, e: &Expr) -> Expr<'hir>

source

fn lower_unop(&mut self, u: UnOp) -> UnOp

source

fn lower_binop(&mut self, b: BinOp) -> BinOp

source

fn lower_legacy_const_generics( &mut self, f: Expr, args: ThinVec<AstP<Expr>>, legacy_args_idx: &[usize] ) -> ExprKind<'hir>

source

fn lower_expr_if( &mut self, cond: &Expr, then: &Block, else_opt: Option<&Expr> ) -> ExprKind<'hir>

source

fn lower_cond(&mut self, cond: &Expr) -> &'hir Expr<'hir>

source

fn lower_expr_while_in_loop_scope( &mut self, span: Span, cond: &Expr, body: &Block, opt_label: Option<Label> ) -> ExprKind<'hir>

source

fn lower_expr_try_block(&mut self, body: &Block) -> ExprKind<'hir>

Desugar try { <stmts>; <expr> } into { <stmts>; ::std::ops::Try::from_output(<expr>) }, try { <stmts>; } into { <stmts>; ::std::ops::Try::from_output(()) } and save the block id to use it as a break target for desugaring of the ? operator.

source

fn wrap_in_try_constructor( &mut self, lang_item: LangItem, method_span: Span, expr: &'hir Expr<'hir>, overall_span: Span ) -> &'hir Expr<'hir>

source

fn lower_arm(&mut self, arm: &Arm) -> Arm<'hir>

source

pub(crate) fn make_async_expr( &mut self, capture_clause: CaptureBy, closure_node_id: NodeId, ret_ty: Option<FnRetTy<'hir>>, span: Span, async_gen_kind: AsyncGeneratorKind, body: impl FnOnce(&mut Self) -> Expr<'hir> ) -> ExprKind<'hir>

Lower an async construct to a generator that implements Future.

This results in:

static move? |_task_context| -> <ret_ty> {
    <body>
}
source

pub(crate) fn maybe_forward_track_caller( &mut self, span: Span, outer_hir_id: HirId, inner_hir_id: HirId )

Forwards a possible #[track_caller] annotation from outer_hir_id to inner_hir_id in case the async_fn_track_caller feature is enabled.

source

fn lower_expr_await( &mut self, await_kw_span: Span, expr: &Expr ) -> ExprKind<'hir>

Desugar <expr>.await into:

match ::std::future::IntoFuture::into_future(<expr>) {
    mut __awaitee => loop {
        match unsafe { ::std::future::Future::poll(
            <::std::pin::Pin>::new_unchecked(&mut __awaitee),
            ::std::future::get_context(task_context),
        ) } {
            ::std::task::Poll::Ready(result) => break result,
            ::std::task::Poll::Pending => {}
        }
        task_context = yield ();
    }
}
source

fn lower_expr_closure( &mut self, binder: &ClosureBinder, capture_clause: CaptureBy, closure_id: NodeId, constness: Const, movability: Movability, decl: &FnDecl, body: &Expr, fn_decl_span: Span, fn_arg_span: Span ) -> ExprKind<'hir>

source

fn generator_movability_for_fn( &mut self, decl: &FnDecl, fn_decl_span: Span, generator_kind: Option<GeneratorKind>, movability: Movability ) -> Option<Movability>

source

fn lower_closure_binder<'c>( &mut self, binder: &'c ClosureBinder ) -> (ClosureBinder, &'c [GenericParam])

source

fn lower_expr_async_closure( &mut self, binder: &ClosureBinder, capture_clause: CaptureBy, closure_id: NodeId, closure_hir_id: HirId, inner_closure_id: NodeId, decl: &FnDecl, body: &Expr, fn_decl_span: Span, fn_arg_span: Span ) -> ExprKind<'hir>

source

fn lower_expr_assign( &mut self, lhs: &Expr, rhs: &Expr, eq_sign_span: Span, whole_span: Span ) -> ExprKind<'hir>

Destructure the LHS of complex assignments. For instance, lower (a, b) = t to { let (lhs1, lhs2) = t; a = lhs1; b = lhs2; }.

source

fn extract_tuple_struct_path<'a>( &mut self, expr: &'a Expr ) -> Option<(&'a Option<AstP<QSelf>>, &'a Path)>

If the given expression is a path to a tuple struct, returns that path. It is not a complete check, but just tries to reject most paths early if they are not tuple structs. Type checking will take care of the full validation later.

source

fn extract_unit_struct_path<'a>( &mut self, expr: &'a Expr ) -> Option<(&'a Option<AstP<QSelf>>, &'a Path)>

If the given expression is a path to a unit struct, returns that path. It is not a complete check, but just tries to reject most paths early if they are not unit structs. Type checking will take care of the full validation later.

source

fn destructure_assign( &mut self, lhs: &Expr, eq_sign_span: Span, assignments: &mut Vec<Stmt<'hir>> ) -> &'hir Pat<'hir>

Convert the LHS of a destructuring assignment to a pattern. Each sub-assignment is recorded in assignments.

source

fn destructure_assign_mut( &mut self, lhs: &Expr, eq_sign_span: Span, assignments: &mut Vec<Stmt<'hir>> ) -> Pat<'hir>

source

fn destructure_sequence( &mut self, elements: &[AstP<Expr>], ctx: &str, eq_sign_span: Span, assignments: &mut Vec<Stmt<'hir>> ) -> (&'hir [Pat<'hir>], Option<(usize, Span)>)

Destructure a sequence of expressions occurring on the LHS of an assignment. Such a sequence occurs in a tuple (struct)/slice. Return a sequence of corresponding patterns, and the index and the span of .. if it exists. Each sub-assignment is recorded in assignments.

source

fn lower_expr_range_closed( &mut self, span: Span, e1: &Expr, e2: &Expr ) -> ExprKind<'hir>

Desugar <start>..=<end> into std::ops::RangeInclusive::new(<start>, <end>).

source

fn lower_expr_range( &mut self, span: Span, e1: Option<&Expr>, e2: Option<&Expr>, lims: RangeLimits ) -> ExprKind<'hir>

source

fn lower_label(&self, opt_label: Option<Label>) -> Option<Label>

source

fn lower_loop_destination( &mut self, destination: Option<(NodeId, Label)> ) -> Destination

source

fn lower_jump_destination( &mut self, id: NodeId, opt_label: Option<Label> ) -> Destination

source

fn with_catch_scope<T>( &mut self, catch_id: NodeId, f: impl FnOnce(&mut Self) -> T ) -> T

source

fn with_loop_scope<T>( &mut self, loop_id: NodeId, f: impl FnOnce(&mut Self) -> T ) -> T

source

fn with_loop_condition_scope<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T

source

fn lower_expr_field(&mut self, f: &ExprField) -> ExprField<'hir>

source

fn lower_expr_yield( &mut self, span: Span, opt_expr: Option<&Expr> ) -> ExprKind<'hir>

source

fn lower_expr_for( &mut self, e: &Expr, pat: &Pat, head: &Expr, body: &Block, opt_label: Option<Label> ) -> Expr<'hir>

Desugar ExprForLoop from: [opt_ident]: for <pat> in <head> <body> into:

{
    let result = match IntoIterator::into_iter(<head>) {
        mut iter => {
            [opt_ident]: loop {
                match Iterator::next(&mut iter) {
                    None => break,
                    Some(<pat>) => <body>,
                };
            }
        }
    };
    result
}
source

fn lower_expr_try(&mut self, span: Span, sub_expr: &Expr) -> ExprKind<'hir>

Desugar ExprKind::Try from: <expr>? into:

match Try::branch(<expr>) {
    ControlFlow::Continue(val) => #[allow(unreachable_code)] val,,
    ControlFlow::Break(residual) =>
        #[allow(unreachable_code)]
        // If there is an enclosing `try {...}`:
        break 'catch_target Try::from_residual(residual),
        // Otherwise:
        return Try::from_residual(residual),
}
source

fn lower_expr_yeet( &mut self, span: Span, sub_expr: Option<&Expr> ) -> ExprKind<'hir>

Desugar ExprKind::Yeet from: do yeet <expr> into:

// If there is an enclosing `try {...}`:
break 'catch_target FromResidual::from_residual(Yeet(residual));
// Otherwise:
return FromResidual::from_residual(Yeet(residual));

But to simplify this, there’s a from_yeet lang item function which handles the combined FromResidual::from_residual(Yeet(residual)).

source

pub(crate) fn expr_drop_temps( &mut self, span: Span, expr: &'hir Expr<'hir> ) -> &'hir Expr<'hir>

Wrap the given expr in a terminating scope using hir::ExprKind::DropTemps.

In terms of drop order, it has the same effect as wrapping expr in { let _t = $expr; _t } but should provide better compile-time performance.

The drop order can be important in e.g. if expr { .. }.

source

pub(crate) fn expr_drop_temps_mut( &mut self, span: Span, expr: &'hir Expr<'hir> ) -> Expr<'hir>

source

pub(crate) fn expr_match( &mut self, span: Span, arg: &'hir Expr<'hir>, arms: &'hir [Arm<'hir>], source: MatchSource ) -> Expr<'hir>

source

fn expr_break(&mut self, span: Span) -> Expr<'hir>

source

fn expr_break_alloc(&mut self, span: Span) -> &'hir Expr<'hir>

source

fn expr_mut_addr_of(&mut self, span: Span, e: &'hir Expr<'hir>) -> Expr<'hir>

source

fn expr_unit(&mut self, sp: Span) -> &'hir Expr<'hir>

source

pub(crate) fn expr_usize(&mut self, sp: Span, value: usize) -> Expr<'hir>

source

pub(crate) fn expr_u32(&mut self, sp: Span, value: u32) -> Expr<'hir>

source

pub(crate) fn expr_char(&mut self, sp: Span, value: char) -> Expr<'hir>

source

pub(crate) fn expr_str(&mut self, sp: Span, value: Symbol) -> Expr<'hir>

source

pub(crate) fn expr_call_mut( &mut self, span: Span, e: &'hir Expr<'hir>, args: &'hir [Expr<'hir>] ) -> Expr<'hir>

source

pub(crate) fn expr_call( &mut self, span: Span, e: &'hir Expr<'hir>, args: &'hir [Expr<'hir>] ) -> &'hir Expr<'hir>

source

fn expr_call_lang_item_fn_mut( &mut self, span: Span, lang_item: LangItem, args: &'hir [Expr<'hir>], hir_id: Option<HirId> ) -> Expr<'hir>

source

fn expr_call_lang_item_fn( &mut self, span: Span, lang_item: LangItem, args: &'hir [Expr<'hir>], hir_id: Option<HirId> ) -> &'hir Expr<'hir>

source

fn expr_lang_item_path( &mut self, span: Span, lang_item: LangItem, hir_id: Option<HirId> ) -> Expr<'hir>

source

pub(crate) fn expr_lang_item_type_relative( &mut self, span: Span, lang_item: LangItem, name: Symbol ) -> Expr<'hir>

<LangItem>::name

source

pub(crate) fn expr_ident( &mut self, sp: Span, ident: Ident, binding: HirId ) -> &'hir Expr<'hir>

source

pub(crate) fn expr_ident_mut( &mut self, span: Span, ident: Ident, binding: HirId ) -> Expr<'hir>

source

fn expr_unsafe(&mut self, expr: &'hir Expr<'hir>) -> Expr<'hir>

source

fn expr_block_empty(&mut self, span: Span) -> &'hir Expr<'hir>

source

pub(crate) fn expr_block(&mut self, b: &'hir Block<'hir>) -> Expr<'hir>

source

pub(crate) fn expr_array_ref( &mut self, span: Span, elements: &'hir [Expr<'hir>] ) -> Expr<'hir>

source

pub(crate) fn expr(&mut self, span: Span, kind: ExprKind<'hir>) -> Expr<'hir>

source

pub(crate) fn expr_field( &mut self, ident: Ident, expr: &'hir Expr<'hir>, span: Span ) -> ExprField<'hir>

source

pub(crate) fn arm( &mut self, pat: &'hir Pat<'hir>, expr: &'hir Expr<'hir> ) -> Arm<'hir>

source§

impl<'hir> LoweringContext<'_, 'hir>

source

pub(crate) fn lower_format_args( &mut self, sp: Span, fmt: &FormatArgs ) -> ExprKind<'hir>

source§

impl<'hir> LoweringContext<'_, 'hir>

source

pub(crate) fn lower_mod( &mut self, items: &[P<Item>], spans: &ModSpans ) -> &'hir Mod<'hir>

source

pub(crate) fn lower_item_ref(&mut self, i: &Item) -> SmallVec<[ItemId; 1]>

source

fn lower_item_id_use_tree( &mut self, tree: &UseTree, vec: &mut SmallVec<[ItemId; 1]> )

source

fn lower_item(&mut self, i: &Item) -> &'hir Item<'hir>

source

fn lower_item_kind( &mut self, span: Span, id: NodeId, hir_id: HirId, ident: &mut Ident, attrs: Option<&'hir [Attribute]>, vis_span: Span, i: &ItemKind ) -> ItemKind<'hir>

source

fn lower_const_item( &mut self, ty: &Ty, span: Span, body: Option<&Expr> ) -> (&'hir Ty<'hir>, BodyId)

source

fn lower_use_tree( &mut self, tree: &UseTree, prefix: &Path, id: NodeId, vis_span: Span, ident: &mut Ident, attrs: Option<&'hir [Attribute]> ) -> ItemKind<'hir>

source

fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir ForeignItem<'hir>

source

fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> ForeignItemRef

source

fn lower_variant(&mut self, v: &Variant) -> Variant<'hir>

source

fn lower_variant_data( &mut self, parent_id: HirId, vdata: &VariantData ) -> VariantData<'hir>

source

fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> FieldDef<'hir>

source

fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir TraitItem<'hir>

source

fn lower_trait_item_ref(&mut self, i: &AssocItem) -> TraitItemRef

source

pub(crate) fn expr_err( &mut self, span: Span, guar: ErrorGuaranteed ) -> Expr<'hir>

Construct ExprKind::Err for the given span.

source

fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir ImplItem<'hir>

source

fn lower_impl_item_ref(&mut self, i: &AssocItem) -> ImplItemRef

source

fn lower_defaultness( &self, d: Defaultness, has_value: bool ) -> (Defaultness, Option<Span>)

source

fn record_body( &mut self, params: &'hir [Param<'hir>], value: Expr<'hir> ) -> BodyId

source

pub(crate) fn lower_body( &mut self, f: impl FnOnce(&mut Self) -> (&'hir [Param<'hir>], Expr<'hir>) ) -> BodyId

source

fn lower_param(&mut self, param: &Param) -> Param<'hir>

source

pub(crate) fn lower_fn_body( &mut self, decl: &FnDecl, body: impl FnOnce(&mut Self) -> Expr<'hir> ) -> BodyId

source

fn lower_fn_body_block( &mut self, span: Span, decl: &FnDecl, body: Option<&Block> ) -> BodyId

source

fn lower_block_expr_opt( &mut self, span: Span, block: Option<&Block> ) -> Expr<'hir>

source

pub(crate) fn lower_const_body( &mut self, span: Span, expr: Option<&Expr> ) -> BodyId

source

fn lower_maybe_async_body( &mut self, span: Span, fn_id: HirId, decl: &FnDecl, asyncness: Async, body: Option<&Block> ) -> BodyId

source

fn lower_method_sig( &mut self, generics: &Generics, sig: &FnSig, id: NodeId, kind: FnDeclKind, is_async: Option<(NodeId, Span)> ) -> (&'hir Generics<'hir>, FnSig<'hir>)

source

fn lower_fn_header(&mut self, h: FnHeader) -> FnHeader

source

pub(crate) fn lower_abi(&mut self, abi: StrLit) -> Abi

source

pub(crate) fn lower_extern(&mut self, ext: Extern) -> Abi

source

fn error_on_invalid_abi(&self, abi: StrLit, err: AbiUnsupported)

source

fn lower_asyncness(&mut self, a: Async) -> IsAsync

source

pub(crate) fn lower_constness(&mut self, c: Const) -> Constness

source

pub(crate) fn lower_unsafety(&mut self, u: Unsafe) -> Unsafety

source

fn lower_generics<T>( &mut self, generics: &Generics, constness: Const, parent_node_id: NodeId, itctx: &ImplTraitContext, f: impl FnOnce(&mut Self) -> T ) -> (&'hir Generics<'hir>, T)

Return the pair of the lowered generics as hir::Generics and the evaluation of f with the carried impl trait definitions and bounds.

source

pub(crate) fn lower_generic_bound_predicate( &mut self, ident: Ident, id: NodeId, kind: &GenericParamKind, bounds: &[GenericBound], colon_span: Option<Span>, parent_span: Span, itctx: &ImplTraitContext, origin: PredicateOrigin ) -> Option<WherePredicate<'hir>>

source

fn lower_where_predicate( &mut self, pred: &WherePredicate ) -> WherePredicate<'hir>

source§

impl<'a, 'hir> LoweringContext<'a, 'hir>

source

pub(crate) fn lower_pat(&mut self, pattern: &Pat) -> &'hir Pat<'hir>

source

pub(crate) fn lower_pat_mut(&mut self, pattern: &Pat) -> Pat<'hir>

source

fn lower_pat_tuple( &mut self, pats: &[P<Pat>], ctx: &str ) -> (&'hir [Pat<'hir>], DotDotPos)

source

fn lower_pat_slice(&mut self, pats: &[P<Pat>]) -> PatKind<'hir>

Lower a slice pattern of form [pat_0, ..., pat_n] into hir::PatKind::Slice(before, slice, after).

When encountering ($binding_mode $ident @)? .. (slice), this is interpreted as a sub-slice pattern semantically. Patterns that follow, which are not like slice – or an error occurs, are in after.

source

fn lower_pat_ident( &mut self, p: &Pat, annotation: BindingAnnotation, ident: Ident, lower_sub: impl FnOnce(&mut Self) -> Option<&'hir Pat<'hir>> ) -> PatKind<'hir>

source

fn pat_wild_with_node_id_of(&mut self, p: &Pat) -> &'hir Pat<'hir>

source

fn pat_with_node_id_of(&mut self, p: &Pat, kind: PatKind<'hir>) -> Pat<'hir>

Construct a Pat with the HirId of p.id lowered.

source

pub(crate) fn ban_extra_rest_pat(&self, sp: Span, prev_sp: Span, ctx: &str)

Emit a friendly error for extra .. patterns in a tuple/tuple struct/slice pattern.

source

fn ban_illegal_rest_pat(&self, sp: Span) -> PatKind<'hir>

Used to ban the .. pattern in places it shouldn’t be semantically.

source

fn lower_range_end(&mut self, e: &RangeEnd, has_end: bool) -> RangeEnd

source

fn lower_expr_within_pat( &mut self, expr: &Expr, allow_paths: bool ) -> &'hir Expr<'hir>

Matches '-' lit | lit (cf. parser::Parser::parse_literal_maybe_minus), or paths for ranges.

source§

impl<'a, 'hir> LoweringContext<'a, 'hir>

source

pub(crate) fn lower_qpath( &mut self, id: NodeId, qself: &Option<P<QSelf>>, p: &Path, param_mode: ParamMode, itctx: &ImplTraitContext, constness: Option<Const> ) -> QPath<'hir>

source

pub(crate) fn lower_use_path( &mut self, res: SmallVec<[Res; 3]>, p: &Path, param_mode: ParamMode ) -> &'hir UsePath<'hir>

source

pub(crate) fn lower_path_segment( &mut self, path_span: Span, segment: &PathSegment, param_mode: ParamMode, parenthesized_generic_args: ParenthesizedGenericArgs, itctx: &ImplTraitContext, constness: Option<Const> ) -> PathSegment<'hir>

source

fn maybe_insert_elided_lifetimes_in_path( &mut self, path_span: Span, segment_id: NodeId, segment_ident_span: Span, generic_args: &mut GenericArgsCtor<'hir> )

source

pub(crate) fn lower_angle_bracketed_parameter_data( &mut self, data: &AngleBracketedArgs, param_mode: ParamMode, itctx: &ImplTraitContext ) -> (GenericArgsCtor<'hir>, bool)

source

fn lower_parenthesized_parameter_data( &mut self, data: &ParenthesizedArgs, itctx: &ImplTraitContext ) -> (GenericArgsCtor<'hir>, bool)

source

pub(crate) fn output_ty_binding( &mut self, span: Span, ty: &'hir Ty<'hir> ) -> TypeBinding<'hir>

An associated type binding Output = $ty.

source§

impl<'a, 'hir> LoweringContext<'a, 'hir>

source

pub(crate) fn create_def( &mut self, parent: LocalDefId, node_id: NodeId, data: DefPathData, span: Span ) -> LocalDefId

source

pub(crate) fn next_node_id(&mut self) -> NodeId

source

pub(crate) fn orig_opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>

Given the id of some node in the AST, finds the LocalDefId associated with it by the name resolver (if any).

source

pub(crate) fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>

Given the id of some node in the AST, finds the LocalDefId associated with it by the name resolver (if any), after applying any remapping from get_remapped_def_id.

For example, in a function like fn foo<'a>(x: &'a u32), invoking with the id from the ast::Lifetime node found inside the &'a u32 type would return the LocalDefId of the 'a parameter declared on foo.

This function also applies remapping from get_remapped_def_id. These are used when synthesizing opaque types from -> impl Trait return types and so forth. For example, in a function like fn foo<'a>() -> impl Debug + 'a, we would create an opaque type type FooReturn<'a1> = impl Debug + 'a1. When lowering the Debug + 'a bounds, we add a remapping to map 'a to 'a1.

source

pub(crate) fn local_def_id(&self, node: NodeId) -> LocalDefId

source

pub(crate) fn get_remapped_def_id(&self, local_def_id: LocalDefId) -> LocalDefId

Get the previously recorded to local def id given the from local def id, obtained using generics_def_id_map field.

source

pub(crate) fn with_hir_id_owner( &mut self, owner: NodeId, f: impl FnOnce(&mut Self) -> OwnerNode<'hir> )

Freshen the LoweringContext and ready it to lower a nested item. The lowered item is registered into self.children.

This function sets up HirId lowering infrastructure, and stashes the shared mutable state to avoid pollution by the closure.

source

pub(crate) fn with_remapping<R>( &mut self, remap: FxHashMap<LocalDefId, LocalDefId>, f: impl FnOnce(&mut Self) -> R ) -> R

Installs the remapping remap in scope while f is being executed. This causes references to the LocalDefId keys to be changed to refer to the values instead.

The remapping is used when one piece of AST expands to multiple pieces of HIR. For example, the function fn foo<'a>(...) -> impl Debug + 'a, expands to both a function definition (foo) and a TAIT for the return value, both of which have a lifetime parameter 'a. The remapping allows us to rewrite the 'a in the return value to refer to the 'a declared on the TAIT, instead of the function.

source

pub(crate) fn make_owner_info( &mut self, node: OwnerNode<'hir> ) -> &'hir OwnerInfo<'hir>

source

pub(crate) fn lower_node_id(&mut self, ast_node_id: NodeId) -> HirId

This method allocates a new HirId for the given NodeId and stores it in the LoweringContext’s NodeId => HirId map. Take care not to call this method if the resulting HirId is then not actually used in the HIR, as that would trigger an assertion in the HirIdValidator later on, which makes sure that all NodeIds got mapped properly. Calling the method twice with the same NodeId is fine though.

source

pub(crate) fn next_id(&mut self) -> HirId

Generate a new HirId without a backing NodeId.

source

pub(crate) fn lower_res(&mut self, res: Res<NodeId>) -> Res

source

pub(crate) fn expect_full_res(&mut self, id: NodeId) -> Res<NodeId>

source

pub(crate) fn expect_full_res_from_use( &mut self, id: NodeId ) -> impl Iterator<Item = Res<NodeId>>

source

pub(crate) fn diagnostic(&self) -> &Handler

source

pub(crate) fn mark_span_with_reason( &self, reason: DesugaringKind, span: Span, allow_internal_unstable: Option<Lrc<[Symbol]>> ) -> Span

Reuses the span but adds information like the kind of the desugaring and features that are allowed inside this span.

source

pub(crate) fn lower_span(&self, span: Span) -> Span

Intercept all spans entering HIR. Mark a span as relative to the current owning item.

source

pub(crate) fn lower_ident(&self, ident: Ident) -> Ident

source

pub(crate) fn lifetime_res_to_generic_param( &mut self, ident: Ident, node_id: NodeId, res: LifetimeRes, source: GenericParamSource ) -> Option<GenericParam<'hir>>

Converts a lifetime into a new generic parameter.

source

pub(crate) fn lower_lifetime_binder( &mut self, binder: NodeId, generic_params: &[GenericParam] ) -> &'hir [GenericParam<'hir>]

Lowers a lifetime binder that defines generic_params, returning the corresponding HIR nodes. The returned list includes any “extra” lifetime parameters that were added by the name resolver owing to lifetime elision; this also populates the resolver’s node-id->def-id map, so that later calls to opt_node_id_to_def_id that refer to these extra lifetime parameters will be successful.

source

pub(crate) fn with_dyn_type_scope<T>( &mut self, in_scope: bool, f: impl FnOnce(&mut Self) -> T ) -> T

source

pub(crate) fn with_new_scopes<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T

source

pub(crate) fn lower_attrs( &mut self, id: HirId, attrs: &[Attribute] ) -> Option<&'hir [Attribute]>

source

pub(crate) fn lower_attr(&self, attr: &Attribute) -> Attribute

source

pub(crate) fn alias_attrs(&mut self, id: HirId, target_id: HirId)

source

pub(crate) fn lower_attr_args(&self, args: &AttrArgs) -> AttrArgs

source

pub(crate) fn lower_delim_args(&self, args: &DelimArgs) -> DelimArgs

source

pub(crate) fn lower_assoc_ty_constraint( &mut self, constraint: &AssocConstraint, itctx: &ImplTraitContext ) -> TypeBinding<'hir>

Given an associated type constraint like one of these:

T: Iterator<Item: Debug>
            ^^^^^^^^^^^
T: Iterator<Item = Debug>
            ^^^^^^^^^^^^

returns a hir::TypeBinding representing Item.

source

pub(crate) fn emit_bad_parenthesized_trait_in_assoc_ty( &self, data: &ParenthesizedArgs )

source

pub(crate) fn lower_generic_arg( &mut self, arg: &GenericArg, itctx: &ImplTraitContext ) -> GenericArg<'hir>

source

pub(crate) fn lower_ty( &mut self, t: &Ty, itctx: &ImplTraitContext ) -> &'hir Ty<'hir>

source

pub(crate) fn lower_path_ty( &mut self, t: &Ty, qself: &Option<P<QSelf>>, path: &Path, param_mode: ParamMode, itctx: &ImplTraitContext ) -> Ty<'hir>

source

pub(crate) fn ty(&mut self, span: Span, kind: TyKind<'hir>) -> Ty<'hir>

source

pub(crate) fn ty_tup(&mut self, span: Span, tys: &'hir [Ty<'hir>]) -> Ty<'hir>

source

pub(crate) fn lower_ty_direct( &mut self, t: &Ty, itctx: &ImplTraitContext ) -> Ty<'hir>

source

pub(crate) fn lower_opaque_impl_trait( &mut self, span: Span, origin: OpaqueTyOrigin, opaque_ty_node_id: NodeId, bounds: &GenericBounds, fn_kind: Option<FnDeclKind>, itctx: &ImplTraitContext ) -> TyKind<'hir>

Lowers a ReturnPositionOpaqueTy (-> impl Trait) or a TypeAliasesOpaqueTy (type F = impl Trait): this creates the associated Opaque Type (TAIT) definition and then returns a HIR type that references the TAIT.

Given a function definition like:

use std::fmt::Debug;

fn test<'a, T: Debug>(x: &'a T) -> impl Debug + 'a {
    x
}

we will create a TAIT definition in the HIR like

type TestReturn<'a, T, 'x> = impl Debug + 'x

and return a type like TestReturn<'static, T, 'a>, so that the function looks like:

fn test<'a, T: Debug>(x: &'a T) -> TestReturn<'static, T, 'a>

Note the subtlety around type parameters! The new TAIT, TestReturn, inherits all the type parameters from the function test (this is implemented in the query layer, they aren’t added explicitly in the HIR). But this includes all the lifetimes, and we only want to capture the lifetimes that are referenced in the bounds. Therefore, we add extra lifetime parameters for the lifetimes that get captured ('x, in our example above) and reference those.

source

pub(crate) fn lower_opaque_inner( &mut self, opaque_ty_node_id: NodeId, origin: OpaqueTyOrigin, in_trait: bool, captured_lifetimes_to_duplicate: Vec<Lifetime>, span: Span, opaque_ty_span: Span, lower_item_bounds: impl FnOnce(&mut Self) -> &'hir [GenericBound<'hir>] ) -> TyKind<'hir>

source

pub(crate) fn lower_fn_params_to_names( &mut self, decl: &FnDecl ) -> &'hir [Ident]

source

pub(crate) fn lower_fn_decl( &mut self, decl: &FnDecl, fn_node_id: NodeId, fn_span: Span, kind: FnDeclKind, make_ret_async: Option<(NodeId, Span)> ) -> &'hir FnDecl<'hir>

source

pub(crate) fn lower_async_fn_ret_ty( &mut self, output: &FnRetTy, fn_def_id: LocalDefId, opaque_ty_node_id: NodeId, fn_kind: FnDeclKind, fn_span: Span ) -> FnRetTy<'hir>

source

pub(crate) fn lower_async_fn_output_type_to_future_bound( &mut self, output: &FnRetTy, span: Span, nested_impl_trait_context: ImplTraitContext ) -> GenericBound<'hir>

Transforms -> T into Future<Output = T>.

source

pub(crate) fn lower_param_bound( &mut self, tpb: &GenericBound, itctx: &ImplTraitContext ) -> GenericBound<'hir>

source

pub(crate) fn lower_lifetime(&mut self, l: &Lifetime) -> &'hir Lifetime

source

pub(crate) fn new_named_lifetime_with_res( &mut self, id: NodeId, ident: Ident, res: LifetimeRes ) -> &'hir Lifetime

source

pub(crate) fn new_named_lifetime( &mut self, id: NodeId, new_id: NodeId, ident: Ident ) -> &'hir Lifetime

source

pub(crate) fn lower_generic_params_mut<'s>( &'s mut self, params: &'s [GenericParam], source: GenericParamSource ) -> impl Iterator<Item = GenericParam<'hir>> + Captures<'a> + Captures<'s>

source

pub(crate) fn lower_generic_params( &mut self, params: &[GenericParam], source: GenericParamSource ) -> &'hir [GenericParam<'hir>]

source

pub(crate) fn lower_generic_param( &mut self, param: &GenericParam, source: GenericParamSource ) -> GenericParam<'hir>

source

pub(crate) fn lower_generic_param_kind( &mut self, param: &GenericParam ) -> (ParamName, GenericParamKind<'hir>)

source

pub(crate) fn lower_trait_ref( &mut self, constness: Const, p: &TraitRef, itctx: &ImplTraitContext ) -> TraitRef<'hir>

source

pub(crate) fn lower_poly_trait_ref( &mut self, p: &PolyTraitRef, itctx: &ImplTraitContext, constness: Const ) -> PolyTraitRef<'hir>

source

pub(crate) fn lower_mt( &mut self, mt: &MutTy, itctx: &ImplTraitContext ) -> MutTy<'hir>

source

pub(crate) fn lower_param_bounds( &mut self, bounds: &[GenericBound], itctx: &ImplTraitContext ) -> GenericBounds<'hir>

source

pub(crate) fn lower_param_bounds_mut<'s>( &'s mut self, bounds: &'s [GenericBound], itctx: &'s ImplTraitContext ) -> impl Iterator<Item = GenericBound<'hir>> + Captures<'s> + Captures<'a>

source

pub(crate) fn lower_universal_param_and_bounds( &mut self, node_id: NodeId, span: Span, ident: Ident, bounds: &[GenericBound] ) -> (GenericParam<'hir>, Option<WherePredicate<'hir>>, TyKind<'hir>)

source

pub(crate) fn lower_block_expr(&mut self, b: &Block) -> Expr<'hir>

Lowers a block directly to an expression, presuming that it has no attributes and is not targeted by a break.

source

pub(crate) fn lower_array_length(&mut self, c: &AnonConst) -> ArrayLen

source

pub(crate) fn lower_anon_const(&mut self, c: &AnonConst) -> AnonConst

source

pub(crate) fn lower_unsafe_source(&mut self, u: UnsafeSource) -> UnsafeSource

source

pub(crate) fn lower_trait_bound_modifier( &mut self, f: TraitBoundModifier ) -> TraitBoundModifier

source

pub(crate) fn stmt(&mut self, span: Span, kind: StmtKind<'hir>) -> Stmt<'hir>

source

pub(crate) fn stmt_expr(&mut self, span: Span, expr: Expr<'hir>) -> Stmt<'hir>

source

pub(crate) fn stmt_let_pat( &mut self, attrs: Option<&'hir [Attribute]>, span: Span, init: Option<&'hir Expr<'hir>>, pat: &'hir Pat<'hir>, source: LocalSource ) -> Stmt<'hir>

source

pub(crate) fn block_expr(&mut self, expr: &'hir Expr<'hir>) -> &'hir Block<'hir>

source

pub(crate) fn block_all( &mut self, span: Span, stmts: &'hir [Stmt<'hir>], expr: Option<&'hir Expr<'hir>> ) -> &'hir Block<'hir>

source

pub(crate) fn pat_cf_continue( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir Pat<'hir>

source

pub(crate) fn pat_cf_break( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir Pat<'hir>

source

pub(crate) fn pat_some( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir Pat<'hir>

source

pub(crate) fn pat_none(&mut self, span: Span) -> &'hir Pat<'hir>

source

pub(crate) fn single_pat_field( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir [PatField<'hir>]

source

pub(crate) fn pat_lang_item_variant( &mut self, span: Span, lang_item: LangItem, fields: &'hir [PatField<'hir>], hir_id: Option<HirId> ) -> &'hir Pat<'hir>

source

pub(crate) fn pat_ident( &mut self, span: Span, ident: Ident ) -> (&'hir Pat<'hir>, HirId)

source

pub(crate) fn pat_ident_mut( &mut self, span: Span, ident: Ident ) -> (Pat<'hir>, HirId)

source

pub(crate) fn pat_ident_binding_mode( &mut self, span: Span, ident: Ident, bm: BindingAnnotation ) -> (&'hir Pat<'hir>, HirId)

source

pub(crate) fn pat_ident_binding_mode_mut( &mut self, span: Span, ident: Ident, bm: BindingAnnotation ) -> (Pat<'hir>, HirId)

source

pub(crate) fn pat(&mut self, span: Span, kind: PatKind<'hir>) -> &'hir Pat<'hir>

source

pub(crate) fn pat_without_dbm( &mut self, span: Span, kind: PatKind<'hir> ) -> Pat<'hir>

source

pub(crate) fn ty_path( &mut self, hir_id: HirId, span: Span, qpath: QPath<'hir> ) -> Ty<'hir>

source

pub(crate) fn elided_dyn_bound(&mut self, span: Span) -> &'hir Lifetime

Invoked to create the lifetime argument(s) for an elided trait object bound, like the bound in Box<dyn Debug>. This method is not invoked when the bound is written, even if it is written with '_ like in Box<dyn Debug + '_>. In those cases, lower_lifetime is invoked.

Auto Trait Implementations§

§

impl<'a, 'hir> !RefUnwindSafe for LoweringContext<'a, 'hir>

§

impl<'a, 'hir> !Send for LoweringContext<'a, 'hir>

§

impl<'a, 'hir> !Sync for LoweringContext<'a, 'hir>

§

impl<'a, 'hir> Unpin for LoweringContext<'a, 'hir>

§

impl<'a, 'hir> !UnwindSafe for LoweringContext<'a, 'hir>

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

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