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

#![cfg_attr(any(), rustfmt::skip)]

use super::base::Translator;

use super::mappings::TextValue;

use crate::emit_detached;

use crate::generated;

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

use ra_ap_syntax::ast::{

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

HasTypeBounds, HasVisibility, RangeItem,

};

use ra_ap_syntax::{ast, AstNode};

impl Translator<'_> {

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

match node {

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

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

}

}

pub(crate) fn emit_assoc_item(&mut self, node: ast::AssocItem) -> Label<generated::AssocItem> {

match node {

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

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

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

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

}

}

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

match node {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

}

pub(crate) fn emit_extern_item(&mut self, node: ast::ExternItem) -> Label<generated::ExternItem> {

match node {

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

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

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

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

}

}

pub(crate) fn emit_field_list(&mut self, node: ast::FieldList) -> Label<generated::FieldList> {

match node {

ast::FieldList::RecordFieldList(inner) => self.emit_record_field_list(inner).into(),

ast::FieldList::TupleFieldList(inner) => self.emit_tuple_field_list(inner).into(),

}

}

pub(crate) fn emit_generic_arg(&mut self, node: ast::GenericArg) -> Label<generated::GenericArg> {

match node {

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

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

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

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

}

}

pub(crate) fn emit_generic_param(&mut self, node: ast::GenericParam) -> Label<generated::GenericParam> {

match node {

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

ast::GenericParam::LifetimeParam(inner) => self.emit_lifetime_param(inner).into(),

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

}

}

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

match node {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

}

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

match node {

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

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

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

}

}

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

match node {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

}

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

match node {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

}

}

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

let abi_string = node.try_get_text();

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

id: TrapId::Star,

abi_string,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_arg_list(&mut self, node: ast::ArgList) -> Label<generated::ArgList> {

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

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

id: TrapId::Star,

args,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_array_expr(&mut self, node: ast::ArrayExpr) -> Label<generated::ArrayExpr> {

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

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

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

id: TrapId::Star,

attrs,

exprs,

});

self.emit_location(label, &node);

emit_detached!(ArrayExpr, self, node, label);

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

label

}

pub(crate) fn emit_array_type(&mut self, node: ast::ArrayType) -> Label<generated::ArrayType> {

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

let ty = node.ty().map(|x| self.emit_type(x));

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

id: TrapId::Star,

const_arg,

ty,

});

self.emit_location(label, &node);

emit_detached!(ArrayType, self, node, label);

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

label

}

pub(crate) fn emit_asm_expr(&mut self, node: ast::AsmExpr) -> Label<generated::AsmExpr> {

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

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

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

id: TrapId::Star,

attrs,

expr,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_assoc_item_list(&mut self, node: ast::AssocItemList) -> Label<generated::AssocItemList> {

let assoc_items = node.assoc_items().map(|x| self.emit_assoc_item(x)).collect();

let attrs = node.attrs().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);

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

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

label

}

pub(crate) fn emit_assoc_type_arg(&mut self, node: ast::AssocTypeArg) -> Label<generated::AssocTypeArg> {

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

let generic_arg_list = node.generic_arg_list().map(|x| self.emit_generic_arg_list(x));

let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));

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

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

let return_type_syntax = node.return_type_syntax().map(|x| self.emit_return_type_syntax(x));

let ty = node.ty().map(|x| self.emit_type(x));

let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));

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

id: TrapId::Star,

const_arg,

generic_arg_list,

name_ref,

param_list,

ret_type,

return_type_syntax,

ty,

type_bound_list,

});

self.emit_location(label, &node);

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

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

label

}

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

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

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

id: TrapId::Star,

