//! Generated by `ast-generator`, do not edit by hand.

use super::base::Translator;

use super::mappings::TextValue;

use crate::generated;

use crate::trap::{Label, TrapId};

use crate::{post_emit, pre_emit};

use ra_ap_syntax::ast::{

HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasModuleItem, HasName,

HasTypeBounds, HasVisibility, RangeItem,

};

#[rustfmt::skip]

use ra_ap_syntax::{AstNode, ast};

impl Translator<'_> {

fn emit_else_branch(&mut self, node: &ast::ElseBranch) -> Option<Label<generated::Expr>> {

match node {

ast::ElseBranch::IfExpr(inner) => self.emit_if_expr(inner).map(Into::into),

ast::ElseBranch::Block(inner) => self.emit_block_expr(inner).map(Into::into),

}

}

pub(crate) fn emit_asm_operand(

&mut self,

node: &ast::AsmOperand,

) -> Option<Label<generated::AsmOperand>> {

pre_emit!(AsmOperand, self, node);

let label = match node {

ast::AsmOperand::AsmConst(inner) => self.emit_asm_const(inner).map(Into::into),

ast::AsmOperand::AsmLabel(inner) => self.emit_asm_label(inner).map(Into::into),

ast::AsmOperand::AsmRegOperand(inner) => {

self.emit_asm_reg_operand(inner).map(Into::into)

}

ast::AsmOperand::AsmSym(inner) => self.emit_asm_sym(inner).map(Into::into),

}?;

post_emit!(AsmOperand, self, node, label);

Some(label)

}

pub(crate) fn emit_asm_piece(

&mut self,

node: &ast::AsmPiece,

) -> Option<Label<generated::AsmPiece>> {

pre_emit!(AsmPiece, self, node);

let label = match node {

ast::AsmPiece::AsmClobberAbi(inner) => self.emit_asm_clobber_abi(inner).map(Into::into),

ast::AsmPiece::AsmOperandNamed(inner) => {

self.emit_asm_operand_named(inner).map(Into::into)

}

ast::AsmPiece::AsmOptions(inner) => self.emit_asm_options(inner).map(Into::into),

}?;

post_emit!(AsmPiece, self, node, label);

Some(label)

}

pub(crate) fn emit_assoc_item(

&mut self,

node: &ast::AssocItem,

) -> Option<Label<generated::AssocItem>> {

pre_emit!(AssocItem, self, node);

let label = match node {

ast::AssocItem::Const(inner) => self.emit_const(inner).map(Into::into),

ast::AssocItem::Fn(inner) => self.emit_fn(inner).map(Into::into),

ast::AssocItem::MacroCall(inner) => self.emit_macro_call(inner).map(Into::into),

ast::AssocItem::TypeAlias(inner) => self.emit_type_alias(inner).map(Into::into),

}?;

post_emit!(AssocItem, self, node, label);

Some(label)

}

