Struct rustc_ast_lowering::LoweringContext
source · 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_id
s to TAIT generics def_id
s.
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>
impl<'a, 'hir> LoweringContext<'a, 'hir>
pub(crate) fn lower_inline_asm( &mut self, sp: Span, asm: &InlineAsm ) -> &'hir InlineAsm<'hir>
source§impl<'a, 'hir> LoweringContext<'a, 'hir>
impl<'a, 'hir> LoweringContext<'a, 'hir>
pub(crate) fn lower_block( &mut self, b: &Block, targeted_by_break: bool ) -> &'hir Block<'hir>
pub(crate) fn lower_block_noalloc( &mut self, b: &Block, targeted_by_break: bool ) -> Block<'hir>
fn lower_stmts( &mut self, ast_stmts: &[Stmt] ) -> (&'hir [Stmt<'hir>], Option<&'hir Expr<'hir>>)
fn lower_local(&mut self, l: &Local) -> &'hir Local<'hir>
fn lower_block_check_mode(&mut self, b: &BlockCheckMode) -> BlockCheckMode
source§impl<'hir> LoweringContext<'_, 'hir>
impl<'hir> LoweringContext<'_, 'hir>
fn lower_exprs(&mut self, exprs: &[AstP<Expr>]) -> &'hir [Expr<'hir>]
pub(crate) fn lower_expr(&mut self, e: &Expr) -> &'hir Expr<'hir>
pub(crate) fn lower_expr_mut(&mut self, e: &Expr) -> Expr<'hir>
fn lower_unop(&mut self, u: UnOp) -> UnOp
fn lower_binop(&mut self, b: BinOp) -> BinOp
fn lower_legacy_const_generics( &mut self, f: Expr, args: ThinVec<AstP<Expr>>, legacy_args_idx: &[usize] ) -> ExprKind<'hir>
fn lower_expr_if( &mut self, cond: &Expr, then: &Block, else_opt: Option<&Expr> ) -> ExprKind<'hir>
fn lower_cond(&mut self, cond: &Expr) -> &'hir Expr<'hir>
fn lower_expr_while_in_loop_scope( &mut self, span: Span, cond: &Expr, body: &Block, opt_label: Option<Label> ) -> ExprKind<'hir>
sourcefn lower_expr_try_block(&mut self, body: &Block) -> ExprKind<'hir>
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.
fn wrap_in_try_constructor( &mut self, lang_item: LangItem, method_span: Span, expr: &'hir Expr<'hir>, overall_span: Span ) -> &'hir Expr<'hir>
fn lower_arm(&mut self, arm: &Arm) -> Arm<'hir>
sourcepub(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>
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>
}
sourcepub(crate) fn maybe_forward_track_caller(
&mut self,
span: Span,
outer_hir_id: HirId,
inner_hir_id: HirId
)
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.
sourcefn lower_expr_await(
&mut self,
await_kw_span: Span,
expr: &Expr
) -> ExprKind<'hir>
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 ();
}
}
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>
fn generator_movability_for_fn( &mut self, decl: &FnDecl, fn_decl_span: Span, generator_kind: Option<GeneratorKind>, movability: Movability ) -> Option<Movability>
fn lower_closure_binder<'c>( &mut self, binder: &'c ClosureBinder ) -> (ClosureBinder, &'c [GenericParam])
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>
sourcefn lower_expr_assign(
&mut self,
lhs: &Expr,
rhs: &Expr,
eq_sign_span: Span,
whole_span: Span
) -> ExprKind<'hir>
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; }
.
sourcefn extract_tuple_struct_path<'a>(
&mut self,
expr: &'a Expr
) -> Option<(&'a Option<AstP<QSelf>>, &'a Path)>
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.
sourcefn extract_unit_struct_path<'a>(
&mut self,
expr: &'a Expr
) -> Option<(&'a Option<AstP<QSelf>>, &'a Path)>
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.
sourcefn destructure_assign(
&mut self,
lhs: &Expr,
eq_sign_span: Span,
assignments: &mut Vec<Stmt<'hir>>
) -> &'hir Pat<'hir>
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
.
fn destructure_assign_mut( &mut self, lhs: &Expr, eq_sign_span: Span, assignments: &mut Vec<Stmt<'hir>> ) -> Pat<'hir>
sourcefn destructure_sequence(
&mut self,
elements: &[AstP<Expr>],
ctx: &str,
eq_sign_span: Span,
assignments: &mut Vec<Stmt<'hir>>
) -> (&'hir [Pat<'hir>], Option<(usize, Span)>)
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
.
sourcefn lower_expr_range_closed(
&mut self,
span: Span,
e1: &Expr,
e2: &Expr
) -> ExprKind<'hir>
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>)
.
fn lower_expr_range( &mut self, span: Span, e1: Option<&Expr>, e2: Option<&Expr>, lims: RangeLimits ) -> ExprKind<'hir>
fn lower_label(&self, opt_label: Option<Label>) -> Option<Label>
fn lower_loop_destination( &mut self, destination: Option<(NodeId, Label)> ) -> Destination
fn lower_jump_destination( &mut self, id: NodeId, opt_label: Option<Label> ) -> Destination
fn with_catch_scope<T>( &mut self, catch_id: NodeId, f: impl FnOnce(&mut Self) -> T ) -> T
fn with_loop_scope<T>( &mut self, loop_id: NodeId, f: impl FnOnce(&mut Self) -> T ) -> T
fn with_loop_condition_scope<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T
fn lower_expr_field(&mut self, f: &ExprField) -> ExprField<'hir>
fn lower_expr_yield( &mut self, span: Span, opt_expr: Option<&Expr> ) -> ExprKind<'hir>
sourcefn lower_expr_for(
&mut self,
e: &Expr,
pat: &Pat,
head: &Expr,
body: &Block,
opt_label: Option<Label>
) -> Expr<'hir>
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
}
sourcefn lower_expr_try(&mut self, span: Span, sub_expr: &Expr) -> ExprKind<'hir>
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),
}
sourcefn lower_expr_yeet(
&mut self,
span: Span,
sub_expr: Option<&Expr>
) -> ExprKind<'hir>
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))
.
sourcepub(crate) fn expr_drop_temps(
&mut self,
span: Span,
expr: &'hir Expr<'hir>
) -> &'hir Expr<'hir>
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 { .. }
.
pub(crate) fn expr_drop_temps_mut( &mut self, span: Span, expr: &'hir Expr<'hir> ) -> Expr<'hir>
pub(crate) fn expr_match( &mut self, span: Span, arg: &'hir Expr<'hir>, arms: &'hir [Arm<'hir>], source: MatchSource ) -> Expr<'hir>
fn expr_break(&mut self, span: Span) -> Expr<'hir>
fn expr_break_alloc(&mut self, span: Span) -> &'hir Expr<'hir>
fn expr_mut_addr_of(&mut self, span: Span, e: &'hir Expr<'hir>) -> Expr<'hir>
fn expr_unit(&mut self, sp: Span) -> &'hir Expr<'hir>
pub(crate) fn expr_usize(&mut self, sp: Span, value: usize) -> Expr<'hir>
pub(crate) fn expr_u32(&mut self, sp: Span, value: u32) -> Expr<'hir>
pub(crate) fn expr_char(&mut self, sp: Span, value: char) -> Expr<'hir>
pub(crate) fn expr_str(&mut self, sp: Span, value: Symbol) -> Expr<'hir>
pub(crate) fn expr_call_mut( &mut self, span: Span, e: &'hir Expr<'hir>, args: &'hir [Expr<'hir>] ) -> Expr<'hir>
pub(crate) fn expr_call( &mut self, span: Span, e: &'hir Expr<'hir>, args: &'hir [Expr<'hir>] ) -> &'hir Expr<'hir>
fn expr_call_lang_item_fn_mut( &mut self, span: Span, lang_item: LangItem, args: &'hir [Expr<'hir>], hir_id: Option<HirId> ) -> Expr<'hir>
fn expr_call_lang_item_fn( &mut self, span: Span, lang_item: LangItem, args: &'hir [Expr<'hir>], hir_id: Option<HirId> ) -> &'hir Expr<'hir>
fn expr_lang_item_path( &mut self, span: Span, lang_item: LangItem, hir_id: Option<HirId> ) -> Expr<'hir>
sourcepub(crate) fn expr_lang_item_type_relative(
&mut self,
span: Span,
lang_item: LangItem,
name: Symbol
) -> Expr<'hir>
pub(crate) fn expr_lang_item_type_relative( &mut self, span: Span, lang_item: LangItem, name: Symbol ) -> Expr<'hir>
<LangItem>::name
pub(crate) fn expr_ident( &mut self, sp: Span, ident: Ident, binding: HirId ) -> &'hir Expr<'hir>
pub(crate) fn expr_ident_mut( &mut self, span: Span, ident: Ident, binding: HirId ) -> Expr<'hir>
fn expr_unsafe(&mut self, expr: &'hir Expr<'hir>) -> Expr<'hir>
fn expr_block_empty(&mut self, span: Span) -> &'hir Expr<'hir>
pub(crate) fn expr_block(&mut self, b: &'hir Block<'hir>) -> Expr<'hir>
pub(crate) fn expr_array_ref( &mut self, span: Span, elements: &'hir [Expr<'hir>] ) -> Expr<'hir>
pub(crate) fn expr(&mut self, span: Span, kind: ExprKind<'hir>) -> Expr<'hir>
pub(crate) fn expr_field( &mut self, ident: Ident, expr: &'hir Expr<'hir>, span: Span ) -> ExprField<'hir>
pub(crate) fn arm( &mut self, pat: &'hir Pat<'hir>, expr: &'hir Expr<'hir> ) -> Arm<'hir>
source§impl<'hir> LoweringContext<'_, 'hir>
impl<'hir> LoweringContext<'_, 'hir>
pub(crate) fn lower_format_args( &mut self, sp: Span, fmt: &FormatArgs ) -> ExprKind<'hir>
source§impl<'hir> LoweringContext<'_, 'hir>
impl<'hir> LoweringContext<'_, 'hir>
pub(crate) fn lower_mod( &mut self, items: &[P<Item>], spans: &ModSpans ) -> &'hir Mod<'hir>
pub(crate) fn lower_item_ref(&mut self, i: &Item) -> SmallVec<[ItemId; 1]>
fn lower_item_id_use_tree( &mut self, tree: &UseTree, vec: &mut SmallVec<[ItemId; 1]> )
fn lower_item(&mut self, i: &Item) -> &'hir Item<'hir>
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>
fn lower_const_item( &mut self, ty: &Ty, span: Span, body: Option<&Expr> ) -> (&'hir Ty<'hir>, BodyId)
fn lower_use_tree( &mut self, tree: &UseTree, prefix: &Path, id: NodeId, vis_span: Span, ident: &mut Ident, attrs: Option<&'hir [Attribute]> ) -> ItemKind<'hir>
fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir ForeignItem<'hir>
fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> ForeignItemRef
fn lower_variant(&mut self, v: &Variant) -> Variant<'hir>
fn lower_variant_data( &mut self, parent_id: HirId, vdata: &VariantData ) -> VariantData<'hir>
fn lower_field_def(&mut self, (index, f): (usize, &FieldDef)) -> FieldDef<'hir>
fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir TraitItem<'hir>
fn lower_trait_item_ref(&mut self, i: &AssocItem) -> TraitItemRef
sourcepub(crate) fn expr_err(
&mut self,
span: Span,
guar: ErrorGuaranteed
) -> Expr<'hir>
pub(crate) fn expr_err( &mut self, span: Span, guar: ErrorGuaranteed ) -> Expr<'hir>
Construct ExprKind::Err
for the given span
.
fn lower_impl_item(&mut self, i: &AssocItem) -> &'hir ImplItem<'hir>
fn lower_impl_item_ref(&mut self, i: &AssocItem) -> ImplItemRef
fn lower_defaultness( &self, d: Defaultness, has_value: bool ) -> (Defaultness, Option<Span>)
fn record_body( &mut self, params: &'hir [Param<'hir>], value: Expr<'hir> ) -> BodyId
pub(crate) fn lower_body( &mut self, f: impl FnOnce(&mut Self) -> (&'hir [Param<'hir>], Expr<'hir>) ) -> BodyId
fn lower_param(&mut self, param: &Param) -> Param<'hir>
pub(crate) fn lower_fn_body( &mut self, decl: &FnDecl, body: impl FnOnce(&mut Self) -> Expr<'hir> ) -> BodyId
fn lower_fn_body_block( &mut self, span: Span, decl: &FnDecl, body: Option<&Block> ) -> BodyId
fn lower_block_expr_opt( &mut self, span: Span, block: Option<&Block> ) -> Expr<'hir>
pub(crate) fn lower_const_body( &mut self, span: Span, expr: Option<&Expr> ) -> BodyId
fn lower_maybe_async_body( &mut self, span: Span, fn_id: HirId, decl: &FnDecl, asyncness: Async, body: Option<&Block> ) -> BodyId
fn lower_method_sig( &mut self, generics: &Generics, sig: &FnSig, id: NodeId, kind: FnDeclKind, is_async: Option<(NodeId, Span)> ) -> (&'hir Generics<'hir>, FnSig<'hir>)
fn lower_fn_header(&mut self, h: FnHeader) -> FnHeader
pub(crate) fn lower_abi(&mut self, abi: StrLit) -> Abi
pub(crate) fn lower_extern(&mut self, ext: Extern) -> Abi
fn error_on_invalid_abi(&self, abi: StrLit, err: AbiUnsupported)
fn lower_asyncness(&mut self, a: Async) -> IsAsync
pub(crate) fn lower_constness(&mut self, c: Const) -> Constness
pub(crate) fn lower_unsafety(&mut self, u: Unsafe) -> Unsafety
sourcefn 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)
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.
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>>
fn lower_where_predicate( &mut self, pred: &WherePredicate ) -> WherePredicate<'hir>
source§impl<'a, 'hir> LoweringContext<'a, 'hir>
impl<'a, 'hir> LoweringContext<'a, 'hir>
pub(crate) fn lower_pat(&mut self, pattern: &Pat) -> &'hir Pat<'hir>
pub(crate) fn lower_pat_mut(&mut self, pattern: &Pat) -> Pat<'hir>
fn lower_pat_tuple( &mut self, pats: &[P<Pat>], ctx: &str ) -> (&'hir [Pat<'hir>], DotDotPos)
sourcefn lower_pat_slice(&mut self, pats: &[P<Pat>]) -> PatKind<'hir>
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
.
fn lower_pat_ident( &mut self, p: &Pat, annotation: BindingAnnotation, ident: Ident, lower_sub: impl FnOnce(&mut Self) -> Option<&'hir Pat<'hir>> ) -> PatKind<'hir>
fn pat_wild_with_node_id_of(&mut self, p: &Pat) -> &'hir Pat<'hir>
sourcefn pat_with_node_id_of(&mut self, p: &Pat, kind: PatKind<'hir>) -> Pat<'hir>
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.
sourcepub(crate) fn ban_extra_rest_pat(&self, sp: Span, prev_sp: Span, ctx: &str)
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.
sourcefn ban_illegal_rest_pat(&self, sp: Span) -> PatKind<'hir>
fn ban_illegal_rest_pat(&self, sp: Span) -> PatKind<'hir>
Used to ban the ..
pattern in places it shouldn’t be semantically.
fn lower_range_end(&mut self, e: &RangeEnd, has_end: bool) -> RangeEnd
sourcefn lower_expr_within_pat(
&mut self,
expr: &Expr,
allow_paths: bool
) -> &'hir Expr<'hir>
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>
impl<'a, 'hir> LoweringContext<'a, 'hir>
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>
pub(crate) fn lower_use_path( &mut self, res: SmallVec<[Res; 3]>, p: &Path, param_mode: ParamMode ) -> &'hir UsePath<'hir>
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>
fn maybe_insert_elided_lifetimes_in_path( &mut self, path_span: Span, segment_id: NodeId, segment_ident_span: Span, generic_args: &mut GenericArgsCtor<'hir> )
pub(crate) fn lower_angle_bracketed_parameter_data( &mut self, data: &AngleBracketedArgs, param_mode: ParamMode, itctx: &ImplTraitContext ) -> (GenericArgsCtor<'hir>, bool)
fn lower_parenthesized_parameter_data( &mut self, data: &ParenthesizedArgs, itctx: &ImplTraitContext ) -> (GenericArgsCtor<'hir>, bool)
sourcepub(crate) fn output_ty_binding(
&mut self,
span: Span,
ty: &'hir Ty<'hir>
) -> TypeBinding<'hir>
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>
impl<'a, 'hir> LoweringContext<'a, 'hir>
pub(crate) fn create_def( &mut self, parent: LocalDefId, node_id: NodeId, data: DefPathData, span: Span ) -> LocalDefId
pub(crate) fn next_node_id(&mut self) -> NodeId
sourcepub(crate) fn orig_opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>
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).
sourcepub(crate) fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>
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
.
pub(crate) fn local_def_id(&self, node: NodeId) -> LocalDefId
sourcepub(crate) fn get_remapped_def_id(&self, local_def_id: LocalDefId) -> LocalDefId
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.
sourcepub(crate) fn with_hir_id_owner(
&mut self,
owner: NodeId,
f: impl FnOnce(&mut Self) -> OwnerNode<'hir>
)
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.
sourcepub(crate) fn with_remapping<R>(
&mut self,
remap: FxHashMap<LocalDefId, LocalDefId>,
f: impl FnOnce(&mut Self) -> R
) -> R
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.
pub(crate) fn make_owner_info( &mut self, node: OwnerNode<'hir> ) -> &'hir OwnerInfo<'hir>
sourcepub(crate) fn lower_node_id(&mut self, ast_node_id: NodeId) -> HirId
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 NodeId
s got mapped
properly. Calling the method twice with the same NodeId
is fine though.
pub(crate) fn lower_res(&mut self, res: Res<NodeId>) -> Res
pub(crate) fn expect_full_res(&mut self, id: NodeId) -> Res<NodeId>
pub(crate) fn expect_full_res_from_use( &mut self, id: NodeId ) -> impl Iterator<Item = Res<NodeId>>
pub(crate) fn diagnostic(&self) -> &Handler
sourcepub(crate) fn mark_span_with_reason(
&self,
reason: DesugaringKind,
span: Span,
allow_internal_unstable: Option<Lrc<[Symbol]>>
) -> Span
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.
sourcepub(crate) fn lower_span(&self, span: Span) -> Span
pub(crate) fn lower_span(&self, span: Span) -> Span
Intercept all spans entering HIR. Mark a span as relative to the current owning item.
pub(crate) fn lower_ident(&self, ident: Ident) -> Ident
sourcepub(crate) fn lifetime_res_to_generic_param(
&mut self,
ident: Ident,
node_id: NodeId,
res: LifetimeRes,
source: GenericParamSource
) -> Option<GenericParam<'hir>>
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.
sourcepub(crate) fn lower_lifetime_binder(
&mut self,
binder: NodeId,
generic_params: &[GenericParam]
) -> &'hir [GenericParam<'hir>]
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.
pub(crate) fn with_dyn_type_scope<T>( &mut self, in_scope: bool, f: impl FnOnce(&mut Self) -> T ) -> T
pub(crate) fn with_new_scopes<T>(&mut self, f: impl FnOnce(&mut Self) -> T) -> T
pub(crate) fn lower_attrs( &mut self, id: HirId, attrs: &[Attribute] ) -> Option<&'hir [Attribute]>
pub(crate) fn lower_attr(&self, attr: &Attribute) -> Attribute
pub(crate) fn alias_attrs(&mut self, id: HirId, target_id: HirId)
pub(crate) fn lower_attr_args(&self, args: &AttrArgs) -> AttrArgs
pub(crate) fn lower_delim_args(&self, args: &DelimArgs) -> DelimArgs
sourcepub(crate) fn lower_assoc_ty_constraint(
&mut self,
constraint: &AssocConstraint,
itctx: &ImplTraitContext
) -> TypeBinding<'hir>
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
.
pub(crate) fn emit_bad_parenthesized_trait_in_assoc_ty( &self, data: &ParenthesizedArgs )
pub(crate) fn lower_generic_arg( &mut self, arg: &GenericArg, itctx: &ImplTraitContext ) -> GenericArg<'hir>
pub(crate) fn lower_ty( &mut self, t: &Ty, itctx: &ImplTraitContext ) -> &'hir Ty<'hir>
pub(crate) fn lower_path_ty( &mut self, t: &Ty, qself: &Option<P<QSelf>>, path: &Path, param_mode: ParamMode, itctx: &ImplTraitContext ) -> Ty<'hir>
pub(crate) fn ty(&mut self, span: Span, kind: TyKind<'hir>) -> Ty<'hir>
pub(crate) fn ty_tup(&mut self, span: Span, tys: &'hir [Ty<'hir>]) -> Ty<'hir>
pub(crate) fn lower_ty_direct( &mut self, t: &Ty, itctx: &ImplTraitContext ) -> Ty<'hir>
sourcepub(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>
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.
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>
pub(crate) fn lower_fn_params_to_names( &mut self, decl: &FnDecl ) -> &'hir [Ident]
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>
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>
sourcepub(crate) fn lower_async_fn_output_type_to_future_bound(
&mut self,
output: &FnRetTy,
span: Span,
nested_impl_trait_context: ImplTraitContext
) -> GenericBound<'hir>
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>
.
pub(crate) fn lower_param_bound( &mut self, tpb: &GenericBound, itctx: &ImplTraitContext ) -> GenericBound<'hir>
pub(crate) fn lower_lifetime(&mut self, l: &Lifetime) -> &'hir Lifetime
pub(crate) fn new_named_lifetime_with_res( &mut self, id: NodeId, ident: Ident, res: LifetimeRes ) -> &'hir Lifetime
pub(crate) fn new_named_lifetime( &mut self, id: NodeId, new_id: NodeId, ident: Ident ) -> &'hir Lifetime
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>
pub(crate) fn lower_generic_params( &mut self, params: &[GenericParam], source: GenericParamSource ) -> &'hir [GenericParam<'hir>]
pub(crate) fn lower_generic_param( &mut self, param: &GenericParam, source: GenericParamSource ) -> GenericParam<'hir>
pub(crate) fn lower_generic_param_kind( &mut self, param: &GenericParam ) -> (ParamName, GenericParamKind<'hir>)
pub(crate) fn lower_trait_ref( &mut self, constness: Const, p: &TraitRef, itctx: &ImplTraitContext ) -> TraitRef<'hir>
pub(crate) fn lower_poly_trait_ref( &mut self, p: &PolyTraitRef, itctx: &ImplTraitContext, constness: Const ) -> PolyTraitRef<'hir>
pub(crate) fn lower_mt( &mut self, mt: &MutTy, itctx: &ImplTraitContext ) -> MutTy<'hir>
pub(crate) fn lower_param_bounds( &mut self, bounds: &[GenericBound], itctx: &ImplTraitContext ) -> GenericBounds<'hir>
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>
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>)
sourcepub(crate) fn lower_block_expr(&mut self, b: &Block) -> Expr<'hir>
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
.
pub(crate) fn lower_array_length(&mut self, c: &AnonConst) -> ArrayLen
pub(crate) fn lower_anon_const(&mut self, c: &AnonConst) -> AnonConst
pub(crate) fn lower_unsafe_source(&mut self, u: UnsafeSource) -> UnsafeSource
pub(crate) fn lower_trait_bound_modifier( &mut self, f: TraitBoundModifier ) -> TraitBoundModifier
pub(crate) fn stmt(&mut self, span: Span, kind: StmtKind<'hir>) -> Stmt<'hir>
pub(crate) fn stmt_expr(&mut self, span: Span, expr: Expr<'hir>) -> Stmt<'hir>
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>
pub(crate) fn block_expr(&mut self, expr: &'hir Expr<'hir>) -> &'hir Block<'hir>
pub(crate) fn block_all( &mut self, span: Span, stmts: &'hir [Stmt<'hir>], expr: Option<&'hir Expr<'hir>> ) -> &'hir Block<'hir>
pub(crate) fn pat_cf_continue( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir Pat<'hir>
pub(crate) fn pat_cf_break( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir Pat<'hir>
pub(crate) fn pat_some( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir Pat<'hir>
pub(crate) fn pat_none(&mut self, span: Span) -> &'hir Pat<'hir>
pub(crate) fn single_pat_field( &mut self, span: Span, pat: &'hir Pat<'hir> ) -> &'hir [PatField<'hir>]
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>
pub(crate) fn pat_ident( &mut self, span: Span, ident: Ident ) -> (&'hir Pat<'hir>, HirId)
pub(crate) fn pat_ident_mut( &mut self, span: Span, ident: Ident ) -> (Pat<'hir>, HirId)
pub(crate) fn pat_ident_binding_mode( &mut self, span: Span, ident: Ident, bm: BindingAnnotation ) -> (&'hir Pat<'hir>, HirId)
pub(crate) fn pat_ident_binding_mode_mut( &mut self, span: Span, ident: Ident, bm: BindingAnnotation ) -> (Pat<'hir>, HirId)
pub(crate) fn pat(&mut self, span: Span, kind: PatKind<'hir>) -> &'hir Pat<'hir>
pub(crate) fn pat_without_dbm( &mut self, span: Span, kind: PatKind<'hir> ) -> Pat<'hir>
pub(crate) fn ty_path( &mut self, hir_id: HirId, span: Span, qpath: QPath<'hir> ) -> Ty<'hir>
sourcepub(crate) fn elided_dyn_bound(&mut self, span: Span) -> &'hir Lifetime
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> 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
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