meta,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_await_expr(&mut self, node: ast::AwaitExpr) -> Label<generated::AwaitExpr> {

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

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

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

id: TrapId::Star,

attrs,

expr,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_become_expr(&mut self, node: ast::BecomeExpr) -> Label<generated::BecomeExpr> {

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

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

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

id: TrapId::Star,

attrs,

expr,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_bin_expr(&mut self, node: ast::BinExpr) -> Label<generated::BinaryExpr> {

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

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

let operator_name = node.try_get_text();

let rhs = node.rhs().map(|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);

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

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

label

}

pub(crate) fn emit_block_expr(&mut self, node: ast::BlockExpr) -> Label<generated::BlockExpr> {

let attrs = node.attrs().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().map(|x| self.emit_label(x));

let stmt_list = node.stmt_list().map(|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);

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

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

label

}

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

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

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

id: TrapId::Star,

pat,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_break_expr(&mut self, node: ast::BreakExpr) -> Label<generated::BreakExpr> {

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

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

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

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

id: TrapId::Star,

attrs,

expr,

lifetime,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_call_expr(&mut self, node: ast::CallExpr) -> Label<generated::CallExpr> {

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

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

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

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

id: TrapId::Star,

arg_list,

attrs,

expr,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_cast_expr(&mut self, node: ast::CastExpr) -> Label<generated::CastExpr> {

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

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

let ty = node.ty().map(|x| self.emit_type(x));

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

id: TrapId::Star,

attrs,

expr,

ty,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_closure_binder(&mut self, node: ast::ClosureBinder) -> Label<generated::ClosureBinder> {

let generic_param_list = node.generic_param_list().map(|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);

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

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

label

}

pub(crate) fn emit_closure_expr(&mut self, node: ast::ClosureExpr) -> Label<generated::ClosureExpr> {

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

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

let closure_binder = node.closure_binder().map(|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().map(|x| self.emit_param_list(x));

let ret_type = node.ret_type().map(|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);

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

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

label

}

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

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

let body = node.body().map(|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().map(|x| self.emit_name(x));

let ty = node.ty().map(|x| self.emit_type(x));

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

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

id: TrapId::Star,

attrs,

body,

is_const,

is_default,

name,

ty,

visibility,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_const_arg(&mut self, node: ast::ConstArg) -> Label<generated::ConstArg> {

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

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

id: TrapId::Star,

expr,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_const_block_pat(&mut self, node: ast::ConstBlockPat) -> Label<generated::ConstBlockPat> {

let block_expr = node.block_expr().map(|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);

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

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

label

}

pub(crate) fn emit_const_param(&mut self, node: ast::ConstParam) -> Label<generated::ConstParam> {

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

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

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

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

let ty = node.ty().map(|x| self.emit_type(x));

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

id: TrapId::Star,

attrs,

default_val,

is_const,

name,

ty,

});

self.emit_location(label, &node);

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

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

label

}

pub(crate) fn emit_continue_expr(&mut self, node: ast::ContinueExpr) -> Label<generated::ContinueExpr> {

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

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

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

id: TrapId::Star,

attrs,

lifetime,

});

self.emit_location(label, &node);

emit_detached!(ContinueExpr, self, node, label);

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

label

}

pub(crate) fn emit_dyn_trait_type(&mut self, node: ast::DynTraitType) -> Label<generated::DynTraitType> {

let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));

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

id: TrapId::Star,

type_bound_list,

});

self.emit_location(label, &node);

emit_detached!(DynTraitType, self, node, label);

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

label

}

pub(crate) fn emit_enum(&mut self, node: ast::Enum) -> Label<generated::Enum> {

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

let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));

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

let variant_list = node.variant_list().map(|x| self.emit_variant_list(x));

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

let where_clause = node.where_clause().map(|x| self.emit_where_clause(x));

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

id: TrapId::Star,

attrs,

generic_param_list,

name,

variant_list,

visibility,

where_clause,

});

self.emit_location(label, &node);

emit_detached!(Enum, self, node, label);

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

label

}

pub(crate) fn emit_expr_stmt(&mut self, node: ast::ExprStmt) -> Label<generated::ExprStmt> {

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

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

id: TrapId::Star,

expr,

});

self.emit_location(label, &node);

emit_detached!(ExprStmt, self, node, label);

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

label

}

pub(crate) fn emit_extern_block(&mut self, node: ast::ExternBlock) -> Label<generated::ExternBlock> {

let abi = node.abi().map(|x| self.emit_abi(x));

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

let extern_item_list = node.extern_item_list().map(|x| self.emit_extern_item_list(x));

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

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

id: TrapId::Star,

abi,

attrs,

extern_item_list,

is_unsafe,

});

self.emit_location(label, &node);

emit_detached!(ExternBlock, self, node, label);

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

label

}

pub(crate) fn emit_extern_crate(&mut self, node: ast::ExternCrate) -> Label<generated::ExternCrate> {

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

let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));

let rename = node.rename().map(|x| self.emit_rename(x));

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

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

id: TrapId::Star,

attrs,

name_ref,

rename,

visibility,

});

self.emit_location(label, &node);

emit_detached!(ExternCrate, self, node, label);

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

label

}