pub(crate) fn emit_expr(&mut self, node: &ast::Expr) -> Option<Label<generated::Expr>> {

pre_emit!(Expr, self, node);

let label = match node {

ast::Expr::ArrayExpr(inner) => self.emit_array_expr(inner).map(Into::into),

ast::Expr::AsmExpr(inner) => self.emit_asm_expr(inner).map(Into::into),

ast::Expr::AwaitExpr(inner) => self.emit_await_expr(inner).map(Into::into),

ast::Expr::BecomeExpr(inner) => self.emit_become_expr(inner).map(Into::into),

ast::Expr::BinExpr(inner) => self.emit_bin_expr(inner).map(Into::into),

ast::Expr::BlockExpr(inner) => self.emit_block_expr(inner).map(Into::into),

ast::Expr::BreakExpr(inner) => self.emit_break_expr(inner).map(Into::into),

ast::Expr::CallExpr(inner) => self.emit_call_expr(inner).map(Into::into),

ast::Expr::CastExpr(inner) => self.emit_cast_expr(inner).map(Into::into),

ast::Expr::ClosureExpr(inner) => self.emit_closure_expr(inner).map(Into::into),

ast::Expr::ContinueExpr(inner) => self.emit_continue_expr(inner).map(Into::into),

ast::Expr::FieldExpr(inner) => self.emit_field_expr(inner).map(Into::into),

ast::Expr::ForExpr(inner) => self.emit_for_expr(inner).map(Into::into),

ast::Expr::FormatArgsExpr(inner) => self.emit_format_args_expr(inner).map(Into::into),

ast::Expr::IfExpr(inner) => self.emit_if_expr(inner).map(Into::into),

ast::Expr::IndexExpr(inner) => self.emit_index_expr(inner).map(Into::into),

ast::Expr::LetExpr(inner) => self.emit_let_expr(inner).map(Into::into),

ast::Expr::Literal(inner) => self.emit_literal(inner).map(Into::into),

ast::Expr::LoopExpr(inner) => self.emit_loop_expr(inner).map(Into::into),

ast::Expr::MacroExpr(inner) => self.emit_macro_expr(inner).map(Into::into),

ast::Expr::MatchExpr(inner) => self.emit_match_expr(inner).map(Into::into),

ast::Expr::MethodCallExpr(inner) => self.emit_method_call_expr(inner).map(Into::into),

ast::Expr::OffsetOfExpr(inner) => self.emit_offset_of_expr(inner).map(Into::into),

ast::Expr::ParenExpr(inner) => self.emit_paren_expr(inner).map(Into::into),

ast::Expr::PathExpr(inner) => self.emit_path_expr(inner).map(Into::into),

ast::Expr::PrefixExpr(inner) => self.emit_prefix_expr(inner).map(Into::into),

ast::Expr::RangeExpr(inner) => self.emit_range_expr(inner).map(Into::into),

ast::Expr::RecordExpr(inner) => self.emit_record_expr(inner).map(Into::into),

ast::Expr::RefExpr(inner) => self.emit_ref_expr(inner).map(Into::into),

ast::Expr::ReturnExpr(inner) => self.emit_return_expr(inner).map(Into::into),

ast::Expr::TryExpr(inner) => self.emit_try_expr(inner).map(Into::into),

ast::Expr::TupleExpr(inner) => self.emit_tuple_expr(inner).map(Into::into),

ast::Expr::UnderscoreExpr(inner) => self.emit_underscore_expr(inner).map(Into::into),

ast::Expr::WhileExpr(inner) => self.emit_while_expr(inner).map(Into::into),

ast::Expr::YeetExpr(inner) => self.emit_yeet_expr(inner).map(Into::into),

ast::Expr::YieldExpr(inner) => self.emit_yield_expr(inner).map(Into::into),

}?;

post_emit!(Expr, self, node, label);

Some(label)

}

pub(crate) fn emit_extern_item(

&mut self,

node: &ast::ExternItem,

) -> Option<Label<generated::ExternItem>> {

pre_emit!(ExternItem, self, node);

let label = match node {

ast::ExternItem::Fn(inner) => self.emit_fn(inner).map(Into::into),

ast::ExternItem::MacroCall(inner) => self.emit_macro_call(inner).map(Into::into),

ast::ExternItem::Static(inner) => self.emit_static(inner).map(Into::into),

ast::ExternItem::TypeAlias(inner) => self.emit_type_alias(inner).map(Into::into),

}?;

post_emit!(ExternItem, self, node, label);

Some(label)

}

pub(crate) fn emit_field_list(

&mut self,

node: &ast::FieldList,

) -> Option<Label<generated::FieldList>> {

pre_emit!(FieldList, self, node);

let label = match node {

ast::FieldList::RecordFieldList(inner) => {

self.emit_record_field_list(inner).map(Into::into)

}

ast::FieldList::TupleFieldList(inner) => {

self.emit_tuple_field_list(inner).map(Into::into)

}

}?;

post_emit!(FieldList, self, node, label);

Some(label)

}

pub(crate) fn emit_generic_arg(

&mut self,

node: &ast::GenericArg,

) -> Option<Label<generated::GenericArg>> {

pre_emit!(GenericArg, self, node);

let label = match node {

ast::GenericArg::AssocTypeArg(inner) => self.emit_assoc_type_arg(inner).map(Into::into),

ast::GenericArg::ConstArg(inner) => self.emit_const_arg(inner).map(Into::into),

ast::GenericArg::LifetimeArg(inner) => self.emit_lifetime_arg(inner).map(Into::into),

ast::GenericArg::TypeArg(inner) => self.emit_type_arg(inner).map(Into::into),

}?;

post_emit!(GenericArg, self, node, label);

Some(label)

}

