Struct oxc_ast::ast_builder::AstBuilder

#[non_exhaustive]
pub struct AstBuilder<'a> {
    pub allocator: &'a Allocator,
}

AST builder for creating AST nodes

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

allocator: &'a Allocator

Implementations

impl<'a> AstBuilder<'a>

pub fn new(allocator: &'a Allocator) -> Self

pub fn alloc<T>(self, value: T) -> Box<'a, T>

pub fn vec<T>(self) -> Vec<'a, T>

pub fn vec_with_capacity<T>(self, capacity: usize) -> Vec<'a, T>

pub fn vec1<T>(self, value: T) -> Vec<'a, T>

pub fn vec_from_iter<T, I: IntoIterator<Item = T>>(self, iter: I) -> Vec<'a, T>

pub fn str(self, value: &str) -> &'a str

pub fn atom(self, value: &str) -> Atom<'a>

pub unsafe fn copy<T>(self, src: &T) -> T

SAFETY

This method is completely unsound and should not be used. We need to remove all uses of it. Please don’t add any more! https://github.com/oxc-project/oxc/issues/3483

pub fn move_expression(self, expr: &mut Expression<'a>) -> Expression<'a>

Moves the expression out by replacing it with a null expression.

pub fn move_statement(self, stmt: &mut Statement<'a>) -> Statement<'a>

pub fn move_assignment_target( self, target: &mut AssignmentTarget<'a>, ) -> AssignmentTarget<'a>

pub fn move_declaration(self, decl: &mut Declaration<'a>) -> Declaration<'a>

pub fn move_vec<T>(self, vec: &mut Vec<'a, T>) -> Vec<'a, T>

pub fn void_0(self) -> Expression<'a>

void 0

pub fn plain_formal_parameter( self, span: Span, pattern: BindingPattern<'a>, ) -> FormalParameter<'a>

pub fn plain_function( self, type: FunctionType, span: Span, id: Option<BindingIdentifier<'a>>, params: FormalParameters<'a>, body: Option<FunctionBody<'a>>, ) -> Box<'a, Function<'a>>

pub fn plain_export_named_declaration_declaration( self, span: Span, declaration: Declaration<'a>, ) -> Box<'a, ExportNamedDeclaration<'a>>

pub fn plain_export_named_declaration( self, span: Span, specifiers: Vec<'a, ExportSpecifier<'a>>, source: Option<StringLiteral<'a>>, ) -> Box<'a, ExportNamedDeclaration<'a>>

pub fn ts_interface_heritages( self, extends: Vec<'a, (Expression<'a>, Option<Box<'a, TSTypeParameterInstantiation<'a>>>, Span)>, ) -> Vec<'a, TSInterfaceHeritage<'a>>

pub fn jsx_opening_fragment(self, span: Span) -> JSXOpeningFragment

pub fn jsx_closing_fragment(self, span: Span) -> JSXClosingFragment

impl<'a> AstBuilder<'a>

pub fn boolean_literal(self, span: Span, value: bool) -> BooleanLiteral

Builds a BooleanLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_boolean_literal instead.

Parameters

• span: The Span covering this node
• value

pub fn alloc_boolean_literal( self, span: Span, value: bool, ) -> Box<'a, BooleanLiteral>

Builds a BooleanLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::boolean_literal instead.

Parameters

• span: The Span covering this node
• value

pub fn null_literal(self, span: Span) -> NullLiteral

Builds a NullLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_null_literal instead.

Parameters

• span: The Span covering this node

pub fn alloc_null_literal(self, span: Span) -> Box<'a, NullLiteral>

Builds a NullLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::null_literal instead.

Parameters

• span: The Span covering this node

pub fn numeric_literal<S>( self, span: Span, value: f64, raw: S, base: NumberBase, ) -> NumericLiteral<'a>

where S: IntoIn<'a, &'a str>,

Builds a NumericLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_numeric_literal instead.

Parameters

• span: The Span covering this node
• value: The value of the number, converted into base 10
• raw: The number as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn alloc_numeric_literal<S>( self, span: Span, value: f64, raw: S, base: NumberBase, ) -> Box<'a, NumericLiteral<'a>>

where S: IntoIn<'a, &'a str>,

Builds a NumericLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::numeric_literal instead.

Parameters

• span: The Span covering this node
• value: The value of the number, converted into base 10
• raw: The number as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn big_int_literal<A>( self, span: Span, raw: A, base: BigintBase, ) -> BigIntLiteral<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a BigIntLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_big_int_literal instead.

Parameters

• span: The Span covering this node
• raw: The bigint as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn alloc_big_int_literal<A>( self, span: Span, raw: A, base: BigintBase, ) -> Box<'a, BigIntLiteral<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a BigIntLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::big_int_literal instead.

Parameters

• span: The Span covering this node
• raw: The bigint as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn reg_exp_literal( self, span: Span, value: EmptyObject, regex: RegExp<'a>, ) -> RegExpLiteral<'a>

Builds a RegExpLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_reg_exp_literal instead.

Parameters

• span: The Span covering this node
• value
• regex

pub fn alloc_reg_exp_literal( self, span: Span, value: EmptyObject, regex: RegExp<'a>, ) -> Box<'a, RegExpLiteral<'a>>

Builds a RegExpLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::reg_exp_literal instead.

Parameters

• span: The Span covering this node
• value
• regex

pub fn string_literal<A>(self, span: Span, value: A) -> StringLiteral<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a StringLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_string_literal instead.

Parameters

• span: The Span covering this node
• value

pub fn alloc_string_literal<A>( self, span: Span, value: A, ) -> Box<'a, StringLiteral<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a StringLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::string_literal instead.

Parameters

• span: The Span covering this node
• value

pub fn program( self, span: Span, source_type: SourceType, hashbang: Option<Hashbang<'a>>, directives: Vec<'a, Directive<'a>>, body: Vec<'a, Statement<'a>>, ) -> Program<'a>

Builds a Program

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_program instead.

Parameters

• span: The Span covering this node
• source_type
• hashbang
• directives
• body

pub fn alloc_program( self, span: Span, source_type: SourceType, hashbang: Option<Hashbang<'a>>, directives: Vec<'a, Directive<'a>>, body: Vec<'a, Statement<'a>>, ) -> Box<'a, Program<'a>>

Builds a Program and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::program instead.

Parameters

• span: The Span covering this node
• source_type
• hashbang
• directives
• body

pub fn expression_boolean_literal( self, span: Span, value: bool, ) -> Expression<'a>

Build a Expression::BooleanLiteral

This node contains a BooleanLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value

pub fn expression_from_boolean_literal<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, BooleanLiteral>>,

Convert a BooleanLiteral into a Expression::BooleanLiteral

pub fn expression_null_literal(self, span: Span) -> Expression<'a>

Build a Expression::NullLiteral

This node contains a NullLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn expression_from_null_literal<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, NullLiteral>>,

Convert a NullLiteral into a Expression::NullLiteral

pub fn expression_numeric_literal<S>( self, span: Span, value: f64, raw: S, base: NumberBase, ) -> Expression<'a>

where S: IntoIn<'a, &'a str>,

Build a Expression::NumericLiteral

This node contains a NumericLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value: The value of the number, converted into base 10
• raw: The number as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn expression_from_numeric_literal<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, NumericLiteral<'a>>>,

Convert a NumericLiteral into a Expression::NumericLiteral

pub fn expression_big_int_literal<A>( self, span: Span, raw: A, base: BigintBase, ) -> Expression<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a Expression::BigIntLiteral

This node contains a BigIntLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• raw: The bigint as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn expression_from_big_int_literal<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, BigIntLiteral<'a>>>,

Convert a BigIntLiteral into a Expression::BigIntLiteral

pub fn expression_reg_exp_literal( self, span: Span, value: EmptyObject, regex: RegExp<'a>, ) -> Expression<'a>

Build a Expression::RegExpLiteral

This node contains a RegExpLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value
• regex

pub fn expression_from_reg_exp_literal<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, RegExpLiteral<'a>>>,

Convert a RegExpLiteral into a Expression::RegExpLiteral

pub fn expression_string_literal<A>( self, span: Span, value: A, ) -> Expression<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a Expression::StringLiteral

This node contains a StringLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value

pub fn expression_from_string_literal<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, StringLiteral<'a>>>,

Convert a StringLiteral into a Expression::StringLiteral

pub fn expression_template_literal( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, expressions: Vec<'a, Expression<'a>>, ) -> Expression<'a>

Build a Expression::TemplateLiteral

This node contains a TemplateLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• quasis
• expressions

pub fn expression_from_template_literal<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, TemplateLiteral<'a>>>,

Convert a TemplateLiteral into a Expression::TemplateLiteral

pub fn expression_identifier_reference<A>( self, span: Span, name: A, ) -> Expression<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a Expression::Identifier

This node contains a IdentifierReference that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The name of the identifier being referenced.

pub fn expression_from_identifier_reference<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, IdentifierReference<'a>>>,

Convert a IdentifierReference into a Expression::Identifier

pub fn expression_meta_property( self, span: Span, meta: IdentifierName<'a>, property: IdentifierName<'a>, ) -> Expression<'a>

Build a Expression::MetaProperty

This node contains a MetaProperty that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• meta
• property

pub fn expression_from_meta_property<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, MetaProperty<'a>>>,

Convert a MetaProperty into a Expression::MetaProperty

pub fn expression_super(self, span: Span) -> Expression<'a>

Build a Expression::Super

This node contains a Super that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn expression_from_super<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, Super>>,

Convert a Super into a Expression::Super

pub fn expression_array( self, span: Span, elements: Vec<'a, ArrayExpressionElement<'a>>, trailing_comma: Option<Span>, ) -> Expression<'a>

Build a Expression::ArrayExpression

This node contains a ArrayExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• elements
• trailing_comma: Array trailing comma

pub fn expression_from_array<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ArrayExpression<'a>>>,

Convert a ArrayExpression into a Expression::ArrayExpression

pub fn expression_arrow_function<T1, T2, T3, T4>( self, span: Span, expression: bool, async: bool, type_parameters: T1, params: T2, return_type: T3, body: T4, ) -> Expression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Box<'a, FunctionBody<'a>>>,

Build a Expression::ArrowFunctionExpression

This node contains a ArrowFunctionExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression: Is the function body an arrow expression? i.e. () => expr instead of () => {}
• r#async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.

pub fn expression_from_arrow_function<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ArrowFunctionExpression<'a>>>,

Convert a ArrowFunctionExpression into a Expression::ArrowFunctionExpression

pub fn expression_assignment( self, span: Span, operator: AssignmentOperator, left: AssignmentTarget<'a>, right: Expression<'a>, ) -> Expression<'a>

Build a Expression::AssignmentExpression

This node contains a AssignmentExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• operator
• left
• right

pub fn expression_from_assignment<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, AssignmentExpression<'a>>>,

Convert a AssignmentExpression into a Expression::AssignmentExpression

pub fn expression_await( self, span: Span, argument: Expression<'a>, ) -> Expression<'a>

Build a Expression::AwaitExpression

This node contains a AwaitExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• argument

pub fn expression_from_await<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, AwaitExpression<'a>>>,

Convert a AwaitExpression into a Expression::AwaitExpression

pub fn expression_binary( self, span: Span, left: Expression<'a>, operator: BinaryOperator, right: Expression<'a>, ) -> Expression<'a>

Build a Expression::BinaryExpression

This node contains a BinaryExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn expression_from_binary<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, BinaryExpression<'a>>>,

Convert a BinaryExpression into a Expression::BinaryExpression

pub fn expression_call<T1>( self, span: Span, callee: Expression<'a>, type_parameters: T1, arguments: Vec<'a, Argument<'a>>, optional: bool, ) -> Expression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a Expression::CallExpression

This node contains a CallExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• callee
• type_parameters
• arguments
• optional

pub fn expression_from_call<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, CallExpression<'a>>>,

Convert a CallExpression into a Expression::CallExpression

pub fn expression_chain( self, span: Span, expression: ChainElement<'a>, ) -> Expression<'a>

Build a Expression::ChainExpression

This node contains a ChainExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression

pub fn expression_from_chain<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ChainExpression<'a>>>,

Convert a ChainExpression into a Expression::ChainExpression

pub fn expression_class<T1, T2, T3>( self, type: ClassType, span: Span, decorators: Vec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_parameters: T2, implements: Option<Vec<'a, TSClassImplements<'a>>>, body: T3, abstract: bool, declare: bool, ) -> Expression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>, T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,

Build a Expression::ClassExpression

This node contains a Class that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the class.
• id: Class identifier, AKA the name
• type_parameters
• super_class: Super class. When present, this will usually be an IdentifierReference.
• super_type_parameters: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• r#abstract: Whether the class is abstract
• declare: Whether the class was declareed

pub fn expression_from_class<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, Class<'a>>>,

Convert a Class into a Expression::ClassExpression

pub fn expression_conditional( self, span: Span, test: Expression<'a>, consequent: Expression<'a>, alternate: Expression<'a>, ) -> Expression<'a>

Build a Expression::ConditionalExpression

This node contains a ConditionalExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• test
• consequent
• alternate

pub fn expression_from_conditional<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ConditionalExpression<'a>>>,

Convert a ConditionalExpression into a Expression::ConditionalExpression

pub fn expression_function<T1, T2, T3, T4>( self, type: FunctionType, span: Span, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: Option<TSThisParameter<'a>>, params: T2, return_type: T3, body: T4, ) -> Expression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Option<Box<'a, FunctionBody<'a>>>>,

Build a Expression::FunctionExpression

This node contains a Function that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• id
• generator
• r#async
• declare
• type_parameters
• this_param: Declaring this in a Function https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function
• params
• return_type
• body

pub fn expression_from_function<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, Function<'a>>>,

Convert a Function into a Expression::FunctionExpression

pub fn expression_import( self, span: Span, source: Expression<'a>, arguments: Vec<'a, Expression<'a>>, ) -> Expression<'a>

Build a Expression::ImportExpression

This node contains a ImportExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• source
• arguments

pub fn expression_from_import<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ImportExpression<'a>>>,

Convert a ImportExpression into a Expression::ImportExpression

pub fn expression_logical( self, span: Span, left: Expression<'a>, operator: LogicalOperator, right: Expression<'a>, ) -> Expression<'a>

Build a Expression::LogicalExpression

This node contains a LogicalExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn expression_from_logical<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, LogicalExpression<'a>>>,

Convert a LogicalExpression into a Expression::LogicalExpression

pub fn expression_new<T1>( self, span: Span, callee: Expression<'a>, arguments: Vec<'a, Argument<'a>>, type_parameters: T1, ) -> Expression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a Expression::NewExpression

This node contains a NewExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• callee
• arguments
• type_parameters

pub fn expression_from_new<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, NewExpression<'a>>>,

Convert a NewExpression into a Expression::NewExpression

pub fn expression_object( self, span: Span, properties: Vec<'a, ObjectPropertyKind<'a>>, trailing_comma: Option<Span>, ) -> Expression<'a>

Build a Expression::ObjectExpression

This node contains a ObjectExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• properties: Properties declared in the object
• trailing_comma

pub fn expression_from_object<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ObjectExpression<'a>>>,

Convert a ObjectExpression into a Expression::ObjectExpression

pub fn expression_parenthesized( self, span: Span, expression: Expression<'a>, ) -> Expression<'a>

Build a Expression::ParenthesizedExpression

This node contains a ParenthesizedExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression

pub fn expression_from_parenthesized<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ParenthesizedExpression<'a>>>,

Convert a ParenthesizedExpression into a Expression::ParenthesizedExpression

pub fn expression_sequence( self, span: Span, expressions: Vec<'a, Expression<'a>>, ) -> Expression<'a>

Build a Expression::SequenceExpression

This node contains a SequenceExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expressions

pub fn expression_from_sequence<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, SequenceExpression<'a>>>,

Convert a SequenceExpression into a Expression::SequenceExpression

pub fn expression_tagged_template<T1>( self, span: Span, tag: Expression<'a>, quasi: TemplateLiteral<'a>, type_parameters: T1, ) -> Expression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a Expression::TaggedTemplateExpression

This node contains a TaggedTemplateExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• tag
• quasi
• type_parameters

pub fn expression_from_tagged_template<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, TaggedTemplateExpression<'a>>>,

Convert a TaggedTemplateExpression into a Expression::TaggedTemplateExpression

pub fn expression_this(self, span: Span) -> Expression<'a>

Build a Expression::ThisExpression

This node contains a ThisExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn expression_from_this<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, ThisExpression>>,

Convert a ThisExpression into a Expression::ThisExpression

pub fn expression_unary( self, span: Span, operator: UnaryOperator, argument: Expression<'a>, ) -> Expression<'a>

Build a Expression::UnaryExpression

This node contains a UnaryExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• operator
• argument

pub fn expression_from_unary<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, UnaryExpression<'a>>>,

Convert a UnaryExpression into a Expression::UnaryExpression

pub fn expression_update( self, span: Span, operator: UpdateOperator, prefix: bool, argument: SimpleAssignmentTarget<'a>, ) -> Expression<'a>

Build a Expression::UpdateExpression

This node contains a UpdateExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• operator
• prefix
• argument

pub fn expression_from_update<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, UpdateExpression<'a>>>,

Convert a UpdateExpression into a Expression::UpdateExpression

pub fn expression_yield( self, span: Span, delegate: bool, argument: Option<Expression<'a>>, ) -> Expression<'a>

Build a Expression::YieldExpression

This node contains a YieldExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• delegate
• argument

pub fn expression_from_yield<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, YieldExpression<'a>>>,

Convert a YieldExpression into a Expression::YieldExpression

pub fn expression_private_in( self, span: Span, left: PrivateIdentifier<'a>, operator: BinaryOperator, right: Expression<'a>, ) -> Expression<'a>

Build a Expression::PrivateInExpression

This node contains a PrivateInExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn expression_from_private_in<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, PrivateInExpression<'a>>>,

Convert a PrivateInExpression into a Expression::PrivateInExpression

pub fn expression_jsx_element<T1, T2>( self, span: Span, opening_element: T1, closing_element: T2, children: Vec<'a, JSXChild<'a>>, ) -> Expression<'a>

where T1: IntoIn<'a, Box<'a, JSXOpeningElement<'a>>>, T2: IntoIn<'a, Option<Box<'a, JSXClosingElement<'a>>>>,

Build a Expression::JSXElement

This node contains a JSXElement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• opening_element: Opening tag of the element.
• closing_element: Closing tag of the element. Will be None for self-closing tags.
• children: Children of the element. This can be text, other elements, or expressions.

pub fn expression_from_jsx_element<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, JSXElement<'a>>>,

Convert a JSXElement into a Expression::JSXElement

pub fn expression_jsx_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, closing_fragment: JSXClosingFragment, children: Vec<'a, JSXChild<'a>>, ) -> Expression<'a>

Build a Expression::JSXFragment

This node contains a JSXFragment that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• opening_fragment: <>
• closing_fragment: </>
• children: Elements inside the fragment.

pub fn expression_from_jsx_fragment<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, JSXFragment<'a>>>,

Convert a JSXFragment into a Expression::JSXFragment

pub fn expression_ts_as( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> Expression<'a>

Build a Expression::TSAsExpression

This node contains a TSAsExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn expression_from_ts_as<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, TSAsExpression<'a>>>,

Convert a TSAsExpression into a Expression::TSAsExpression

pub fn expression_ts_satisfies( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> Expression<'a>

Build a Expression::TSSatisfiesExpression

This node contains a TSSatisfiesExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn expression_from_ts_satisfies<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, TSSatisfiesExpression<'a>>>,

Convert a TSSatisfiesExpression into a Expression::TSSatisfiesExpression

pub fn expression_ts_type_assertion( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> Expression<'a>

Build a Expression::TSTypeAssertion

This node contains a TSTypeAssertion that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn expression_from_ts_type_assertion<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, TSTypeAssertion<'a>>>,

Convert a TSTypeAssertion into a Expression::TSTypeAssertion

pub fn expression_ts_non_null( self, span: Span, expression: Expression<'a>, ) -> Expression<'a>

Build a Expression::TSNonNullExpression

This node contains a TSNonNullExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression

pub fn expression_from_ts_non_null<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, TSNonNullExpression<'a>>>,

Convert a TSNonNullExpression into a Expression::TSNonNullExpression

pub fn expression_ts_instantiation<T1>( self, span: Span, expression: Expression<'a>, type_parameters: T1, ) -> Expression<'a>

where T1: IntoIn<'a, Box<'a, TSTypeParameterInstantiation<'a>>>,

Build a Expression::TSInstantiationExpression

This node contains a TSInstantiationExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn expression_from_ts_instantiation<T>(self, inner: T) -> Expression<'a>

where T: IntoIn<'a, Box<'a, TSInstantiationExpression<'a>>>,

Convert a TSInstantiationExpression into a Expression::TSInstantiationExpression

pub fn expression_member(self, inner: MemberExpression<'a>) -> Expression<'a>

pub fn identifier_name<A>(self, span: Span, name: A) -> IdentifierName<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a IdentifierName

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_identifier_name instead.

Parameters

• span: The Span covering this node
• name

pub fn alloc_identifier_name<A>( self, span: Span, name: A, ) -> Box<'a, IdentifierName<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a IdentifierName and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::identifier_name instead.

Parameters

• span: The Span covering this node
• name

pub fn identifier_reference<A>( self, span: Span, name: A, ) -> IdentifierReference<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a IdentifierReference

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_identifier_reference instead.

Parameters

• span: The Span covering this node
• name: The name of the identifier being referenced.

pub fn alloc_identifier_reference<A>( self, span: Span, name: A, ) -> Box<'a, IdentifierReference<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a IdentifierReference and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::identifier_reference instead.

Parameters

• span: The Span covering this node
• name: The name of the identifier being referenced.

pub fn binding_identifier<A>(self, span: Span, name: A) -> BindingIdentifier<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a BindingIdentifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_binding_identifier instead.

Parameters

• span: The Span covering this node
• name: The identifier name being bound.

pub fn alloc_binding_identifier<A>( self, span: Span, name: A, ) -> Box<'a, BindingIdentifier<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a BindingIdentifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::binding_identifier instead.

Parameters

• span: The Span covering this node
• name: The identifier name being bound.

pub fn label_identifier<A>(self, span: Span, name: A) -> LabelIdentifier<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a LabelIdentifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_label_identifier instead.

Parameters

• span: The Span covering this node
• name

pub fn alloc_label_identifier<A>( self, span: Span, name: A, ) -> Box<'a, LabelIdentifier<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a LabelIdentifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::label_identifier instead.

Parameters

• span: The Span covering this node
• name

pub fn this_expression(self, span: Span) -> ThisExpression

Builds a ThisExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_this_expression instead.

Parameters

• span: The Span covering this node

pub fn alloc_this_expression(self, span: Span) -> Box<'a, ThisExpression>

Builds a ThisExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::this_expression instead.

Parameters

• span: The Span covering this node

pub fn array_expression( self, span: Span, elements: Vec<'a, ArrayExpressionElement<'a>>, trailing_comma: Option<Span>, ) -> ArrayExpression<'a>

Builds a ArrayExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_array_expression instead.

Parameters

• span: The Span covering this node
• elements
• trailing_comma: Array trailing comma

pub fn alloc_array_expression( self, span: Span, elements: Vec<'a, ArrayExpressionElement<'a>>, trailing_comma: Option<Span>, ) -> Box<'a, ArrayExpression<'a>>

Builds a ArrayExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::array_expression instead.

Parameters

• span: The Span covering this node
• elements
• trailing_comma: Array trailing comma

pub fn array_expression_element_spread_element( self, span: Span, argument: Expression<'a>, ) -> ArrayExpressionElement<'a>

Build a ArrayExpressionElement::SpreadElement

This node contains a SpreadElement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• argument: The expression being spread.

pub fn array_expression_element_from_spread_element<T>( self, inner: T, ) -> ArrayExpressionElement<'a>

where T: IntoIn<'a, Box<'a, SpreadElement<'a>>>,

Convert a SpreadElement into a ArrayExpressionElement::SpreadElement

pub fn array_expression_element_elision( self, span: Span, ) -> ArrayExpressionElement<'a>

Build a ArrayExpressionElement::Elision

Parameters

• span: The Span covering this node

pub fn array_expression_element_from_elision<T>( self, inner: T, ) -> ArrayExpressionElement<'a>

where T: IntoIn<'a, Elision>,

Convert a Elision into a ArrayExpressionElement::Elision

pub fn array_expression_element_expression( self, inner: Expression<'a>, ) -> ArrayExpressionElement<'a>

pub fn elision(self, span: Span) -> Elision

Builds a Elision

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_elision instead.

Parameters

• span: The Span covering this node

pub fn alloc_elision(self, span: Span) -> Box<'a, Elision>

Builds a Elision and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::elision instead.

Parameters

• span: The Span covering this node

pub fn object_expression( self, span: Span, properties: Vec<'a, ObjectPropertyKind<'a>>, trailing_comma: Option<Span>, ) -> ObjectExpression<'a>

Builds a ObjectExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_object_expression instead.

Parameters

• span: The Span covering this node
• properties: Properties declared in the object
• trailing_comma

pub fn alloc_object_expression( self, span: Span, properties: Vec<'a, ObjectPropertyKind<'a>>, trailing_comma: Option<Span>, ) -> Box<'a, ObjectExpression<'a>>

Builds a ObjectExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::object_expression instead.

Parameters

• span: The Span covering this node
• properties: Properties declared in the object
• trailing_comma

pub fn object_property_kind_object_property( self, span: Span, kind: PropertyKind, key: PropertyKey<'a>, value: Expression<'a>, init: Option<Expression<'a>>, method: bool, shorthand: bool, computed: bool, ) -> ObjectPropertyKind<'a>

Build a ObjectPropertyKind::ObjectProperty

This node contains a ObjectProperty that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• kind
• key
• value
• init
• method
• shorthand
• computed

pub fn object_property_kind_from_object_property<T>( self, inner: T, ) -> ObjectPropertyKind<'a>

where T: IntoIn<'a, Box<'a, ObjectProperty<'a>>>,

Convert a ObjectProperty into a ObjectPropertyKind::ObjectProperty

pub fn object_property_kind_spread_element( self, span: Span, argument: Expression<'a>, ) -> ObjectPropertyKind<'a>

Build a ObjectPropertyKind::SpreadProperty

This node contains a SpreadElement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• argument: The expression being spread.

pub fn object_property_kind_from_spread_element<T>( self, inner: T, ) -> ObjectPropertyKind<'a>

where T: IntoIn<'a, Box<'a, SpreadElement<'a>>>,

Convert a SpreadElement into a ObjectPropertyKind::SpreadProperty

pub fn object_property( self, span: Span, kind: PropertyKind, key: PropertyKey<'a>, value: Expression<'a>, init: Option<Expression<'a>>, method: bool, shorthand: bool, computed: bool, ) -> ObjectProperty<'a>

Builds a ObjectProperty

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_object_property instead.

Parameters

• span: The Span covering this node
• kind
• key
• value
• init
• method
• shorthand
• computed

pub fn alloc_object_property( self, span: Span, kind: PropertyKind, key: PropertyKey<'a>, value: Expression<'a>, init: Option<Expression<'a>>, method: bool, shorthand: bool, computed: bool, ) -> Box<'a, ObjectProperty<'a>>

Builds a ObjectProperty and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::object_property instead.

Parameters

• span: The Span covering this node
• kind
• key
• value
• init
• method
• shorthand
• computed

pub fn property_key_identifier_name<A>( self, span: Span, name: A, ) -> PropertyKey<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a PropertyKey::StaticIdentifier

This node contains a IdentifierName that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name

pub fn property_key_from_identifier_name<T>(self, inner: T) -> PropertyKey<'a>

where T: IntoIn<'a, Box<'a, IdentifierName<'a>>>,

Convert a IdentifierName into a PropertyKey::StaticIdentifier

pub fn property_key_private_identifier<A>( self, span: Span, name: A, ) -> PropertyKey<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a PropertyKey::PrivateIdentifier

This node contains a PrivateIdentifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name

pub fn property_key_from_private_identifier<T>( self, inner: T, ) -> PropertyKey<'a>

where T: IntoIn<'a, Box<'a, PrivateIdentifier<'a>>>,

Convert a PrivateIdentifier into a PropertyKey::PrivateIdentifier

pub fn property_key_expression(self, inner: Expression<'a>) -> PropertyKey<'a>

pub fn template_literal( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, expressions: Vec<'a, Expression<'a>>, ) -> TemplateLiteral<'a>

Builds a TemplateLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_template_literal instead.

Parameters

• span: The Span covering this node
• quasis
• expressions

pub fn alloc_template_literal( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, expressions: Vec<'a, Expression<'a>>, ) -> Box<'a, TemplateLiteral<'a>>

Builds a TemplateLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::template_literal instead.

Parameters

• span: The Span covering this node
• quasis
• expressions

pub fn tagged_template_expression<T1>( self, span: Span, tag: Expression<'a>, quasi: TemplateLiteral<'a>, type_parameters: T1, ) -> TaggedTemplateExpression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TaggedTemplateExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_tagged_template_expression instead.

Parameters

• span: The Span covering this node
• tag
• quasi
• type_parameters

pub fn alloc_tagged_template_expression<T1>( self, span: Span, tag: Expression<'a>, quasi: TemplateLiteral<'a>, type_parameters: T1, ) -> Box<'a, TaggedTemplateExpression<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TaggedTemplateExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::tagged_template_expression instead.

Parameters

• span: The Span covering this node
• tag
• quasi
• type_parameters

pub fn template_element( self, span: Span, tail: bool, value: TemplateElementValue<'a>, ) -> TemplateElement<'a>

Builds a TemplateElement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_template_element instead.

Parameters

• span: The Span covering this node
• tail
• value

pub fn alloc_template_element( self, span: Span, tail: bool, value: TemplateElementValue<'a>, ) -> Box<'a, TemplateElement<'a>>

Builds a TemplateElement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::template_element instead.

Parameters

• span: The Span covering this node
• tail
• value

pub fn member_expression_computed( self, span: Span, object: Expression<'a>, expression: Expression<'a>, optional: bool, ) -> MemberExpression<'a>

Build a MemberExpression::ComputedMemberExpression

This node contains a ComputedMemberExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• object
• expression
• optional

pub fn member_expression_from_computed<T>( self, inner: T, ) -> MemberExpression<'a>

where T: IntoIn<'a, Box<'a, ComputedMemberExpression<'a>>>,

Convert a ComputedMemberExpression into a MemberExpression::ComputedMemberExpression

pub fn member_expression_static( self, span: Span, object: Expression<'a>, property: IdentifierName<'a>, optional: bool, ) -> MemberExpression<'a>

Build a MemberExpression::StaticMemberExpression

This node contains a StaticMemberExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• object
• property
• optional

pub fn member_expression_from_static<T>(self, inner: T) -> MemberExpression<'a>

where T: IntoIn<'a, Box<'a, StaticMemberExpression<'a>>>,

Convert a StaticMemberExpression into a MemberExpression::StaticMemberExpression

pub fn member_expression_private_field_expression( self, span: Span, object: Expression<'a>, field: PrivateIdentifier<'a>, optional: bool, ) -> MemberExpression<'a>

Build a MemberExpression::PrivateFieldExpression

This node contains a PrivateFieldExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• object
• field
• optional

pub fn member_expression_from_private_field_expression<T>( self, inner: T, ) -> MemberExpression<'a>

where T: IntoIn<'a, Box<'a, PrivateFieldExpression<'a>>>,

Convert a PrivateFieldExpression into a MemberExpression::PrivateFieldExpression

pub fn computed_member_expression( self, span: Span, object: Expression<'a>, expression: Expression<'a>, optional: bool, ) -> ComputedMemberExpression<'a>

Builds a ComputedMemberExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_computed_member_expression instead.

Parameters

• span: The Span covering this node
• object
• expression
• optional

pub fn alloc_computed_member_expression( self, span: Span, object: Expression<'a>, expression: Expression<'a>, optional: bool, ) -> Box<'a, ComputedMemberExpression<'a>>

Builds a ComputedMemberExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::computed_member_expression instead.

Parameters

• span: The Span covering this node
• object
• expression
• optional

pub fn static_member_expression( self, span: Span, object: Expression<'a>, property: IdentifierName<'a>, optional: bool, ) -> StaticMemberExpression<'a>

Builds a StaticMemberExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_static_member_expression instead.

Parameters

• span: The Span covering this node
• object
• property
• optional

pub fn alloc_static_member_expression( self, span: Span, object: Expression<'a>, property: IdentifierName<'a>, optional: bool, ) -> Box<'a, StaticMemberExpression<'a>>

Builds a StaticMemberExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::static_member_expression instead.

Parameters

• span: The Span covering this node
• object
• property
• optional

pub fn private_field_expression( self, span: Span, object: Expression<'a>, field: PrivateIdentifier<'a>, optional: bool, ) -> PrivateFieldExpression<'a>

Builds a PrivateFieldExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_private_field_expression instead.

Parameters

• span: The Span covering this node
• object
• field
• optional

pub fn alloc_private_field_expression( self, span: Span, object: Expression<'a>, field: PrivateIdentifier<'a>, optional: bool, ) -> Box<'a, PrivateFieldExpression<'a>>

Builds a PrivateFieldExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::private_field_expression instead.

Parameters

• span: The Span covering this node
• object
• field
• optional

pub fn call_expression<T1>( self, span: Span, callee: Expression<'a>, type_parameters: T1, arguments: Vec<'a, Argument<'a>>, optional: bool, ) -> CallExpression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a CallExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_call_expression instead.

Parameters

• span: The Span covering this node
• callee
• type_parameters
• arguments
• optional

pub fn alloc_call_expression<T1>( self, span: Span, callee: Expression<'a>, type_parameters: T1, arguments: Vec<'a, Argument<'a>>, optional: bool, ) -> Box<'a, CallExpression<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a CallExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::call_expression instead.

Parameters

• span: The Span covering this node
• callee
• type_parameters
• arguments
• optional

pub fn new_expression<T1>( self, span: Span, callee: Expression<'a>, arguments: Vec<'a, Argument<'a>>, type_parameters: T1, ) -> NewExpression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a NewExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_new_expression instead.

Parameters

• span: The Span covering this node
• callee
• arguments
• type_parameters

pub fn alloc_new_expression<T1>( self, span: Span, callee: Expression<'a>, arguments: Vec<'a, Argument<'a>>, type_parameters: T1, ) -> Box<'a, NewExpression<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a NewExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::new_expression instead.

Parameters

• span: The Span covering this node
• callee
• arguments
• type_parameters

pub fn meta_property( self, span: Span, meta: IdentifierName<'a>, property: IdentifierName<'a>, ) -> MetaProperty<'a>

Builds a MetaProperty

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_meta_property instead.

Parameters

• span: The Span covering this node
• meta
• property

pub fn alloc_meta_property( self, span: Span, meta: IdentifierName<'a>, property: IdentifierName<'a>, ) -> Box<'a, MetaProperty<'a>>

Builds a MetaProperty and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::meta_property instead.

Parameters

• span: The Span covering this node
• meta
• property

pub fn spread_element( self, span: Span, argument: Expression<'a>, ) -> SpreadElement<'a>

Builds a SpreadElement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_spread_element instead.

Parameters

• span: The Span covering this node
• argument: The expression being spread.

pub fn alloc_spread_element( self, span: Span, argument: Expression<'a>, ) -> Box<'a, SpreadElement<'a>>

Builds a SpreadElement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::spread_element instead.

Parameters

• span: The Span covering this node
• argument: The expression being spread.

pub fn argument_spread_element( self, span: Span, argument: Expression<'a>, ) -> Argument<'a>

Build a Argument::SpreadElement

This node contains a SpreadElement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• argument: The expression being spread.

pub fn argument_from_spread_element<T>(self, inner: T) -> Argument<'a>

where T: IntoIn<'a, Box<'a, SpreadElement<'a>>>,

Convert a SpreadElement into a Argument::SpreadElement

pub fn argument_expression(self, inner: Expression<'a>) -> Argument<'a>

pub fn update_expression( self, span: Span, operator: UpdateOperator, prefix: bool, argument: SimpleAssignmentTarget<'a>, ) -> UpdateExpression<'a>

Builds a UpdateExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_update_expression instead.

Parameters

• span: The Span covering this node
• operator
• prefix
• argument

pub fn alloc_update_expression( self, span: Span, operator: UpdateOperator, prefix: bool, argument: SimpleAssignmentTarget<'a>, ) -> Box<'a, UpdateExpression<'a>>

Builds a UpdateExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::update_expression instead.

Parameters

• span: The Span covering this node
• operator
• prefix
• argument

pub fn unary_expression( self, span: Span, operator: UnaryOperator, argument: Expression<'a>, ) -> UnaryExpression<'a>

Builds a UnaryExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_unary_expression instead.

Parameters

• span: The Span covering this node
• operator
• argument

pub fn alloc_unary_expression( self, span: Span, operator: UnaryOperator, argument: Expression<'a>, ) -> Box<'a, UnaryExpression<'a>>

Builds a UnaryExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::unary_expression instead.

Parameters

• span: The Span covering this node
• operator
• argument

pub fn binary_expression( self, span: Span, left: Expression<'a>, operator: BinaryOperator, right: Expression<'a>, ) -> BinaryExpression<'a>

Builds a BinaryExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_binary_expression instead.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn alloc_binary_expression( self, span: Span, left: Expression<'a>, operator: BinaryOperator, right: Expression<'a>, ) -> Box<'a, BinaryExpression<'a>>

Builds a BinaryExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::binary_expression instead.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn private_in_expression( self, span: Span, left: PrivateIdentifier<'a>, operator: BinaryOperator, right: Expression<'a>, ) -> PrivateInExpression<'a>

Builds a PrivateInExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_private_in_expression instead.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn alloc_private_in_expression( self, span: Span, left: PrivateIdentifier<'a>, operator: BinaryOperator, right: Expression<'a>, ) -> Box<'a, PrivateInExpression<'a>>

Builds a PrivateInExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::private_in_expression instead.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn logical_expression( self, span: Span, left: Expression<'a>, operator: LogicalOperator, right: Expression<'a>, ) -> LogicalExpression<'a>

Builds a LogicalExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_logical_expression instead.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn alloc_logical_expression( self, span: Span, left: Expression<'a>, operator: LogicalOperator, right: Expression<'a>, ) -> Box<'a, LogicalExpression<'a>>

Builds a LogicalExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::logical_expression instead.

Parameters

• span: The Span covering this node
• left
• operator
• right

pub fn conditional_expression( self, span: Span, test: Expression<'a>, consequent: Expression<'a>, alternate: Expression<'a>, ) -> ConditionalExpression<'a>

Builds a ConditionalExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_conditional_expression instead.

Parameters

• span: The Span covering this node
• test
• consequent
• alternate

pub fn alloc_conditional_expression( self, span: Span, test: Expression<'a>, consequent: Expression<'a>, alternate: Expression<'a>, ) -> Box<'a, ConditionalExpression<'a>>

Builds a ConditionalExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::conditional_expression instead.

Parameters

• span: The Span covering this node
• test
• consequent
• alternate

pub fn assignment_expression( self, span: Span, operator: AssignmentOperator, left: AssignmentTarget<'a>, right: Expression<'a>, ) -> AssignmentExpression<'a>

Builds a AssignmentExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_assignment_expression instead.

Parameters

• span: The Span covering this node
• operator
• left
• right

pub fn alloc_assignment_expression( self, span: Span, operator: AssignmentOperator, left: AssignmentTarget<'a>, right: Expression<'a>, ) -> Box<'a, AssignmentExpression<'a>>

Builds a AssignmentExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::assignment_expression instead.

Parameters

• span: The Span covering this node
• operator
• left
• right

pub fn assignment_target_simple( self, inner: SimpleAssignmentTarget<'a>, ) -> AssignmentTarget<'a>

pub fn assignment_target_assignment_target_pattern( self, inner: AssignmentTargetPattern<'a>, ) -> AssignmentTarget<'a>

pub fn simple_assignment_target_identifier_reference<A>( self, span: Span, name: A, ) -> SimpleAssignmentTarget<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a SimpleAssignmentTarget::AssignmentTargetIdentifier

This node contains a IdentifierReference that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The name of the identifier being referenced.

pub fn simple_assignment_target_from_identifier_reference<T>( self, inner: T, ) -> SimpleAssignmentTarget<'a>

where T: IntoIn<'a, Box<'a, IdentifierReference<'a>>>,

Convert a IdentifierReference into a SimpleAssignmentTarget::AssignmentTargetIdentifier

pub fn simple_assignment_target_ts_as_expression( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> SimpleAssignmentTarget<'a>

Build a SimpleAssignmentTarget::TSAsExpression

This node contains a TSAsExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn simple_assignment_target_from_ts_as_expression<T>( self, inner: T, ) -> SimpleAssignmentTarget<'a>

where T: IntoIn<'a, Box<'a, TSAsExpression<'a>>>,

Convert a TSAsExpression into a SimpleAssignmentTarget::TSAsExpression

pub fn simple_assignment_target_ts_satisfies_expression( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> SimpleAssignmentTarget<'a>

Build a SimpleAssignmentTarget::TSSatisfiesExpression

This node contains a TSSatisfiesExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn simple_assignment_target_from_ts_satisfies_expression<T>( self, inner: T, ) -> SimpleAssignmentTarget<'a>

where T: IntoIn<'a, Box<'a, TSSatisfiesExpression<'a>>>,

Convert a TSSatisfiesExpression into a SimpleAssignmentTarget::TSSatisfiesExpression

pub fn simple_assignment_target_ts_non_null_expression( self, span: Span, expression: Expression<'a>, ) -> SimpleAssignmentTarget<'a>

Build a SimpleAssignmentTarget::TSNonNullExpression

This node contains a TSNonNullExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression

pub fn simple_assignment_target_from_ts_non_null_expression<T>( self, inner: T, ) -> SimpleAssignmentTarget<'a>

where T: IntoIn<'a, Box<'a, TSNonNullExpression<'a>>>,

Convert a TSNonNullExpression into a SimpleAssignmentTarget::TSNonNullExpression

pub fn simple_assignment_target_ts_type_assertion( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> SimpleAssignmentTarget<'a>

Build a SimpleAssignmentTarget::TSTypeAssertion

This node contains a TSTypeAssertion that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn simple_assignment_target_from_ts_type_assertion<T>( self, inner: T, ) -> SimpleAssignmentTarget<'a>

where T: IntoIn<'a, Box<'a, TSTypeAssertion<'a>>>,

Convert a TSTypeAssertion into a SimpleAssignmentTarget::TSTypeAssertion

pub fn simple_assignment_target_ts_instantiation_expression<T1>( self, span: Span, expression: Expression<'a>, type_parameters: T1, ) -> SimpleAssignmentTarget<'a>

where T1: IntoIn<'a, Box<'a, TSTypeParameterInstantiation<'a>>>,

Build a SimpleAssignmentTarget::TSInstantiationExpression

This node contains a TSInstantiationExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn simple_assignment_target_from_ts_instantiation_expression<T>( self, inner: T, ) -> SimpleAssignmentTarget<'a>

where T: IntoIn<'a, Box<'a, TSInstantiationExpression<'a>>>,

Convert a TSInstantiationExpression into a SimpleAssignmentTarget::TSInstantiationExpression

pub fn simple_assignment_target_member_expression( self, inner: MemberExpression<'a>, ) -> SimpleAssignmentTarget<'a>

pub fn assignment_target_pattern_array_assignment_target( self, span: Span, elements: Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>, rest: Option<AssignmentTargetRest<'a>>, trailing_comma: Option<Span>, ) -> AssignmentTargetPattern<'a>

Build a AssignmentTargetPattern::ArrayAssignmentTarget

This node contains a ArrayAssignmentTarget that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• elements
• rest
• trailing_comma

pub fn assignment_target_pattern_from_array_assignment_target<T>( self, inner: T, ) -> AssignmentTargetPattern<'a>

where T: IntoIn<'a, Box<'a, ArrayAssignmentTarget<'a>>>,

Convert a ArrayAssignmentTarget into a AssignmentTargetPattern::ArrayAssignmentTarget

pub fn assignment_target_pattern_object_assignment_target( self, span: Span, properties: Vec<'a, AssignmentTargetProperty<'a>>, rest: Option<AssignmentTargetRest<'a>>, ) -> AssignmentTargetPattern<'a>

Build a AssignmentTargetPattern::ObjectAssignmentTarget

This node contains a ObjectAssignmentTarget that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• properties
• rest

pub fn assignment_target_pattern_from_object_assignment_target<T>( self, inner: T, ) -> AssignmentTargetPattern<'a>

where T: IntoIn<'a, Box<'a, ObjectAssignmentTarget<'a>>>,

Convert a ObjectAssignmentTarget into a AssignmentTargetPattern::ObjectAssignmentTarget

pub fn array_assignment_target( self, span: Span, elements: Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>, rest: Option<AssignmentTargetRest<'a>>, trailing_comma: Option<Span>, ) -> ArrayAssignmentTarget<'a>

Builds a ArrayAssignmentTarget

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_array_assignment_target instead.

Parameters

• span: The Span covering this node
• elements
• rest
• trailing_comma

pub fn alloc_array_assignment_target( self, span: Span, elements: Vec<'a, Option<AssignmentTargetMaybeDefault<'a>>>, rest: Option<AssignmentTargetRest<'a>>, trailing_comma: Option<Span>, ) -> Box<'a, ArrayAssignmentTarget<'a>>

Builds a ArrayAssignmentTarget and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::array_assignment_target instead.

Parameters

• span: The Span covering this node
• elements
• rest
• trailing_comma

pub fn object_assignment_target( self, span: Span, properties: Vec<'a, AssignmentTargetProperty<'a>>, rest: Option<AssignmentTargetRest<'a>>, ) -> ObjectAssignmentTarget<'a>

Builds a ObjectAssignmentTarget

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_object_assignment_target instead.

Parameters

• span: The Span covering this node
• properties
• rest

pub fn alloc_object_assignment_target( self, span: Span, properties: Vec<'a, AssignmentTargetProperty<'a>>, rest: Option<AssignmentTargetRest<'a>>, ) -> Box<'a, ObjectAssignmentTarget<'a>>

Builds a ObjectAssignmentTarget and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::object_assignment_target instead.

Parameters

• span: The Span covering this node
• properties
• rest

pub fn assignment_target_rest( self, span: Span, target: AssignmentTarget<'a>, ) -> AssignmentTargetRest<'a>

Builds a AssignmentTargetRest

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_assignment_target_rest instead.

Parameters

• span: The Span covering this node
• target

pub fn alloc_assignment_target_rest( self, span: Span, target: AssignmentTarget<'a>, ) -> Box<'a, AssignmentTargetRest<'a>>

Builds a AssignmentTargetRest and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::assignment_target_rest instead.

Parameters

• span: The Span covering this node
• target

pub fn assignment_target_maybe_default_assignment_target_with_default( self, span: Span, binding: AssignmentTarget<'a>, init: Expression<'a>, ) -> AssignmentTargetMaybeDefault<'a>

Build a AssignmentTargetMaybeDefault::AssignmentTargetWithDefault

This node contains a AssignmentTargetWithDefault that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• binding
• init

pub fn assignment_target_maybe_default_from_assignment_target_with_default<T>( self, inner: T, ) -> AssignmentTargetMaybeDefault<'a>

where T: IntoIn<'a, Box<'a, AssignmentTargetWithDefault<'a>>>,

Convert a AssignmentTargetWithDefault into a AssignmentTargetMaybeDefault::AssignmentTargetWithDefault

pub fn assignment_target_maybe_default_assignment_target( self, inner: AssignmentTarget<'a>, ) -> AssignmentTargetMaybeDefault<'a>

pub fn assignment_target_with_default( self, span: Span, binding: AssignmentTarget<'a>, init: Expression<'a>, ) -> AssignmentTargetWithDefault<'a>

Builds a AssignmentTargetWithDefault

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_assignment_target_with_default instead.

Parameters

• span: The Span covering this node
• binding
• init

pub fn alloc_assignment_target_with_default( self, span: Span, binding: AssignmentTarget<'a>, init: Expression<'a>, ) -> Box<'a, AssignmentTargetWithDefault<'a>>

Builds a AssignmentTargetWithDefault and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::assignment_target_with_default instead.

Parameters

• span: The Span covering this node
• binding
• init

pub fn assignment_target_property_assignment_target_property_identifier( self, span: Span, binding: IdentifierReference<'a>, init: Option<Expression<'a>>, ) -> AssignmentTargetProperty<'a>

Build a AssignmentTargetProperty::AssignmentTargetPropertyIdentifier

This node contains a AssignmentTargetPropertyIdentifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• binding
• init

pub fn assignment_target_property_from_assignment_target_property_identifier<T>( self, inner: T, ) -> AssignmentTargetProperty<'a>

where T: IntoIn<'a, Box<'a, AssignmentTargetPropertyIdentifier<'a>>>,

Convert a AssignmentTargetPropertyIdentifier into a AssignmentTargetProperty::AssignmentTargetPropertyIdentifier

pub fn assignment_target_property_assignment_target_property_property( self, span: Span, name: PropertyKey<'a>, binding: AssignmentTargetMaybeDefault<'a>, ) -> AssignmentTargetProperty<'a>

Build a AssignmentTargetProperty::AssignmentTargetPropertyProperty

This node contains a AssignmentTargetPropertyProperty that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name
• binding

pub fn assignment_target_property_from_assignment_target_property_property<T>( self, inner: T, ) -> AssignmentTargetProperty<'a>

where T: IntoIn<'a, Box<'a, AssignmentTargetPropertyProperty<'a>>>,

Convert a AssignmentTargetPropertyProperty into a AssignmentTargetProperty::AssignmentTargetPropertyProperty

pub fn assignment_target_property_identifier( self, span: Span, binding: IdentifierReference<'a>, init: Option<Expression<'a>>, ) -> AssignmentTargetPropertyIdentifier<'a>

Builds a AssignmentTargetPropertyIdentifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_assignment_target_property_identifier instead.

Parameters

• span: The Span covering this node
• binding
• init

pub fn alloc_assignment_target_property_identifier( self, span: Span, binding: IdentifierReference<'a>, init: Option<Expression<'a>>, ) -> Box<'a, AssignmentTargetPropertyIdentifier<'a>>

Builds a AssignmentTargetPropertyIdentifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::assignment_target_property_identifier instead.

Parameters

• span: The Span covering this node
• binding
• init

pub fn assignment_target_property_property( self, span: Span, name: PropertyKey<'a>, binding: AssignmentTargetMaybeDefault<'a>, ) -> AssignmentTargetPropertyProperty<'a>

Builds a AssignmentTargetPropertyProperty

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_assignment_target_property_property instead.

Parameters

• span: The Span covering this node
• name
• binding

pub fn alloc_assignment_target_property_property( self, span: Span, name: PropertyKey<'a>, binding: AssignmentTargetMaybeDefault<'a>, ) -> Box<'a, AssignmentTargetPropertyProperty<'a>>

Builds a AssignmentTargetPropertyProperty and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::assignment_target_property_property instead.

Parameters

• span: The Span covering this node
• name
• binding

pub fn sequence_expression( self, span: Span, expressions: Vec<'a, Expression<'a>>, ) -> SequenceExpression<'a>

Builds a SequenceExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_sequence_expression instead.

Parameters

• span: The Span covering this node
• expressions

pub fn alloc_sequence_expression( self, span: Span, expressions: Vec<'a, Expression<'a>>, ) -> Box<'a, SequenceExpression<'a>>

Builds a SequenceExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::sequence_expression instead.

Parameters

• span: The Span covering this node
• expressions

pub fn super_(self, span: Span) -> Super

Builds a Super

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_super_ instead.

Parameters

• span: The Span covering this node

pub fn alloc_super_(self, span: Span) -> Box<'a, Super>

Builds a Super and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::super_ instead.

Parameters

• span: The Span covering this node

pub fn await_expression( self, span: Span, argument: Expression<'a>, ) -> AwaitExpression<'a>

Builds a AwaitExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_await_expression instead.

Parameters

• span: The Span covering this node
• argument

pub fn alloc_await_expression( self, span: Span, argument: Expression<'a>, ) -> Box<'a, AwaitExpression<'a>>

Builds a AwaitExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::await_expression instead.

Parameters

• span: The Span covering this node
• argument

pub fn chain_expression( self, span: Span, expression: ChainElement<'a>, ) -> ChainExpression<'a>

Builds a ChainExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_chain_expression instead.

Parameters

• span: The Span covering this node
• expression

pub fn alloc_chain_expression( self, span: Span, expression: ChainElement<'a>, ) -> Box<'a, ChainExpression<'a>>

Builds a ChainExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::chain_expression instead.

Parameters

• span: The Span covering this node
• expression

pub fn chain_element_call_expression<T1>( self, span: Span, callee: Expression<'a>, type_parameters: T1, arguments: Vec<'a, Argument<'a>>, optional: bool, ) -> ChainElement<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a ChainElement::CallExpression

This node contains a CallExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• callee
• type_parameters
• arguments
• optional

pub fn chain_element_from_call_expression<T>(self, inner: T) -> ChainElement<'a>

where T: IntoIn<'a, Box<'a, CallExpression<'a>>>,

Convert a CallExpression into a ChainElement::CallExpression

pub fn chain_element_member_expression( self, inner: MemberExpression<'a>, ) -> ChainElement<'a>

pub fn parenthesized_expression( self, span: Span, expression: Expression<'a>, ) -> ParenthesizedExpression<'a>

Builds a ParenthesizedExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_parenthesized_expression instead.

Parameters

• span: The Span covering this node
• expression

pub fn alloc_parenthesized_expression( self, span: Span, expression: Expression<'a>, ) -> Box<'a, ParenthesizedExpression<'a>>

Builds a ParenthesizedExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::parenthesized_expression instead.

Parameters

• span: The Span covering this node
• expression

pub fn statement_block( self, span: Span, body: Vec<'a, Statement<'a>>, ) -> Statement<'a>

Build a Statement::BlockStatement

This node contains a BlockStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• body

pub fn statement_from_block<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, BlockStatement<'a>>>,

Convert a BlockStatement into a Statement::BlockStatement

pub fn statement_break( self, span: Span, label: Option<LabelIdentifier<'a>>, ) -> Statement<'a>

Build a Statement::BreakStatement

This node contains a BreakStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• label

pub fn statement_from_break<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, BreakStatement<'a>>>,

Convert a BreakStatement into a Statement::BreakStatement

pub fn statement_continue( self, span: Span, label: Option<LabelIdentifier<'a>>, ) -> Statement<'a>

Build a Statement::ContinueStatement

This node contains a ContinueStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• label

pub fn statement_from_continue<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, ContinueStatement<'a>>>,

Convert a ContinueStatement into a Statement::ContinueStatement

pub fn statement_debugger(self, span: Span) -> Statement<'a>

Build a Statement::DebuggerStatement

This node contains a DebuggerStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn statement_from_debugger<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, DebuggerStatement>>,

Convert a DebuggerStatement into a Statement::DebuggerStatement

pub fn statement_do_while( self, span: Span, body: Statement<'a>, test: Expression<'a>, ) -> Statement<'a>

Build a Statement::DoWhileStatement

This node contains a DoWhileStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• body
• test

pub fn statement_from_do_while<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, DoWhileStatement<'a>>>,

Convert a DoWhileStatement into a Statement::DoWhileStatement

pub fn statement_empty(self, span: Span) -> Statement<'a>

Build a Statement::EmptyStatement

This node contains a EmptyStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn statement_from_empty<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, EmptyStatement>>,

Convert a EmptyStatement into a Statement::EmptyStatement

pub fn statement_expression( self, span: Span, expression: Expression<'a>, ) -> Statement<'a>

Build a Statement::ExpressionStatement

This node contains a ExpressionStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression

pub fn statement_from_expression<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, ExpressionStatement<'a>>>,

Convert a ExpressionStatement into a Statement::ExpressionStatement

pub fn statement_for_in( self, span: Span, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> Statement<'a>

Build a Statement::ForInStatement

This node contains a ForInStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• left
• right
• body

pub fn statement_from_for_in<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, ForInStatement<'a>>>,

Convert a ForInStatement into a Statement::ForInStatement

pub fn statement_for_of( self, span: Span, await: bool, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> Statement<'a>

Build a Statement::ForOfStatement

This node contains a ForOfStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• r#await
• left
• right
• body

pub fn statement_from_for_of<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, ForOfStatement<'a>>>,

Convert a ForOfStatement into a Statement::ForOfStatement

pub fn statement_for( self, span: Span, init: Option<ForStatementInit<'a>>, test: Option<Expression<'a>>, update: Option<Expression<'a>>, body: Statement<'a>, ) -> Statement<'a>

Build a Statement::ForStatement

This node contains a ForStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• init
• test
• update
• body

pub fn statement_from_for<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, ForStatement<'a>>>,

Convert a ForStatement into a Statement::ForStatement

pub fn statement_if( self, span: Span, test: Expression<'a>, consequent: Statement<'a>, alternate: Option<Statement<'a>>, ) -> Statement<'a>

Build a Statement::IfStatement

This node contains a IfStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• test
• consequent
• alternate

pub fn statement_from_if<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, IfStatement<'a>>>,

Convert a IfStatement into a Statement::IfStatement

pub fn statement_labeled( self, span: Span, label: LabelIdentifier<'a>, body: Statement<'a>, ) -> Statement<'a>

Build a Statement::LabeledStatement

This node contains a LabeledStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• label
• body

pub fn statement_from_labeled<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, LabeledStatement<'a>>>,

Convert a LabeledStatement into a Statement::LabeledStatement

pub fn statement_return( self, span: Span, argument: Option<Expression<'a>>, ) -> Statement<'a>

Build a Statement::ReturnStatement

This node contains a ReturnStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• argument

pub fn statement_from_return<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, ReturnStatement<'a>>>,

Convert a ReturnStatement into a Statement::ReturnStatement

pub fn statement_switch( self, span: Span, discriminant: Expression<'a>, cases: Vec<'a, SwitchCase<'a>>, ) -> Statement<'a>

Build a Statement::SwitchStatement

This node contains a SwitchStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• discriminant
• cases

pub fn statement_from_switch<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, SwitchStatement<'a>>>,

Convert a SwitchStatement into a Statement::SwitchStatement

pub fn statement_throw( self, span: Span, argument: Expression<'a>, ) -> Statement<'a>

Build a Statement::ThrowStatement

This node contains a ThrowStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• argument

pub fn statement_from_throw<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, ThrowStatement<'a>>>,

Convert a ThrowStatement into a Statement::ThrowStatement

pub fn statement_try<T1, T2, T3>( self, span: Span, block: T1, handler: T2, finalizer: T3, ) -> Statement<'a>

where T1: IntoIn<'a, Box<'a, BlockStatement<'a>>>, T2: IntoIn<'a, Option<Box<'a, CatchClause<'a>>>>, T3: IntoIn<'a, Option<Box<'a, BlockStatement<'a>>>>,

Build a Statement::TryStatement

This node contains a TryStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• block
• handler
• finalizer

pub fn statement_from_try<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, TryStatement<'a>>>,

Convert a TryStatement into a Statement::TryStatement

pub fn statement_while( self, span: Span, test: Expression<'a>, body: Statement<'a>, ) -> Statement<'a>

Build a Statement::WhileStatement

This node contains a WhileStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• test
• body

pub fn statement_from_while<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, WhileStatement<'a>>>,

Convert a WhileStatement into a Statement::WhileStatement

pub fn statement_with( self, span: Span, object: Expression<'a>, body: Statement<'a>, ) -> Statement<'a>

Build a Statement::WithStatement

This node contains a WithStatement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• object
• body

pub fn statement_from_with<T>(self, inner: T) -> Statement<'a>

where T: IntoIn<'a, Box<'a, WithStatement<'a>>>,

Convert a WithStatement into a Statement::WithStatement

pub fn statement_declaration(self, inner: Declaration<'a>) -> Statement<'a>

pub fn statement_module_declaration( self, inner: ModuleDeclaration<'a>, ) -> Statement<'a>

pub fn directive<A>( self, span: Span, expression: StringLiteral<'a>, directive: A, ) -> Directive<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a Directive

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_directive instead.

Parameters

• span: The Span covering this node
• expression: Directive with any escapes unescaped
• directive: Raw content of directive as it appears in source, any escapes left as is

pub fn alloc_directive<A>( self, span: Span, expression: StringLiteral<'a>, directive: A, ) -> Box<'a, Directive<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a Directive and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::directive instead.

Parameters

• span: The Span covering this node
• expression: Directive with any escapes unescaped
• directive: Raw content of directive as it appears in source, any escapes left as is

pub fn hashbang<A>(self, span: Span, value: A) -> Hashbang<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a Hashbang

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_hashbang instead.

Parameters

• span: The Span covering this node
• value

pub fn alloc_hashbang<A>(self, span: Span, value: A) -> Box<'a, Hashbang<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a Hashbang and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::hashbang instead.

Parameters

• span: The Span covering this node
• value

pub fn block_statement( self, span: Span, body: Vec<'a, Statement<'a>>, ) -> BlockStatement<'a>

Builds a BlockStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_block_statement instead.

Parameters

• span: The Span covering this node
• body

pub fn alloc_block_statement( self, span: Span, body: Vec<'a, Statement<'a>>, ) -> Box<'a, BlockStatement<'a>>

Builds a BlockStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::block_statement instead.

Parameters

• span: The Span covering this node
• body

pub fn declaration_variable( self, span: Span, kind: VariableDeclarationKind, declarations: Vec<'a, VariableDeclarator<'a>>, declare: bool, ) -> Declaration<'a>

Build a Declaration::VariableDeclaration

This node contains a VariableDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• kind
• declarations
• declare

pub fn declaration_from_variable<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, VariableDeclaration<'a>>>,

Convert a VariableDeclaration into a Declaration::VariableDeclaration

pub fn declaration_function<T1, T2, T3, T4>( self, type: FunctionType, span: Span, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: Option<TSThisParameter<'a>>, params: T2, return_type: T3, body: T4, ) -> Declaration<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Option<Box<'a, FunctionBody<'a>>>>,

Build a Declaration::FunctionDeclaration

This node contains a Function that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• id
• generator
• r#async
• declare
• type_parameters
• this_param: Declaring this in a Function https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function
• params
• return_type
• body

pub fn declaration_from_function<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, Function<'a>>>,

Convert a Function into a Declaration::FunctionDeclaration

pub fn declaration_class<T1, T2, T3>( self, type: ClassType, span: Span, decorators: Vec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_parameters: T2, implements: Option<Vec<'a, TSClassImplements<'a>>>, body: T3, abstract: bool, declare: bool, ) -> Declaration<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>, T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,

Build a Declaration::ClassDeclaration

This node contains a Class that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the class.
• id: Class identifier, AKA the name
• type_parameters
• super_class: Super class. When present, this will usually be an IdentifierReference.
• super_type_parameters: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• r#abstract: Whether the class is abstract
• declare: Whether the class was declareed

pub fn declaration_from_class<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, Class<'a>>>,

Convert a Class into a Declaration::ClassDeclaration

pub fn declaration_using( self, span: Span, is_await: bool, declarations: Vec<'a, VariableDeclarator<'a>>, ) -> Declaration<'a>

Build a Declaration::UsingDeclaration

This node contains a UsingDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• is_await
• declarations

pub fn declaration_from_using<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, UsingDeclaration<'a>>>,

Convert a UsingDeclaration into a Declaration::UsingDeclaration

pub fn declaration_ts_type_alias<T1>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, type_annotation: TSType<'a>, declare: bool, ) -> Declaration<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Build a Declaration::TSTypeAliasDeclaration

This node contains a TSTypeAliasDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id
• type_parameters
• type_annotation
• declare

pub fn declaration_from_ts_type_alias<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, TSTypeAliasDeclaration<'a>>>,

Convert a TSTypeAliasDeclaration into a Declaration::TSTypeAliasDeclaration

pub fn declaration_ts_interface<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, extends: Option<Vec<'a, TSInterfaceHeritage<'a>>>, type_parameters: T1, body: T2, declare: bool, ) -> Declaration<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, TSInterfaceBody<'a>>>,

Build a Declaration::TSInterfaceDeclaration

This node contains a TSInterfaceDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id: The identifier (name) of the interface.
• extends
• type_parameters
• body
• declare

pub fn declaration_from_ts_interface<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, TSInterfaceDeclaration<'a>>>,

Convert a TSInterfaceDeclaration into a Declaration::TSInterfaceDeclaration

pub fn declaration_ts_enum( self, span: Span, id: BindingIdentifier<'a>, members: Vec<'a, TSEnumMember<'a>>, const: bool, declare: bool, ) -> Declaration<'a>

Build a Declaration::TSEnumDeclaration

This node contains a TSEnumDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id
• members
• r#const
• declare

pub fn declaration_from_ts_enum<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, TSEnumDeclaration<'a>>>,

Convert a TSEnumDeclaration into a Declaration::TSEnumDeclaration

pub fn declaration_ts_module( self, span: Span, id: TSModuleDeclarationName<'a>, body: Option<TSModuleDeclarationBody<'a>>, kind: TSModuleDeclarationKind, declare: bool, ) -> Declaration<'a>

Build a Declaration::TSModuleDeclaration

This node contains a TSModuleDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id
• body
• kind: The keyword used to define this module declaration
• declare

pub fn declaration_from_ts_module<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, TSModuleDeclaration<'a>>>,

Convert a TSModuleDeclaration into a Declaration::TSModuleDeclaration

pub fn declaration_ts_import_equals( self, span: Span, id: BindingIdentifier<'a>, module_reference: TSModuleReference<'a>, import_kind: ImportOrExportKind, ) -> Declaration<'a>

Build a Declaration::TSImportEqualsDeclaration

This node contains a TSImportEqualsDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id
• module_reference
• import_kind

pub fn declaration_from_ts_import_equals<T>(self, inner: T) -> Declaration<'a>

where T: IntoIn<'a, Box<'a, TSImportEqualsDeclaration<'a>>>,

Convert a TSImportEqualsDeclaration into a Declaration::TSImportEqualsDeclaration

pub fn variable_declaration( self, span: Span, kind: VariableDeclarationKind, declarations: Vec<'a, VariableDeclarator<'a>>, declare: bool, ) -> VariableDeclaration<'a>

Builds a VariableDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_variable_declaration instead.

Parameters

• span: The Span covering this node
• kind
• declarations
• declare

pub fn alloc_variable_declaration( self, span: Span, kind: VariableDeclarationKind, declarations: Vec<'a, VariableDeclarator<'a>>, declare: bool, ) -> Box<'a, VariableDeclaration<'a>>

Builds a VariableDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::variable_declaration instead.

Parameters

• span: The Span covering this node
• kind
• declarations
• declare

pub fn variable_declarator( self, span: Span, kind: VariableDeclarationKind, id: BindingPattern<'a>, init: Option<Expression<'a>>, definite: bool, ) -> VariableDeclarator<'a>

Builds a VariableDeclarator

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_variable_declarator instead.

Parameters

• span: The Span covering this node
• kind
• id
• init
• definite

pub fn alloc_variable_declarator( self, span: Span, kind: VariableDeclarationKind, id: BindingPattern<'a>, init: Option<Expression<'a>>, definite: bool, ) -> Box<'a, VariableDeclarator<'a>>

Builds a VariableDeclarator and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::variable_declarator instead.

Parameters

• span: The Span covering this node
• kind
• id
• init
• definite

pub fn using_declaration( self, span: Span, is_await: bool, declarations: Vec<'a, VariableDeclarator<'a>>, ) -> UsingDeclaration<'a>

Builds a UsingDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_using_declaration instead.

Parameters

• span: The Span covering this node
• is_await
• declarations

pub fn alloc_using_declaration( self, span: Span, is_await: bool, declarations: Vec<'a, VariableDeclarator<'a>>, ) -> Box<'a, UsingDeclaration<'a>>

Builds a UsingDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::using_declaration instead.

Parameters

• span: The Span covering this node
• is_await
• declarations

pub fn empty_statement(self, span: Span) -> EmptyStatement

Builds a EmptyStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_empty_statement instead.

Parameters

• span: The Span covering this node

pub fn alloc_empty_statement(self, span: Span) -> Box<'a, EmptyStatement>

Builds a EmptyStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::empty_statement instead.

Parameters

• span: The Span covering this node

pub fn expression_statement( self, span: Span, expression: Expression<'a>, ) -> ExpressionStatement<'a>

Builds a ExpressionStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_expression_statement instead.

Parameters

• span: The Span covering this node
• expression

pub fn alloc_expression_statement( self, span: Span, expression: Expression<'a>, ) -> Box<'a, ExpressionStatement<'a>>

Builds a ExpressionStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::expression_statement instead.

Parameters

• span: The Span covering this node
• expression

pub fn if_statement( self, span: Span, test: Expression<'a>, consequent: Statement<'a>, alternate: Option<Statement<'a>>, ) -> IfStatement<'a>

Builds a IfStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_if_statement instead.

Parameters

• span: The Span covering this node
• test
• consequent
• alternate

pub fn alloc_if_statement( self, span: Span, test: Expression<'a>, consequent: Statement<'a>, alternate: Option<Statement<'a>>, ) -> Box<'a, IfStatement<'a>>

Builds a IfStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::if_statement instead.

Parameters

• span: The Span covering this node
• test
• consequent
• alternate

pub fn do_while_statement( self, span: Span, body: Statement<'a>, test: Expression<'a>, ) -> DoWhileStatement<'a>

Builds a DoWhileStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_do_while_statement instead.

Parameters

• span: The Span covering this node
• body
• test

pub fn alloc_do_while_statement( self, span: Span, body: Statement<'a>, test: Expression<'a>, ) -> Box<'a, DoWhileStatement<'a>>

Builds a DoWhileStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::do_while_statement instead.

Parameters

• span: The Span covering this node
• body
• test

pub fn while_statement( self, span: Span, test: Expression<'a>, body: Statement<'a>, ) -> WhileStatement<'a>

Builds a WhileStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_while_statement instead.

Parameters

• span: The Span covering this node
• test
• body

pub fn alloc_while_statement( self, span: Span, test: Expression<'a>, body: Statement<'a>, ) -> Box<'a, WhileStatement<'a>>

Builds a WhileStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::while_statement instead.

Parameters

• span: The Span covering this node
• test
• body

pub fn for_statement( self, span: Span, init: Option<ForStatementInit<'a>>, test: Option<Expression<'a>>, update: Option<Expression<'a>>, body: Statement<'a>, ) -> ForStatement<'a>

Builds a ForStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_for_statement instead.

Parameters

• span: The Span covering this node
• init
• test
• update
• body

pub fn alloc_for_statement( self, span: Span, init: Option<ForStatementInit<'a>>, test: Option<Expression<'a>>, update: Option<Expression<'a>>, body: Statement<'a>, ) -> Box<'a, ForStatement<'a>>

Builds a ForStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::for_statement instead.

Parameters

• span: The Span covering this node
• init
• test
• update
• body

pub fn for_statement_init_variable_declaration( self, span: Span, kind: VariableDeclarationKind, declarations: Vec<'a, VariableDeclarator<'a>>, declare: bool, ) -> ForStatementInit<'a>

Build a ForStatementInit::VariableDeclaration

This node contains a VariableDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• kind
• declarations
• declare

pub fn for_statement_init_from_variable_declaration<T>( self, inner: T, ) -> ForStatementInit<'a>

where T: IntoIn<'a, Box<'a, VariableDeclaration<'a>>>,

Convert a VariableDeclaration into a ForStatementInit::VariableDeclaration

pub fn for_statement_init_using_declaration( self, span: Span, is_await: bool, declarations: Vec<'a, VariableDeclarator<'a>>, ) -> ForStatementInit<'a>

Build a ForStatementInit::UsingDeclaration

This node contains a UsingDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• is_await
• declarations

pub fn for_statement_init_from_using_declaration<T>( self, inner: T, ) -> ForStatementInit<'a>

where T: IntoIn<'a, Box<'a, UsingDeclaration<'a>>>,

Convert a UsingDeclaration into a ForStatementInit::UsingDeclaration

pub fn for_statement_init_expression( self, inner: Expression<'a>, ) -> ForStatementInit<'a>

pub fn for_in_statement( self, span: Span, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> ForInStatement<'a>

Builds a ForInStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_for_in_statement instead.

Parameters

• span: The Span covering this node
• left
• right
• body

pub fn alloc_for_in_statement( self, span: Span, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> Box<'a, ForInStatement<'a>>

Builds a ForInStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::for_in_statement instead.

Parameters

• span: The Span covering this node
• left
• right
• body

pub fn for_statement_left_variable_declaration( self, span: Span, kind: VariableDeclarationKind, declarations: Vec<'a, VariableDeclarator<'a>>, declare: bool, ) -> ForStatementLeft<'a>

Build a ForStatementLeft::VariableDeclaration

This node contains a VariableDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• kind
• declarations
• declare

pub fn for_statement_left_from_variable_declaration<T>( self, inner: T, ) -> ForStatementLeft<'a>

where T: IntoIn<'a, Box<'a, VariableDeclaration<'a>>>,

Convert a VariableDeclaration into a ForStatementLeft::VariableDeclaration

pub fn for_statement_left_using_declaration( self, span: Span, is_await: bool, declarations: Vec<'a, VariableDeclarator<'a>>, ) -> ForStatementLeft<'a>

Build a ForStatementLeft::UsingDeclaration

This node contains a UsingDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• is_await
• declarations

pub fn for_statement_left_from_using_declaration<T>( self, inner: T, ) -> ForStatementLeft<'a>

where T: IntoIn<'a, Box<'a, UsingDeclaration<'a>>>,

Convert a UsingDeclaration into a ForStatementLeft::UsingDeclaration

pub fn for_statement_left_assignment_target( self, inner: AssignmentTarget<'a>, ) -> ForStatementLeft<'a>

pub fn for_of_statement( self, span: Span, await: bool, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> ForOfStatement<'a>

Builds a ForOfStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_for_of_statement instead.

Parameters

• span: The Span covering this node
• r#await
• left
• right
• body

pub fn alloc_for_of_statement( self, span: Span, await: bool, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> Box<'a, ForOfStatement<'a>>

Builds a ForOfStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::for_of_statement instead.

Parameters

• span: The Span covering this node
• r#await
• left
• right
• body

pub fn continue_statement( self, span: Span, label: Option<LabelIdentifier<'a>>, ) -> ContinueStatement<'a>

Builds a ContinueStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_continue_statement instead.

Parameters

• span: The Span covering this node
• label

pub fn alloc_continue_statement( self, span: Span, label: Option<LabelIdentifier<'a>>, ) -> Box<'a, ContinueStatement<'a>>

Builds a ContinueStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::continue_statement instead.

Parameters

• span: The Span covering this node
• label

pub fn break_statement( self, span: Span, label: Option<LabelIdentifier<'a>>, ) -> BreakStatement<'a>

Builds a BreakStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_break_statement instead.

Parameters

• span: The Span covering this node
• label

pub fn alloc_break_statement( self, span: Span, label: Option<LabelIdentifier<'a>>, ) -> Box<'a, BreakStatement<'a>>

Builds a BreakStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::break_statement instead.

Parameters

• span: The Span covering this node
• label

pub fn return_statement( self, span: Span, argument: Option<Expression<'a>>, ) -> ReturnStatement<'a>

Builds a ReturnStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_return_statement instead.

Parameters

• span: The Span covering this node
• argument

pub fn alloc_return_statement( self, span: Span, argument: Option<Expression<'a>>, ) -> Box<'a, ReturnStatement<'a>>

Builds a ReturnStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::return_statement instead.

Parameters

• span: The Span covering this node
• argument

pub fn with_statement( self, span: Span, object: Expression<'a>, body: Statement<'a>, ) -> WithStatement<'a>

Builds a WithStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_with_statement instead.

Parameters

• span: The Span covering this node
• object
• body

pub fn alloc_with_statement( self, span: Span, object: Expression<'a>, body: Statement<'a>, ) -> Box<'a, WithStatement<'a>>

Builds a WithStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::with_statement instead.

Parameters

• span: The Span covering this node
• object
• body

pub fn switch_statement( self, span: Span, discriminant: Expression<'a>, cases: Vec<'a, SwitchCase<'a>>, ) -> SwitchStatement<'a>

Builds a SwitchStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_switch_statement instead.

Parameters

• span: The Span covering this node
• discriminant
• cases

pub fn alloc_switch_statement( self, span: Span, discriminant: Expression<'a>, cases: Vec<'a, SwitchCase<'a>>, ) -> Box<'a, SwitchStatement<'a>>

Builds a SwitchStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::switch_statement instead.

Parameters

• span: The Span covering this node
• discriminant
• cases

pub fn switch_case( self, span: Span, test: Option<Expression<'a>>, consequent: Vec<'a, Statement<'a>>, ) -> SwitchCase<'a>

Builds a SwitchCase

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_switch_case instead.

Parameters

• span: The Span covering this node
• test
• consequent

pub fn alloc_switch_case( self, span: Span, test: Option<Expression<'a>>, consequent: Vec<'a, Statement<'a>>, ) -> Box<'a, SwitchCase<'a>>

Builds a SwitchCase and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::switch_case instead.

Parameters

• span: The Span covering this node
• test
• consequent

pub fn labeled_statement( self, span: Span, label: LabelIdentifier<'a>, body: Statement<'a>, ) -> LabeledStatement<'a>

Builds a LabeledStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_labeled_statement instead.

Parameters

• span: The Span covering this node
• label
• body

pub fn alloc_labeled_statement( self, span: Span, label: LabelIdentifier<'a>, body: Statement<'a>, ) -> Box<'a, LabeledStatement<'a>>

Builds a LabeledStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::labeled_statement instead.

Parameters

• span: The Span covering this node
• label
• body

pub fn throw_statement( self, span: Span, argument: Expression<'a>, ) -> ThrowStatement<'a>

Builds a ThrowStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_throw_statement instead.

Parameters

• span: The Span covering this node
• argument

pub fn alloc_throw_statement( self, span: Span, argument: Expression<'a>, ) -> Box<'a, ThrowStatement<'a>>

Builds a ThrowStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::throw_statement instead.

Parameters

• span: The Span covering this node
• argument

pub fn try_statement<T1, T2, T3>( self, span: Span, block: T1, handler: T2, finalizer: T3, ) -> TryStatement<'a>

where T1: IntoIn<'a, Box<'a, BlockStatement<'a>>>, T2: IntoIn<'a, Option<Box<'a, CatchClause<'a>>>>, T3: IntoIn<'a, Option<Box<'a, BlockStatement<'a>>>>,

Builds a TryStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_try_statement instead.

Parameters

• span: The Span covering this node
• block
• handler
• finalizer

pub fn alloc_try_statement<T1, T2, T3>( self, span: Span, block: T1, handler: T2, finalizer: T3, ) -> Box<'a, TryStatement<'a>>

where T1: IntoIn<'a, Box<'a, BlockStatement<'a>>>, T2: IntoIn<'a, Option<Box<'a, CatchClause<'a>>>>, T3: IntoIn<'a, Option<Box<'a, BlockStatement<'a>>>>,

Builds a TryStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::try_statement instead.

Parameters

• span: The Span covering this node
• block
• handler
• finalizer

pub fn catch_clause<T1>( self, span: Span, param: Option<CatchParameter<'a>>, body: T1, ) -> CatchClause<'a>

where T1: IntoIn<'a, Box<'a, BlockStatement<'a>>>,

Builds a CatchClause

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_catch_clause instead.

Parameters

• span: The Span covering this node
• param
• body

pub fn alloc_catch_clause<T1>( self, span: Span, param: Option<CatchParameter<'a>>, body: T1, ) -> Box<'a, CatchClause<'a>>

where T1: IntoIn<'a, Box<'a, BlockStatement<'a>>>,

Builds a CatchClause and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::catch_clause instead.

Parameters

• span: The Span covering this node
• param
• body

pub fn catch_parameter( self, span: Span, pattern: BindingPattern<'a>, ) -> CatchParameter<'a>

Builds a CatchParameter

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_catch_parameter instead.

Parameters

• span: The Span covering this node
• pattern

pub fn alloc_catch_parameter( self, span: Span, pattern: BindingPattern<'a>, ) -> Box<'a, CatchParameter<'a>>

Builds a CatchParameter and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::catch_parameter instead.

Parameters

• span: The Span covering this node
• pattern

pub fn debugger_statement(self, span: Span) -> DebuggerStatement

Builds a DebuggerStatement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_debugger_statement instead.

Parameters

• span: The Span covering this node

pub fn alloc_debugger_statement(self, span: Span) -> Box<'a, DebuggerStatement>

Builds a DebuggerStatement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::debugger_statement instead.

Parameters

• span: The Span covering this node

pub fn binding_pattern<T1>( self, kind: BindingPatternKind<'a>, type_annotation: T1, optional: bool, ) -> BindingPattern<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a BindingPattern

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_binding_pattern instead.

Parameters

• kind
• type_annotation
• optional

pub fn alloc_binding_pattern<T1>( self, kind: BindingPatternKind<'a>, type_annotation: T1, optional: bool, ) -> Box<'a, BindingPattern<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a BindingPattern and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::binding_pattern instead.

Parameters

• kind
• type_annotation
• optional

pub fn binding_pattern_kind_binding_identifier<A>( self, span: Span, name: A, ) -> BindingPatternKind<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a BindingPatternKind::BindingIdentifier

This node contains a BindingIdentifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The identifier name being bound.

pub fn binding_pattern_kind_from_binding_identifier<T>( self, inner: T, ) -> BindingPatternKind<'a>

where T: IntoIn<'a, Box<'a, BindingIdentifier<'a>>>,

Convert a BindingIdentifier into a BindingPatternKind::BindingIdentifier

pub fn binding_pattern_kind_object_pattern<T1>( self, span: Span, properties: Vec<'a, BindingProperty<'a>>, rest: T1, ) -> BindingPatternKind<'a>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Build a BindingPatternKind::ObjectPattern

This node contains a ObjectPattern that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• properties
• rest

pub fn binding_pattern_kind_from_object_pattern<T>( self, inner: T, ) -> BindingPatternKind<'a>

where T: IntoIn<'a, Box<'a, ObjectPattern<'a>>>,

Convert a ObjectPattern into a BindingPatternKind::ObjectPattern

pub fn binding_pattern_kind_array_pattern<T1>( self, span: Span, elements: Vec<'a, Option<BindingPattern<'a>>>, rest: T1, ) -> BindingPatternKind<'a>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Build a BindingPatternKind::ArrayPattern

This node contains a ArrayPattern that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• elements
• rest

pub fn binding_pattern_kind_from_array_pattern<T>( self, inner: T, ) -> BindingPatternKind<'a>

where T: IntoIn<'a, Box<'a, ArrayPattern<'a>>>,

Convert a ArrayPattern into a BindingPatternKind::ArrayPattern

pub fn binding_pattern_kind_assignment_pattern( self, span: Span, left: BindingPattern<'a>, right: Expression<'a>, ) -> BindingPatternKind<'a>

Build a BindingPatternKind::AssignmentPattern

This node contains a AssignmentPattern that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• left
• right

pub fn binding_pattern_kind_from_assignment_pattern<T>( self, inner: T, ) -> BindingPatternKind<'a>

where T: IntoIn<'a, Box<'a, AssignmentPattern<'a>>>,

Convert a AssignmentPattern into a BindingPatternKind::AssignmentPattern

pub fn assignment_pattern( self, span: Span, left: BindingPattern<'a>, right: Expression<'a>, ) -> AssignmentPattern<'a>

Builds a AssignmentPattern

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_assignment_pattern instead.

Parameters

• span: The Span covering this node
• left
• right

pub fn alloc_assignment_pattern( self, span: Span, left: BindingPattern<'a>, right: Expression<'a>, ) -> Box<'a, AssignmentPattern<'a>>

Builds a AssignmentPattern and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::assignment_pattern instead.

Parameters

• span: The Span covering this node
• left
• right

pub fn object_pattern<T1>( self, span: Span, properties: Vec<'a, BindingProperty<'a>>, rest: T1, ) -> ObjectPattern<'a>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Builds a ObjectPattern

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_object_pattern instead.

Parameters

• span: The Span covering this node
• properties
• rest

pub fn alloc_object_pattern<T1>( self, span: Span, properties: Vec<'a, BindingProperty<'a>>, rest: T1, ) -> Box<'a, ObjectPattern<'a>>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Builds a ObjectPattern and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::object_pattern instead.

Parameters

• span: The Span covering this node
• properties
• rest

pub fn binding_property( self, span: Span, key: PropertyKey<'a>, value: BindingPattern<'a>, shorthand: bool, computed: bool, ) -> BindingProperty<'a>

Builds a BindingProperty

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_binding_property instead.

Parameters

• span: The Span covering this node
• key
• value
• shorthand
• computed

pub fn alloc_binding_property( self, span: Span, key: PropertyKey<'a>, value: BindingPattern<'a>, shorthand: bool, computed: bool, ) -> Box<'a, BindingProperty<'a>>

Builds a BindingProperty and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::binding_property instead.

Parameters

• span: The Span covering this node
• key
• value
• shorthand
• computed

pub fn array_pattern<T1>( self, span: Span, elements: Vec<'a, Option<BindingPattern<'a>>>, rest: T1, ) -> ArrayPattern<'a>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Builds a ArrayPattern

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_array_pattern instead.

Parameters

• span: The Span covering this node
• elements
• rest

pub fn alloc_array_pattern<T1>( self, span: Span, elements: Vec<'a, Option<BindingPattern<'a>>>, rest: T1, ) -> Box<'a, ArrayPattern<'a>>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Builds a ArrayPattern and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::array_pattern instead.

Parameters

• span: The Span covering this node
• elements
• rest

pub fn binding_rest_element( self, span: Span, argument: BindingPattern<'a>, ) -> BindingRestElement<'a>

Builds a BindingRestElement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_binding_rest_element instead.

Parameters

• span: The Span covering this node
• argument

pub fn alloc_binding_rest_element( self, span: Span, argument: BindingPattern<'a>, ) -> Box<'a, BindingRestElement<'a>>

Builds a BindingRestElement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::binding_rest_element instead.

Parameters

• span: The Span covering this node
• argument

pub fn function<T1, T2, T3, T4>( self, type: FunctionType, span: Span, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: Option<TSThisParameter<'a>>, params: T2, return_type: T3, body: T4, ) -> Function<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Option<Box<'a, FunctionBody<'a>>>>,

Builds a Function

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_function instead.

Parameters

• r#type
• span: The Span covering this node
• id
• generator
• r#async
• declare
• type_parameters
• this_param: Declaring this in a Function https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function
• params
• return_type
• body

pub fn alloc_function<T1, T2, T3, T4>( self, type: FunctionType, span: Span, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: Option<TSThisParameter<'a>>, params: T2, return_type: T3, body: T4, ) -> Box<'a, Function<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Option<Box<'a, FunctionBody<'a>>>>,

Builds a Function and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::function instead.

Parameters

• r#type
• span: The Span covering this node
• id
• generator
• r#async
• declare
• type_parameters
• this_param: Declaring this in a Function https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function
• params
• return_type
• body

pub fn formal_parameters<T1>( self, span: Span, kind: FormalParameterKind, items: Vec<'a, FormalParameter<'a>>, rest: T1, ) -> FormalParameters<'a>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Builds a FormalParameters

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_formal_parameters instead.

Parameters

• span: The Span covering this node
• kind
• items
• rest

pub fn alloc_formal_parameters<T1>( self, span: Span, kind: FormalParameterKind, items: Vec<'a, FormalParameter<'a>>, rest: T1, ) -> Box<'a, FormalParameters<'a>>

where T1: IntoIn<'a, Option<Box<'a, BindingRestElement<'a>>>>,

Builds a FormalParameters and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::formal_parameters instead.

Parameters

• span: The Span covering this node
• kind
• items
• rest

pub fn formal_parameter( self, span: Span, decorators: Vec<'a, Decorator<'a>>, pattern: BindingPattern<'a>, accessibility: Option<TSAccessibility>, readonly: bool, override: bool, ) -> FormalParameter<'a>

Builds a FormalParameter

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_formal_parameter instead.

Parameters

• span: The Span covering this node
• decorators
• pattern
• accessibility
• readonly
• r#override

pub fn alloc_formal_parameter( self, span: Span, decorators: Vec<'a, Decorator<'a>>, pattern: BindingPattern<'a>, accessibility: Option<TSAccessibility>, readonly: bool, override: bool, ) -> Box<'a, FormalParameter<'a>>

Builds a FormalParameter and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::formal_parameter instead.

Parameters

• span: The Span covering this node
• decorators
• pattern
• accessibility
• readonly
• r#override

pub fn function_body( self, span: Span, directives: Vec<'a, Directive<'a>>, statements: Vec<'a, Statement<'a>>, ) -> FunctionBody<'a>

Builds a FunctionBody

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_function_body instead.

Parameters

• span: The Span covering this node
• directives
• statements

pub fn alloc_function_body( self, span: Span, directives: Vec<'a, Directive<'a>>, statements: Vec<'a, Statement<'a>>, ) -> Box<'a, FunctionBody<'a>>

Builds a FunctionBody and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::function_body instead.

Parameters

• span: The Span covering this node
• directives
• statements

pub fn arrow_function_expression<T1, T2, T3, T4>( self, span: Span, expression: bool, async: bool, type_parameters: T1, params: T2, return_type: T3, body: T4, ) -> ArrowFunctionExpression<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Box<'a, FunctionBody<'a>>>,

Builds a ArrowFunctionExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_arrow_function_expression instead.

Parameters

• span: The Span covering this node
• expression: Is the function body an arrow expression? i.e. () => expr instead of () => {}
• r#async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.

pub fn alloc_arrow_function_expression<T1, T2, T3, T4>( self, span: Span, expression: bool, async: bool, type_parameters: T1, params: T2, return_type: T3, body: T4, ) -> Box<'a, ArrowFunctionExpression<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Box<'a, FunctionBody<'a>>>,

Builds a ArrowFunctionExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::arrow_function_expression instead.

Parameters

• span: The Span covering this node
• expression: Is the function body an arrow expression? i.e. () => expr instead of () => {}
• r#async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.

pub fn yield_expression( self, span: Span, delegate: bool, argument: Option<Expression<'a>>, ) -> YieldExpression<'a>

Builds a YieldExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_yield_expression instead.

Parameters

• span: The Span covering this node
• delegate
• argument

pub fn alloc_yield_expression( self, span: Span, delegate: bool, argument: Option<Expression<'a>>, ) -> Box<'a, YieldExpression<'a>>

Builds a YieldExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::yield_expression instead.

Parameters

• span: The Span covering this node
• delegate
• argument

pub fn class<T1, T2, T3>( self, type: ClassType, span: Span, decorators: Vec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_parameters: T2, implements: Option<Vec<'a, TSClassImplements<'a>>>, body: T3, abstract: bool, declare: bool, ) -> Class<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>, T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,

Builds a Class

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_class instead.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the class.
• id: Class identifier, AKA the name
• type_parameters
• super_class: Super class. When present, this will usually be an IdentifierReference.
• super_type_parameters: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• r#abstract: Whether the class is abstract
• declare: Whether the class was declareed

pub fn alloc_class<T1, T2, T3>( self, type: ClassType, span: Span, decorators: Vec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_parameters: T2, implements: Option<Vec<'a, TSClassImplements<'a>>>, body: T3, abstract: bool, declare: bool, ) -> Box<'a, Class<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>, T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,

Builds a Class and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::class instead.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the class.
• id: Class identifier, AKA the name
• type_parameters
• super_class: Super class. When present, this will usually be an IdentifierReference.
• super_type_parameters: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• r#abstract: Whether the class is abstract
• declare: Whether the class was declareed

pub fn class_body( self, span: Span, body: Vec<'a, ClassElement<'a>>, ) -> ClassBody<'a>

Builds a ClassBody

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_class_body instead.

Parameters

• span: The Span covering this node
• body

pub fn alloc_class_body( self, span: Span, body: Vec<'a, ClassElement<'a>>, ) -> Box<'a, ClassBody<'a>>

Builds a ClassBody and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::class_body instead.

Parameters

• span: The Span covering this node
• body

pub fn class_element_static_block( self, span: Span, body: Vec<'a, Statement<'a>>, ) -> ClassElement<'a>

Build a ClassElement::StaticBlock

This node contains a StaticBlock that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• body

pub fn class_element_from_static_block<T>(self, inner: T) -> ClassElement<'a>

where T: IntoIn<'a, Box<'a, StaticBlock<'a>>>,

Convert a StaticBlock into a ClassElement::StaticBlock

pub fn class_element_method_definition<T1>( self, type: MethodDefinitionType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: T1, kind: MethodDefinitionKind, computed: bool, static: bool, override: bool, optional: bool, accessibility: Option<TSAccessibility>, ) -> ClassElement<'a>

where T1: IntoIn<'a, Box<'a, Function<'a>>>,

Build a ClassElement::MethodDefinition

This node contains a MethodDefinition that will be stored in the memory arena.

Parameters

• r#type: Method definition type
• span: The Span covering this node
• decorators
• key
• value
• kind
• computed
• r#static
• r#override
• optional
• accessibility

pub fn class_element_from_method_definition<T>( self, inner: T, ) -> ClassElement<'a>

where T: IntoIn<'a, Box<'a, MethodDefinition<'a>>>,

Convert a MethodDefinition into a ClassElement::MethodDefinition

pub fn class_element_property_definition<T1>( self, type: PropertyDefinitionType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: Option<Expression<'a>>, computed: bool, static: bool, declare: bool, override: bool, optional: bool, definite: bool, readonly: bool, type_annotation: T1, accessibility: Option<TSAccessibility>, ) -> ClassElement<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Build a ClassElement::PropertyDefinition

This node contains a PropertyDefinition that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the property.
• key: The expression used to declare the property.
• value: Initialized value in the declaration.
• computed: Property was declared with a computed key
• r#static: Property was declared with a static modifier
• declare: Property is declared with a declare modifier.
• r#override
• optional: true when created with an optional modifier (?)
• definite
• readonly: true when declared with a readonly modifier
• type_annotation: Type annotation on the property.
• accessibility: Accessibility modifier.

pub fn class_element_from_property_definition<T>( self, inner: T, ) -> ClassElement<'a>

where T: IntoIn<'a, Box<'a, PropertyDefinition<'a>>>,

Convert a PropertyDefinition into a ClassElement::PropertyDefinition

pub fn class_element_accessor_property( self, type: AccessorPropertyType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: Option<Expression<'a>>, computed: bool, static: bool, ) -> ClassElement<'a>

Build a ClassElement::AccessorProperty

This node contains a AccessorProperty that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the accessor property.
• key: The expression used to declare the property.
• value: Initialized value in the declaration, if present.
• computed
• r#static

pub fn class_element_from_accessor_property<T>( self, inner: T, ) -> ClassElement<'a>

where T: IntoIn<'a, Box<'a, AccessorProperty<'a>>>,

Convert a AccessorProperty into a ClassElement::AccessorProperty

pub fn class_element_ts_index_signature<T1>( self, span: Span, parameters: Vec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, ) -> ClassElement<'a>

where T1: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,

Build a ClassElement::TSIndexSignature

This node contains a TSIndexSignature that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• parameters
• type_annotation
• readonly

pub fn class_element_from_ts_index_signature<T>( self, inner: T, ) -> ClassElement<'a>

where T: IntoIn<'a, Box<'a, TSIndexSignature<'a>>>,

Convert a TSIndexSignature into a ClassElement::TSIndexSignature

pub fn method_definition<T1>( self, type: MethodDefinitionType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: T1, kind: MethodDefinitionKind, computed: bool, static: bool, override: bool, optional: bool, accessibility: Option<TSAccessibility>, ) -> MethodDefinition<'a>

where T1: IntoIn<'a, Box<'a, Function<'a>>>,

Builds a MethodDefinition

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_method_definition instead.

Parameters

• r#type: Method definition type
• span: The Span covering this node
• decorators
• key
• value
• kind
• computed
• r#static
• r#override
• optional
• accessibility

pub fn alloc_method_definition<T1>( self, type: MethodDefinitionType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: T1, kind: MethodDefinitionKind, computed: bool, static: bool, override: bool, optional: bool, accessibility: Option<TSAccessibility>, ) -> Box<'a, MethodDefinition<'a>>

where T1: IntoIn<'a, Box<'a, Function<'a>>>,

Builds a MethodDefinition and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::method_definition instead.

Parameters

• r#type: Method definition type
• span: The Span covering this node
• decorators
• key
• value
• kind
• computed
• r#static
• r#override
• optional
• accessibility

pub fn property_definition<T1>( self, type: PropertyDefinitionType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: Option<Expression<'a>>, computed: bool, static: bool, declare: bool, override: bool, optional: bool, definite: bool, readonly: bool, type_annotation: T1, accessibility: Option<TSAccessibility>, ) -> PropertyDefinition<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a PropertyDefinition

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_property_definition instead.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the property.
• key: The expression used to declare the property.
• value: Initialized value in the declaration.
• computed: Property was declared with a computed key
• r#static: Property was declared with a static modifier
• declare: Property is declared with a declare modifier.
• r#override
• optional: true when created with an optional modifier (?)
• definite
• readonly: true when declared with a readonly modifier
• type_annotation: Type annotation on the property.
• accessibility: Accessibility modifier.

pub fn alloc_property_definition<T1>( self, type: PropertyDefinitionType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: Option<Expression<'a>>, computed: bool, static: bool, declare: bool, override: bool, optional: bool, definite: bool, readonly: bool, type_annotation: T1, accessibility: Option<TSAccessibility>, ) -> Box<'a, PropertyDefinition<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a PropertyDefinition and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::property_definition instead.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the property.
• key: The expression used to declare the property.
• value: Initialized value in the declaration.
• computed: Property was declared with a computed key
• r#static: Property was declared with a static modifier
• declare: Property is declared with a declare modifier.
• r#override
• optional: true when created with an optional modifier (?)
• definite
• readonly: true when declared with a readonly modifier
• type_annotation: Type annotation on the property.
• accessibility: Accessibility modifier.

pub fn private_identifier<A>(self, span: Span, name: A) -> PrivateIdentifier<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a PrivateIdentifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_private_identifier instead.

Parameters

• span: The Span covering this node
• name

pub fn alloc_private_identifier<A>( self, span: Span, name: A, ) -> Box<'a, PrivateIdentifier<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a PrivateIdentifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::private_identifier instead.

Parameters

• span: The Span covering this node
• name

pub fn static_block( self, span: Span, body: Vec<'a, Statement<'a>>, ) -> StaticBlock<'a>

Builds a StaticBlock

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_static_block instead.

Parameters

• span: The Span covering this node
• body

pub fn alloc_static_block( self, span: Span, body: Vec<'a, Statement<'a>>, ) -> Box<'a, StaticBlock<'a>>

Builds a StaticBlock and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::static_block instead.

Parameters

• span: The Span covering this node
• body

pub fn module_declaration_import_declaration( self, span: Span, specifiers: Option<Vec<'a, ImportDeclarationSpecifier<'a>>>, source: StringLiteral<'a>, with_clause: Option<WithClause<'a>>, import_kind: ImportOrExportKind, ) -> ModuleDeclaration<'a>

Build a ModuleDeclaration::ImportDeclaration

This node contains a ImportDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• specifiers: None for import 'foo', Some([]) for import {} from 'foo'
• source
• with_clause: Some(vec![]) for empty assertion
• import_kind: import type { foo } from 'bar'

pub fn module_declaration_from_import_declaration<T>( self, inner: T, ) -> ModuleDeclaration<'a>

where T: IntoIn<'a, Box<'a, ImportDeclaration<'a>>>,

Convert a ImportDeclaration into a ModuleDeclaration::ImportDeclaration

pub fn module_declaration_export_all_declaration( self, span: Span, exported: Option<ModuleExportName<'a>>, source: StringLiteral<'a>, with_clause: Option<WithClause<'a>>, export_kind: ImportOrExportKind, ) -> ModuleDeclaration<'a>

Build a ModuleDeclaration::ExportAllDeclaration

This node contains a ExportAllDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• exported: If this declaration is re-named
• source
• with_clause: Will be Some(vec![]) for empty assertion
• export_kind

pub fn module_declaration_from_export_all_declaration<T>( self, inner: T, ) -> ModuleDeclaration<'a>

where T: IntoIn<'a, Box<'a, ExportAllDeclaration<'a>>>,

Convert a ExportAllDeclaration into a ModuleDeclaration::ExportAllDeclaration

pub fn module_declaration_export_default_declaration( self, span: Span, declaration: ExportDefaultDeclarationKind<'a>, exported: ModuleExportName<'a>, ) -> ModuleDeclaration<'a>

Build a ModuleDeclaration::ExportDefaultDeclaration

This node contains a ExportDefaultDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• declaration
• exported

pub fn module_declaration_from_export_default_declaration<T>( self, inner: T, ) -> ModuleDeclaration<'a>

where T: IntoIn<'a, Box<'a, ExportDefaultDeclaration<'a>>>,

Convert a ExportDefaultDeclaration into a ModuleDeclaration::ExportDefaultDeclaration

pub fn module_declaration_export_named_declaration( self, span: Span, declaration: Option<Declaration<'a>>, specifiers: Vec<'a, ExportSpecifier<'a>>, source: Option<StringLiteral<'a>>, export_kind: ImportOrExportKind, with_clause: Option<WithClause<'a>>, ) -> ModuleDeclaration<'a>

Build a ModuleDeclaration::ExportNamedDeclaration

This node contains a ExportNamedDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• declaration
• specifiers
• source
• export_kind: export type { foo }
• with_clause: Some(vec![]) for empty assertion

pub fn module_declaration_from_export_named_declaration<T>( self, inner: T, ) -> ModuleDeclaration<'a>

where T: IntoIn<'a, Box<'a, ExportNamedDeclaration<'a>>>,

Convert a ExportNamedDeclaration into a ModuleDeclaration::ExportNamedDeclaration

pub fn module_declaration_ts_export_assignment( self, span: Span, expression: Expression<'a>, ) -> ModuleDeclaration<'a>

Build a ModuleDeclaration::TSExportAssignment

This node contains a TSExportAssignment that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression

pub fn module_declaration_from_ts_export_assignment<T>( self, inner: T, ) -> ModuleDeclaration<'a>

where T: IntoIn<'a, Box<'a, TSExportAssignment<'a>>>,

Convert a TSExportAssignment into a ModuleDeclaration::TSExportAssignment

pub fn module_declaration_ts_namespace_export_declaration( self, span: Span, id: IdentifierName<'a>, ) -> ModuleDeclaration<'a>

Build a ModuleDeclaration::TSNamespaceExportDeclaration

This node contains a TSNamespaceExportDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id

pub fn module_declaration_from_ts_namespace_export_declaration<T>( self, inner: T, ) -> ModuleDeclaration<'a>

where T: IntoIn<'a, Box<'a, TSNamespaceExportDeclaration<'a>>>,

Convert a TSNamespaceExportDeclaration into a ModuleDeclaration::TSNamespaceExportDeclaration

pub fn accessor_property( self, type: AccessorPropertyType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: Option<Expression<'a>>, computed: bool, static: bool, ) -> AccessorProperty<'a>

Builds a AccessorProperty

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_accessor_property instead.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the accessor property.
• key: The expression used to declare the property.
• value: Initialized value in the declaration, if present.
• computed
• r#static

pub fn alloc_accessor_property( self, type: AccessorPropertyType, span: Span, decorators: Vec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: Option<Expression<'a>>, computed: bool, static: bool, ) -> Box<'a, AccessorProperty<'a>>

Builds a AccessorProperty and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::accessor_property instead.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the accessor property.
• key: The expression used to declare the property.
• value: Initialized value in the declaration, if present.
• computed
• r#static

pub fn import_expression( self, span: Span, source: Expression<'a>, arguments: Vec<'a, Expression<'a>>, ) -> ImportExpression<'a>

Builds a ImportExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_import_expression instead.

Parameters

• span: The Span covering this node
• source
• arguments

pub fn alloc_import_expression( self, span: Span, source: Expression<'a>, arguments: Vec<'a, Expression<'a>>, ) -> Box<'a, ImportExpression<'a>>

Builds a ImportExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::import_expression instead.

Parameters

• span: The Span covering this node
• source
• arguments

pub fn import_declaration( self, span: Span, specifiers: Option<Vec<'a, ImportDeclarationSpecifier<'a>>>, source: StringLiteral<'a>, with_clause: Option<WithClause<'a>>, import_kind: ImportOrExportKind, ) -> ImportDeclaration<'a>

Builds a ImportDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_import_declaration instead.

Parameters

• span: The Span covering this node
• specifiers: None for import 'foo', Some([]) for import {} from 'foo'
• source
• with_clause: Some(vec![]) for empty assertion
• import_kind: import type { foo } from 'bar'

pub fn alloc_import_declaration( self, span: Span, specifiers: Option<Vec<'a, ImportDeclarationSpecifier<'a>>>, source: StringLiteral<'a>, with_clause: Option<WithClause<'a>>, import_kind: ImportOrExportKind, ) -> Box<'a, ImportDeclaration<'a>>

Builds a ImportDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::import_declaration instead.

Parameters

• span: The Span covering this node
• specifiers: None for import 'foo', Some([]) for import {} from 'foo'
• source
• with_clause: Some(vec![]) for empty assertion
• import_kind: import type { foo } from 'bar'

pub fn import_declaration_specifier_import_specifier( self, span: Span, imported: ModuleExportName<'a>, local: BindingIdentifier<'a>, import_kind: ImportOrExportKind, ) -> ImportDeclarationSpecifier<'a>

Build a ImportDeclarationSpecifier::ImportSpecifier

This node contains a ImportSpecifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• imported
• local: The name of the imported symbol.
• import_kind

pub fn import_declaration_specifier_from_import_specifier<T>( self, inner: T, ) -> ImportDeclarationSpecifier<'a>

where T: IntoIn<'a, Box<'a, ImportSpecifier<'a>>>,

Convert a ImportSpecifier into a ImportDeclarationSpecifier::ImportSpecifier

pub fn import_declaration_specifier_import_default_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> ImportDeclarationSpecifier<'a>

Build a ImportDeclarationSpecifier::ImportDefaultSpecifier

This node contains a ImportDefaultSpecifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• local: The name of the imported symbol.

pub fn import_declaration_specifier_from_import_default_specifier<T>( self, inner: T, ) -> ImportDeclarationSpecifier<'a>

where T: IntoIn<'a, Box<'a, ImportDefaultSpecifier<'a>>>,

Convert a ImportDefaultSpecifier into a ImportDeclarationSpecifier::ImportDefaultSpecifier

pub fn import_declaration_specifier_import_namespace_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> ImportDeclarationSpecifier<'a>

Build a ImportDeclarationSpecifier::ImportNamespaceSpecifier

This node contains a ImportNamespaceSpecifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• local

pub fn import_declaration_specifier_from_import_namespace_specifier<T>( self, inner: T, ) -> ImportDeclarationSpecifier<'a>

where T: IntoIn<'a, Box<'a, ImportNamespaceSpecifier<'a>>>,

Convert a ImportNamespaceSpecifier into a ImportDeclarationSpecifier::ImportNamespaceSpecifier

pub fn import_specifier( self, span: Span, imported: ModuleExportName<'a>, local: BindingIdentifier<'a>, import_kind: ImportOrExportKind, ) -> ImportSpecifier<'a>

Builds a ImportSpecifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_import_specifier instead.

Parameters

• span: The Span covering this node
• imported
• local: The name of the imported symbol.
• import_kind

pub fn alloc_import_specifier( self, span: Span, imported: ModuleExportName<'a>, local: BindingIdentifier<'a>, import_kind: ImportOrExportKind, ) -> Box<'a, ImportSpecifier<'a>>

Builds a ImportSpecifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::import_specifier instead.

Parameters

• span: The Span covering this node
• imported
• local: The name of the imported symbol.
• import_kind

pub fn import_default_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> ImportDefaultSpecifier<'a>

Builds a ImportDefaultSpecifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_import_default_specifier instead.

Parameters

• span: The Span covering this node
• local: The name of the imported symbol.

pub fn alloc_import_default_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> Box<'a, ImportDefaultSpecifier<'a>>

Builds a ImportDefaultSpecifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::import_default_specifier instead.

Parameters

• span: The Span covering this node
• local: The name of the imported symbol.

pub fn import_namespace_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> ImportNamespaceSpecifier<'a>

Builds a ImportNamespaceSpecifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_import_namespace_specifier instead.

Parameters

• span: The Span covering this node
• local

pub fn alloc_import_namespace_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> Box<'a, ImportNamespaceSpecifier<'a>>

Builds a ImportNamespaceSpecifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::import_namespace_specifier instead.

Parameters

• span: The Span covering this node
• local

pub fn with_clause( self, span: Span, attributes_keyword: IdentifierName<'a>, with_entries: Vec<'a, ImportAttribute<'a>>, ) -> WithClause<'a>

Builds a WithClause

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_with_clause instead.

Parameters

• span: The Span covering this node
• attributes_keyword
• with_entries

pub fn alloc_with_clause( self, span: Span, attributes_keyword: IdentifierName<'a>, with_entries: Vec<'a, ImportAttribute<'a>>, ) -> Box<'a, WithClause<'a>>

Builds a WithClause and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::with_clause instead.

Parameters

• span: The Span covering this node
• attributes_keyword
• with_entries

pub fn import_attribute( self, span: Span, key: ImportAttributeKey<'a>, value: StringLiteral<'a>, ) -> ImportAttribute<'a>

Builds a ImportAttribute

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_import_attribute instead.

Parameters

• span: The Span covering this node
• key
• value

pub fn alloc_import_attribute( self, span: Span, key: ImportAttributeKey<'a>, value: StringLiteral<'a>, ) -> Box<'a, ImportAttribute<'a>>

Builds a ImportAttribute and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::import_attribute instead.

Parameters

• span: The Span covering this node
• key
• value

pub fn import_attribute_key_identifier_name<A>( self, span: Span, name: A, ) -> ImportAttributeKey<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a ImportAttributeKey::Identifier

Parameters

• span: The Span covering this node
• name

pub fn import_attribute_key_from_identifier_name<T>( self, inner: T, ) -> ImportAttributeKey<'a>

where T: IntoIn<'a, IdentifierName<'a>>,

Convert a IdentifierName into a ImportAttributeKey::Identifier

pub fn import_attribute_key_string_literal<A>( self, span: Span, value: A, ) -> ImportAttributeKey<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a ImportAttributeKey::StringLiteral

Parameters

• span: The Span covering this node
• value

pub fn import_attribute_key_from_string_literal<T>( self, inner: T, ) -> ImportAttributeKey<'a>

where T: IntoIn<'a, StringLiteral<'a>>,

Convert a StringLiteral into a ImportAttributeKey::StringLiteral

pub fn export_named_declaration( self, span: Span, declaration: Option<Declaration<'a>>, specifiers: Vec<'a, ExportSpecifier<'a>>, source: Option<StringLiteral<'a>>, export_kind: ImportOrExportKind, with_clause: Option<WithClause<'a>>, ) -> ExportNamedDeclaration<'a>

Builds a ExportNamedDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_export_named_declaration instead.

Parameters

• span: The Span covering this node
• declaration
• specifiers
• source
• export_kind: export type { foo }
• with_clause: Some(vec![]) for empty assertion

pub fn alloc_export_named_declaration( self, span: Span, declaration: Option<Declaration<'a>>, specifiers: Vec<'a, ExportSpecifier<'a>>, source: Option<StringLiteral<'a>>, export_kind: ImportOrExportKind, with_clause: Option<WithClause<'a>>, ) -> Box<'a, ExportNamedDeclaration<'a>>

Builds a ExportNamedDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::export_named_declaration instead.

Parameters

• span: The Span covering this node
• declaration
• specifiers
• source
• export_kind: export type { foo }
• with_clause: Some(vec![]) for empty assertion

pub fn export_default_declaration( self, span: Span, declaration: ExportDefaultDeclarationKind<'a>, exported: ModuleExportName<'a>, ) -> ExportDefaultDeclaration<'a>

Builds a ExportDefaultDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_export_default_declaration instead.

Parameters

• span: The Span covering this node
• declaration
• exported

pub fn alloc_export_default_declaration( self, span: Span, declaration: ExportDefaultDeclarationKind<'a>, exported: ModuleExportName<'a>, ) -> Box<'a, ExportDefaultDeclaration<'a>>

Builds a ExportDefaultDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::export_default_declaration instead.

Parameters

• span: The Span covering this node
• declaration
• exported

pub fn export_all_declaration( self, span: Span, exported: Option<ModuleExportName<'a>>, source: StringLiteral<'a>, with_clause: Option<WithClause<'a>>, export_kind: ImportOrExportKind, ) -> ExportAllDeclaration<'a>

Builds a ExportAllDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_export_all_declaration instead.

Parameters

• span: The Span covering this node
• exported: If this declaration is re-named
• source
• with_clause: Will be Some(vec![]) for empty assertion
• export_kind

pub fn alloc_export_all_declaration( self, span: Span, exported: Option<ModuleExportName<'a>>, source: StringLiteral<'a>, with_clause: Option<WithClause<'a>>, export_kind: ImportOrExportKind, ) -> Box<'a, ExportAllDeclaration<'a>>

Builds a ExportAllDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::export_all_declaration instead.

Parameters

• span: The Span covering this node
• exported: If this declaration is re-named
• source
• with_clause: Will be Some(vec![]) for empty assertion
• export_kind

pub fn export_specifier( self, span: Span, local: ModuleExportName<'a>, exported: ModuleExportName<'a>, export_kind: ImportOrExportKind, ) -> ExportSpecifier<'a>

Builds a ExportSpecifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_export_specifier instead.

Parameters

• span: The Span covering this node
• local
• exported
• export_kind

pub fn alloc_export_specifier( self, span: Span, local: ModuleExportName<'a>, exported: ModuleExportName<'a>, export_kind: ImportOrExportKind, ) -> Box<'a, ExportSpecifier<'a>>

Builds a ExportSpecifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::export_specifier instead.

Parameters

• span: The Span covering this node
• local
• exported
• export_kind

pub fn export_default_declaration_kind_function<T1, T2, T3, T4>( self, type: FunctionType, span: Span, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: Option<TSThisParameter<'a>>, params: T2, return_type: T3, body: T4, ) -> ExportDefaultDeclarationKind<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, Option<Box<'a, FunctionBody<'a>>>>,

Build a ExportDefaultDeclarationKind::FunctionDeclaration

This node contains a Function that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• id
• generator
• r#async
• declare
• type_parameters
• this_param: Declaring this in a Function https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function
• params
• return_type
• body

pub fn export_default_declaration_kind_from_function<T>( self, inner: T, ) -> ExportDefaultDeclarationKind<'a>

where T: IntoIn<'a, Box<'a, Function<'a>>>,

Convert a Function into a ExportDefaultDeclarationKind::FunctionDeclaration

pub fn export_default_declaration_kind_class<T1, T2, T3>( self, type: ClassType, span: Span, decorators: Vec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_parameters: T2, implements: Option<Vec<'a, TSClassImplements<'a>>>, body: T3, abstract: bool, declare: bool, ) -> ExportDefaultDeclarationKind<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>, T3: IntoIn<'a, Box<'a, ClassBody<'a>>>,

Build a ExportDefaultDeclarationKind::ClassDeclaration

This node contains a Class that will be stored in the memory arena.

Parameters

• r#type
• span: The Span covering this node
• decorators: Decorators applied to the class.
• id: Class identifier, AKA the name
• type_parameters
• super_class: Super class. When present, this will usually be an IdentifierReference.
• super_type_parameters: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• r#abstract: Whether the class is abstract
• declare: Whether the class was declareed

pub fn export_default_declaration_kind_from_class<T>( self, inner: T, ) -> ExportDefaultDeclarationKind<'a>

where T: IntoIn<'a, Box<'a, Class<'a>>>,

Convert a Class into a ExportDefaultDeclarationKind::ClassDeclaration

pub fn export_default_declaration_kind_ts_interface_declaration<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, extends: Option<Vec<'a, TSInterfaceHeritage<'a>>>, type_parameters: T1, body: T2, declare: bool, ) -> ExportDefaultDeclarationKind<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, TSInterfaceBody<'a>>>,

Build a ExportDefaultDeclarationKind::TSInterfaceDeclaration

This node contains a TSInterfaceDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id: The identifier (name) of the interface.
• extends
• type_parameters
• body
• declare

pub fn export_default_declaration_kind_from_ts_interface_declaration<T>( self, inner: T, ) -> ExportDefaultDeclarationKind<'a>

where T: IntoIn<'a, Box<'a, TSInterfaceDeclaration<'a>>>,

Convert a TSInterfaceDeclaration into a ExportDefaultDeclarationKind::TSInterfaceDeclaration

pub fn export_default_declaration_kind_expression( self, inner: Expression<'a>, ) -> ExportDefaultDeclarationKind<'a>

pub fn module_export_name_identifier_name<A>( self, span: Span, name: A, ) -> ModuleExportName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a ModuleExportName::IdentifierName

Parameters

• span: The Span covering this node
• name

pub fn module_export_name_from_identifier_name<T>( self, inner: T, ) -> ModuleExportName<'a>

where T: IntoIn<'a, IdentifierName<'a>>,

Convert a IdentifierName into a ModuleExportName::IdentifierName

pub fn module_export_name_identifier_reference<A>( self, span: Span, name: A, ) -> ModuleExportName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a ModuleExportName::IdentifierReference

Parameters

• span: The Span covering this node
• name: The name of the identifier being referenced.

pub fn module_export_name_from_identifier_reference<T>( self, inner: T, ) -> ModuleExportName<'a>

where T: IntoIn<'a, IdentifierReference<'a>>,

Convert a IdentifierReference into a ModuleExportName::IdentifierReference

pub fn module_export_name_string_literal<A>( self, span: Span, value: A, ) -> ModuleExportName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a ModuleExportName::StringLiteral

Parameters

• span: The Span covering this node
• value

pub fn module_export_name_from_string_literal<T>( self, inner: T, ) -> ModuleExportName<'a>

where T: IntoIn<'a, StringLiteral<'a>>,

Convert a StringLiteral into a ModuleExportName::StringLiteral

pub fn ts_this_parameter<T1>( self, span: Span, this: IdentifierName<'a>, type_annotation: T1, ) -> TSThisParameter<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a TSThisParameter

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_this_parameter instead.

Parameters

• span: The Span covering this node
• this
• type_annotation

pub fn alloc_ts_this_parameter<T1>( self, span: Span, this: IdentifierName<'a>, type_annotation: T1, ) -> Box<'a, TSThisParameter<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a TSThisParameter and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_this_parameter instead.

Parameters

• span: The Span covering this node
• this
• type_annotation

pub fn ts_enum_declaration( self, span: Span, id: BindingIdentifier<'a>, members: Vec<'a, TSEnumMember<'a>>, const: bool, declare: bool, ) -> TSEnumDeclaration<'a>

Builds a TSEnumDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_enum_declaration instead.

Parameters

• span: The Span covering this node
• id
• members
• r#const
• declare

pub fn alloc_ts_enum_declaration( self, span: Span, id: BindingIdentifier<'a>, members: Vec<'a, TSEnumMember<'a>>, const: bool, declare: bool, ) -> Box<'a, TSEnumDeclaration<'a>>

Builds a TSEnumDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_enum_declaration instead.

Parameters

• span: The Span covering this node
• id
• members
• r#const
• declare

pub fn ts_enum_member( self, span: Span, id: TSEnumMemberName<'a>, initializer: Option<Expression<'a>>, ) -> TSEnumMember<'a>

Builds a TSEnumMember

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_enum_member instead.

Parameters

• span: The Span covering this node
• id
• initializer

pub fn alloc_ts_enum_member( self, span: Span, id: TSEnumMemberName<'a>, initializer: Option<Expression<'a>>, ) -> Box<'a, TSEnumMember<'a>>

Builds a TSEnumMember and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_enum_member instead.

Parameters

• span: The Span covering this node
• id
• initializer

pub fn ts_enum_member_name_identifier_name<A>( self, span: Span, name: A, ) -> TSEnumMemberName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSEnumMemberName::StaticIdentifier

This node contains a IdentifierName that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name

pub fn ts_enum_member_name_from_identifier_name<T>( self, inner: T, ) -> TSEnumMemberName<'a>

where T: IntoIn<'a, Box<'a, IdentifierName<'a>>>,

Convert a IdentifierName into a TSEnumMemberName::StaticIdentifier

pub fn ts_enum_member_name_string_literal<A>( self, span: Span, value: A, ) -> TSEnumMemberName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSEnumMemberName::StaticStringLiteral

This node contains a StringLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value

pub fn ts_enum_member_name_from_string_literal<T>( self, inner: T, ) -> TSEnumMemberName<'a>

where T: IntoIn<'a, Box<'a, StringLiteral<'a>>>,

Convert a StringLiteral into a TSEnumMemberName::StaticStringLiteral

pub fn ts_enum_member_name_template_literal( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, expressions: Vec<'a, Expression<'a>>, ) -> TSEnumMemberName<'a>

Build a TSEnumMemberName::StaticTemplateLiteral

This node contains a TemplateLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• quasis
• expressions

pub fn ts_enum_member_name_from_template_literal<T>( self, inner: T, ) -> TSEnumMemberName<'a>

where T: IntoIn<'a, Box<'a, TemplateLiteral<'a>>>,

Convert a TemplateLiteral into a TSEnumMemberName::StaticTemplateLiteral

pub fn ts_enum_member_name_numeric_literal<S>( self, span: Span, value: f64, raw: S, base: NumberBase, ) -> TSEnumMemberName<'a>

where S: IntoIn<'a, &'a str>,

Build a TSEnumMemberName::StaticNumericLiteral

This node contains a NumericLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value: The value of the number, converted into base 10
• raw: The number as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn ts_enum_member_name_from_numeric_literal<T>( self, inner: T, ) -> TSEnumMemberName<'a>

where T: IntoIn<'a, Box<'a, NumericLiteral<'a>>>,

Convert a NumericLiteral into a TSEnumMemberName::StaticNumericLiteral

pub fn ts_enum_member_name_expression( self, inner: Expression<'a>, ) -> TSEnumMemberName<'a>

pub fn ts_type_annotation( self, span: Span, type_annotation: TSType<'a>, ) -> TSTypeAnnotation<'a>

Builds a TSTypeAnnotation

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_annotation instead.

Parameters

• span: starts at the : token and ends at the end of the type annotation
• type_annotation

pub fn alloc_ts_type_annotation( self, span: Span, type_annotation: TSType<'a>, ) -> Box<'a, TSTypeAnnotation<'a>>

Builds a TSTypeAnnotation and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_annotation instead.

Parameters

• span: starts at the : token and ends at the end of the type annotation
• type_annotation

pub fn ts_literal_type( self, span: Span, literal: TSLiteral<'a>, ) -> TSLiteralType<'a>

Builds a TSLiteralType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_literal_type instead.

Parameters

• span: The Span covering this node
• literal

pub fn alloc_ts_literal_type( self, span: Span, literal: TSLiteral<'a>, ) -> Box<'a, TSLiteralType<'a>>

Builds a TSLiteralType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_literal_type instead.

Parameters

• span: The Span covering this node
• literal

pub fn ts_literal_boolean_literal( self, span: Span, value: bool, ) -> TSLiteral<'a>

Build a TSLiteral::BooleanLiteral

This node contains a BooleanLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value

pub fn ts_literal_from_boolean_literal<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, BooleanLiteral>>,

Convert a BooleanLiteral into a TSLiteral::BooleanLiteral

pub fn ts_literal_null_literal(self, span: Span) -> TSLiteral<'a>

Build a TSLiteral::NullLiteral

This node contains a NullLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_literal_from_null_literal<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, NullLiteral>>,

Convert a NullLiteral into a TSLiteral::NullLiteral

pub fn ts_literal_numeric_literal<S>( self, span: Span, value: f64, raw: S, base: NumberBase, ) -> TSLiteral<'a>

where S: IntoIn<'a, &'a str>,

Build a TSLiteral::NumericLiteral

This node contains a NumericLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value: The value of the number, converted into base 10
• raw: The number as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn ts_literal_from_numeric_literal<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, NumericLiteral<'a>>>,

Convert a NumericLiteral into a TSLiteral::NumericLiteral

pub fn ts_literal_big_int_literal<A>( self, span: Span, raw: A, base: BigintBase, ) -> TSLiteral<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSLiteral::BigIntLiteral

This node contains a BigIntLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• raw: The bigint as it appears in the source code
• base: The base representation used by the literal in the source code

pub fn ts_literal_from_big_int_literal<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, BigIntLiteral<'a>>>,

Convert a BigIntLiteral into a TSLiteral::BigIntLiteral

pub fn ts_literal_reg_exp_literal( self, span: Span, value: EmptyObject, regex: RegExp<'a>, ) -> TSLiteral<'a>

Build a TSLiteral::RegExpLiteral

This node contains a RegExpLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value
• regex

pub fn ts_literal_from_reg_exp_literal<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, RegExpLiteral<'a>>>,

Convert a RegExpLiteral into a TSLiteral::RegExpLiteral

pub fn ts_literal_string_literal<A>(self, span: Span, value: A) -> TSLiteral<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSLiteral::StringLiteral

This node contains a StringLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value

pub fn ts_literal_from_string_literal<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, StringLiteral<'a>>>,

Convert a StringLiteral into a TSLiteral::StringLiteral

pub fn ts_literal_template_literal( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, expressions: Vec<'a, Expression<'a>>, ) -> TSLiteral<'a>

Build a TSLiteral::TemplateLiteral

This node contains a TemplateLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• quasis
• expressions

pub fn ts_literal_from_template_literal<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, TemplateLiteral<'a>>>,

Convert a TemplateLiteral into a TSLiteral::TemplateLiteral

pub fn ts_literal_unary_expression( self, span: Span, operator: UnaryOperator, argument: Expression<'a>, ) -> TSLiteral<'a>

Build a TSLiteral::UnaryExpression

This node contains a UnaryExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• operator
• argument

pub fn ts_literal_from_unary_expression<T>(self, inner: T) -> TSLiteral<'a>

where T: IntoIn<'a, Box<'a, UnaryExpression<'a>>>,

Convert a UnaryExpression into a TSLiteral::UnaryExpression

pub fn ts_type_any_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSAnyKeyword

This node contains a TSAnyKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_any_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSAnyKeyword>>,

Convert a TSAnyKeyword into a TSType::TSAnyKeyword

pub fn ts_type_big_int_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSBigIntKeyword

This node contains a TSBigIntKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_big_int_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSBigIntKeyword>>,

Convert a TSBigIntKeyword into a TSType::TSBigIntKeyword

pub fn ts_type_boolean_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSBooleanKeyword

This node contains a TSBooleanKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_boolean_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSBooleanKeyword>>,

Convert a TSBooleanKeyword into a TSType::TSBooleanKeyword

pub fn ts_type_intrinsic_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSIntrinsicKeyword

This node contains a TSIntrinsicKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_intrinsic_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSIntrinsicKeyword>>,

Convert a TSIntrinsicKeyword into a TSType::TSIntrinsicKeyword

pub fn ts_type_never_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSNeverKeyword

This node contains a TSNeverKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_never_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSNeverKeyword>>,

Convert a TSNeverKeyword into a TSType::TSNeverKeyword

pub fn ts_type_null_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSNullKeyword

This node contains a TSNullKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_null_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSNullKeyword>>,

Convert a TSNullKeyword into a TSType::TSNullKeyword

pub fn ts_type_number_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSNumberKeyword

This node contains a TSNumberKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_number_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSNumberKeyword>>,

Convert a TSNumberKeyword into a TSType::TSNumberKeyword

pub fn ts_type_object_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSObjectKeyword

This node contains a TSObjectKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_object_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSObjectKeyword>>,

Convert a TSObjectKeyword into a TSType::TSObjectKeyword

pub fn ts_type_string_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSStringKeyword

This node contains a TSStringKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_string_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSStringKeyword>>,

Convert a TSStringKeyword into a TSType::TSStringKeyword

pub fn ts_type_symbol_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSSymbolKeyword

This node contains a TSSymbolKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_symbol_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSSymbolKeyword>>,

Convert a TSSymbolKeyword into a TSType::TSSymbolKeyword

pub fn ts_type_undefined_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSUndefinedKeyword

This node contains a TSUndefinedKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_undefined_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSUndefinedKeyword>>,

Convert a TSUndefinedKeyword into a TSType::TSUndefinedKeyword

pub fn ts_type_unknown_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSUnknownKeyword

This node contains a TSUnknownKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_unknown_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSUnknownKeyword>>,

Convert a TSUnknownKeyword into a TSType::TSUnknownKeyword

pub fn ts_type_void_keyword(self, span: Span) -> TSType<'a>

Build a TSType::TSVoidKeyword

This node contains a TSVoidKeyword that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_void_keyword<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSVoidKeyword>>,

Convert a TSVoidKeyword into a TSType::TSVoidKeyword

pub fn ts_type_array_type( self, span: Span, element_type: TSType<'a>, ) -> TSType<'a>

Build a TSType::TSArrayType

This node contains a TSArrayType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• element_type

pub fn ts_type_from_ts_array_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSArrayType<'a>>>,

Convert a TSArrayType into a TSType::TSArrayType

pub fn ts_type_conditional_type( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, ) -> TSType<'a>

Build a TSType::TSConditionalType

This node contains a TSConditionalType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• check_type
• extends_type
• true_type
• false_type

pub fn ts_type_from_ts_conditional_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSConditionalType<'a>>>,

Convert a TSConditionalType into a TSType::TSConditionalType

pub fn ts_type_constructor_type<T1, T2, T3>( self, span: Span, abstract: bool, params: T1, return_type: T2, type_parameters: T3, ) -> TSType<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Build a TSType::TSConstructorType

This node contains a TSConstructorType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• r#abstract
• params
• return_type
• type_parameters

pub fn ts_type_from_ts_constructor_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSConstructorType<'a>>>,

Convert a TSConstructorType into a TSType::TSConstructorType

pub fn ts_type_function_type<T1, T2, T3>( self, span: Span, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> TSType<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Build a TSType::TSFunctionType

This node contains a TSFunctionType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• this_param
• params
• return_type
• type_parameters

pub fn ts_type_from_ts_function_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSFunctionType<'a>>>,

Convert a TSFunctionType into a TSType::TSFunctionType

pub fn ts_type_import_type<T1>( self, span: Span, is_type_of: bool, parameter: TSType<'a>, qualifier: Option<TSTypeName<'a>>, attributes: Option<TSImportAttributes<'a>>, type_parameters: T1, ) -> TSType<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a TSType::TSImportType

This node contains a TSImportType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• is_type_of
• parameter
• qualifier
• attributes
• type_parameters

pub fn ts_type_from_ts_import_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSImportType<'a>>>,

Convert a TSImportType into a TSType::TSImportType

pub fn ts_type_indexed_access_type( self, span: Span, object_type: TSType<'a>, index_type: TSType<'a>, ) -> TSType<'a>

Build a TSType::TSIndexedAccessType

This node contains a TSIndexedAccessType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• object_type
• index_type

pub fn ts_type_from_ts_indexed_access_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSIndexedAccessType<'a>>>,

Convert a TSIndexedAccessType into a TSType::TSIndexedAccessType

pub fn ts_type_infer_type<T1>( self, span: Span, type_parameter: T1, ) -> TSType<'a>

where T1: IntoIn<'a, Box<'a, TSTypeParameter<'a>>>,

Build a TSType::TSInferType

This node contains a TSInferType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_parameter

pub fn ts_type_from_ts_infer_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSInferType<'a>>>,

Convert a TSInferType into a TSType::TSInferType

pub fn ts_type_intersection_type( self, span: Span, types: Vec<'a, TSType<'a>>, ) -> TSType<'a>

Build a TSType::TSIntersectionType

This node contains a TSIntersectionType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• types

pub fn ts_type_from_ts_intersection_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSIntersectionType<'a>>>,

Convert a TSIntersectionType into a TSType::TSIntersectionType

pub fn ts_type_literal_type( self, span: Span, literal: TSLiteral<'a>, ) -> TSType<'a>

Build a TSType::TSLiteralType

This node contains a TSLiteralType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• literal

pub fn ts_type_from_ts_literal_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSLiteralType<'a>>>,

Convert a TSLiteralType into a TSType::TSLiteralType

pub fn ts_type_mapped_type<T1>( self, span: Span, type_parameter: T1, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: TSMappedTypeModifierOperator, readonly: TSMappedTypeModifierOperator, ) -> TSType<'a>

where T1: IntoIn<'a, Box<'a, TSTypeParameter<'a>>>,

Build a TSType::TSMappedType

This node contains a TSMappedType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_parameter
• name_type
• type_annotation
• optional
• readonly

pub fn ts_type_from_ts_mapped_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSMappedType<'a>>>,

Convert a TSMappedType into a TSType::TSMappedType

pub fn ts_type_named_tuple_member( self, span: Span, element_type: TSTupleElement<'a>, label: IdentifierName<'a>, optional: bool, ) -> TSType<'a>

Build a TSType::TSNamedTupleMember

This node contains a TSNamedTupleMember that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• element_type
• label
• optional

pub fn ts_type_from_ts_named_tuple_member<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSNamedTupleMember<'a>>>,

Convert a TSNamedTupleMember into a TSType::TSNamedTupleMember

pub fn ts_type_qualified_name( self, span: Span, left: TSTypeName<'a>, right: IdentifierName<'a>, ) -> TSType<'a>

Build a TSType::TSQualifiedName

This node contains a TSQualifiedName that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• left
• right

pub fn ts_type_from_ts_qualified_name<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSQualifiedName<'a>>>,

Convert a TSQualifiedName into a TSType::TSQualifiedName

pub fn ts_type_template_literal_type( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, types: Vec<'a, TSType<'a>>, ) -> TSType<'a>

Build a TSType::TSTemplateLiteralType

This node contains a TSTemplateLiteralType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• quasis
• types

pub fn ts_type_from_ts_template_literal_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSTemplateLiteralType<'a>>>,

Convert a TSTemplateLiteralType into a TSType::TSTemplateLiteralType

pub fn ts_type_this_type(self, span: Span) -> TSType<'a>

Build a TSType::TSThisType

This node contains a TSThisType that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_ts_this_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSThisType>>,

Convert a TSThisType into a TSType::TSThisType

pub fn ts_type_tuple_type( self, span: Span, element_types: Vec<'a, TSTupleElement<'a>>, ) -> TSType<'a>

Build a TSType::TSTupleType

This node contains a TSTupleType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• element_types

pub fn ts_type_from_ts_tuple_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSTupleType<'a>>>,

Convert a TSTupleType into a TSType::TSTupleType

pub fn ts_type_type_literal( self, span: Span, members: Vec<'a, TSSignature<'a>>, ) -> TSType<'a>

Build a TSType::TSTypeLiteral

This node contains a TSTypeLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• members

pub fn ts_type_from_ts_type_literal<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSTypeLiteral<'a>>>,

Convert a TSTypeLiteral into a TSType::TSTypeLiteral

pub fn ts_type_type_operator( self, span: Span, operator: TSTypeOperatorOperator, type_annotation: TSType<'a>, ) -> TSType<'a>

Build a TSType::TSTypeOperatorType

This node contains a TSTypeOperator that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• operator
• type_annotation

pub fn ts_type_from_ts_type_operator<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSTypeOperator<'a>>>,

Convert a TSTypeOperator into a TSType::TSTypeOperatorType

pub fn ts_type_type_predicate<T1>( self, span: Span, parameter_name: TSTypePredicateName<'a>, asserts: bool, type_annotation: T1, ) -> TSType<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Build a TSType::TSTypePredicate

This node contains a TSTypePredicate that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• parameter_name
• asserts
• type_annotation

pub fn ts_type_from_ts_type_predicate<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSTypePredicate<'a>>>,

Convert a TSTypePredicate into a TSType::TSTypePredicate

pub fn ts_type_type_query<T1>( self, span: Span, expr_name: TSTypeQueryExprName<'a>, type_parameters: T1, ) -> TSType<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a TSType::TSTypeQuery

This node contains a TSTypeQuery that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expr_name
• type_parameters

pub fn ts_type_from_ts_type_query<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSTypeQuery<'a>>>,

Convert a TSTypeQuery into a TSType::TSTypeQuery

pub fn ts_type_type_reference<T1>( self, span: Span, type_name: TSTypeName<'a>, type_parameters: T1, ) -> TSType<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a TSType::TSTypeReference

This node contains a TSTypeReference that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_name
• type_parameters

pub fn ts_type_from_ts_type_reference<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSTypeReference<'a>>>,

Convert a TSTypeReference into a TSType::TSTypeReference

pub fn ts_type_union_type( self, span: Span, types: Vec<'a, TSType<'a>>, ) -> TSType<'a>

Build a TSType::TSUnionType

This node contains a TSUnionType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• types

pub fn ts_type_from_ts_union_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSUnionType<'a>>>,

Convert a TSUnionType into a TSType::TSUnionType

pub fn ts_type_parenthesized_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSType<'a>

Build a TSType::TSParenthesizedType

This node contains a TSParenthesizedType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_annotation

pub fn ts_type_from_ts_parenthesized_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, TSParenthesizedType<'a>>>,

Convert a TSParenthesizedType into a TSType::TSParenthesizedType

pub fn ts_type_js_doc_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> TSType<'a>

Build a TSType::JSDocNullableType

This node contains a JSDocNullableType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_annotation
• postfix: Was ? after the type annotation?

pub fn ts_type_from_js_doc_nullable_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, JSDocNullableType<'a>>>,

Convert a JSDocNullableType into a TSType::JSDocNullableType

pub fn ts_type_js_doc_non_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> TSType<'a>

Build a TSType::JSDocNonNullableType

This node contains a JSDocNonNullableType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_annotation
• postfix

pub fn ts_type_from_js_doc_non_nullable_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, JSDocNonNullableType<'a>>>,

Convert a JSDocNonNullableType into a TSType::JSDocNonNullableType

pub fn ts_type_js_doc_unknown_type(self, span: Span) -> TSType<'a>

Build a TSType::JSDocUnknownType

This node contains a JSDocUnknownType that will be stored in the memory arena.

Parameters

• span: The Span covering this node

pub fn ts_type_from_js_doc_unknown_type<T>(self, inner: T) -> TSType<'a>

where T: IntoIn<'a, Box<'a, JSDocUnknownType>>,

Convert a JSDocUnknownType into a TSType::JSDocUnknownType

pub fn ts_conditional_type( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, ) -> TSConditionalType<'a>

Builds a TSConditionalType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_conditional_type instead.

Parameters

• span: The Span covering this node
• check_type
• extends_type
• true_type
• false_type

pub fn alloc_ts_conditional_type( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, ) -> Box<'a, TSConditionalType<'a>>

Builds a TSConditionalType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_conditional_type instead.

Parameters

• span: The Span covering this node
• check_type
• extends_type
• true_type
• false_type

pub fn ts_union_type( self, span: Span, types: Vec<'a, TSType<'a>>, ) -> TSUnionType<'a>

Builds a TSUnionType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_union_type instead.

Parameters

• span: The Span covering this node
• types

pub fn alloc_ts_union_type( self, span: Span, types: Vec<'a, TSType<'a>>, ) -> Box<'a, TSUnionType<'a>>

Builds a TSUnionType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_union_type instead.

Parameters

• span: The Span covering this node
• types

pub fn ts_intersection_type( self, span: Span, types: Vec<'a, TSType<'a>>, ) -> TSIntersectionType<'a>

Builds a TSIntersectionType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_intersection_type instead.

Parameters

• span: The Span covering this node
• types

pub fn alloc_ts_intersection_type( self, span: Span, types: Vec<'a, TSType<'a>>, ) -> Box<'a, TSIntersectionType<'a>>

Builds a TSIntersectionType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_intersection_type instead.

Parameters

• span: The Span covering this node
• types

pub fn ts_parenthesized_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSParenthesizedType<'a>

Builds a TSParenthesizedType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_parenthesized_type instead.

Parameters

• span: The Span covering this node
• type_annotation

pub fn alloc_ts_parenthesized_type( self, span: Span, type_annotation: TSType<'a>, ) -> Box<'a, TSParenthesizedType<'a>>

Builds a TSParenthesizedType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_parenthesized_type instead.

Parameters

• span: The Span covering this node
• type_annotation

pub fn ts_type_operator( self, span: Span, operator: TSTypeOperatorOperator, type_annotation: TSType<'a>, ) -> TSTypeOperator<'a>

Builds a TSTypeOperator

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_operator instead.

Parameters

• span: The Span covering this node
• operator
• type_annotation

pub fn alloc_ts_type_operator( self, span: Span, operator: TSTypeOperatorOperator, type_annotation: TSType<'a>, ) -> Box<'a, TSTypeOperator<'a>>

Builds a TSTypeOperator and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_operator instead.

Parameters

• span: The Span covering this node
• operator
• type_annotation

pub fn ts_array_type( self, span: Span, element_type: TSType<'a>, ) -> TSArrayType<'a>

Builds a TSArrayType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_array_type instead.

Parameters

• span: The Span covering this node
• element_type

pub fn alloc_ts_array_type( self, span: Span, element_type: TSType<'a>, ) -> Box<'a, TSArrayType<'a>>

Builds a TSArrayType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_array_type instead.

Parameters

• span: The Span covering this node
• element_type

pub fn ts_indexed_access_type( self, span: Span, object_type: TSType<'a>, index_type: TSType<'a>, ) -> TSIndexedAccessType<'a>

Builds a TSIndexedAccessType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_indexed_access_type instead.

Parameters

• span: The Span covering this node
• object_type
• index_type

pub fn alloc_ts_indexed_access_type( self, span: Span, object_type: TSType<'a>, index_type: TSType<'a>, ) -> Box<'a, TSIndexedAccessType<'a>>

Builds a TSIndexedAccessType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_indexed_access_type instead.

Parameters

• span: The Span covering this node
• object_type
• index_type

pub fn ts_tuple_type( self, span: Span, element_types: Vec<'a, TSTupleElement<'a>>, ) -> TSTupleType<'a>

Builds a TSTupleType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_tuple_type instead.

Parameters

• span: The Span covering this node
• element_types

pub fn alloc_ts_tuple_type( self, span: Span, element_types: Vec<'a, TSTupleElement<'a>>, ) -> Box<'a, TSTupleType<'a>>

Builds a TSTupleType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_tuple_type instead.

Parameters

• span: The Span covering this node
• element_types

pub fn ts_named_tuple_member( self, span: Span, element_type: TSTupleElement<'a>, label: IdentifierName<'a>, optional: bool, ) -> TSNamedTupleMember<'a>

Builds a TSNamedTupleMember

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_named_tuple_member instead.

Parameters

• span: The Span covering this node
• element_type
• label
• optional

pub fn alloc_ts_named_tuple_member( self, span: Span, element_type: TSTupleElement<'a>, label: IdentifierName<'a>, optional: bool, ) -> Box<'a, TSNamedTupleMember<'a>>

Builds a TSNamedTupleMember and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_named_tuple_member instead.

Parameters

• span: The Span covering this node
• element_type
• label
• optional

pub fn ts_optional_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSOptionalType<'a>

Builds a TSOptionalType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_optional_type instead.

Parameters

• span: The Span covering this node
• type_annotation

pub fn alloc_ts_optional_type( self, span: Span, type_annotation: TSType<'a>, ) -> Box<'a, TSOptionalType<'a>>

Builds a TSOptionalType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_optional_type instead.

Parameters

• span: The Span covering this node
• type_annotation

pub fn ts_rest_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSRestType<'a>

Builds a TSRestType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_rest_type instead.

Parameters

• span: The Span covering this node
• type_annotation

pub fn alloc_ts_rest_type( self, span: Span, type_annotation: TSType<'a>, ) -> Box<'a, TSRestType<'a>>

Builds a TSRestType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_rest_type instead.

Parameters

• span: The Span covering this node
• type_annotation

pub fn ts_tuple_element_optional_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSTupleElement<'a>

Build a TSTupleElement::TSOptionalType

This node contains a TSOptionalType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_annotation

pub fn ts_tuple_element_from_ts_optional_type<T>( self, inner: T, ) -> TSTupleElement<'a>

where T: IntoIn<'a, Box<'a, TSOptionalType<'a>>>,

Convert a TSOptionalType into a TSTupleElement::TSOptionalType

pub fn ts_tuple_element_rest_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSTupleElement<'a>

Build a TSTupleElement::TSRestType

This node contains a TSRestType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type_annotation

pub fn ts_tuple_element_from_ts_rest_type<T>( self, inner: T, ) -> TSTupleElement<'a>

where T: IntoIn<'a, Box<'a, TSRestType<'a>>>,

Convert a TSRestType into a TSTupleElement::TSRestType

pub fn ts_tuple_element_type(self, inner: TSType<'a>) -> TSTupleElement<'a>

pub fn ts_any_keyword(self, span: Span) -> TSAnyKeyword

Builds a TSAnyKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_any_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_any_keyword(self, span: Span) -> Box<'a, TSAnyKeyword>

Builds a TSAnyKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_any_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_string_keyword(self, span: Span) -> TSStringKeyword

Builds a TSStringKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_string_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_string_keyword(self, span: Span) -> Box<'a, TSStringKeyword>

Builds a TSStringKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_string_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_boolean_keyword(self, span: Span) -> TSBooleanKeyword

Builds a TSBooleanKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_boolean_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_boolean_keyword(self, span: Span) -> Box<'a, TSBooleanKeyword>

Builds a TSBooleanKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_boolean_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_number_keyword(self, span: Span) -> TSNumberKeyword

Builds a TSNumberKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_number_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_number_keyword(self, span: Span) -> Box<'a, TSNumberKeyword>

Builds a TSNumberKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_number_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_never_keyword(self, span: Span) -> TSNeverKeyword

Builds a TSNeverKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_never_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_never_keyword(self, span: Span) -> Box<'a, TSNeverKeyword>

Builds a TSNeverKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_never_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_intrinsic_keyword(self, span: Span) -> TSIntrinsicKeyword

Builds a TSIntrinsicKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_intrinsic_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_intrinsic_keyword( self, span: Span, ) -> Box<'a, TSIntrinsicKeyword>

Builds a TSIntrinsicKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_intrinsic_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_unknown_keyword(self, span: Span) -> TSUnknownKeyword

Builds a TSUnknownKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_unknown_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_unknown_keyword(self, span: Span) -> Box<'a, TSUnknownKeyword>

Builds a TSUnknownKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_unknown_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_null_keyword(self, span: Span) -> TSNullKeyword

Builds a TSNullKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_null_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_null_keyword(self, span: Span) -> Box<'a, TSNullKeyword>

Builds a TSNullKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_null_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_undefined_keyword(self, span: Span) -> TSUndefinedKeyword

Builds a TSUndefinedKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_undefined_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_undefined_keyword( self, span: Span, ) -> Box<'a, TSUndefinedKeyword>

Builds a TSUndefinedKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_undefined_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_void_keyword(self, span: Span) -> TSVoidKeyword

Builds a TSVoidKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_void_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_void_keyword(self, span: Span) -> Box<'a, TSVoidKeyword>

Builds a TSVoidKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_void_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_symbol_keyword(self, span: Span) -> TSSymbolKeyword

Builds a TSSymbolKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_symbol_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_symbol_keyword(self, span: Span) -> Box<'a, TSSymbolKeyword>

Builds a TSSymbolKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_symbol_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_this_type(self, span: Span) -> TSThisType

Builds a TSThisType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_this_type instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_this_type(self, span: Span) -> Box<'a, TSThisType>

Builds a TSThisType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_this_type instead.

Parameters

• span: The Span covering this node

pub fn ts_object_keyword(self, span: Span) -> TSObjectKeyword

Builds a TSObjectKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_object_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_object_keyword(self, span: Span) -> Box<'a, TSObjectKeyword>

Builds a TSObjectKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_object_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_big_int_keyword(self, span: Span) -> TSBigIntKeyword

Builds a TSBigIntKeyword

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_big_int_keyword instead.

Parameters

• span: The Span covering this node

pub fn alloc_ts_big_int_keyword(self, span: Span) -> Box<'a, TSBigIntKeyword>

Builds a TSBigIntKeyword and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_big_int_keyword instead.

Parameters

• span: The Span covering this node

pub fn ts_type_reference<T1>( self, span: Span, type_name: TSTypeName<'a>, type_parameters: T1, ) -> TSTypeReference<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSTypeReference

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_reference instead.

Parameters

• span: The Span covering this node
• type_name
• type_parameters

pub fn alloc_ts_type_reference<T1>( self, span: Span, type_name: TSTypeName<'a>, type_parameters: T1, ) -> Box<'a, TSTypeReference<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSTypeReference and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_reference instead.

Parameters

• span: The Span covering this node
• type_name
• type_parameters

pub fn ts_type_name_identifier_reference<A>( self, span: Span, name: A, ) -> TSTypeName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSTypeName::IdentifierReference

This node contains a IdentifierReference that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The name of the identifier being referenced.

pub fn ts_type_name_from_identifier_reference<T>( self, inner: T, ) -> TSTypeName<'a>

where T: IntoIn<'a, Box<'a, IdentifierReference<'a>>>,

Convert a IdentifierReference into a TSTypeName::IdentifierReference

pub fn ts_type_name_qualified_name( self, span: Span, left: TSTypeName<'a>, right: IdentifierName<'a>, ) -> TSTypeName<'a>

Build a TSTypeName::QualifiedName

This node contains a TSQualifiedName that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• left
• right

pub fn ts_type_name_from_ts_qualified_name<T>(self, inner: T) -> TSTypeName<'a>

where T: IntoIn<'a, Box<'a, TSQualifiedName<'a>>>,

Convert a TSQualifiedName into a TSTypeName::QualifiedName

pub fn ts_qualified_name( self, span: Span, left: TSTypeName<'a>, right: IdentifierName<'a>, ) -> TSQualifiedName<'a>

Builds a TSQualifiedName

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_qualified_name instead.

Parameters

• span: The Span covering this node
• left
• right

pub fn alloc_ts_qualified_name( self, span: Span, left: TSTypeName<'a>, right: IdentifierName<'a>, ) -> Box<'a, TSQualifiedName<'a>>

Builds a TSQualifiedName and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_qualified_name instead.

Parameters

• span: The Span covering this node
• left
• right

pub fn ts_type_parameter_instantiation( self, span: Span, params: Vec<'a, TSType<'a>>, ) -> TSTypeParameterInstantiation<'a>

Builds a TSTypeParameterInstantiation

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_parameter_instantiation instead.

Parameters

• span: The Span covering this node
• params

pub fn alloc_ts_type_parameter_instantiation( self, span: Span, params: Vec<'a, TSType<'a>>, ) -> Box<'a, TSTypeParameterInstantiation<'a>>

Builds a TSTypeParameterInstantiation and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_parameter_instantiation instead.

Parameters

• span: The Span covering this node
• params

pub fn ts_type_parameter( self, span: Span, name: BindingIdentifier<'a>, constraint: Option<TSType<'a>>, default: Option<TSType<'a>>, in: bool, out: bool, const: bool, ) -> TSTypeParameter<'a>

Builds a TSTypeParameter

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_parameter instead.

Parameters

• span: The Span covering this node
• name
• constraint
• default
• r#in
• out
• r#const

pub fn alloc_ts_type_parameter( self, span: Span, name: BindingIdentifier<'a>, constraint: Option<TSType<'a>>, default: Option<TSType<'a>>, in: bool, out: bool, const: bool, ) -> Box<'a, TSTypeParameter<'a>>

Builds a TSTypeParameter and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_parameter instead.

Parameters

• span: The Span covering this node
• name
• constraint
• default
• r#in
• out
• r#const

pub fn ts_type_parameter_declaration( self, span: Span, params: Vec<'a, TSTypeParameter<'a>>, ) -> TSTypeParameterDeclaration<'a>

Builds a TSTypeParameterDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_parameter_declaration instead.

Parameters

• span: The Span covering this node
• params

pub fn alloc_ts_type_parameter_declaration( self, span: Span, params: Vec<'a, TSTypeParameter<'a>>, ) -> Box<'a, TSTypeParameterDeclaration<'a>>

Builds a TSTypeParameterDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_parameter_declaration instead.

Parameters

• span: The Span covering this node
• params

pub fn ts_type_alias_declaration<T1>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, type_annotation: TSType<'a>, declare: bool, ) -> TSTypeAliasDeclaration<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSTypeAliasDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_alias_declaration instead.

Parameters

• span: The Span covering this node
• id
• type_parameters
• type_annotation
• declare

pub fn alloc_ts_type_alias_declaration<T1>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, type_annotation: TSType<'a>, declare: bool, ) -> Box<'a, TSTypeAliasDeclaration<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSTypeAliasDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_alias_declaration instead.

Parameters

• span: The Span covering this node
• id
• type_parameters
• type_annotation
• declare

pub fn ts_class_implements<T1>( self, span: Span, expression: TSTypeName<'a>, type_parameters: T1, ) -> TSClassImplements<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSClassImplements

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_class_implements instead.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn alloc_ts_class_implements<T1>( self, span: Span, expression: TSTypeName<'a>, type_parameters: T1, ) -> Box<'a, TSClassImplements<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSClassImplements and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_class_implements instead.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn ts_interface_declaration<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, extends: Option<Vec<'a, TSInterfaceHeritage<'a>>>, type_parameters: T1, body: T2, declare: bool, ) -> TSInterfaceDeclaration<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, TSInterfaceBody<'a>>>,

Builds a TSInterfaceDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_interface_declaration instead.

Parameters

• span: The Span covering this node
• id: The identifier (name) of the interface.
• extends
• type_parameters
• body
• declare

pub fn alloc_ts_interface_declaration<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, extends: Option<Vec<'a, TSInterfaceHeritage<'a>>>, type_parameters: T1, body: T2, declare: bool, ) -> Box<'a, TSInterfaceDeclaration<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, Box<'a, TSInterfaceBody<'a>>>,

Builds a TSInterfaceDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_interface_declaration instead.

Parameters

• span: The Span covering this node
• id: The identifier (name) of the interface.
• extends
• type_parameters
• body
• declare

pub fn ts_interface_body( self, span: Span, body: Vec<'a, TSSignature<'a>>, ) -> TSInterfaceBody<'a>

Builds a TSInterfaceBody

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_interface_body instead.

Parameters

• span: The Span covering this node
• body

pub fn alloc_ts_interface_body( self, span: Span, body: Vec<'a, TSSignature<'a>>, ) -> Box<'a, TSInterfaceBody<'a>>

Builds a TSInterfaceBody and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_interface_body instead.

Parameters

• span: The Span covering this node
• body

pub fn ts_property_signature<T1>( self, span: Span, computed: bool, optional: bool, readonly: bool, key: PropertyKey<'a>, type_annotation: T1, ) -> TSPropertySignature<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a TSPropertySignature

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_property_signature instead.

Parameters

• span: The Span covering this node
• computed
• optional
• readonly
• key
• type_annotation

pub fn alloc_ts_property_signature<T1>( self, span: Span, computed: bool, optional: bool, readonly: bool, key: PropertyKey<'a>, type_annotation: T1, ) -> Box<'a, TSPropertySignature<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a TSPropertySignature and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_property_signature instead.

Parameters

• span: The Span covering this node
• computed
• optional
• readonly
• key
• type_annotation

pub fn ts_signature_index_signature<T1>( self, span: Span, parameters: Vec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, ) -> TSSignature<'a>

where T1: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,

Build a TSSignature::TSIndexSignature

This node contains a TSIndexSignature that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• parameters
• type_annotation
• readonly

pub fn ts_signature_from_ts_index_signature<T>( self, inner: T, ) -> TSSignature<'a>

where T: IntoIn<'a, Box<'a, TSIndexSignature<'a>>>,

Convert a TSIndexSignature into a TSSignature::TSIndexSignature

pub fn ts_signature_property_signature<T1>( self, span: Span, computed: bool, optional: bool, readonly: bool, key: PropertyKey<'a>, type_annotation: T1, ) -> TSSignature<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Build a TSSignature::TSPropertySignature

This node contains a TSPropertySignature that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• computed
• optional
• readonly
• key
• type_annotation

pub fn ts_signature_from_ts_property_signature<T>( self, inner: T, ) -> TSSignature<'a>

where T: IntoIn<'a, Box<'a, TSPropertySignature<'a>>>,

Convert a TSPropertySignature into a TSSignature::TSPropertySignature

pub fn ts_signature_call_signature_declaration<T1, T2, T3>( self, span: Span, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> TSSignature<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Build a TSSignature::TSCallSignatureDeclaration

This node contains a TSCallSignatureDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• this_param
• params
• return_type
• type_parameters

pub fn ts_signature_from_ts_call_signature_declaration<T>( self, inner: T, ) -> TSSignature<'a>

where T: IntoIn<'a, Box<'a, TSCallSignatureDeclaration<'a>>>,

Convert a TSCallSignatureDeclaration into a TSSignature::TSCallSignatureDeclaration

pub fn ts_signature_construct_signature_declaration<T1, T2, T3>( self, span: Span, params: T1, return_type: T2, type_parameters: T3, ) -> TSSignature<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Build a TSSignature::TSConstructSignatureDeclaration

This node contains a TSConstructSignatureDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• params
• return_type
• type_parameters

pub fn ts_signature_from_ts_construct_signature_declaration<T>( self, inner: T, ) -> TSSignature<'a>

where T: IntoIn<'a, Box<'a, TSConstructSignatureDeclaration<'a>>>,

Convert a TSConstructSignatureDeclaration into a TSSignature::TSConstructSignatureDeclaration

pub fn ts_signature_method_signature<T1, T2, T3>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> TSSignature<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Build a TSSignature::TSMethodSignature

This node contains a TSMethodSignature that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• key
• computed
• optional
• kind
• this_param
• params
• return_type
• type_parameters

pub fn ts_signature_from_ts_method_signature<T>( self, inner: T, ) -> TSSignature<'a>

where T: IntoIn<'a, Box<'a, TSMethodSignature<'a>>>,

Convert a TSMethodSignature into a TSSignature::TSMethodSignature

pub fn ts_index_signature<T1>( self, span: Span, parameters: Vec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, ) -> TSIndexSignature<'a>

where T1: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,

Builds a TSIndexSignature

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_index_signature instead.

Parameters

• span: The Span covering this node
• parameters
• type_annotation
• readonly

pub fn alloc_ts_index_signature<T1>( self, span: Span, parameters: Vec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, ) -> Box<'a, TSIndexSignature<'a>>

where T1: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,

Builds a TSIndexSignature and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_index_signature instead.

Parameters

• span: The Span covering this node
• parameters
• type_annotation
• readonly

pub fn ts_call_signature_declaration<T1, T2, T3>( self, span: Span, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> TSCallSignatureDeclaration<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSCallSignatureDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_call_signature_declaration instead.

Parameters

• span: The Span covering this node
• this_param
• params
• return_type
• type_parameters

pub fn alloc_ts_call_signature_declaration<T1, T2, T3>( self, span: Span, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> Box<'a, TSCallSignatureDeclaration<'a>>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSCallSignatureDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_call_signature_declaration instead.

Parameters

• span: The Span covering this node
• this_param
• params
• return_type
• type_parameters

pub fn ts_method_signature<T1, T2, T3>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> TSMethodSignature<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSMethodSignature

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_method_signature instead.

Parameters

• span: The Span covering this node
• key
• computed
• optional
• kind
• this_param
• params
• return_type
• type_parameters

pub fn alloc_ts_method_signature<T1, T2, T3>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> Box<'a, TSMethodSignature<'a>>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSMethodSignature and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_method_signature instead.

Parameters

• span: The Span covering this node
• key
• computed
• optional
• kind
• this_param
• params
• return_type
• type_parameters

pub fn ts_construct_signature_declaration<T1, T2, T3>( self, span: Span, params: T1, return_type: T2, type_parameters: T3, ) -> TSConstructSignatureDeclaration<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSConstructSignatureDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_construct_signature_declaration instead.

Parameters

• span: The Span covering this node
• params
• return_type
• type_parameters

pub fn alloc_ts_construct_signature_declaration<T1, T2, T3>( self, span: Span, params: T1, return_type: T2, type_parameters: T3, ) -> Box<'a, TSConstructSignatureDeclaration<'a>>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSConstructSignatureDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_construct_signature_declaration instead.

Parameters

• span: The Span covering this node
• params
• return_type
• type_parameters

pub fn ts_index_signature_name<A, T1>( self, span: Span, name: A, type_annotation: T1, ) -> TSIndexSignatureName<'a>

where A: IntoIn<'a, Atom<'a>>, T1: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,

Builds a TSIndexSignatureName

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_index_signature_name instead.

Parameters

• span: The Span covering this node
• name
• type_annotation

pub fn alloc_ts_index_signature_name<A, T1>( self, span: Span, name: A, type_annotation: T1, ) -> Box<'a, TSIndexSignatureName<'a>>

where A: IntoIn<'a, Atom<'a>>, T1: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>,

Builds a TSIndexSignatureName and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_index_signature_name instead.

Parameters

• span: The Span covering this node
• name
• type_annotation

pub fn ts_interface_heritage<T1>( self, span: Span, expression: Expression<'a>, type_parameters: T1, ) -> TSInterfaceHeritage<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSInterfaceHeritage

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_interface_heritage instead.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn alloc_ts_interface_heritage<T1>( self, span: Span, expression: Expression<'a>, type_parameters: T1, ) -> Box<'a, TSInterfaceHeritage<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSInterfaceHeritage and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_interface_heritage instead.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn ts_type_predicate<T1>( self, span: Span, parameter_name: TSTypePredicateName<'a>, asserts: bool, type_annotation: T1, ) -> TSTypePredicate<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a TSTypePredicate

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_predicate instead.

Parameters

• span: The Span covering this node
• parameter_name
• asserts
• type_annotation

pub fn alloc_ts_type_predicate<T1>( self, span: Span, parameter_name: TSTypePredicateName<'a>, asserts: bool, type_annotation: T1, ) -> Box<'a, TSTypePredicate<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeAnnotation<'a>>>>,

Builds a TSTypePredicate and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_predicate instead.

Parameters

• span: The Span covering this node
• parameter_name
• asserts
• type_annotation

pub fn ts_type_predicate_name_identifier_name<A>( self, span: Span, name: A, ) -> TSTypePredicateName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSTypePredicateName::Identifier

This node contains a IdentifierName that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name

pub fn ts_type_predicate_name_from_identifier_name<T>( self, inner: T, ) -> TSTypePredicateName<'a>

where T: IntoIn<'a, Box<'a, IdentifierName<'a>>>,

Convert a IdentifierName into a TSTypePredicateName::Identifier

pub fn ts_type_predicate_name_this_type( self, span: Span, ) -> TSTypePredicateName<'a>

Build a TSTypePredicateName::This

Parameters

• span: The Span covering this node

pub fn ts_type_predicate_name_from_ts_this_type<T>( self, inner: T, ) -> TSTypePredicateName<'a>

where T: IntoIn<'a, TSThisType>,

Convert a TSThisType into a TSTypePredicateName::This

pub fn ts_module_declaration( self, span: Span, id: TSModuleDeclarationName<'a>, body: Option<TSModuleDeclarationBody<'a>>, kind: TSModuleDeclarationKind, declare: bool, ) -> TSModuleDeclaration<'a>

Builds a TSModuleDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_module_declaration instead.

Parameters

• span: The Span covering this node
• id
• body
• kind: The keyword used to define this module declaration
• declare

pub fn alloc_ts_module_declaration( self, span: Span, id: TSModuleDeclarationName<'a>, body: Option<TSModuleDeclarationBody<'a>>, kind: TSModuleDeclarationKind, declare: bool, ) -> Box<'a, TSModuleDeclaration<'a>>

Builds a TSModuleDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_module_declaration instead.

Parameters

• span: The Span covering this node
• id
• body
• kind: The keyword used to define this module declaration
• declare

pub fn ts_module_declaration_name_identifier_name<A>( self, span: Span, name: A, ) -> TSModuleDeclarationName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSModuleDeclarationName::Identifier

Parameters

• span: The Span covering this node
• name

pub fn ts_module_declaration_name_from_identifier_name<T>( self, inner: T, ) -> TSModuleDeclarationName<'a>

where T: IntoIn<'a, IdentifierName<'a>>,

Convert a IdentifierName into a TSModuleDeclarationName::Identifier

pub fn ts_module_declaration_name_string_literal<A>( self, span: Span, value: A, ) -> TSModuleDeclarationName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSModuleDeclarationName::StringLiteral

Parameters

• span: The Span covering this node
• value

pub fn ts_module_declaration_name_from_string_literal<T>( self, inner: T, ) -> TSModuleDeclarationName<'a>

where T: IntoIn<'a, StringLiteral<'a>>,

Convert a StringLiteral into a TSModuleDeclarationName::StringLiteral

pub fn ts_module_declaration_body_module_declaration( self, span: Span, id: TSModuleDeclarationName<'a>, body: Option<TSModuleDeclarationBody<'a>>, kind: TSModuleDeclarationKind, declare: bool, ) -> TSModuleDeclarationBody<'a>

Build a TSModuleDeclarationBody::TSModuleDeclaration

This node contains a TSModuleDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• id
• body
• kind: The keyword used to define this module declaration
• declare

pub fn ts_module_declaration_body_from_ts_module_declaration<T>( self, inner: T, ) -> TSModuleDeclarationBody<'a>

where T: IntoIn<'a, Box<'a, TSModuleDeclaration<'a>>>,

Convert a TSModuleDeclaration into a TSModuleDeclarationBody::TSModuleDeclaration

pub fn ts_module_declaration_body_module_block( self, span: Span, directives: Vec<'a, Directive<'a>>, body: Vec<'a, Statement<'a>>, ) -> TSModuleDeclarationBody<'a>

Build a TSModuleDeclarationBody::TSModuleBlock

This node contains a TSModuleBlock that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• directives
• body

pub fn ts_module_declaration_body_from_ts_module_block<T>( self, inner: T, ) -> TSModuleDeclarationBody<'a>

where T: IntoIn<'a, Box<'a, TSModuleBlock<'a>>>,

Convert a TSModuleBlock into a TSModuleDeclarationBody::TSModuleBlock

pub fn ts_module_block( self, span: Span, directives: Vec<'a, Directive<'a>>, body: Vec<'a, Statement<'a>>, ) -> TSModuleBlock<'a>

Builds a TSModuleBlock

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_module_block instead.

Parameters

• span: The Span covering this node
• directives
• body

pub fn alloc_ts_module_block( self, span: Span, directives: Vec<'a, Directive<'a>>, body: Vec<'a, Statement<'a>>, ) -> Box<'a, TSModuleBlock<'a>>

Builds a TSModuleBlock and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_module_block instead.

Parameters

• span: The Span covering this node
• directives
• body

pub fn ts_type_literal( self, span: Span, members: Vec<'a, TSSignature<'a>>, ) -> TSTypeLiteral<'a>

Builds a TSTypeLiteral

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_literal instead.

Parameters

• span: The Span covering this node
• members

pub fn alloc_ts_type_literal( self, span: Span, members: Vec<'a, TSSignature<'a>>, ) -> Box<'a, TSTypeLiteral<'a>>

Builds a TSTypeLiteral and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_literal instead.

Parameters

• span: The Span covering this node
• members

pub fn ts_infer_type<T1>( self, span: Span, type_parameter: T1, ) -> TSInferType<'a>

where T1: IntoIn<'a, Box<'a, TSTypeParameter<'a>>>,

Builds a TSInferType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_infer_type instead.

Parameters

• span: The Span covering this node
• type_parameter

pub fn alloc_ts_infer_type<T1>( self, span: Span, type_parameter: T1, ) -> Box<'a, TSInferType<'a>>

where T1: IntoIn<'a, Box<'a, TSTypeParameter<'a>>>,

Builds a TSInferType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_infer_type instead.

Parameters

• span: The Span covering this node
• type_parameter

pub fn ts_type_query<T1>( self, span: Span, expr_name: TSTypeQueryExprName<'a>, type_parameters: T1, ) -> TSTypeQuery<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSTypeQuery

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_query instead.

Parameters

• span: The Span covering this node
• expr_name
• type_parameters

pub fn alloc_ts_type_query<T1>( self, span: Span, expr_name: TSTypeQueryExprName<'a>, type_parameters: T1, ) -> Box<'a, TSTypeQuery<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSTypeQuery and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_query instead.

Parameters

• span: The Span covering this node
• expr_name
• type_parameters

pub fn ts_type_query_expr_name_import_type<T1>( self, span: Span, is_type_of: bool, parameter: TSType<'a>, qualifier: Option<TSTypeName<'a>>, attributes: Option<TSImportAttributes<'a>>, type_parameters: T1, ) -> TSTypeQueryExprName<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Build a TSTypeQueryExprName::TSImportType

This node contains a TSImportType that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• is_type_of
• parameter
• qualifier
• attributes
• type_parameters

pub fn ts_type_query_expr_name_from_ts_import_type<T>( self, inner: T, ) -> TSTypeQueryExprName<'a>

where T: IntoIn<'a, Box<'a, TSImportType<'a>>>,

Convert a TSImportType into a TSTypeQueryExprName::TSImportType

pub fn ts_type_query_expr_name_type_name( self, inner: TSTypeName<'a>, ) -> TSTypeQueryExprName<'a>

pub fn ts_import_type<T1>( self, span: Span, is_type_of: bool, parameter: TSType<'a>, qualifier: Option<TSTypeName<'a>>, attributes: Option<TSImportAttributes<'a>>, type_parameters: T1, ) -> TSImportType<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSImportType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_import_type instead.

Parameters

• span: The Span covering this node
• is_type_of
• parameter
• qualifier
• attributes
• type_parameters

pub fn alloc_ts_import_type<T1>( self, span: Span, is_type_of: bool, parameter: TSType<'a>, qualifier: Option<TSTypeName<'a>>, attributes: Option<TSImportAttributes<'a>>, type_parameters: T1, ) -> Box<'a, TSImportType<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a TSImportType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_import_type instead.

Parameters

• span: The Span covering this node
• is_type_of
• parameter
• qualifier
• attributes
• type_parameters

pub fn ts_import_attributes( self, span: Span, attributes_keyword: IdentifierName<'a>, elements: Vec<'a, TSImportAttribute<'a>>, ) -> TSImportAttributes<'a>

Builds a TSImportAttributes

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_import_attributes instead.

Parameters

• span: The Span covering this node
• attributes_keyword
• elements

pub fn alloc_ts_import_attributes( self, span: Span, attributes_keyword: IdentifierName<'a>, elements: Vec<'a, TSImportAttribute<'a>>, ) -> Box<'a, TSImportAttributes<'a>>

Builds a TSImportAttributes and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_import_attributes instead.

Parameters

• span: The Span covering this node
• attributes_keyword
• elements

pub fn ts_import_attribute( self, span: Span, name: TSImportAttributeName<'a>, value: Expression<'a>, ) -> TSImportAttribute<'a>

Builds a TSImportAttribute

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_import_attribute instead.

Parameters

• span: The Span covering this node
• name
• value

pub fn alloc_ts_import_attribute( self, span: Span, name: TSImportAttributeName<'a>, value: Expression<'a>, ) -> Box<'a, TSImportAttribute<'a>>

Builds a TSImportAttribute and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_import_attribute instead.

Parameters

• span: The Span covering this node
• name
• value

pub fn ts_import_attribute_name_identifier_name<A>( self, span: Span, name: A, ) -> TSImportAttributeName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSImportAttributeName::Identifier

Parameters

• span: The Span covering this node
• name

pub fn ts_import_attribute_name_from_identifier_name<T>( self, inner: T, ) -> TSImportAttributeName<'a>

where T: IntoIn<'a, IdentifierName<'a>>,

Convert a IdentifierName into a TSImportAttributeName::Identifier

pub fn ts_import_attribute_name_string_literal<A>( self, span: Span, value: A, ) -> TSImportAttributeName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a TSImportAttributeName::StringLiteral

Parameters

• span: The Span covering this node
• value

pub fn ts_import_attribute_name_from_string_literal<T>( self, inner: T, ) -> TSImportAttributeName<'a>

where T: IntoIn<'a, StringLiteral<'a>>,

Convert a StringLiteral into a TSImportAttributeName::StringLiteral

pub fn ts_function_type<T1, T2, T3>( self, span: Span, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> TSFunctionType<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSFunctionType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_function_type instead.

Parameters

• span: The Span covering this node
• this_param
• params
• return_type
• type_parameters

pub fn alloc_ts_function_type<T1, T2, T3>( self, span: Span, this_param: Option<TSThisParameter<'a>>, params: T1, return_type: T2, type_parameters: T3, ) -> Box<'a, TSFunctionType<'a>>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSFunctionType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_function_type instead.

Parameters

• span: The Span covering this node
• this_param
• params
• return_type
• type_parameters

pub fn ts_constructor_type<T1, T2, T3>( self, span: Span, abstract: bool, params: T1, return_type: T2, type_parameters: T3, ) -> TSConstructorType<'a>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSConstructorType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_constructor_type instead.

Parameters

• span: The Span covering this node
• r#abstract
• params
• return_type
• type_parameters

pub fn alloc_ts_constructor_type<T1, T2, T3>( self, span: Span, abstract: bool, params: T1, return_type: T2, type_parameters: T3, ) -> Box<'a, TSConstructorType<'a>>

where T1: IntoIn<'a, Box<'a, FormalParameters<'a>>>, T2: IntoIn<'a, Box<'a, TSTypeAnnotation<'a>>>, T3: IntoIn<'a, Option<Box<'a, TSTypeParameterDeclaration<'a>>>>,

Builds a TSConstructorType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_constructor_type instead.

Parameters

• span: The Span covering this node
• r#abstract
• params
• return_type
• type_parameters

pub fn ts_mapped_type<T1>( self, span: Span, type_parameter: T1, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: TSMappedTypeModifierOperator, readonly: TSMappedTypeModifierOperator, ) -> TSMappedType<'a>

where T1: IntoIn<'a, Box<'a, TSTypeParameter<'a>>>,

Builds a TSMappedType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_mapped_type instead.

Parameters

• span: The Span covering this node
• type_parameter
• name_type
• type_annotation
• optional
• readonly

pub fn alloc_ts_mapped_type<T1>( self, span: Span, type_parameter: T1, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: TSMappedTypeModifierOperator, readonly: TSMappedTypeModifierOperator, ) -> Box<'a, TSMappedType<'a>>

where T1: IntoIn<'a, Box<'a, TSTypeParameter<'a>>>,

Builds a TSMappedType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_mapped_type instead.

Parameters

• span: The Span covering this node
• type_parameter
• name_type
• type_annotation
• optional
• readonly

pub fn ts_template_literal_type( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, types: Vec<'a, TSType<'a>>, ) -> TSTemplateLiteralType<'a>

Builds a TSTemplateLiteralType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_template_literal_type instead.

Parameters

• span: The Span covering this node
• quasis
• types

pub fn alloc_ts_template_literal_type( self, span: Span, quasis: Vec<'a, TemplateElement<'a>>, types: Vec<'a, TSType<'a>>, ) -> Box<'a, TSTemplateLiteralType<'a>>

Builds a TSTemplateLiteralType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_template_literal_type instead.

Parameters

• span: The Span covering this node
• quasis
• types

pub fn ts_as_expression( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> TSAsExpression<'a>

Builds a TSAsExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_as_expression instead.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn alloc_ts_as_expression( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> Box<'a, TSAsExpression<'a>>

Builds a TSAsExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_as_expression instead.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn ts_satisfies_expression( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> TSSatisfiesExpression<'a>

Builds a TSSatisfiesExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_satisfies_expression instead.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn alloc_ts_satisfies_expression( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> Box<'a, TSSatisfiesExpression<'a>>

Builds a TSSatisfiesExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_satisfies_expression instead.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn ts_type_assertion( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> TSTypeAssertion<'a>

Builds a TSTypeAssertion

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_type_assertion instead.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn alloc_ts_type_assertion( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> Box<'a, TSTypeAssertion<'a>>

Builds a TSTypeAssertion and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_type_assertion instead.

Parameters

• span: The Span covering this node
• expression
• type_annotation

pub fn ts_import_equals_declaration( self, span: Span, id: BindingIdentifier<'a>, module_reference: TSModuleReference<'a>, import_kind: ImportOrExportKind, ) -> TSImportEqualsDeclaration<'a>

Builds a TSImportEqualsDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_import_equals_declaration instead.

Parameters

• span: The Span covering this node
• id
• module_reference
• import_kind

pub fn alloc_ts_import_equals_declaration( self, span: Span, id: BindingIdentifier<'a>, module_reference: TSModuleReference<'a>, import_kind: ImportOrExportKind, ) -> Box<'a, TSImportEqualsDeclaration<'a>>

Builds a TSImportEqualsDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_import_equals_declaration instead.

Parameters

• span: The Span covering this node
• id
• module_reference
• import_kind

pub fn ts_module_reference_external_module_reference( self, span: Span, expression: StringLiteral<'a>, ) -> TSModuleReference<'a>

Build a TSModuleReference::ExternalModuleReference

This node contains a TSExternalModuleReference that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression

pub fn ts_module_reference_from_ts_external_module_reference<T>( self, inner: T, ) -> TSModuleReference<'a>

where T: IntoIn<'a, Box<'a, TSExternalModuleReference<'a>>>,

Convert a TSExternalModuleReference into a TSModuleReference::ExternalModuleReference

pub fn ts_module_reference_type_name( self, inner: TSTypeName<'a>, ) -> TSModuleReference<'a>

pub fn ts_external_module_reference( self, span: Span, expression: StringLiteral<'a>, ) -> TSExternalModuleReference<'a>

Builds a TSExternalModuleReference

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_external_module_reference instead.

Parameters

• span: The Span covering this node
• expression

pub fn alloc_ts_external_module_reference( self, span: Span, expression: StringLiteral<'a>, ) -> Box<'a, TSExternalModuleReference<'a>>

Builds a TSExternalModuleReference and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_external_module_reference instead.

Parameters

• span: The Span covering this node
• expression

pub fn ts_non_null_expression( self, span: Span, expression: Expression<'a>, ) -> TSNonNullExpression<'a>

Builds a TSNonNullExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_non_null_expression instead.

Parameters

• span: The Span covering this node
• expression

pub fn alloc_ts_non_null_expression( self, span: Span, expression: Expression<'a>, ) -> Box<'a, TSNonNullExpression<'a>>

Builds a TSNonNullExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_non_null_expression instead.

Parameters

• span: The Span covering this node
• expression

pub fn decorator(self, span: Span, expression: Expression<'a>) -> Decorator<'a>

Builds a Decorator

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_decorator instead.

Parameters

• span: The Span covering this node
• expression

pub fn alloc_decorator( self, span: Span, expression: Expression<'a>, ) -> Box<'a, Decorator<'a>>

Builds a Decorator and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::decorator instead.

Parameters

• span: The Span covering this node
• expression

pub fn ts_export_assignment( self, span: Span, expression: Expression<'a>, ) -> TSExportAssignment<'a>

Builds a TSExportAssignment

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_export_assignment instead.

Parameters

• span: The Span covering this node
• expression

pub fn alloc_ts_export_assignment( self, span: Span, expression: Expression<'a>, ) -> Box<'a, TSExportAssignment<'a>>

Builds a TSExportAssignment and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_export_assignment instead.

Parameters

• span: The Span covering this node
• expression

pub fn ts_namespace_export_declaration( self, span: Span, id: IdentifierName<'a>, ) -> TSNamespaceExportDeclaration<'a>

Builds a TSNamespaceExportDeclaration

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_namespace_export_declaration instead.

Parameters

• span: The Span covering this node
• id

pub fn alloc_ts_namespace_export_declaration( self, span: Span, id: IdentifierName<'a>, ) -> Box<'a, TSNamespaceExportDeclaration<'a>>

Builds a TSNamespaceExportDeclaration and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_namespace_export_declaration instead.

Parameters

• span: The Span covering this node
• id

pub fn ts_instantiation_expression<T1>( self, span: Span, expression: Expression<'a>, type_parameters: T1, ) -> TSInstantiationExpression<'a>

where T1: IntoIn<'a, Box<'a, TSTypeParameterInstantiation<'a>>>,

Builds a TSInstantiationExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_ts_instantiation_expression instead.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn alloc_ts_instantiation_expression<T1>( self, span: Span, expression: Expression<'a>, type_parameters: T1, ) -> Box<'a, TSInstantiationExpression<'a>>

where T1: IntoIn<'a, Box<'a, TSTypeParameterInstantiation<'a>>>,

Builds a TSInstantiationExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::ts_instantiation_expression instead.

Parameters

• span: The Span covering this node
• expression
• type_parameters

pub fn js_doc_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> JSDocNullableType<'a>

Builds a JSDocNullableType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_js_doc_nullable_type instead.

Parameters

• span: The Span covering this node
• type_annotation
• postfix: Was ? after the type annotation?

pub fn alloc_js_doc_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> Box<'a, JSDocNullableType<'a>>

Builds a JSDocNullableType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::js_doc_nullable_type instead.

Parameters

• span: The Span covering this node
• type_annotation
• postfix: Was ? after the type annotation?

pub fn js_doc_non_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> JSDocNonNullableType<'a>

Builds a JSDocNonNullableType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_js_doc_non_nullable_type instead.

Parameters

• span: The Span covering this node
• type_annotation
• postfix

pub fn alloc_js_doc_non_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> Box<'a, JSDocNonNullableType<'a>>

Builds a JSDocNonNullableType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::js_doc_non_nullable_type instead.

Parameters

• span: The Span covering this node
• type_annotation
• postfix

pub fn js_doc_unknown_type(self, span: Span) -> JSDocUnknownType

Builds a JSDocUnknownType

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_js_doc_unknown_type instead.

Parameters

• span: The Span covering this node

pub fn alloc_js_doc_unknown_type(self, span: Span) -> Box<'a, JSDocUnknownType>

Builds a JSDocUnknownType and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::js_doc_unknown_type instead.

Parameters

• span: The Span covering this node

pub fn jsx_element<T1, T2>( self, span: Span, opening_element: T1, closing_element: T2, children: Vec<'a, JSXChild<'a>>, ) -> JSXElement<'a>

where T1: IntoIn<'a, Box<'a, JSXOpeningElement<'a>>>, T2: IntoIn<'a, Option<Box<'a, JSXClosingElement<'a>>>>,

Builds a JSXElement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_element instead.

Parameters

• span: The Span covering this node
• opening_element: Opening tag of the element.
• closing_element: Closing tag of the element. Will be None for self-closing tags.
• children: Children of the element. This can be text, other elements, or expressions.

pub fn alloc_jsx_element<T1, T2>( self, span: Span, opening_element: T1, closing_element: T2, children: Vec<'a, JSXChild<'a>>, ) -> Box<'a, JSXElement<'a>>

where T1: IntoIn<'a, Box<'a, JSXOpeningElement<'a>>>, T2: IntoIn<'a, Option<Box<'a, JSXClosingElement<'a>>>>,

Builds a JSXElement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_element instead.

Parameters

• span: The Span covering this node
• opening_element: Opening tag of the element.
• closing_element: Closing tag of the element. Will be None for self-closing tags.
• children: Children of the element. This can be text, other elements, or expressions.

pub fn jsx_opening_element<T1>( self, span: Span, self_closing: bool, name: JSXElementName<'a>, attributes: Vec<'a, JSXAttributeItem<'a>>, type_parameters: T1, ) -> JSXOpeningElement<'a>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a JSXOpeningElement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_opening_element instead.

Parameters

• span: The Span covering this node
• self_closing: Is this tag self-closing?
• name
• attributes: List of JSX attributes. In React-like applications, these become props.
• type_parameters: Type parameters for generic JSX elements.

pub fn alloc_jsx_opening_element<T1>( self, span: Span, self_closing: bool, name: JSXElementName<'a>, attributes: Vec<'a, JSXAttributeItem<'a>>, type_parameters: T1, ) -> Box<'a, JSXOpeningElement<'a>>

where T1: IntoIn<'a, Option<Box<'a, TSTypeParameterInstantiation<'a>>>>,

Builds a JSXOpeningElement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_opening_element instead.

Parameters

• span: The Span covering this node
• self_closing: Is this tag self-closing?
• name
• attributes: List of JSX attributes. In React-like applications, these become props.
• type_parameters: Type parameters for generic JSX elements.

pub fn jsx_closing_element( self, span: Span, name: JSXElementName<'a>, ) -> JSXClosingElement<'a>

Builds a JSXClosingElement

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_closing_element instead.

Parameters

• span: The Span covering this node
• name

pub fn alloc_jsx_closing_element( self, span: Span, name: JSXElementName<'a>, ) -> Box<'a, JSXClosingElement<'a>>

Builds a JSXClosingElement and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_closing_element instead.

Parameters

• span: The Span covering this node
• name

pub fn jsx_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, closing_fragment: JSXClosingFragment, children: Vec<'a, JSXChild<'a>>, ) -> JSXFragment<'a>

Builds a JSXFragment

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_fragment instead.

Parameters

• span: The Span covering this node
• opening_fragment: <>
• closing_fragment: </>
• children: Elements inside the fragment.

pub fn alloc_jsx_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, closing_fragment: JSXClosingFragment, children: Vec<'a, JSXChild<'a>>, ) -> Box<'a, JSXFragment<'a>>

Builds a JSXFragment and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_fragment instead.

Parameters

• span: The Span covering this node
• opening_fragment: <>
• closing_fragment: </>
• children: Elements inside the fragment.

pub fn jsx_element_name_jsx_identifier<A>( self, span: Span, name: A, ) -> JSXElementName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a JSXElementName::Identifier

This node contains a JSXIdentifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The name of the identifier.

pub fn jsx_element_name_from_jsx_identifier<T>( self, inner: T, ) -> JSXElementName<'a>

where T: IntoIn<'a, Box<'a, JSXIdentifier<'a>>>,

Convert a JSXIdentifier into a JSXElementName::Identifier

pub fn jsx_element_name_jsx_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, property: JSXIdentifier<'a>, ) -> JSXElementName<'a>

Build a JSXElementName::NamespacedName

This node contains a JSXNamespacedName that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• property: Name portion of the name, e.g. Orange in <Apple:Orange />

pub fn jsx_element_name_from_jsx_namespaced_name<T>( self, inner: T, ) -> JSXElementName<'a>

where T: IntoIn<'a, Box<'a, JSXNamespacedName<'a>>>,

Convert a JSXNamespacedName into a JSXElementName::NamespacedName

pub fn jsx_element_name_jsx_member_expression( self, span: Span, object: JSXMemberExpressionObject<'a>, property: JSXIdentifier<'a>, ) -> JSXElementName<'a>

Build a JSXElementName::MemberExpression

This node contains a JSXMemberExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• object: The object being accessed. This is everything before the last ..
• property: The property being accessed. This is everything after the last ..

pub fn jsx_element_name_from_jsx_member_expression<T>( self, inner: T, ) -> JSXElementName<'a>

where T: IntoIn<'a, Box<'a, JSXMemberExpression<'a>>>,

Convert a JSXMemberExpression into a JSXElementName::MemberExpression

pub fn jsx_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, property: JSXIdentifier<'a>, ) -> JSXNamespacedName<'a>

Builds a JSXNamespacedName

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_namespaced_name instead.

Parameters

• span: The Span covering this node
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• property: Name portion of the name, e.g. Orange in <Apple:Orange />

pub fn alloc_jsx_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, property: JSXIdentifier<'a>, ) -> Box<'a, JSXNamespacedName<'a>>

Builds a JSXNamespacedName and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_namespaced_name instead.

Parameters

• span: The Span covering this node
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• property: Name portion of the name, e.g. Orange in <Apple:Orange />

pub fn jsx_member_expression( self, span: Span, object: JSXMemberExpressionObject<'a>, property: JSXIdentifier<'a>, ) -> JSXMemberExpression<'a>

Builds a JSXMemberExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_member_expression instead.

Parameters

• span: The Span covering this node
• object: The object being accessed. This is everything before the last ..
• property: The property being accessed. This is everything after the last ..

pub fn alloc_jsx_member_expression( self, span: Span, object: JSXMemberExpressionObject<'a>, property: JSXIdentifier<'a>, ) -> Box<'a, JSXMemberExpression<'a>>

Builds a JSXMemberExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_member_expression instead.

Parameters

• span: The Span covering this node
• object: The object being accessed. This is everything before the last ..
• property: The property being accessed. This is everything after the last ..

pub fn jsx_member_expression_object_jsx_identifier<A>( self, span: Span, name: A, ) -> JSXMemberExpressionObject<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a JSXMemberExpressionObject::Identifier

This node contains a JSXIdentifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The name of the identifier.

pub fn jsx_member_expression_object_from_jsx_identifier<T>( self, inner: T, ) -> JSXMemberExpressionObject<'a>

where T: IntoIn<'a, Box<'a, JSXIdentifier<'a>>>,

Convert a JSXIdentifier into a JSXMemberExpressionObject::Identifier

pub fn jsx_member_expression_object_jsx_member_expression( self, span: Span, object: JSXMemberExpressionObject<'a>, property: JSXIdentifier<'a>, ) -> JSXMemberExpressionObject<'a>

Build a JSXMemberExpressionObject::MemberExpression

This node contains a JSXMemberExpression that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• object: The object being accessed. This is everything before the last ..
• property: The property being accessed. This is everything after the last ..

pub fn jsx_member_expression_object_from_jsx_member_expression<T>( self, inner: T, ) -> JSXMemberExpressionObject<'a>

where T: IntoIn<'a, Box<'a, JSXMemberExpression<'a>>>,

Convert a JSXMemberExpression into a JSXMemberExpressionObject::MemberExpression

pub fn jsx_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> JSXExpressionContainer<'a>

Builds a JSXExpressionContainer

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_expression_container instead.

Parameters

• span: The Span covering this node
• expression: The expression inside the container.

pub fn alloc_jsx_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> Box<'a, JSXExpressionContainer<'a>>

Builds a JSXExpressionContainer and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_expression_container instead.

Parameters

• span: The Span covering this node
• expression: The expression inside the container.

pub fn jsx_expression_jsx_empty_expression( self, span: Span, ) -> JSXExpression<'a>

Build a JSXExpression::EmptyExpression

Parameters

• span: The Span covering this node

pub fn jsx_expression_from_jsx_empty_expression<T>( self, inner: T, ) -> JSXExpression<'a>

where T: IntoIn<'a, JSXEmptyExpression>,

Convert a JSXEmptyExpression into a JSXExpression::EmptyExpression

pub fn jsx_expression_expression( self, inner: Expression<'a>, ) -> JSXExpression<'a>

pub fn jsx_empty_expression(self, span: Span) -> JSXEmptyExpression

Builds a JSXEmptyExpression

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_empty_expression instead.

Parameters

• span: The Span covering this node

pub fn alloc_jsx_empty_expression( self, span: Span, ) -> Box<'a, JSXEmptyExpression>

Builds a JSXEmptyExpression and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_empty_expression instead.

Parameters

• span: The Span covering this node

pub fn jsx_attribute_item_jsx_attribute( self, span: Span, name: JSXAttributeName<'a>, value: Option<JSXAttributeValue<'a>>, ) -> JSXAttributeItem<'a>

Build a JSXAttributeItem::Attribute

This node contains a JSXAttribute that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The name of the attribute. This is a prop in React-like applications.
• value: The value of the attribute. This can be a string literal, an expression,

pub fn jsx_attribute_item_from_jsx_attribute<T>( self, inner: T, ) -> JSXAttributeItem<'a>

where T: IntoIn<'a, Box<'a, JSXAttribute<'a>>>,

Convert a JSXAttribute into a JSXAttributeItem::Attribute

pub fn jsx_attribute_item_jsx_spread_attribute( self, span: Span, argument: Expression<'a>, ) -> JSXAttributeItem<'a>

Build a JSXAttributeItem::SpreadAttribute

This node contains a JSXSpreadAttribute that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• argument

pub fn jsx_attribute_item_from_jsx_spread_attribute<T>( self, inner: T, ) -> JSXAttributeItem<'a>

where T: IntoIn<'a, Box<'a, JSXSpreadAttribute<'a>>>,

Convert a JSXSpreadAttribute into a JSXAttributeItem::SpreadAttribute

pub fn jsx_attribute( self, span: Span, name: JSXAttributeName<'a>, value: Option<JSXAttributeValue<'a>>, ) -> JSXAttribute<'a>

Builds a JSXAttribute

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_attribute instead.

Parameters

• span: The Span covering this node
• name: The name of the attribute. This is a prop in React-like applications.
• value: The value of the attribute. This can be a string literal, an expression,

pub fn alloc_jsx_attribute( self, span: Span, name: JSXAttributeName<'a>, value: Option<JSXAttributeValue<'a>>, ) -> Box<'a, JSXAttribute<'a>>

Builds a JSXAttribute and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_attribute instead.

Parameters

• span: The Span covering this node
• name: The name of the attribute. This is a prop in React-like applications.
• value: The value of the attribute. This can be a string literal, an expression,

pub fn jsx_spread_attribute( self, span: Span, argument: Expression<'a>, ) -> JSXSpreadAttribute<'a>

Builds a JSXSpreadAttribute

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_spread_attribute instead.

Parameters

• span: The Span covering this node
• argument

pub fn alloc_jsx_spread_attribute( self, span: Span, argument: Expression<'a>, ) -> Box<'a, JSXSpreadAttribute<'a>>

Builds a JSXSpreadAttribute and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_spread_attribute instead.

Parameters

• span: The Span covering this node
• argument

pub fn jsx_attribute_name_jsx_identifier<A>( self, span: Span, name: A, ) -> JSXAttributeName<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a JSXAttributeName::Identifier

This node contains a JSXIdentifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• name: The name of the identifier.

pub fn jsx_attribute_name_from_jsx_identifier<T>( self, inner: T, ) -> JSXAttributeName<'a>

where T: IntoIn<'a, Box<'a, JSXIdentifier<'a>>>,

Convert a JSXIdentifier into a JSXAttributeName::Identifier

pub fn jsx_attribute_name_jsx_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, property: JSXIdentifier<'a>, ) -> JSXAttributeName<'a>

Build a JSXAttributeName::NamespacedName

This node contains a JSXNamespacedName that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• property: Name portion of the name, e.g. Orange in <Apple:Orange />

pub fn jsx_attribute_name_from_jsx_namespaced_name<T>( self, inner: T, ) -> JSXAttributeName<'a>

where T: IntoIn<'a, Box<'a, JSXNamespacedName<'a>>>,

Convert a JSXNamespacedName into a JSXAttributeName::NamespacedName

pub fn jsx_attribute_value_string_literal<A>( self, span: Span, value: A, ) -> JSXAttributeValue<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a JSXAttributeValue::StringLiteral

This node contains a StringLiteral that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value

pub fn jsx_attribute_value_from_string_literal<T>( self, inner: T, ) -> JSXAttributeValue<'a>

where T: IntoIn<'a, Box<'a, StringLiteral<'a>>>,

Convert a StringLiteral into a JSXAttributeValue::StringLiteral

pub fn jsx_attribute_value_jsx_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> JSXAttributeValue<'a>

Build a JSXAttributeValue::ExpressionContainer

This node contains a JSXExpressionContainer that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression: The expression inside the container.

pub fn jsx_attribute_value_from_jsx_expression_container<T>( self, inner: T, ) -> JSXAttributeValue<'a>

where T: IntoIn<'a, Box<'a, JSXExpressionContainer<'a>>>,

Convert a JSXExpressionContainer into a JSXAttributeValue::ExpressionContainer

pub fn jsx_attribute_value_jsx_element<T1, T2>( self, span: Span, opening_element: T1, closing_element: T2, children: Vec<'a, JSXChild<'a>>, ) -> JSXAttributeValue<'a>

where T1: IntoIn<'a, Box<'a, JSXOpeningElement<'a>>>, T2: IntoIn<'a, Option<Box<'a, JSXClosingElement<'a>>>>,

Build a JSXAttributeValue::Element

This node contains a JSXElement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• opening_element: Opening tag of the element.
• closing_element: Closing tag of the element. Will be None for self-closing tags.
• children: Children of the element. This can be text, other elements, or expressions.

pub fn jsx_attribute_value_from_jsx_element<T>( self, inner: T, ) -> JSXAttributeValue<'a>

where T: IntoIn<'a, Box<'a, JSXElement<'a>>>,

Convert a JSXElement into a JSXAttributeValue::Element

pub fn jsx_attribute_value_jsx_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, closing_fragment: JSXClosingFragment, children: Vec<'a, JSXChild<'a>>, ) -> JSXAttributeValue<'a>

Build a JSXAttributeValue::Fragment

This node contains a JSXFragment that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• opening_fragment: <>
• closing_fragment: </>
• children: Elements inside the fragment.

pub fn jsx_attribute_value_from_jsx_fragment<T>( self, inner: T, ) -> JSXAttributeValue<'a>

where T: IntoIn<'a, Box<'a, JSXFragment<'a>>>,

Convert a JSXFragment into a JSXAttributeValue::Fragment

pub fn jsx_identifier<A>(self, span: Span, name: A) -> JSXIdentifier<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a JSXIdentifier

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_identifier instead.

Parameters

• span: The Span covering this node
• name: The name of the identifier.

pub fn alloc_jsx_identifier<A>( self, span: Span, name: A, ) -> Box<'a, JSXIdentifier<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a JSXIdentifier and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_identifier instead.

Parameters

• span: The Span covering this node
• name: The name of the identifier.

pub fn jsx_child_jsx_text<A>(self, span: Span, value: A) -> JSXChild<'a>

where A: IntoIn<'a, Atom<'a>>,

Build a JSXChild::Text

This node contains a JSXText that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• value: The text content.

pub fn jsx_child_from_jsx_text<T>(self, inner: T) -> JSXChild<'a>

where T: IntoIn<'a, Box<'a, JSXText<'a>>>,

Convert a JSXText into a JSXChild::Text

pub fn jsx_child_jsx_element<T1, T2>( self, span: Span, opening_element: T1, closing_element: T2, children: Vec<'a, JSXChild<'a>>, ) -> JSXChild<'a>

where T1: IntoIn<'a, Box<'a, JSXOpeningElement<'a>>>, T2: IntoIn<'a, Option<Box<'a, JSXClosingElement<'a>>>>,

Build a JSXChild::Element

This node contains a JSXElement that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• opening_element: Opening tag of the element.
• closing_element: Closing tag of the element. Will be None for self-closing tags.
• children: Children of the element. This can be text, other elements, or expressions.

pub fn jsx_child_from_jsx_element<T>(self, inner: T) -> JSXChild<'a>

where T: IntoIn<'a, Box<'a, JSXElement<'a>>>,

Convert a JSXElement into a JSXChild::Element

pub fn jsx_child_jsx_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, closing_fragment: JSXClosingFragment, children: Vec<'a, JSXChild<'a>>, ) -> JSXChild<'a>

Build a JSXChild::Fragment

This node contains a JSXFragment that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• opening_fragment: <>
• closing_fragment: </>
• children: Elements inside the fragment.

pub fn jsx_child_from_jsx_fragment<T>(self, inner: T) -> JSXChild<'a>

where T: IntoIn<'a, Box<'a, JSXFragment<'a>>>,

Convert a JSXFragment into a JSXChild::Fragment

pub fn jsx_child_jsx_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> JSXChild<'a>

Build a JSXChild::ExpressionContainer

This node contains a JSXExpressionContainer that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression: The expression inside the container.

pub fn jsx_child_from_jsx_expression_container<T>( self, inner: T, ) -> JSXChild<'a>

where T: IntoIn<'a, Box<'a, JSXExpressionContainer<'a>>>,

Convert a JSXExpressionContainer into a JSXChild::ExpressionContainer

pub fn jsx_child_jsx_spread_child( self, span: Span, expression: Expression<'a>, ) -> JSXChild<'a>

Build a JSXChild::Spread

This node contains a JSXSpreadChild that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• expression: The expression being spread.

pub fn jsx_child_from_jsx_spread_child<T>(self, inner: T) -> JSXChild<'a>

where T: IntoIn<'a, Box<'a, JSXSpreadChild<'a>>>,

Convert a JSXSpreadChild into a JSXChild::Spread

pub fn jsx_spread_child( self, span: Span, expression: Expression<'a>, ) -> JSXSpreadChild<'a>

Builds a JSXSpreadChild

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_spread_child instead.

Parameters

• span: The Span covering this node
• expression: The expression being spread.

pub fn alloc_jsx_spread_child( self, span: Span, expression: Expression<'a>, ) -> Box<'a, JSXSpreadChild<'a>>

Builds a JSXSpreadChild and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_spread_child instead.

Parameters

• span: The Span covering this node
• expression: The expression being spread.

pub fn jsx_text<A>(self, span: Span, value: A) -> JSXText<'a>

where A: IntoIn<'a, Atom<'a>>,

Builds a JSXText

If you want the built node to be allocated in the memory arena, use AstBuilder::alloc_jsx_text instead.

Parameters

• span: The Span covering this node
• value: The text content.

pub fn alloc_jsx_text<A>(self, span: Span, value: A) -> Box<'a, JSXText<'a>>

where A: IntoIn<'a, Atom<'a>>,

Builds a JSXText and stores it in the memory arena.

Returns a Box containing the newly-allocated node. If you want a stack-allocated node, use AstBuilder::jsx_text instead.

Parameters

• span: The Span covering this node
• value: The text content.

Trait Implementations

impl<'a> Clone for AstBuilder<'a>

fn clone(&self) -> AstBuilder<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for AstBuilder<'a>