pub(crate) fn emit_extern_item_list(&mut self, node: ast::ExternItemList) -> Label<generated::ExternItemList> {

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

let extern_items = node.extern_items().map(|x| self.emit_extern_item(x)).collect();

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

id: TrapId::Star,

attrs,

extern_items,

});

self.emit_location(label, &node);

emit_detached!(ExternItemList, self, node, label);

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

label

}

pub(crate) fn emit_field_expr(&mut self, node: ast::FieldExpr) -> Label<generated::FieldExpr> {

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

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

let name_ref = node.name_ref().map(|x| self.emit_name_ref(x));

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

id: TrapId::Star,

attrs,

expr,

name_ref,

});

self.emit_location(label, &node);

emit_detached!(FieldExpr, self, node, label);

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

label

}

pub(crate) fn emit_fn(&mut self, node: ast::Fn) -> Label<generated::Function> {

let abi = node.abi().map(|x| self.emit_abi(x));

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

let body = node.body().map(|x| self.emit_block_expr(x));

let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));

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

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

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

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

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

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

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

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

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

let where_clause = node.where_clause().map(|x| self.emit_where_clause(x));

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

id: TrapId::Star,

abi,

attrs,

body,

generic_param_list,

is_async,

is_const,

is_default,

is_gen,

is_unsafe,

name,

param_list,

ret_type,

visibility,

where_clause,

});

self.emit_location(label, &node);

emit_detached!(Function, self, node, label);

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

label

}

pub(crate) fn emit_fn_ptr_type(&mut self, node: ast::FnPtrType) -> Label<generated::FnPtrType> {

let abi = node.abi().map(|x| self.emit_abi(x));

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

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

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

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

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

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

id: TrapId::Star,

abi,

is_async,

is_const,

is_unsafe,

param_list,

ret_type,

});

self.emit_location(label, &node);

emit_detached!(FnPtrType, self, node, label);

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

label

}

pub(crate) fn emit_for_expr(&mut self, node: ast::ForExpr) -> Label<generated::ForExpr> {

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

let iterable = node.iterable().map(|x| self.emit_expr(x));

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

let loop_body = node.loop_body().map(|x| self.emit_block_expr(x));

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

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

id: TrapId::Star,

attrs,

iterable,

label,

loop_body,

pat,

});

self.emit_location(label, &node);

emit_detached!(ForExpr, self, node, label);

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

label

}

pub(crate) fn emit_for_type(&mut self, node: ast::ForType) -> Label<generated::ForType> {

let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));

let ty = node.ty().map(|x| self.emit_type(x));

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

id: TrapId::Star,

generic_param_list,

ty,

});

self.emit_location(label, &node);

emit_detached!(ForType, self, node, label);

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

label

}

pub(crate) fn emit_format_args_arg(&mut self, node: ast::FormatArgsArg) -> Label<generated::FormatArgsArg> {

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

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

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

id: TrapId::Star,

expr,

name,

});

self.emit_location(label, &node);

emit_detached!(FormatArgsArg, self, node, label);

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

label

}

pub(crate) fn emit_format_args_expr(&mut self, node: ast::FormatArgsExpr) -> Label<generated::FormatArgsExpr> {

let args = node.args().map(|x| self.emit_format_args_arg(x)).collect();

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

let template = node.template().map(|x| self.emit_expr(x));

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

id: TrapId::Star,

args,

attrs,

template,

});

self.emit_location(label, &node);

emit_detached!(FormatArgsExpr, self, node, label);

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

label

}

pub(crate) fn emit_generic_arg_list(&mut self, node: ast::GenericArgList) -> Label<generated::GenericArgList> {

let generic_args = node.generic_args().map(|x| self.emit_generic_arg(x)).collect();

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

id: TrapId::Star,

generic_args,

});

self.emit_location(label, &node);

emit_detached!(GenericArgList, self, node, label);

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

label

}

pub(crate) fn emit_generic_param_list(&mut self, node: ast::GenericParamList) -> Label<generated::GenericParamList> {

let generic_params = node.generic_params().map(|x| self.emit_generic_param(x)).collect();

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

id: TrapId::Star,

generic_params,

});

self.emit_location(label, &node);

emit_detached!(GenericParamList, self, node, label);

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

label

}

pub(crate) fn emit_ident_pat(&mut self, node: ast::IdentPat) -> Label<generated::IdentPat> {

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

let is_mut = node.mut_token().is_some();

let is_ref = node.ref_token().is_some();

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

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

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

id: TrapId::Star,

attrs,

is_mut,

is_ref,

name,

pat,

});