pub(crate) fn emit_generic_param(

&mut self,

node: &ast::GenericParam,

) -> Option<Label<generated::GenericParam>> {

pre_emit!(GenericParam, self, node);

let label = match node {

ast::GenericParam::ConstParam(inner) => self.emit_const_param(inner).map(Into::into),

ast::GenericParam::LifetimeParam(inner) => {

self.emit_lifetime_param(inner).map(Into::into)

}

ast::GenericParam::TypeParam(inner) => self.emit_type_param(inner).map(Into::into),

}?;

post_emit!(GenericParam, self, node, label);

Some(label)

}

pub(crate) fn emit_pat(&mut self, node: &ast::Pat) -> Option<Label<generated::Pat>> {

pre_emit!(Pat, self, node);

let label = match node {

ast::Pat::BoxPat(inner) => self.emit_box_pat(inner).map(Into::into),

ast::Pat::ConstBlockPat(inner) => self.emit_const_block_pat(inner).map(Into::into),

ast::Pat::IdentPat(inner) => self.emit_ident_pat(inner).map(Into::into),

ast::Pat::LiteralPat(inner) => self.emit_literal_pat(inner).map(Into::into),

ast::Pat::MacroPat(inner) => self.emit_macro_pat(inner).map(Into::into),

ast::Pat::OrPat(inner) => self.emit_or_pat(inner).map(Into::into),

ast::Pat::ParenPat(inner) => self.emit_paren_pat(inner).map(Into::into),

ast::Pat::PathPat(inner) => self.emit_path_pat(inner).map(Into::into),

ast::Pat::RangePat(inner) => self.emit_range_pat(inner).map(Into::into),

ast::Pat::RecordPat(inner) => self.emit_record_pat(inner).map(Into::into),

ast::Pat::RefPat(inner) => self.emit_ref_pat(inner).map(Into::into),

ast::Pat::RestPat(inner) => self.emit_rest_pat(inner).map(Into::into),

ast::Pat::SlicePat(inner) => self.emit_slice_pat(inner).map(Into::into),

ast::Pat::TuplePat(inner) => self.emit_tuple_pat(inner).map(Into::into),

ast::Pat::TupleStructPat(inner) => self.emit_tuple_struct_pat(inner).map(Into::into),

ast::Pat::WildcardPat(inner) => self.emit_wildcard_pat(inner).map(Into::into),

}?;

post_emit!(Pat, self, node, label);

Some(label)

}

pub(crate) fn emit_stmt(&mut self, node: &ast::Stmt) -> Option<Label<generated::Stmt>> {

pre_emit!(Stmt, self, node);

let label = match node {

ast::Stmt::ExprStmt(inner) => self.emit_expr_stmt(inner).map(Into::into),

ast::Stmt::Item(inner) => self.emit_item(inner).map(Into::into),

ast::Stmt::LetStmt(inner) => self.emit_let_stmt(inner).map(Into::into),

}?;

post_emit!(Stmt, self, node, label);

Some(label)

}

pub(crate) fn emit_type(&mut self, node: &ast::Type) -> Option<Label<generated::TypeRepr>> {

pre_emit!(TypeRepr, self, node);

let label = match node {

ast::Type::ArrayType(inner) => self.emit_array_type(inner).map(Into::into),

ast::Type::DynTraitType(inner) => self.emit_dyn_trait_type(inner).map(Into::into),

ast::Type::FnPtrType(inner) => self.emit_fn_ptr_type(inner).map(Into::into),

ast::Type::ForType(inner) => self.emit_for_type(inner).map(Into::into),

ast::Type::ImplTraitType(inner) => self.emit_impl_trait_type(inner).map(Into::into),

ast::Type::InferType(inner) => self.emit_infer_type(inner).map(Into::into),

ast::Type::MacroType(inner) => self.emit_macro_type(inner).map(Into::into),

ast::Type::NeverType(inner) => self.emit_never_type(inner).map(Into::into),

ast::Type::ParenType(inner) => self.emit_paren_type(inner).map(Into::into),

ast::Type::PathType(inner) => self.emit_path_type(inner).map(Into::into),

ast::Type::PtrType(inner) => self.emit_ptr_type(inner).map(Into::into),

ast::Type::RefType(inner) => self.emit_ref_type(inner).map(Into::into),

ast::Type::SliceType(inner) => self.emit_slice_type(inner).map(Into::into),

ast::Type::TupleType(inner) => self.emit_tuple_type(inner).map(Into::into),

}?;

post_emit!(TypeRepr, self, node, label);

Some(label)

}

pub(crate) fn emit_use_bound_generic_arg(

&mut self,

node: &ast::UseBoundGenericArg,

) -> Option<Label<generated::UseBoundGenericArg>> {

pre_emit!(UseBoundGenericArg, self, node);

let label = match node {

ast::UseBoundGenericArg::Lifetime(inner) => self.emit_lifetime(inner).map(Into::into),

ast::UseBoundGenericArg::NameRef(inner) => self.emit_name_ref(inner).map(Into::into),

}?;

post_emit!(UseBoundGenericArg, self, node, label);

Some(label)

}

pub(crate) fn emit_item(&mut self, node: &ast::Item) -> Option<Label<generated::Item>> {

pre_emit!(Item, self, node);

let label = match node {

ast::Item::Const(inner) => self.emit_const(inner).map(Into::into),

ast::Item::Enum(inner) => self.emit_enum(inner).map(Into::into),

ast::Item::ExternBlock(inner) => self.emit_extern_block(inner).map(Into::into),

ast::Item::ExternCrate(inner) => self.emit_extern_crate(inner).map(Into::into),

ast::Item::Fn(inner) => self.emit_fn(inner).map(Into::into),

ast::Item::Impl(inner) => self.emit_impl(inner).map(Into::into),

ast::Item::MacroCall(inner) => self.emit_macro_call(inner).map(Into::into),

ast::Item::MacroDef(inner) => self.emit_macro_def(inner).map(Into::into),

ast::Item::MacroRules(inner) => self.emit_macro_rules(inner).map(Into::into),

ast::Item::Module(inner) => self.emit_module(inner).map(Into::into),

ast::Item::Static(inner) => self.emit_static(inner).map(Into::into),

ast::Item::Struct(inner) => self.emit_struct(inner).map(Into::into),

ast::Item::Trait(inner) => self.emit_trait(inner).map(Into::into),

ast::Item::TraitAlias(inner) => self.emit_trait_alias(inner).map(Into::into),

ast::Item::TypeAlias(inner) => self.emit_type_alias(inner).map(Into::into),

ast::Item::Union(inner) => self.emit_union(inner).map(Into::into),

ast::Item::Use(inner) => self.emit_use(inner).map(Into::into),

}?;

post_emit!(Item, self, node, label);

Some(label)

}