self.emit_location(label, &node);

emit_detached!(IdentPat, self, node, label);

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

label

}

pub(crate) fn emit_if_expr(&mut self, node: ast::IfExpr) -> Label<generated::IfExpr> {

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

let condition = node.condition().map(|x| self.emit_expr(x));

let else_ = node.else_branch().map(|x| self.emit_else_branch(x));

let then = node.then_branch().map(|x| self.emit_block_expr(x));

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

id: TrapId::Star,

attrs,

condition,

else_,

then,

});

self.emit_location(label, &node);

emit_detached!(IfExpr, self, node, label);

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

label

}

pub(crate) fn emit_impl(&mut self, node: ast::Impl) -> Label<generated::Impl> {

let assoc_item_list = node.assoc_item_list().map(|x| self.emit_assoc_item_list(x));

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

let generic_param_list = node.generic_param_list().map(|x| self.emit_generic_param_list(x));

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

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

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

let self_ty = node.self_ty().map(|x| self.emit_type(x));

let trait_ = node.trait_().map(|x| self.emit_type(x));

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

let where_clause = node.where_clause().map(|x| self.emit_where_clause(x));

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

id: TrapId::Star,

assoc_item_list,

attrs,

generic_param_list,

is_const,

is_default,

is_unsafe,

self_ty,

trait_,

visibility,

where_clause,

});

self.emit_location(label, &node);

emit_detached!(Impl, self, node, label);

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

label

}

pub(crate) fn emit_impl_trait_type(&mut self, node: ast::ImplTraitType) -> Label<generated::ImplTraitType> {

let type_bound_list = node.type_bound_list().map(|x| self.emit_type_bound_list(x));

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

id: TrapId::Star,

type_bound_list,

});

self.emit_location(label, &node);

emit_detached!(ImplTraitType, self, node, label);

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

label

}

pub(crate) fn emit_index_expr(&mut self, node: ast::IndexExpr) -> Label<generated::IndexExpr> {

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

let base = node.base().map(|x| self.emit_expr(x));

let index = node.index().map(|x| self.emit_expr(x));

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

id: TrapId::Star,

attrs,

base,

index,

});

self.emit_location(label, &node);

emit_detached!(IndexExpr, self, node, label);

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

label

}

pub(crate) fn emit_infer_type(&mut self, node: ast::InferType) -> Label<generated::InferType> {

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

id: TrapId::Star,

});

self.emit_location(label, &node);

emit_detached!(InferType, self, node, label);

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

label

}

pub(crate) fn emit_item_list(&mut self, node: ast::ItemList) -> Label<generated::ItemList> {

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

let items = node.items().map(|x| self.emit_item(x)).collect();

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

id: TrapId::Star,

attrs,

items,

});

self.emit_location(label, &node);

emit_detached!(ItemList, self, node, label);

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

label

}

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

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

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

id: TrapId::Star,

lifetime,

});

self.emit_location(label, &node);

emit_detached!(Label, self, node, label);

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

label

}

pub(crate) fn emit_let_else(&mut self, node: ast::LetElse) -> Label<generated::LetElse> {

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

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

id: TrapId::Star,

block_expr,

});

self.emit_location(label, &node);

emit_detached!(LetElse, self, node, label);

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

label

}

pub(crate) fn emit_let_expr(&mut self, node: ast::LetExpr) -> Label<generated::LetExpr> {

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

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

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

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

id: TrapId::Star,

attrs,

expr,

pat,

});

self.emit_location(label, &node);

emit_detached!(LetExpr, self, node, label);

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

label

}

pub(crate) fn emit_let_stmt(&mut self, node: ast::LetStmt) -> Label<generated::LetStmt> {

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

let initializer = node.initializer().map(|x| self.emit_expr(x));

let let_else = node.let_else().map(|x| self.emit_let_else(x));

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

let ty = node.ty().map(|x| self.emit_type(x));

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

id: TrapId::Star,

attrs,

initializer,

let_else,

pat,

ty,

});

self.emit_location(label, &node);

emit_detached!(LetStmt, self, node, label);

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

label

}

pub(crate) fn emit_lifetime(&mut self, node: ast::Lifetime) -> Label<generated::Lifetime> {

let text = node.try_get_text();

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

id: TrapId::Star,

text,

});