pub(crate) fn emit_abi(&mut self, node: &ast::Abi) -> Option<Label<generated::Abi>> {

pre_emit!(Abi, self, node);

if self.should_be_excluded(node) {

return None;

}

let abi_string = node.try_get_text();

let label = self.trap.emit(generated::Abi {

id: TrapId::Star,

abi_string,

});

self.emit_location(label, node);

post_emit!(Abi, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_arg_list(

&mut self,

node: &ast::ArgList,

) -> Option<Label<generated::ArgList>> {

pre_emit!(ArgList, self, node);

if self.should_be_excluded(node) {

return None;

}

let args = node.args().filter_map(|x| self.emit_expr(&x)).collect();

let label = self.trap.emit(generated::ArgList {

id: TrapId::Star,

args,

});

self.emit_location(label, node);

post_emit!(ArgList, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_array_expr(

&mut self,

node: &ast::ArrayExpr,

) -> Option<Label<generated::ArrayExprInternal>> {

pre_emit!(ArrayExprInternal, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let exprs = node.exprs().filter_map(|x| self.emit_expr(&x)).collect();

let is_semicolon = node.semicolon_token().is_some();

let label = self.trap.emit(generated::ArrayExprInternal {

id: TrapId::Star,

attrs,

exprs,

is_semicolon,

});

self.emit_location(label, node);

post_emit!(ArrayExprInternal, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_array_type(

&mut self,

node: &ast::ArrayType,

) -> Option<Label<generated::ArrayTypeRepr>> {

pre_emit!(ArrayTypeRepr, self, node);

if self.should_be_excluded(node) {

return None;

}

let const_arg = node.const_arg().and_then(|x| self.emit_const_arg(&x));

let element_type_repr = node.ty().and_then(|x| self.emit_type(&x));

let label = self.trap.emit(generated::ArrayTypeRepr {

id: TrapId::Star,

const_arg,

element_type_repr,

});

self.emit_location(label, node);

post_emit!(ArrayTypeRepr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_clobber_abi(

&mut self,

node: &ast::AsmClobberAbi,

) -> Option<Label<generated::AsmClobberAbi>> {

pre_emit!(AsmClobberAbi, self, node);

if self.should_be_excluded(node) {

return None;

}

let label = self

.trap

.emit(generated::AsmClobberAbi { id: TrapId::Star });

self.emit_location(label, node);

post_emit!(AsmClobberAbi, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_const(

&mut self,

node: &ast::AsmConst,

) -> Option<Label<generated::AsmConst>> {

pre_emit!(AsmConst, self, node);

if self.should_be_excluded(node) {

return None;

}

let expr = node.expr().and_then(|x| self.emit_expr(&x));

let is_const = node.const_token().is_some();

let label = self.trap.emit(generated::AsmConst {

id: TrapId::Star,

expr,

is_const,

});

self.emit_location(label, node);

post_emit!(AsmConst, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_dir_spec(

&mut self,

node: &ast::AsmDirSpec,

) -> Option<Label<generated::AsmDirSpec>> {

pre_emit!(AsmDirSpec, self, node);

if self.should_be_excluded(node) {

return None;

}

let label = self.trap.emit(generated::AsmDirSpec { id: TrapId::Star });

self.emit_location(label, node);

post_emit!(AsmDirSpec, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_expr(

&mut self,

node: &ast::AsmExpr,

) -> Option<Label<generated::AsmExpr>> {

pre_emit!(AsmExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let asm_pieces = node

.asm_pieces()

.filter_map(|x| self.emit_asm_piece(&x))

.collect();

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let template = node.template().filter_map(|x| self.emit_expr(&x)).collect();

let label = self.trap.emit(generated::AsmExpr {

id: TrapId::Star,

asm_pieces,

attrs,

template,

});

self.emit_location(label, node);

post_emit!(AsmExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_label(

&mut self,

node: &ast::AsmLabel,

) -> Option<Label<generated::AsmLabel>> {

pre_emit!(AsmLabel, self, node);

if self.should_be_excluded(node) {

return None;

}

let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x));

let label = self.trap.emit(generated::AsmLabel {

id: TrapId::Star,

block_expr,

});

self.emit_location(label, node);

post_emit!(AsmLabel, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_operand_expr(

&mut self,

node: &ast::AsmOperandExpr,

) -> Option<Label<generated::AsmOperandExpr>> {

pre_emit!(AsmOperandExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

let in_expr = node.in_expr().and_then(|x| self.emit_expr(&x));

let out_expr = node.out_expr().and_then(|x| self.emit_expr(&x));

let label = self.trap.emit(generated::AsmOperandExpr {

id: TrapId::Star,

in_expr,

out_expr,

});

self.emit_location(label, node);

post_emit!(AsmOperandExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_operand_named(

&mut self,

node: &ast::AsmOperandNamed,

) -> Option<Label<generated::AsmOperandNamed>> {

pre_emit!(AsmOperandNamed, self, node);

if self.should_be_excluded(node) {

return None;

}

let asm_operand = node.asm_operand().and_then(|x| self.emit_asm_operand(&x));

let name = node.name().and_then(|x| self.emit_name(&x));

let label = self.trap.emit(generated::AsmOperandNamed {

id: TrapId::Star,

asm_operand,

name,

});

self.emit_location(label, node);

post_emit!(AsmOperandNamed, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_option(

&mut self,

node: &ast::AsmOption,

) -> Option<Label<generated::AsmOption>> {

pre_emit!(AsmOption, self, node);

if self.should_be_excluded(node) {

return None;

}

let is_raw = node.raw_token().is_some();

let label = self.trap.emit(generated::AsmOption {

id: TrapId::Star,

is_raw,

});

self.emit_location(label, node);

post_emit!(AsmOption, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_options(

&mut self,

node: &ast::AsmOptions,

) -> Option<Label<generated::AsmOptionsList>> {

pre_emit!(AsmOptionsList, self, node);

if self.should_be_excluded(node) {

return None;

}

let asm_options = node

.asm_options()

.filter_map(|x| self.emit_asm_option(&x))

.collect();

let label = self.trap.emit(generated::AsmOptionsList {

id: TrapId::Star,

asm_options,

});

self.emit_location(label, node);

post_emit!(AsmOptionsList, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_reg_operand(

&mut self,

node: &ast::AsmRegOperand,

) -> Option<Label<generated::AsmRegOperand>> {

pre_emit!(AsmRegOperand, self, node);

if self.should_be_excluded(node) {

return None;

}

let asm_dir_spec = node.asm_dir_spec().and_then(|x| self.emit_asm_dir_spec(&x));

let asm_operand_expr = node

.asm_operand_expr()

.and_then(|x| self.emit_asm_operand_expr(&x));

let asm_reg_spec = node.asm_reg_spec().and_then(|x| self.emit_asm_reg_spec(&x));

let label = self.trap.emit(generated::AsmRegOperand {

id: TrapId::Star,

asm_dir_spec,

asm_operand_expr,

asm_reg_spec,

});

self.emit_location(label, node);

post_emit!(AsmRegOperand, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_reg_spec(

&mut self,

node: &ast::AsmRegSpec,

) -> Option<Label<generated::AsmRegSpec>> {

pre_emit!(AsmRegSpec, self, node);

if self.should_be_excluded(node) {

return None;

}

let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x));

let label = self.trap.emit(generated::AsmRegSpec {

id: TrapId::Star,

identifier,

});

self.emit_location(label, node);

post_emit!(AsmRegSpec, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_asm_sym(&mut self, node: &ast::AsmSym) -> Option<Label<generated::AsmSym>> {

pre_emit!(AsmSym, self, node);

if self.should_be_excluded(node) {

return None;

}

let path = node.path().and_then(|x| self.emit_path(&x));

let label = self.trap.emit(generated::AsmSym {

id: TrapId::Star,

path,

});

self.emit_location(label, node);

post_emit!(AsmSym, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_assoc_item_list(

&mut self,

node: &ast::AssocItemList,

) -> Option<Label<generated::AssocItemList>> {

pre_emit!(AssocItemList, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let assoc_items = node

.assoc_items()

.filter_map(|x| self.emit_assoc_item(&x))

.collect();

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let label = self.trap.emit(generated::AssocItemList {

id: TrapId::Star,

assoc_items,

attrs,

});

self.emit_location(label, node);

post_emit!(AssocItemList, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_assoc_type_arg(

&mut self,

node: &ast::AssocTypeArg,

) -> Option<Label<generated::AssocTypeArg>> {

pre_emit!(AssocTypeArg, self, node);

if self.should_be_excluded(node) {

return None;

}

let const_arg = node.const_arg().and_then(|x| self.emit_const_arg(&x));

let generic_arg_list = node

.generic_arg_list()

.and_then(|x| self.emit_generic_arg_list(&x));

let identifier = node.name_ref().and_then(|x| self.emit_name_ref(&x));

let param_list = node.param_list().and_then(|x| self.emit_param_list(&x));

let ret_type = node.ret_type().and_then(|x| self.emit_ret_type(&x));

let return_type_syntax = node

.return_type_syntax()

.and_then(|x| self.emit_return_type_syntax(&x));

let type_repr = node.ty().and_then(|x| self.emit_type(&x));

let type_bound_list = node

.type_bound_list()

.and_then(|x| self.emit_type_bound_list(&x));

let label = self.trap.emit(generated::AssocTypeArg {

id: TrapId::Star,

const_arg,

generic_arg_list,

identifier,

param_list,

ret_type,

return_type_syntax,

type_repr,

type_bound_list,

});

self.emit_location(label, node);

post_emit!(AssocTypeArg, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_attr(&mut self, node: &ast::Attr) -> Option<Label<generated::Attr>> {

pre_emit!(Attr, self, node);

if self.should_be_excluded(node) {

return None;

}

let meta = node.meta().and_then(|x| self.emit_meta(&x));

let label = self.trap.emit(generated::Attr {

id: TrapId::Star,

meta,

});

self.emit_location(label, node);

post_emit!(Attr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_await_expr(

&mut self,

node: &ast::AwaitExpr,

) -> Option<Label<generated::AwaitExpr>> {

pre_emit!(AwaitExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let expr = node.expr().and_then(|x| self.emit_expr(&x));

let label = self.trap.emit(generated::AwaitExpr {

id: TrapId::Star,

attrs,

expr,

});

self.emit_location(label, node);

post_emit!(AwaitExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_become_expr(

&mut self,

node: &ast::BecomeExpr,

) -> Option<Label<generated::BecomeExpr>> {

pre_emit!(BecomeExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let expr = node.expr().and_then(|x| self.emit_expr(&x));

let label = self.trap.emit(generated::BecomeExpr {

id: TrapId::Star,

attrs,

expr,

});

self.emit_location(label, node);

post_emit!(BecomeExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_bin_expr(

&mut self,

node: &ast::BinExpr,

) -> Option<Label<generated::BinaryExpr>> {

pre_emit!(BinaryExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let lhs = node.lhs().and_then(|x| self.emit_expr(&x));

let operator_name = node.try_get_text();

let rhs = node.rhs().and_then(|x| self.emit_expr(&x));

let label = self.trap.emit(generated::BinaryExpr {

id: TrapId::Star,

attrs,

lhs,

operator_name,

rhs,

});

self.emit_location(label, node);

post_emit!(BinaryExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_block_expr(

&mut self,

node: &ast::BlockExpr,

) -> Option<Label<generated::BlockExpr>> {

pre_emit!(BlockExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let is_async = node.async_token().is_some();

let is_const = node.const_token().is_some();

let is_gen = node.gen_token().is_some();

let is_move = node.move_token().is_some();

let is_try = node.try_token().is_some();

let is_unsafe = node.unsafe_token().is_some();

let label = node.label().and_then(|x| self.emit_label(&x));

let stmt_list = node.stmt_list().and_then(|x| self.emit_stmt_list(&x));

let label = self.trap.emit(generated::BlockExpr {

id: TrapId::Star,

attrs,

is_async,

is_const,

is_gen,

is_move,

is_try,

is_unsafe,

label,

stmt_list,

});

self.emit_location(label, node);

post_emit!(BlockExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_box_pat(&mut self, node: &ast::BoxPat) -> Option<Label<generated::BoxPat>> {

pre_emit!(BoxPat, self, node);

if self.should_be_excluded(node) {

return None;

}

let pat = node.pat().and_then(|x| self.emit_pat(&x));

let label = self.trap.emit(generated::BoxPat {

id: TrapId::Star,

pat,

});

self.emit_location(label, node);

post_emit!(BoxPat, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_break_expr(

&mut self,

node: &ast::BreakExpr,

) -> Option<Label<generated::BreakExpr>> {

pre_emit!(BreakExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let expr = node.expr().and_then(|x| self.emit_expr(&x));

let lifetime = node.lifetime().and_then(|x| self.emit_lifetime(&x));

let label = self.trap.emit(generated::BreakExpr {

id: TrapId::Star,

attrs,

expr,

lifetime,

});

self.emit_location(label, node);

post_emit!(BreakExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_call_expr(

&mut self,

node: &ast::CallExpr,

) -> Option<Label<generated::CallExpr>> {

pre_emit!(CallExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let arg_list = node.arg_list().and_then(|x| self.emit_arg_list(&x));

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let function = node.expr().and_then(|x| self.emit_expr(&x));

let label = self.trap.emit(generated::CallExpr {

id: TrapId::Star,

arg_list,

attrs,

function,

});

self.emit_location(label, node);

post_emit!(CallExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_cast_expr(

&mut self,

node: &ast::CastExpr,

) -> Option<Label<generated::CastExpr>> {

pre_emit!(CastExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let expr = node.expr().and_then(|x| self.emit_expr(&x));

let type_repr = node.ty().and_then(|x| self.emit_type(&x));

let label = self.trap.emit(generated::CastExpr {

id: TrapId::Star,

attrs,

expr,

type_repr,

});

self.emit_location(label, node);

post_emit!(CastExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_closure_binder(

&mut self,

node: &ast::ClosureBinder,

) -> Option<Label<generated::ClosureBinder>> {

pre_emit!(ClosureBinder, self, node);

if self.should_be_excluded(node) {

return None;

}

let generic_param_list = node

.generic_param_list()

.and_then(|x| self.emit_generic_param_list(&x));

let label = self.trap.emit(generated::ClosureBinder {

id: TrapId::Star,

generic_param_list,

});

self.emit_location(label, node);

post_emit!(ClosureBinder, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_closure_expr(

&mut self,

node: &ast::ClosureExpr,

) -> Option<Label<generated::ClosureExpr>> {

pre_emit!(ClosureExpr, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let body = node.body().and_then(|x| self.emit_expr(&x));

let closure_binder = node

.closure_binder()

.and_then(|x| self.emit_closure_binder(&x));

let is_async = node.async_token().is_some();

let is_const = node.const_token().is_some();

let is_gen = node.gen_token().is_some();

let is_move = node.move_token().is_some();

let is_static = node.static_token().is_some();

let param_list = node.param_list().and_then(|x| self.emit_param_list(&x));

let ret_type = node.ret_type().and_then(|x| self.emit_ret_type(&x));

let label = self.trap.emit(generated::ClosureExpr {

id: TrapId::Star,

attrs,

body,

closure_binder,

is_async,

is_const,

is_gen,

is_move,

is_static,

param_list,

ret_type,

});

self.emit_location(label, node);

post_emit!(ClosureExpr, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_const(&mut self, node: &ast::Const) -> Option<Label<generated::Const>> {

pre_emit!(Const, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let body = node.body().and_then(|x| self.emit_expr(&x));

let is_const = node.const_token().is_some();

let is_default = node.default_token().is_some();

let name = node.name().and_then(|x| self.emit_name(&x));

let type_repr = node.ty().and_then(|x| self.emit_type(&x));

let visibility = node.visibility().and_then(|x| self.emit_visibility(&x));

let label = self.trap.emit(generated::Const {

id: TrapId::Star,

attrs,

body,

is_const,

is_default,

name,

type_repr,

visibility,

});

self.emit_location(label, node);

post_emit!(Const, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_const_arg(

&mut self,

node: &ast::ConstArg,

) -> Option<Label<generated::ConstArg>> {

pre_emit!(ConstArg, self, node);

if self.should_be_excluded(node) {

return None;

}

let expr = node.expr().and_then(|x| self.emit_expr(&x));

let label = self.trap.emit(generated::ConstArg {

id: TrapId::Star,

expr,

});

self.emit_location(label, node);

post_emit!(ConstArg, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_const_block_pat(

&mut self,

node: &ast::ConstBlockPat,

) -> Option<Label<generated::ConstBlockPat>> {

pre_emit!(ConstBlockPat, self, node);

if self.should_be_excluded(node) {

return None;

}

let block_expr = node.block_expr().and_then(|x| self.emit_block_expr(&x));

let is_const = node.const_token().is_some();

let label = self.trap.emit(generated::ConstBlockPat {

id: TrapId::Star,

block_expr,

is_const,

});

self.emit_location(label, node);

post_emit!(ConstBlockPat, self, node, label);

self.emit_tokens(node, label.into(), node.syntax().children_with_tokens());

Some(label)

}

pub(crate) fn emit_const_param(

&mut self,

node: &ast::ConstParam,

) -> Option<Label<generated::ConstParam>> {

pre_emit!(ConstParam, self, node);

if self.should_be_excluded(node) {

return None;

}

if self.should_be_excluded_attrs(node) {

return None;

}

let attrs = node.attrs().filter_map(|x| self.emit_attr(&x)).collect();

let default_val = node.default_val().and_then(|x| self.emit_const_arg(&x));

let is_const = node.const_token().is_some();

let name = node.name().and_then(|x| self.emit_name(&x));

let type_repr = node.ty().and_then(|x| self.emit_type(&x));

let label = self.trap.emit(generated::ConstParam {

id: TrapId::Star,

attrs,

default_val,

is_const,

name,

type_repr,

});

self.emit_location(label, node);

post_emit!(ConstParam, self, node, label);