Struct AstBuilder 

pub struct AstBuilder<'a> {
    pub allocator: &'a Allocator,
}

AST builder which assigns dummy NodeIds to AST nodes.

For use where no NodeIds are required on AST nodes as they are built e.g. parser, because NodeIds are assigned later when building Semantic.

Fields

allocator: &'a Allocator

The memory allocator used to allocate AST nodes in the arena.

Implementations

impl<'a> AstBuilder<'a>

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

👎Deprecated:

Use ArenaBox::new_in instead

Move a value into the memory arena.

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

👎Deprecated:

Use ArenaVec::new_in instead

Create a new empty Vec that stores its elements in the memory arena.

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

👎Deprecated:

Use ArenaVec::with_capacity_in instead

Create a new empty Vec that stores its elements in the memory arena. Enough memory will be pre-allocated to store at least capacity elements.

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

👎Deprecated:

Use ArenaVec::from_value_in instead

Create a new arena-allocated Vec initialized with a single element.

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

👎Deprecated:

Use ArenaVec::from_iter_in instead

Collect an iterator into a new arena-allocated Vec.

pub fn vec_from_array<T, const N: usize>(self, array: [T; N]) -> ArenaVec<'a, T>

👎Deprecated:

Use ArenaVec::from_array_in instead

Create Vec from a fixed-size array.

This is preferable to vec_from_iter where source is an array, as size is statically known, and compiler is more likely to construct the values directly in arena, rather than constructing on stack and then copying to arena.

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

👎Deprecated:

Use Ident::from_in instead

Allocate an Ident from a string slice.

pub fn ident_from_strs_array<const N: usize>( self, strings: [&str; N], ) -> Ident<'a>

👎Deprecated:

Use Ident::from_strs_array_in instead

Allocate an Ident from an array of string slices.

pub fn ident_from_cow(self, value: &Cow<'a, str>) -> Ident<'a>

👎Deprecated:

Use Ident::from_cow_in instead

Convert a Cow<'a, str> to an Ident<'a>.

If the Cow borrows a string from arena, returns an Ident which references that same string, without allocating a new one.

If the Cow is owned, allocates the string into arena to generate a new Ident.

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

👎Deprecated:

Use Str::from_in instead

Allocate a Str from a string slice.

pub fn str_from_strs_array<const N: usize>(self, strings: [&str; N]) -> Str<'a>

👎Deprecated:

Use Str::from_strs_array_in instead

Allocate a Str from an array of string slices.

pub fn str_from_cow(self, value: &Cow<'a, str>) -> Str<'a>

👎Deprecated:

Use Str::from_cow_in instead

Convert a Cow<'a, str> to a Str<'a>.

If the Cow borrows a string from arena, returns a Str which references that same string, without allocating a new one.

If the Cow is owned, allocates the string into arena to generate a new Str.

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

👎Deprecated:

Use Expression::new_number_0 instead

0

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

👎Deprecated:

Use Expression::new_void_0 instead

void 0

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

👎Deprecated:

Use Expression::new_nan instead

NaN

pub fn use_strict_directive(self) -> Directive<'a>

👎Deprecated:

Use Directive::new_use_strict instead

"use strict" directive

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

👎Deprecated:

Use FormalParameter::new_plain instead

Create a FormalParameter with no type annotations, modifiers, decorators, or initializer.

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

👎Deprecated:

Use Function::boxed_plain_with_scope_id instead

Create a Function with no “extras”. i.e. no decorators, type annotations, accessibility modifiers, etc.

pub fn alloc_function_with_scope_id<T1, T2, T3, T4, T5>( self, span: Span, type: FunctionType, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: T2, params: T3, return_type: T4, body: T5, scope_id: ScopeId, ) -> ArenaBox<'a, Function<'a>>

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

👎Deprecated:

Use Function::boxed_with_scope_id instead

Build a Function with scope_id.

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

👎Deprecated:

Use ExportNamedDeclaration::boxed_plain_declaration instead

Create an empty ExportNamedDeclaration with no modifiers

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

👎Deprecated:

Use ExportNamedDeclaration::boxed_plain instead

Create an ExportNamedDeclaration with no modifiers that contains a set of exported symbol names.

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

👎Deprecated:

Use TemplateElement::new_escape_raw instead

Build a TemplateElement, escaping special characters in the raw value.

Like AstBuilder::template_element, but escapes backticks, ${, backslashes, and carriage returns in value.raw first.

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

👎Deprecated:

Use TemplateElement::new_escape_raw_with_lone_surrogates instead

Build a TemplateElement with lone_surrogates, escaping special characters in the raw value.

Like AstBuilder::template_element_with_lone_surrogates, but escapes backticks, ${, backslashes, and carriage returns in value.raw first.

impl<'a> AstBuilder<'a>

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

Create a new AstBuilder that will allocate AST types in the provided Allocator.

impl<'a> AstBuilder<'a>

pub fn program( self, span: Span, source_type: SourceType, source_text: &'a str, comments: ArenaVec<'a, Comment>, hashbang: Option<Hashbang<'a>>, directives: ArenaVec<'a, Directive<'a>>, body: ArenaVec<'a, Statement<'a>>, ) -> Program<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Program.

Parameters

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

pub fn program_with_scope_id( self, span: Span, source_type: SourceType, source_text: &'a str, comments: ArenaVec<'a, Comment>, hashbang: Option<Hashbang<'a>>, directives: ArenaVec<'a, Directive<'a>>, body: ArenaVec<'a, Statement<'a>>, scope_id: ScopeId, ) -> Program<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Program with scope_id.

Parameters

• span: The Span covering this node
• source_type
• source_text
• comments: Sorted comments
• hashbang
• directives
• body
• scope_id

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::BooleanLiteral.

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

Parameters

• span: Node location in source code.
• value: The boolean value itself

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::NullLiteral.

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

Parameters

• span: Node location in source code.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::NumericLiteral.

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

Parameters

• span: Node location in source code.
• value: The value of the number, converted into base 10
• raw: The number as it appears in source code
• base: The base representation used by the literal in source code

pub fn expression_big_int_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, base: BigintBase, ) -> Expression<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::BigIntLiteral.

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

Parameters

• span: Node location in source code.
• value: Bigint value in base 10 with no underscores
• raw: The bigint as it appears in source code
• base: The base representation used by the literal in source code

pub fn expression_reg_exp_literal( self, span: Span, regex: RegExp<'a>, raw: Option<Str<'a>>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::RegExpLiteral.

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

Parameters

• span: Node location in source code.
• regex: The parsed regular expression. See oxc_regular_expression for more
• raw: The regular expression as it appears in source code

pub fn expression_string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> Expression<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::StringLiteral.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn expression_string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> Expression<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::StringLiteral with lone_surrogates.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_identifier<S1>(self, span: Span, name: S1) -> Expression<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::Identifier.

This node contains an 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_identifier_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> Expression<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::Identifier with reference_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_super(self, span: Span) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_array( self, span: Span, elements: ArenaVec<'a, ArrayExpressionElement<'a>>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::ArrayExpression.

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

Parameters

• span: The Span covering this node
• elements

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<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, ArenaBox<'a, FunctionBody<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::ArrowFunctionExpression.

This node contains an 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 () => {}
• async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::ArrowFunctionExpression with scope_id and pure and pife.

This node contains an 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 () => {}
• async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::AssignmentExpression.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::AwaitExpression.

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

Parameters

• span: The Span covering this node
• argument

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_call<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::CallExpression.

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

Parameters

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

pub fn expression_call_with_pure<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, pure: bool, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::CallExpression with pure.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments
• optional
• pure: true if the call expression is marked with a /* @__PURE__ */ comment

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_class<T1, T2, T3>( self, span: Span, type: ClassType, decorators: ArenaVec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_arguments: T2, implements: ArenaVec<'a, TSClassImplements<'a>>, body: T3, abstract: bool, declare: bool, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::ClassExpression.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::ClassExpression with scope_id.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed
• scope_id: Id of the scope created by the Class, including type parameters and

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_function<T1, T2, T3, T4, T5>( self, span: Span, type: FunctionType, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: T2, params: T3, return_type: T4, body: T5, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::FunctionExpression.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::FunctionExpression with scope_id and pure and pife.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

pub fn expression_import( self, span: Span, source: Expression<'a>, options: Option<Expression<'a>>, phase: Option<ImportPhase>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::ImportExpression.

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

Parameters

• span: The Span covering this node
• source
• options
• phase

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_new<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::NewExpression.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments: true if the new expression is marked with a /* @__PURE__ */ comment

pub fn expression_new_with_pure<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, pure: bool, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::NewExpression with pure.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments: true if the new expression is marked with a /* @__PURE__ */ comment
• pure

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::ObjectExpression.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_sequence( self, span: Span, expressions: ArenaVec<'a, Expression<'a>>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_tagged_template<T1>( self, span: Span, tag: Expression<'a>, type_arguments: T1, quasi: TemplateLiteral<'a>, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::TaggedTemplateExpression.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_unary( self, span: Span, operator: UnaryOperator, argument: Expression<'a>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::UnaryExpression.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::UpdateExpression.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_private_in( self, span: Span, left: PrivateIdentifier<'a>, right: Expression<'a>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::PrivateInExpression.

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

Parameters

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

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::JSXElement.

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

Parameters

• span: Node location in source code.
• opening_element: Opening tag of the element.
• children: Children of the element.
• closing_element: Closing tag of the element.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::JSXFragment.

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

Parameters

• span: Node location in source code.
• opening_fragment: <>
• children: Elements inside the fragment.
• closing_fragment: </>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_ts_satisfies( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::TSSatisfiesExpression.

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

Parameters

• span: The Span covering this node
• expression: The value expression being constrained.
• type_annotation: The type expression must satisfy.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::TSTypeAssertion.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_ts_instantiation<T1>( self, span: Span, expression: Expression<'a>, type_arguments: T1, ) -> Expression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::TSInstantiationExpression.

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

Parameters

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

pub fn expression_v8_intrinsic( self, span: Span, name: IdentifierName<'a>, arguments: ArenaVec<'a, Argument<'a>>, ) -> Expression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Expression::V8IntrinsicExpression.

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

Parameters

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

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

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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<S1>( self, span: Span, name: S1, ) -> ArenaBox<'a, IdentifierName<'a>>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an IdentifierName, and store 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<S1>( self, span: Span, name: S1, ) -> IdentifierReference<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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<S1>( self, span: Span, name: S1, ) -> ArenaBox<'a, IdentifierReference<'a>>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an IdentifierReference, and store 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 identifier_reference_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> IdentifierReference<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an IdentifierReference with reference_id.

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

Parameters

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

pub fn alloc_identifier_reference_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> ArenaBox<'a, IdentifierReference<'a>>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an IdentifierReference with reference_id, and store it in the memory arena.

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

Parameters

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

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

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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<S1>( self, span: Span, name: S1, ) -> ArenaBox<'a, BindingIdentifier<'a>>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingIdentifier, and store 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 binding_identifier_with_symbol_id<S1>( self, span: Span, name: S1, symbol_id: SymbolId, ) -> BindingIdentifier<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingIdentifier with symbol_id.

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

Parameters

• span: The Span covering this node
• name: The identifier name being bound.
• symbol_id: Unique identifier for this binding.

pub fn alloc_binding_identifier_with_symbol_id<S1>( self, span: Span, name: S1, symbol_id: SymbolId, ) -> ArenaBox<'a, BindingIdentifier<'a>>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingIdentifier with symbol_id, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• name: The identifier name being bound.
• symbol_id: Unique identifier for this binding.

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

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a LabelIdentifier.

Parameters

• span: The Span covering this node
• name

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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) -> ArenaBox<'a, ThisExpression>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ThisExpression, and store 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: ArenaVec<'a, ArrayExpressionElement<'a>>, ) -> ArrayExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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

pub fn alloc_array_expression( self, span: Span, elements: ArenaVec<'a, ArrayExpressionElement<'a>>, ) -> ArenaBox<'a, ArrayExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ArrayExpression, and store 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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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_elision( self, span: Span, ) -> ArrayExpressionElement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ArrayExpressionElement::Elision.

This node contains an Elision that will be stored in the memory arena.

Parameters

• span: The Span covering this node

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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) -> ArenaBox<'a, Elision>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an Elision, and store 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: ArenaVec<'a, ObjectPropertyKind<'a>>, ) -> ObjectExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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

pub fn alloc_object_expression( self, span: Span, properties: ArenaVec<'a, ObjectPropertyKind<'a>>, ) -> ArenaBox<'a, ObjectExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ObjectExpression, and store 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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ObjectPropertyKind::ObjectProperty.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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( self, span: Span, kind: PropertyKind, key: PropertyKey<'a>, value: Expression<'a>, method: bool, shorthand: bool, computed: bool, ) -> ObjectProperty<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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
• method
• shorthand
• computed

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ObjectProperty, and store 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
• method
• shorthand
• computed

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

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a PropertyKey::StaticIdentifier.

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

Parameters

• span: The Span covering this node
• name

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

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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 template_literal( self, span: Span, quasis: ArenaVec<'a, TemplateElement<'a>>, expressions: ArenaVec<'a, Expression<'a>>, ) -> TemplateLiteral<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, TemplateElement<'a>>, expressions: ArenaVec<'a, Expression<'a>>, ) -> ArenaBox<'a, TemplateLiteral<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TemplateLiteral, and store 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>, type_arguments: T1, quasi: TemplateLiteral<'a>, ) -> TaggedTemplateExpression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• type_arguments
• quasi

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TaggedTemplateExpression, and store 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
• type_arguments
• quasi

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TemplateElement.

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TemplateElement with lone_surrogates.

Parameters

• span: The Span covering this node
• value
• tail
• lone_surrogates: The template element contains lone surrogates.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_static( self, span: Span, object: Expression<'a>, property: IdentifierName<'a>, optional: bool, ) -> MemberExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_private_field_expression( self, span: Span, object: Expression<'a>, field: PrivateIdentifier<'a>, optional: bool, ) -> MemberExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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 computed_member_expression( self, span: Span, object: Expression<'a>, expression: Expression<'a>, optional: bool, ) -> ComputedMemberExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, ComputedMemberExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ComputedMemberExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, StaticMemberExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StaticMemberExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, PrivateFieldExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a PrivateFieldExpression, and store 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_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, ) -> CallExpression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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_arguments
• arguments
• optional

pub fn alloc_call_expression<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, ) -> ArenaBox<'a, CallExpression<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a CallExpression, and store 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_arguments
• arguments
• optional

pub fn call_expression_with_pure<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, pure: bool, ) -> CallExpression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a CallExpression with pure.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments
• optional
• pure: true if the call expression is marked with a /* @__PURE__ */ comment

pub fn alloc_call_expression_with_pure<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, pure: bool, ) -> ArenaBox<'a, CallExpression<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a CallExpression with pure, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments
• optional
• pure: true if the call expression is marked with a /* @__PURE__ */ comment

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• type_arguments
• arguments: true if the new expression is marked with a /* @__PURE__ */ comment

pub fn alloc_new_expression<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, ) -> ArenaBox<'a, NewExpression<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a NewExpression, and store 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
• type_arguments
• arguments: true if the new expression is marked with a /* @__PURE__ */ comment

pub fn new_expression_with_pure<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, pure: bool, ) -> NewExpression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a NewExpression with pure.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments: true if the new expression is marked with a /* @__PURE__ */ comment
• pure

pub fn alloc_new_expression_with_pure<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, pure: bool, ) -> ArenaBox<'a, NewExpression<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a NewExpression with pure, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments: true if the new expression is marked with a /* @__PURE__ */ comment
• pure

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, MetaProperty<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a MetaProperty, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, SpreadElement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SpreadElement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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 update_expression( self, span: Span, operator: UpdateOperator, prefix: bool, argument: SimpleAssignmentTarget<'a>, ) -> UpdateExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, UpdateExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an UpdateExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, UnaryExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an UnaryExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, BinaryExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BinaryExpression, and store 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>, right: Expression<'a>, ) -> PrivateInExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• right

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a PrivateInExpression, and store 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
• right

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, LogicalExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a LogicalExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, ConditionalExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ConditionalExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, AssignmentExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentExpression, and store 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 simple_assignment_target_assignment_target_identifier<S1>( self, span: Span, name: S1, ) -> SimpleAssignmentTarget<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SimpleAssignmentTarget::AssignmentTargetIdentifier.

This node contains an 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_assignment_target_identifier_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> SimpleAssignmentTarget<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SimpleAssignmentTarget::AssignmentTargetIdentifier with reference_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_ts_satisfies_expression( self, span: Span, expression: Expression<'a>, type_annotation: TSType<'a>, ) -> SimpleAssignmentTarget<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The value expression being constrained.
• type_annotation: The type expression must satisfy.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_ts_type_assertion( self, span: Span, type_annotation: TSType<'a>, expression: Expression<'a>, ) -> SimpleAssignmentTarget<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SimpleAssignmentTarget::TSTypeAssertion.

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

Parameters

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

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

where T1: IntoIn<'a, Option<ArenaBox<'a, AssignmentTargetRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetPattern::ArrayAssignmentTarget.

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

Parameters

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

pub fn assignment_target_pattern_object_assignment_target<T1>( self, span: Span, properties: ArenaVec<'a, AssignmentTargetProperty<'a>>, rest: T1, ) -> AssignmentTargetPattern<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, AssignmentTargetRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetPattern::ObjectAssignmentTarget.

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

Parameters

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

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

where T1: IntoIn<'a, Option<ArenaBox<'a, AssignmentTargetRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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

pub fn alloc_array_assignment_target<T1>( self, span: Span, elements: ArenaVec<'a, Option<AssignmentTargetMaybeDefault<'a>>>, rest: T1, ) -> ArenaBox<'a, ArrayAssignmentTarget<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, AssignmentTargetRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ArrayAssignmentTarget, and store 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

pub fn object_assignment_target<T1>( self, span: Span, properties: ArenaVec<'a, AssignmentTargetProperty<'a>>, rest: T1, ) -> ObjectAssignmentTarget<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, AssignmentTargetRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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<T1>( self, span: Span, properties: ArenaVec<'a, AssignmentTargetProperty<'a>>, rest: T1, ) -> ArenaBox<'a, ObjectAssignmentTarget<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, AssignmentTargetRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ObjectAssignmentTarget, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, AssignmentTargetRest<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetRest, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetMaybeDefault::AssignmentTargetWithDefault.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, AssignmentTargetWithDefault<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetWithDefault, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetProperty::AssignmentTargetPropertyIdentifier.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetProperty::AssignmentTargetPropertyProperty.

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

Parameters

• span: The Span covering this node
• name: The property key
• binding: The binding part of the property
• computed: Property was declared with a computed key

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>>, ) -> ArenaBox<'a, AssignmentTargetPropertyIdentifier<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetPropertyIdentifier, and store 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>, computed: bool, ) -> AssignmentTargetPropertyProperty<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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: The property key
• binding: The binding part of the property
• computed: Property was declared with a computed key

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentTargetPropertyProperty, and store 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: The property key
• binding: The binding part of the property
• computed: Property was declared with a computed key

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, Expression<'a>>, ) -> ArenaBox<'a, SequenceExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SequenceExpression, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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) -> ArenaBox<'a, Super>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Super, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, AwaitExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AwaitExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, ChainExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ChainExpression, and store 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_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, ) -> ChainElement<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_arguments
• arguments
• optional

pub fn chain_element_call_expression_with_pure<T1>( self, span: Span, callee: Expression<'a>, type_arguments: T1, arguments: ArenaVec<'a, Argument<'a>>, optional: bool, pure: bool, ) -> ChainElement<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ChainElement::CallExpression with pure.

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

Parameters

• span: The Span covering this node
• callee
• type_arguments
• arguments
• optional
• pure: true if the call expression is marked with a /* @__PURE__ */ comment

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ChainElement::TSNonNullExpression.

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

Parameters

• span: The Span covering this node
• expression

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, ParenthesizedExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ParenthesizedExpression, and store 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: ArenaVec<'a, Statement<'a>>, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_block_with_scope_id( self, span: Span, body: ArenaVec<'a, Statement<'a>>, scope_id: ScopeId, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::BlockStatement with scope_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_continue( self, span: Span, label: Option<LabelIdentifier<'a>>, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_debugger(self, span: Span) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_do_while( self, span: Span, body: Statement<'a>, test: Expression<'a>, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_empty(self, span: Span) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::EmptyStatement.

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

Parameters

• span: The Span covering this node

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::ExpressionStatement.

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

Parameters

• span: The Span covering this node
• expression

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_for_in_with_scope_id( self, span: Span, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, scope_id: ScopeId, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::ForInStatement with scope_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::ForOfStatement.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::ForOfStatement with scope_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_for_with_scope_id( self, span: Span, init: Option<ForStatementInit<'a>>, test: Option<Expression<'a>>, update: Option<Expression<'a>>, body: Statement<'a>, scope_id: ScopeId, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::ForStatement with scope_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::IfStatement.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_return( self, span: Span, argument: Option<Expression<'a>>, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_switch( self, span: Span, discriminant: Expression<'a>, cases: ArenaVec<'a, SwitchCase<'a>>, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_switch_with_scope_id( self, span: Span, discriminant: Expression<'a>, cases: ArenaVec<'a, SwitchCase<'a>>, scope_id: ScopeId, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::SwitchStatement with scope_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The expression being thrown, e.g. err in throw err;

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: Statements in the try block
• handler: The catch clause, including the parameter and the block statement
• finalizer: The finally clause

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_with( self, span: Span, object: Expression<'a>, body: Statement<'a>, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_with_with_scope_id( self, span: Span, object: Expression<'a>, body: Statement<'a>, scope_id: ScopeId, ) -> Statement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Statement::WithStatement with scope_id.

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

Parameters

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

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

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Directive.

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<S1>(self, span: Span, value: S1) -> Hashbang<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Hashbang.

Parameters

• span: The Span covering this node
• value

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, Statement<'a>>, ) -> ArenaBox<'a, BlockStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BlockStatement, and store 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 block_statement_with_scope_id( self, span: Span, body: ArenaVec<'a, Statement<'a>>, scope_id: ScopeId, ) -> BlockStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BlockStatement with scope_id.

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

Parameters

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

pub fn alloc_block_statement_with_scope_id( self, span: Span, body: ArenaVec<'a, Statement<'a>>, scope_id: ScopeId, ) -> ArenaBox<'a, BlockStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BlockStatement with scope_id, and store it in the memory arena.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_function<T1, T2, T3, T4, T5>( self, span: Span, type: FunctionType, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: T2, params: T3, return_type: T4, body: T5, ) -> Declaration<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::FunctionDeclaration.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::FunctionDeclaration with scope_id and pure and pife.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::ClassDeclaration.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::ClassDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed
• scope_id: Id of the scope created by the Class, including type parameters and

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<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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 alias’s identifier, e.g. Foo in type Foo = number.
• type_parameters
• type_annotation
• declare

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::TSTypeAliasDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• id: Type alias’s identifier, e.g. Foo in type Foo = number.
• type_parameters
• type_annotation
• declare
• scope_id

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}

pub fn declaration_ts_interface_with_scope_id<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, extends: ArenaVec<'a, TSInterfaceHeritage<'a>>, body: T2, declare: bool, scope_id: ScopeId, ) -> Declaration<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::TSInterfaceDeclaration with scope_id.

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.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}
• scope_id

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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
• body
• const: true for const enums
• declare

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The name of the module/namespace being declared.
• body
• kind: The keyword used to define this module declaration.
• declare

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::TSModuleDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• id: The name of the module/namespace being declared.
• body
• kind: The keyword used to define this module declaration.
• declare
• scope_id

pub fn declaration_ts_global( self, span: Span, global_span: Span, body: TSModuleBlock<'a>, declare: bool, ) -> Declaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::TSGlobalDeclaration.

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

Parameters

• span: The Span covering this node
• global_span: Span of global keyword
• body
• declare

pub fn declaration_ts_global_with_scope_id( self, span: Span, global_span: Span, body: TSModuleBlock<'a>, declare: bool, scope_id: ScopeId, ) -> Declaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Declaration::TSGlobalDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• global_span: Span of global keyword
• body
• declare
• scope_id

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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 variable_declaration( self, span: Span, kind: VariableDeclarationKind, declarations: ArenaVec<'a, VariableDeclarator<'a>>, declare: bool, ) -> VariableDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, VariableDeclarator<'a>>, declare: bool, ) -> ArenaBox<'a, VariableDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a VariableDeclaration, and store 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<T1>( self, span: Span, kind: VariableDeclarationKind, id: BindingPattern<'a>, type_annotation: T1, init: Option<Expression<'a>>, definite: bool, ) -> VariableDeclarator<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a VariableDeclarator.

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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) -> ArenaBox<'a, EmptyStatement>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an EmptyStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, ExpressionStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExpressionStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>>, ) -> ArenaBox<'a, IfStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an IfStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, DoWhileStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a DoWhileStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, WhileStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a WhileStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, ForStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForStatement, and store 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_with_scope_id( self, span: Span, init: Option<ForStatementInit<'a>>, test: Option<Expression<'a>>, update: Option<Expression<'a>>, body: Statement<'a>, scope_id: ScopeId, ) -> ForStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForStatement with scope_id.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForStatement with scope_id, and store it in the memory arena.

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

Parameters

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

pub fn for_statement_init_variable_declaration( self, span: Span, kind: VariableDeclarationKind, declarations: ArenaVec<'a, VariableDeclarator<'a>>, declare: bool, ) -> ForStatementInit<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_in_statement( self, span: Span, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> ForInStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, ForInStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForInStatement, and store 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_in_statement_with_scope_id( self, span: Span, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, scope_id: ScopeId, ) -> ForInStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForInStatement with scope_id.

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

Parameters

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

pub fn alloc_for_in_statement_with_scope_id( self, span: Span, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, scope_id: ScopeId, ) -> ArenaBox<'a, ForInStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForInStatement with scope_id, and store 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_with_scope_id instead.

Parameters

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

pub fn for_statement_left_variable_declaration( self, span: Span, kind: VariableDeclarationKind, declarations: ArenaVec<'a, VariableDeclarator<'a>>, declare: bool, ) -> ForStatementLeft<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_of_statement( self, span: Span, await: bool, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, ) -> ForOfStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• await
• left
• right
• body

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForOfStatement, and store 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
• await
• left
• right
• body

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForOfStatement with scope_id.

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

Parameters

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

pub fn alloc_for_of_statement_with_scope_id( self, span: Span, await: bool, left: ForStatementLeft<'a>, right: Expression<'a>, body: Statement<'a>, scope_id: ScopeId, ) -> ArenaBox<'a, ForOfStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ForOfStatement with scope_id, and store 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_with_scope_id instead.

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>>, ) -> ArenaBox<'a, ContinueStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ContinueStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>>, ) -> ArenaBox<'a, BreakStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BreakStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>>, ) -> ArenaBox<'a, ReturnStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ReturnStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, WithStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a WithStatement, and store 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 with_statement_with_scope_id( self, span: Span, object: Expression<'a>, body: Statement<'a>, scope_id: ScopeId, ) -> WithStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a WithStatement with scope_id.

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

Parameters

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

pub fn alloc_with_statement_with_scope_id( self, span: Span, object: Expression<'a>, body: Statement<'a>, scope_id: ScopeId, ) -> ArenaBox<'a, WithStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a WithStatement with scope_id, and store it in the memory arena.

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

Parameters

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

pub fn switch_statement( self, span: Span, discriminant: Expression<'a>, cases: ArenaVec<'a, SwitchCase<'a>>, ) -> SwitchStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, SwitchCase<'a>>, ) -> ArenaBox<'a, SwitchStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SwitchStatement, and store 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_statement_with_scope_id( self, span: Span, discriminant: Expression<'a>, cases: ArenaVec<'a, SwitchCase<'a>>, scope_id: ScopeId, ) -> SwitchStatement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SwitchStatement with scope_id.

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

Parameters

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

pub fn alloc_switch_statement_with_scope_id( self, span: Span, discriminant: Expression<'a>, cases: ArenaVec<'a, SwitchCase<'a>>, scope_id: ScopeId, ) -> ArenaBox<'a, SwitchStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SwitchStatement with scope_id, and store it in the memory arena.

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

Parameters

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

pub fn switch_case( self, span: Span, test: Option<Expression<'a>>, consequent: ArenaVec<'a, Statement<'a>>, ) -> SwitchCase<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a SwitchCase.

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, LabeledStatement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a LabeledStatement, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The expression being thrown, e.g. err in throw err;

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ThrowStatement, and store 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: The expression being thrown, e.g. err in throw err;

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: Statements in the try block
• handler: The catch clause, including the parameter and the block statement
• finalizer: The finally clause

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TryStatement, and store 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: Statements in the try block
• handler: The catch clause, including the parameter and the block statement
• finalizer: The finally clause

pub fn catch_clause<T1>( self, span: Span, param: Option<CatchParameter<'a>>, body: T1, ) -> CatchClause<'a>

where T1: IntoIn<'a, ArenaBox<'a, BlockStatement<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The caught error parameter, e.g. e in catch (e) {}
• body: The statements run when an error is caught

pub fn alloc_catch_clause<T1>( self, span: Span, param: Option<CatchParameter<'a>>, body: T1, ) -> ArenaBox<'a, CatchClause<'a>>

where T1: IntoIn<'a, ArenaBox<'a, BlockStatement<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a CatchClause, and store 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: The caught error parameter, e.g. e in catch (e) {}
• body: The statements run when an error is caught

pub fn catch_clause_with_scope_id<T1>( self, span: Span, param: Option<CatchParameter<'a>>, body: T1, scope_id: ScopeId, ) -> CatchClause<'a>

where T1: IntoIn<'a, ArenaBox<'a, BlockStatement<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a CatchClause with scope_id.

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

Parameters

• span: The Span covering this node
• param: The caught error parameter, e.g. e in catch (e) {}
• body: The statements run when an error is caught
• scope_id

pub fn alloc_catch_clause_with_scope_id<T1>( self, span: Span, param: Option<CatchParameter<'a>>, body: T1, scope_id: ScopeId, ) -> ArenaBox<'a, CatchClause<'a>>

where T1: IntoIn<'a, ArenaBox<'a, BlockStatement<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a CatchClause with scope_id, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• param: The caught error parameter, e.g. e in catch (e) {}
• body: The statements run when an error is caught
• scope_id

pub fn catch_parameter<T1>( self, span: Span, pattern: BindingPattern<'a>, type_annotation: T1, ) -> CatchParameter<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a CatchParameter.

Parameters

• span: The Span covering this node
• pattern: The bound error
• type_annotation

pub fn debugger_statement(self, span: Span) -> DebuggerStatement

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, DebuggerStatement>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a DebuggerStatement, and store 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_binding_identifier<S1>( self, span: Span, name: S1, ) -> BindingPattern<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingPattern::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_binding_identifier_with_symbol_id<S1>( self, span: Span, name: S1, symbol_id: SymbolId, ) -> BindingPattern<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingPattern::BindingIdentifier with symbol_id.

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.
• symbol_id: Unique identifier for this binding.

pub fn binding_pattern_object_pattern<T1>( self, span: Span, properties: ArenaVec<'a, BindingProperty<'a>>, rest: T1, ) -> BindingPattern<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, BindingRestElement<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingPattern::ObjectPattern.

This node contains an ObjectPattern that will be stored in the memory arena.

Parameters

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

pub fn binding_pattern_array_pattern<T1>( self, span: Span, elements: ArenaVec<'a, Option<BindingPattern<'a>>>, rest: T1, ) -> BindingPattern<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, BindingRestElement<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingPattern::ArrayPattern.

This node contains an ArrayPattern that will be stored in the memory arena.

Parameters

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

pub fn binding_pattern_assignment_pattern( self, span: Span, left: BindingPattern<'a>, right: Expression<'a>, ) -> BindingPattern<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingPattern::AssignmentPattern.

This node contains an AssignmentPattern that will be stored in the memory arena.

Parameters

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

pub fn assignment_pattern( self, span: Span, left: BindingPattern<'a>, right: Expression<'a>, ) -> AssignmentPattern<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, AssignmentPattern<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AssignmentPattern, and store 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: ArenaVec<'a, BindingProperty<'a>>, rest: T1, ) -> ObjectPattern<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, BindingRestElement<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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: ArenaVec<'a, BindingProperty<'a>>, rest: T1, ) -> ArenaBox<'a, ObjectPattern<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, BindingRestElement<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ObjectPattern, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingProperty.

Parameters

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

pub fn array_pattern<T1>( self, span: Span, elements: ArenaVec<'a, Option<BindingPattern<'a>>>, rest: T1, ) -> ArrayPattern<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, BindingRestElement<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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: ArenaVec<'a, Option<BindingPattern<'a>>>, rest: T1, ) -> ArenaBox<'a, ArrayPattern<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, BindingRestElement<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ArrayPattern, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, BindingRestElement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BindingRestElement, and store 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, T5>( self, span: Span, type: FunctionType, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: T2, params: T3, return_type: T4, body: T5, ) -> Function<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Function.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Function, and store 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

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.

pub fn function_with_scope_id_and_pure_and_pife<T1, T2, T3, T4, T5>( self, span: Span, type: FunctionType, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: T2, params: T3, return_type: T4, body: T5, scope_id: ScopeId, pure: bool, pife: bool, ) -> Function<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Function with scope_id and pure and pife.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

pub fn alloc_function_with_scope_id_and_pure_and_pife<T1, T2, T3, T4, T5>( self, span: Span, type: FunctionType, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: T2, params: T3, return_type: T4, body: T5, scope_id: ScopeId, pure: bool, pife: bool, ) -> ArenaBox<'a, Function<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Function with scope_id and pure and pife, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

pub fn formal_parameters<T1>( self, span: Span, kind: FormalParameterKind, items: ArenaVec<'a, FormalParameter<'a>>, rest: T1, ) -> FormalParameters<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, FormalParameterRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, FormalParameter<'a>>, rest: T1, ) -> ArenaBox<'a, FormalParameters<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, FormalParameterRest<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a FormalParameters, and store 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<T1, T2>( self, span: Span, decorators: ArenaVec<'a, Decorator<'a>>, pattern: BindingPattern<'a>, type_annotation: T1, initializer: T2, optional: bool, accessibility: Option<TSAccessibility>, readonly: bool, override: bool, ) -> FormalParameter<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>, T2: IntoIn<'a, Option<ArenaBox<'a, Expression<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a FormalParameter.

Parameters

• span: The Span covering this node
• decorators
• pattern
• type_annotation
• initializer
• optional
• accessibility
• readonly
• override

pub fn formal_parameter_rest<T1>( self, span: Span, decorators: ArenaVec<'a, Decorator<'a>>, rest: BindingRestElement<'a>, type_annotation: T1, ) -> FormalParameterRest<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a FormalParameterRest.

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

Parameters

• span: The Span covering this node
• decorators
• rest
• type_annotation

pub fn alloc_formal_parameter_rest<T1>( self, span: Span, decorators: ArenaVec<'a, Decorator<'a>>, rest: BindingRestElement<'a>, type_annotation: T1, ) -> ArenaBox<'a, FormalParameterRest<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a FormalParameterRest, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• decorators
• rest
• type_annotation

pub fn function_body( self, span: Span, directives: ArenaVec<'a, Directive<'a>>, statements: ArenaVec<'a, Statement<'a>>, ) -> FunctionBody<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, Directive<'a>>, statements: ArenaVec<'a, Statement<'a>>, ) -> ArenaBox<'a, FunctionBody<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a FunctionBody, and store 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<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>, T4: IntoIn<'a, ArenaBox<'a, FunctionBody<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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 () => {}
• 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, ) -> ArenaBox<'a, ArrowFunctionExpression<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ArrowFunctionExpression, and store 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 () => {}
• async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.

pub fn arrow_function_expression_with_scope_id_and_pure_and_pife<T1, T2, T3, T4>( self, span: Span, expression: bool, async: bool, type_parameters: T1, params: T2, return_type: T3, body: T4, scope_id: ScopeId, pure: bool, pife: bool, ) -> ArrowFunctionExpression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ArrowFunctionExpression with scope_id and pure and pife.

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

Parameters

• span: The Span covering this node
• expression: Is the function body an arrow expression? i.e. () => expr instead of () => {}
• async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

pub fn alloc_arrow_function_expression_with_scope_id_and_pure_and_pife<T1, T2, T3, T4>( self, span: Span, expression: bool, async: bool, type_parameters: T1, params: T2, return_type: T3, body: T4, scope_id: ScopeId, pure: bool, pife: bool, ) -> ArenaBox<'a, ArrowFunctionExpression<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ArrowFunctionExpression with scope_id and pure and pife, and store 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_with_scope_id_and_pure_and_pife instead.

Parameters

• span: The Span covering this node
• expression: Is the function body an arrow expression? i.e. () => expr instead of () => {}
• async
• type_parameters
• params
• return_type
• body: See expression for whether this arrow expression returns an expression.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>>, ) -> ArenaBox<'a, YieldExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a YieldExpression, and store 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, span: Span, type: ClassType, decorators: ArenaVec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_arguments: T2, implements: ArenaVec<'a, TSClassImplements<'a>>, body: T3, abstract: bool, declare: bool, ) -> Class<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Class.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Class, and store 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

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed

pub fn class_with_scope_id<T1, T2, T3>( self, span: Span, type: ClassType, decorators: ArenaVec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_arguments: T2, implements: ArenaVec<'a, TSClassImplements<'a>>, body: T3, abstract: bool, declare: bool, scope_id: ScopeId, ) -> Class<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Class with scope_id.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed
• scope_id: Id of the scope created by the Class, including type parameters and

pub fn alloc_class_with_scope_id<T1, T2, T3>( self, span: Span, type: ClassType, decorators: ArenaVec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_arguments: T2, implements: ArenaVec<'a, TSClassImplements<'a>>, body: T3, abstract: bool, declare: bool, scope_id: ScopeId, ) -> ArenaBox<'a, Class<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Class with scope_id, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed
• scope_id: Id of the scope created by the Class, including type parameters and

pub fn class_body( self, span: Span, body: ArenaVec<'a, ClassElement<'a>>, ) -> ClassBody<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, ClassElement<'a>>, ) -> ArenaBox<'a, ClassBody<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ClassBody, and store 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: ArenaVec<'a, Statement<'a>>, ) -> ClassElement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_static_block_with_scope_id( self, span: Span, body: ArenaVec<'a, Statement<'a>>, scope_id: ScopeId, ) -> ClassElement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ClassElement::StaticBlock with scope_id.

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

Parameters

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

pub fn class_element_method_definition<T1>( self, span: Span, type: MethodDefinitionType, decorators: ArenaVec<'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, ArenaBox<'a, Function<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ClassElement::MethodDefinition.

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

Parameters

• span: The Span covering this node
• type: Method definition type
• decorators
• key
• value
• kind
• computed
• static
• override
• optional
• accessibility

pub fn class_element_property_definition<T1>( self, span: Span, type: PropertyDefinitionType, decorators: ArenaVec<'a, Decorator<'a>>, key: PropertyKey<'a>, type_annotation: T1, value: Option<Expression<'a>>, computed: bool, static: bool, declare: bool, override: bool, optional: bool, definite: bool, readonly: bool, accessibility: Option<TSAccessibility>, ) -> ClassElement<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ClassElement::PropertyDefinition.

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

Parameters

• span: The Span covering this node
• type
• decorators: Decorators applied to the property.
• key: The expression used to declare the property.
• type_annotation: Type annotation on the property.
• value: Initialized value in the declaration.
• computed: Property was declared with a computed key
• static: Property was declared with a static modifier
• declare: Property is declared with a declare modifier.
• override
• optional: true when created with an optional modifier (?)
• definite
• readonly: true when declared with a readonly modifier
• accessibility: Accessibility modifier.

pub fn class_element_accessor_property<T1>( self, span: Span, type: AccessorPropertyType, decorators: ArenaVec<'a, Decorator<'a>>, key: PropertyKey<'a>, type_annotation: T1, value: Option<Expression<'a>>, computed: bool, static: bool, override: bool, definite: bool, accessibility: Option<TSAccessibility>, ) -> ClassElement<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ClassElement::AccessorProperty.

This node contains an AccessorProperty that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• type
• decorators: Decorators applied to the accessor property.
• key: The expression used to declare the property.
• type_annotation: Type annotation on the property.
• value: Initialized value in the declaration, if present.
• computed: Property was declared with a computed key
• static: Property was declared with a static modifier
• override: Property was declared with a override modifier
• definite: Property has a ! after its key.
• accessibility: Accessibility modifier.

pub fn class_element_ts_index_signature<T1>( self, span: Span, parameters: ArenaVec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, static: bool, ) -> ClassElement<'a>

where T1: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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
• static

pub fn method_definition<T1>( self, span: Span, type: MethodDefinitionType, decorators: ArenaVec<'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, ArenaBox<'a, Function<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a MethodDefinition.

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

Parameters

• span: The Span covering this node
• type: Method definition type
• decorators
• key
• value
• kind
• computed
• static
• override
• optional
• accessibility

pub fn alloc_method_definition<T1>( self, span: Span, type: MethodDefinitionType, decorators: ArenaVec<'a, Decorator<'a>>, key: PropertyKey<'a>, value: T1, kind: MethodDefinitionKind, computed: bool, static: bool, override: bool, optional: bool, accessibility: Option<TSAccessibility>, ) -> ArenaBox<'a, MethodDefinition<'a>>

where T1: IntoIn<'a, ArenaBox<'a, Function<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a MethodDefinition, and store 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

• span: The Span covering this node
• type: Method definition type
• decorators
• key
• value
• kind
• computed
• static
• override
• optional
• accessibility

pub fn property_definition<T1>( self, span: Span, type: PropertyDefinitionType, decorators: ArenaVec<'a, Decorator<'a>>, key: PropertyKey<'a>, type_annotation: T1, value: Option<Expression<'a>>, computed: bool, static: bool, declare: bool, override: bool, optional: bool, definite: bool, readonly: bool, accessibility: Option<TSAccessibility>, ) -> PropertyDefinition<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a PropertyDefinition.

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

Parameters

• span: The Span covering this node
• type
• decorators: Decorators applied to the property.
• key: The expression used to declare the property.
• type_annotation: Type annotation on the property.
• value: Initialized value in the declaration.
• computed: Property was declared with a computed key
• static: Property was declared with a static modifier
• declare: Property is declared with a declare modifier.
• override
• optional: true when created with an optional modifier (?)
• definite
• readonly: true when declared with a readonly modifier
• accessibility: Accessibility modifier.

pub fn alloc_property_definition<T1>( self, span: Span, type: PropertyDefinitionType, decorators: ArenaVec<'a, Decorator<'a>>, key: PropertyKey<'a>, type_annotation: T1, value: Option<Expression<'a>>, computed: bool, static: bool, declare: bool, override: bool, optional: bool, definite: bool, readonly: bool, accessibility: Option<TSAccessibility>, ) -> ArenaBox<'a, PropertyDefinition<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a PropertyDefinition, and store 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

• span: The Span covering this node
• type
• decorators: Decorators applied to the property.
• key: The expression used to declare the property.
• type_annotation: Type annotation on the property.
• value: Initialized value in the declaration.
• computed: Property was declared with a computed key
• static: Property was declared with a static modifier
• declare: Property is declared with a declare modifier.
• override
• optional: true when created with an optional modifier (?)
• definite
• readonly: true when declared with a readonly modifier
• accessibility: Accessibility modifier.

pub fn private_identifier<S1>( self, span: Span, name: S1, ) -> PrivateIdentifier<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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<S1>( self, span: Span, name: S1, ) -> ArenaBox<'a, PrivateIdentifier<'a>>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a PrivateIdentifier, and store 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: ArenaVec<'a, Statement<'a>>, ) -> StaticBlock<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, Statement<'a>>, ) -> ArenaBox<'a, StaticBlock<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StaticBlock, and store 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 static_block_with_scope_id( self, span: Span, body: ArenaVec<'a, Statement<'a>>, scope_id: ScopeId, ) -> StaticBlock<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StaticBlock with scope_id.

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

Parameters

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

pub fn alloc_static_block_with_scope_id( self, span: Span, body: ArenaVec<'a, Statement<'a>>, scope_id: ScopeId, ) -> ArenaBox<'a, StaticBlock<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StaticBlock with scope_id, and store it in the memory arena.

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

Parameters

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

pub fn module_declaration_import_declaration<T1>( self, span: Span, specifiers: Option<ArenaVec<'a, ImportDeclarationSpecifier<'a>>>, source: StringLiteral<'a>, phase: Option<ImportPhase>, with_clause: T1, import_kind: ImportOrExportKind, ) -> ModuleDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleDeclaration::ImportDeclaration.

This node contains an 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
• phase
• with_clause: Some(vec![]) for empty assertion
• import_kind: import type { foo } from 'bar'

pub fn module_declaration_export_all_declaration<T1>( self, span: Span, exported: Option<ModuleExportName<'a>>, source: StringLiteral<'a>, with_clause: T1, export_kind: ImportOrExportKind, ) -> ModuleDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleDeclaration::ExportAllDeclaration.

This node contains an 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_export_default_declaration( self, span: Span, declaration: ExportDefaultDeclarationKind<'a>, ) -> ModuleDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleDeclaration::ExportDefaultDeclaration.

This node contains an ExportDefaultDeclaration that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• declaration

pub fn module_declaration_export_named_declaration<T1>( self, span: Span, declaration: Option<Declaration<'a>>, specifiers: ArenaVec<'a, ExportSpecifier<'a>>, source: Option<StringLiteral<'a>>, export_kind: ImportOrExportKind, with_clause: T1, ) -> ModuleDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleDeclaration::ExportNamedDeclaration.

This node contains an 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_ts_export_assignment( self, span: Span, expression: Expression<'a>, ) -> ModuleDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_ts_namespace_export_declaration( self, span: Span, id: IdentifierName<'a>, ) -> ModuleDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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 accessor_property<T1>( self, span: Span, type: AccessorPropertyType, decorators: ArenaVec<'a, Decorator<'a>>, key: PropertyKey<'a>, type_annotation: T1, value: Option<Expression<'a>>, computed: bool, static: bool, override: bool, definite: bool, accessibility: Option<TSAccessibility>, ) -> AccessorProperty<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AccessorProperty.

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

Parameters

• span: The Span covering this node
• type
• decorators: Decorators applied to the accessor property.
• key: The expression used to declare the property.
• type_annotation: Type annotation on the property.
• value: Initialized value in the declaration, if present.
• computed: Property was declared with a computed key
• static: Property was declared with a static modifier
• override: Property was declared with a override modifier
• definite: Property has a ! after its key.
• accessibility: Accessibility modifier.

pub fn alloc_accessor_property<T1>( self, span: Span, type: AccessorPropertyType, decorators: ArenaVec<'a, Decorator<'a>>, key: PropertyKey<'a>, type_annotation: T1, value: Option<Expression<'a>>, computed: bool, static: bool, override: bool, definite: bool, accessibility: Option<TSAccessibility>, ) -> ArenaBox<'a, AccessorProperty<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an AccessorProperty, and store 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

• span: The Span covering this node
• type
• decorators: Decorators applied to the accessor property.
• key: The expression used to declare the property.
• type_annotation: Type annotation on the property.
• value: Initialized value in the declaration, if present.
• computed: Property was declared with a computed key
• static: Property was declared with a static modifier
• override: Property was declared with a override modifier
• definite: Property has a ! after its key.
• accessibility: Accessibility modifier.

pub fn import_expression( self, span: Span, source: Expression<'a>, options: Option<Expression<'a>>, phase: Option<ImportPhase>, ) -> ImportExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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
• options
• phase

pub fn alloc_import_expression( self, span: Span, source: Expression<'a>, options: Option<Expression<'a>>, phase: Option<ImportPhase>, ) -> ArenaBox<'a, ImportExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportExpression, and store 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
• options
• phase

pub fn import_declaration<T1>( self, span: Span, specifiers: Option<ArenaVec<'a, ImportDeclarationSpecifier<'a>>>, source: StringLiteral<'a>, phase: Option<ImportPhase>, with_clause: T1, import_kind: ImportOrExportKind, ) -> ImportDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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
• phase
• with_clause: Some(vec![]) for empty assertion
• import_kind: import type { foo } from 'bar'

pub fn alloc_import_declaration<T1>( self, span: Span, specifiers: Option<ArenaVec<'a, ImportDeclarationSpecifier<'a>>>, source: StringLiteral<'a>, phase: Option<ImportPhase>, with_clause: T1, import_kind: ImportOrExportKind, ) -> ArenaBox<'a, ImportDeclaration<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportDeclaration, and store 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
• phase
• 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportDeclarationSpecifier::ImportSpecifier.

This node contains an ImportSpecifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• imported: Imported symbol.
• local: Binding for local symbol.
• import_kind: Value or type.

pub fn import_declaration_specifier_import_default_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> ImportDeclarationSpecifier<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportDeclarationSpecifier::ImportDefaultSpecifier.

This node contains an 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_import_namespace_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> ImportDeclarationSpecifier<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportDeclarationSpecifier::ImportNamespaceSpecifier.

This node contains an ImportNamespaceSpecifier that will be stored in the memory arena.

Parameters

• span: The Span covering this node
• local

pub fn import_specifier( self, span: Span, imported: ModuleExportName<'a>, local: BindingIdentifier<'a>, import_kind: ImportOrExportKind, ) -> ImportSpecifier<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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: Imported symbol.
• local: Binding for local symbol.
• import_kind: Value or type.

pub fn alloc_import_specifier( self, span: Span, imported: ModuleExportName<'a>, local: BindingIdentifier<'a>, import_kind: ImportOrExportKind, ) -> ArenaBox<'a, ImportSpecifier<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportSpecifier, and store 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: Imported symbol.
• local: Binding for local symbol.
• import_kind: Value or type.

pub fn import_default_specifier( self, span: Span, local: BindingIdentifier<'a>, ) -> ImportDefaultSpecifier<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, ImportDefaultSpecifier<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportDefaultSpecifier, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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>, ) -> ArenaBox<'a, ImportNamespaceSpecifier<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportNamespaceSpecifier, and store 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, keyword: WithClauseKeyword, with_entries: ArenaVec<'a, ImportAttribute<'a>>, ) -> WithClause<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• keyword
• with_entries

pub fn alloc_with_clause( self, span: Span, keyword: WithClauseKeyword, with_entries: ArenaVec<'a, ImportAttribute<'a>>, ) -> ArenaBox<'a, WithClause<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a WithClause, and store 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
• keyword
• with_entries

pub fn import_attribute( self, span: Span, key: ImportAttributeKey<'a>, value: StringLiteral<'a>, ) -> ImportAttribute<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportAttribute.

Parameters

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

pub fn import_attribute_key_identifier<S1>( self, span: Span, name: S1, ) -> ImportAttributeKey<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportAttributeKey::Identifier.

Parameters

• span: The Span covering this node
• name

pub fn import_attribute_key_string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> ImportAttributeKey<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportAttributeKey::StringLiteral.

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn import_attribute_key_string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> ImportAttributeKey<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ImportAttributeKey::StringLiteral with lone_surrogates.

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn export_named_declaration<T1>( self, span: Span, declaration: Option<Declaration<'a>>, specifiers: ArenaVec<'a, ExportSpecifier<'a>>, source: Option<StringLiteral<'a>>, export_kind: ImportOrExportKind, with_clause: T1, ) -> ExportNamedDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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<T1>( self, span: Span, declaration: Option<Declaration<'a>>, specifiers: ArenaVec<'a, ExportSpecifier<'a>>, source: Option<StringLiteral<'a>>, export_kind: ImportOrExportKind, with_clause: T1, ) -> ArenaBox<'a, ExportNamedDeclaration<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportNamedDeclaration, and store 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>, ) -> ExportDefaultDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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

pub fn alloc_export_default_declaration( self, span: Span, declaration: ExportDefaultDeclarationKind<'a>, ) -> ArenaBox<'a, ExportDefaultDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportDefaultDeclaration, and store 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

pub fn export_all_declaration<T1>( self, span: Span, exported: Option<ModuleExportName<'a>>, source: StringLiteral<'a>, with_clause: T1, export_kind: ImportOrExportKind, ) -> ExportAllDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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<T1>( self, span: Span, exported: Option<ModuleExportName<'a>>, source: StringLiteral<'a>, with_clause: T1, export_kind: ImportOrExportKind, ) -> ArenaBox<'a, ExportAllDeclaration<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, WithClause<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportAllDeclaration, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportSpecifier.

Parameters

• span: The Span covering this node
• local
• exported
• export_kind

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportDefaultDeclarationKind::FunctionDeclaration.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.

pub fn export_default_declaration_kind_function_declaration_with_scope_id_and_pure_and_pife<T1, T2, T3, T4, T5>( self, span: Span, type: FunctionType, id: Option<BindingIdentifier<'a>>, generator: bool, async: bool, declare: bool, type_parameters: T1, this_param: T2, params: T3, return_type: T4, body: T5, scope_id: ScopeId, pure: bool, pife: bool, ) -> ExportDefaultDeclarationKind<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportDefaultDeclarationKind::FunctionDeclaration with scope_id and pure and pife.

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

Parameters

• span: The Span covering this node
• type
• id: The function identifier. None for anonymous function expressions.
• generator: Is this a generator function?
• 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: Function parameters.
• return_type: The TypeScript return type annotation.
• body: The function body.
• scope_id
• pure: true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment
• pife: true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportDefaultDeclarationKind::ClassDeclaration.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed

pub fn export_default_declaration_kind_class_declaration_with_scope_id<T1, T2, T3>( self, span: Span, type: ClassType, decorators: ArenaVec<'a, Decorator<'a>>, id: Option<BindingIdentifier<'a>>, type_parameters: T1, super_class: Option<Expression<'a>>, super_type_arguments: T2, implements: ArenaVec<'a, TSClassImplements<'a>>, body: T3, abstract: bool, declare: bool, scope_id: ScopeId, ) -> ExportDefaultDeclarationKind<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportDefaultDeclarationKind::ClassDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• type
• 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_arguments: Type parameters passed to super class.
• implements: Interface implementation clause for TypeScript classes.
• body
• abstract: Whether the class is abstract
• declare: Whether the class was declareed
• scope_id: Id of the scope created by the Class, including type parameters and

pub fn export_default_declaration_kind_ts_interface_declaration<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, extends: ArenaVec<'a, TSInterfaceHeritage<'a>>, body: T2, declare: bool, ) -> ExportDefaultDeclarationKind<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an 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.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}

pub fn export_default_declaration_kind_ts_interface_declaration_with_scope_id<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, extends: ArenaVec<'a, TSInterfaceHeritage<'a>>, body: T2, declare: bool, scope_id: ScopeId, ) -> ExportDefaultDeclarationKind<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build an ExportDefaultDeclarationKind::TSInterfaceDeclaration with scope_id.

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.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}
• scope_id

pub fn module_export_name_identifier_name<S1>( self, span: Span, name: S1, ) -> ModuleExportName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleExportName::IdentifierName.

Parameters

• span: The Span covering this node
• name

pub fn module_export_name_identifier_reference<S1>( self, span: Span, name: S1, ) -> ModuleExportName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleExportName::IdentifierReference.

Parameters

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

pub fn module_export_name_identifier_reference_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> ModuleExportName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleExportName::IdentifierReference with reference_id.

Parameters

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

pub fn module_export_name_string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> ModuleExportName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleExportName::StringLiteral.

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn module_export_name_string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> ModuleExportName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a ModuleExportName::StringLiteral with lone_surrogates.

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn v8_intrinsic_expression( self, span: Span, name: IdentifierName<'a>, arguments: ArenaVec<'a, Argument<'a>>, ) -> V8IntrinsicExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a V8IntrinsicExpression.

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

Parameters

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

pub fn alloc_v8_intrinsic_expression( self, span: Span, name: IdentifierName<'a>, arguments: ArenaVec<'a, Argument<'a>>, ) -> ArenaBox<'a, V8IntrinsicExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a V8IntrinsicExpression, and store it in the memory arena.

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

Parameters

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BooleanLiteral.

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

Parameters

• span: Node location in source code.
• value: The boolean value itself

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BooleanLiteral, and store 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: Node location in source code.
• value: The boolean value itself

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a NullLiteral.

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

Parameters

• span: Node location in source code.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a NullLiteral, and store 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: Node location in source code.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a NumericLiteral.

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

Parameters

• span: Node location in source code.
• value: The value of the number, converted into base 10
• raw: The number as it appears in source code
• base: The base representation used by the literal in source code

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a NumericLiteral, and store 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: Node location in source code.
• value: The value of the number, converted into base 10
• raw: The number as it appears in source code
• base: The base representation used by the literal in source code

pub fn string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> StringLiteral<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StringLiteral.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn alloc_string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> ArenaBox<'a, StringLiteral<'a>>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StringLiteral, and store 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: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> StringLiteral<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StringLiteral with lone_surrogates.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn alloc_string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> ArenaBox<'a, StringLiteral<'a>>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a StringLiteral with lone_surrogates, and store it in the memory arena.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn big_int_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, base: BigintBase, ) -> BigIntLiteral<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BigIntLiteral.

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

Parameters

• span: Node location in source code.
• value: Bigint value in base 10 with no underscores
• raw: The bigint as it appears in source code
• base: The base representation used by the literal in source code

pub fn alloc_big_int_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, base: BigintBase, ) -> ArenaBox<'a, BigIntLiteral<'a>>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a BigIntLiteral, and store 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: Node location in source code.
• value: Bigint value in base 10 with no underscores
• raw: The bigint as it appears in source code
• base: The base representation used by the literal in source code

pub fn reg_exp_literal( self, span: Span, regex: RegExp<'a>, raw: Option<Str<'a>>, ) -> RegExpLiteral<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a RegExpLiteral.

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

Parameters

• span: Node location in source code.
• regex: The parsed regular expression. See oxc_regular_expression for more
• raw: The regular expression as it appears in source code

pub fn alloc_reg_exp_literal( self, span: Span, regex: RegExp<'a>, raw: Option<Str<'a>>, ) -> ArenaBox<'a, RegExpLiteral<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a RegExpLiteral, and store 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: Node location in source code.
• regex: The parsed regular expression. See oxc_regular_expression for more
• raw: The regular expression as it appears in source code

pub fn jsx_element<T1, T2>( self, span: Span, opening_element: T1, children: ArenaVec<'a, JSXChild<'a>>, closing_element: T2, ) -> JSXElement<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElement.

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

Parameters

• span: Node location in source code.
• opening_element: Opening tag of the element.
• children: Children of the element.
• closing_element: Closing tag of the element.

pub fn alloc_jsx_element<T1, T2>( self, span: Span, opening_element: T1, children: ArenaVec<'a, JSXChild<'a>>, closing_element: T2, ) -> ArenaBox<'a, JSXElement<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElement, and store 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: Node location in source code.
• opening_element: Opening tag of the element.
• children: Children of the element.
• closing_element: Closing tag of the element.

pub fn jsx_opening_element<T1>( self, span: Span, name: JSXElementName<'a>, type_arguments: T1, attributes: ArenaVec<'a, JSXAttributeItem<'a>>, ) -> JSXOpeningElement<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXOpeningElement.

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

Parameters

• span: Node location in source code.
• name: The possibly-namespaced tag name, e.g. Foo in <Foo />.
• type_arguments: Type parameters for generic JSX elements.
• attributes: List of JSX attributes. In React-like applications, these become props.

pub fn alloc_jsx_opening_element<T1>( self, span: Span, name: JSXElementName<'a>, type_arguments: T1, attributes: ArenaVec<'a, JSXAttributeItem<'a>>, ) -> ArenaBox<'a, JSXOpeningElement<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXOpeningElement, and store 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: Node location in source code.
• name: The possibly-namespaced tag name, e.g. Foo in <Foo />.
• type_arguments: Type parameters for generic JSX elements.
• attributes: List of JSX attributes. In React-like applications, these become props.

pub fn jsx_closing_element( self, span: Span, name: JSXElementName<'a>, ) -> JSXClosingElement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXClosingElement.

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

Parameters

• span: Node location in source code.
• name: The tag name, e.g. Foo in </Foo>.

pub fn alloc_jsx_closing_element( self, span: Span, name: JSXElementName<'a>, ) -> ArenaBox<'a, JSXClosingElement<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXClosingElement, and store 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: Node location in source code.
• name: The tag name, e.g. Foo in </Foo>.

pub fn jsx_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, children: ArenaVec<'a, JSXChild<'a>>, closing_fragment: JSXClosingFragment, ) -> JSXFragment<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXFragment.

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

Parameters

• span: Node location in source code.
• opening_fragment: <>
• children: Elements inside the fragment.
• closing_fragment: </>

pub fn alloc_jsx_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, children: ArenaVec<'a, JSXChild<'a>>, closing_fragment: JSXClosingFragment, ) -> ArenaBox<'a, JSXFragment<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXFragment, and store 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: Node location in source code.
• opening_fragment: <>
• children: Elements inside the fragment.
• closing_fragment: </>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXOpeningFragment.

Parameters

• span: Node location in source code.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXClosingFragment.

Parameters

• span: Node location in source code.

pub fn jsx_element_name_identifier<S1>( self, span: Span, name: S1, ) -> JSXElementName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElementName::Identifier.

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

Parameters

• span: Node location in source code.
• name: The name of the identifier.

pub fn jsx_element_name_identifier_reference<S1>( self, span: Span, name: S1, ) -> JSXElementName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElementName::IdentifierReference.

This node contains an 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 jsx_element_name_identifier_reference_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> JSXElementName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElementName::IdentifierReference with reference_id.

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

Parameters

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

pub fn jsx_element_name_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, name: JSXIdentifier<'a>, ) -> JSXElementName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElementName::NamespacedName.

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

Parameters

• span: Node location in source code.
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• name: Name portion of the name, e.g. Orange in <Apple:Orange />

pub fn jsx_element_name_member_expression( self, span: Span, object: JSXMemberExpressionObject<'a>, property: JSXIdentifier<'a>, ) -> JSXElementName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElementName::MemberExpression.

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

Parameters

• span: Node location in source code.
• 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_this_expression(self, span: Span) -> JSXElementName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXElementName::ThisExpression.

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

Parameters

• span: The Span covering this node

pub fn jsx_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, name: JSXIdentifier<'a>, ) -> JSXNamespacedName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXNamespacedName.

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

Parameters

• span: Node location in source code.
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• name: Name portion of the name, e.g. Orange in <Apple:Orange />

pub fn alloc_jsx_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, name: JSXIdentifier<'a>, ) -> ArenaBox<'a, JSXNamespacedName<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXNamespacedName, and store 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: Node location in source code.
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• name: 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXMemberExpression.

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

Parameters

• span: Node location in source code.
• 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>, ) -> ArenaBox<'a, JSXMemberExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXMemberExpression, and store 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: Node location in source code.
• 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_identifier_reference<S1>( self, span: Span, name: S1, ) -> JSXMemberExpressionObject<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXMemberExpressionObject::IdentifierReference.

This node contains an 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 jsx_member_expression_object_identifier_reference_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> JSXMemberExpressionObject<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXMemberExpressionObject::IdentifierReference with reference_id.

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

Parameters

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

pub fn jsx_member_expression_object_member_expression( self, span: Span, object: JSXMemberExpressionObject<'a>, property: JSXIdentifier<'a>, ) -> JSXMemberExpressionObject<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXMemberExpressionObject::MemberExpression.

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

Parameters

• span: Node location in source code.
• 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_this_expression( self, span: Span, ) -> JSXMemberExpressionObject<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXMemberExpressionObject::ThisExpression.

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

Parameters

• span: The Span covering this node

pub fn jsx_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> JSXExpressionContainer<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXExpressionContainer.

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

Parameters

• span: Node location in source code.
• expression: The expression inside the container.

pub fn alloc_jsx_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> ArenaBox<'a, JSXExpressionContainer<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXExpressionContainer, and store 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: Node location in source code.
• expression: The expression inside the container.

pub fn jsx_expression_empty_expression(self, span: Span) -> JSXExpression<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXExpression::EmptyExpression.

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

Parameters

• span: Node location in source code.

pub fn jsx_empty_expression(self, span: Span) -> JSXEmptyExpression

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXEmptyExpression.

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

Parameters

• span: Node location in source code.

pub fn alloc_jsx_empty_expression( self, span: Span, ) -> ArenaBox<'a, JSXEmptyExpression>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXEmptyExpression, and store 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: Node location in source code.

pub fn jsx_attribute_item_attribute( self, span: Span, name: JSXAttributeName<'a>, value: Option<JSXAttributeValue<'a>>, ) -> JSXAttributeItem<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeItem::Attribute.

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

Parameters

• span: Node location in source code.
• 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_spread_attribute( self, span: Span, argument: Expression<'a>, ) -> JSXAttributeItem<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeItem::SpreadAttribute.

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

Parameters

• span: Node location in source code.
• argument: The expression being spread.

pub fn jsx_attribute( self, span: Span, name: JSXAttributeName<'a>, value: Option<JSXAttributeValue<'a>>, ) -> JSXAttribute<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttribute.

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

Parameters

• span: Node location in source code.
• 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>>, ) -> ArenaBox<'a, JSXAttribute<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttribute, and store 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: Node location in source code.
• 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXSpreadAttribute.

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

Parameters

• span: Node location in source code.
• argument: The expression being spread.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXSpreadAttribute, and store 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: Node location in source code.
• argument: The expression being spread.

pub fn jsx_attribute_name_identifier<S1>( self, span: Span, name: S1, ) -> JSXAttributeName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeName::Identifier.

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

Parameters

• span: Node location in source code.
• name: The name of the identifier.

pub fn jsx_attribute_name_namespaced_name( self, span: Span, namespace: JSXIdentifier<'a>, name: JSXIdentifier<'a>, ) -> JSXAttributeName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeName::NamespacedName.

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

Parameters

• span: Node location in source code.
• namespace: Namespace portion of the name, e.g. Apple in <Apple:Orange />
• name: Name portion of the name, e.g. Orange in <Apple:Orange />

pub fn jsx_attribute_value_string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> JSXAttributeValue<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeValue::StringLiteral.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn jsx_attribute_value_string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> JSXAttributeValue<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeValue::StringLiteral with lone_surrogates.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn jsx_attribute_value_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> JSXAttributeValue<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeValue::ExpressionContainer.

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

Parameters

• span: Node location in source code.
• expression: The expression inside the container.

pub fn jsx_attribute_value_element<T1, T2>( self, span: Span, opening_element: T1, children: ArenaVec<'a, JSXChild<'a>>, closing_element: T2, ) -> JSXAttributeValue<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeValue::Element.

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

Parameters

• span: Node location in source code.
• opening_element: Opening tag of the element.
• children: Children of the element.
• closing_element: Closing tag of the element.

pub fn jsx_attribute_value_fragment( self, span: Span, opening_fragment: JSXOpeningFragment, children: ArenaVec<'a, JSXChild<'a>>, closing_fragment: JSXClosingFragment, ) -> JSXAttributeValue<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXAttributeValue::Fragment.

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

Parameters

• span: Node location in source code.
• opening_fragment: <>
• children: Elements inside the fragment.
• closing_fragment: </>

pub fn jsx_identifier<S1>(self, span: Span, name: S1) -> JSXIdentifier<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXIdentifier.

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

Parameters

• span: Node location in source code.
• name: The name of the identifier.

pub fn alloc_jsx_identifier<S1>( self, span: Span, name: S1, ) -> ArenaBox<'a, JSXIdentifier<'a>>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXIdentifier, and store 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: Node location in source code.
• name: The name of the identifier.

pub fn jsx_child_text<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> JSXChild<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXChild::Text.

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

Parameters

• span: Node location in source code.
• value: The text content.
• raw: The raw string as it appears in source code.

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

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXChild::Element.

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

Parameters

• span: Node location in source code.
• opening_element: Opening tag of the element.
• children: Children of the element.
• closing_element: Closing tag of the element.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXChild::Fragment.

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

Parameters

• span: Node location in source code.
• opening_fragment: <>
• children: Elements inside the fragment.
• closing_fragment: </>

pub fn jsx_child_expression_container( self, span: Span, expression: JSXExpression<'a>, ) -> JSXChild<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXChild::ExpressionContainer.

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

Parameters

• span: Node location in source code.
• expression: The expression inside the container.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXChild::Spread.

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

Parameters

• span: Node location in source code.
• expression: The expression being spread.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXSpreadChild.

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

Parameters

• span: Node location in source code.
• expression: The expression being spread.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXSpreadChild, and store 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: Node location in source code.
• expression: The expression being spread.

pub fn jsx_text<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> JSXText<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXText.

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

Parameters

• span: Node location in source code.
• value: The text content.
• raw: The raw string as it appears in source code.

pub fn alloc_jsx_text<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> ArenaBox<'a, JSXText<'a>>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSXText, and store 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: Node location in source code.
• value: The text content.
• raw: The raw string as it appears in source code.

pub fn ts_this_parameter<T1>( self, span: Span, this_span: Span, type_annotation: T1, ) -> TSThisParameter<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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_span
• type_annotation: Type type the this keyword will have in the function

pub fn alloc_ts_this_parameter<T1>( self, span: Span, this_span: Span, type_annotation: T1, ) -> ArenaBox<'a, TSThisParameter<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSThisParameter, and store 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_span
• type_annotation: Type type the this keyword will have in the function

pub fn ts_enum_declaration( self, span: Span, id: BindingIdentifier<'a>, body: TSEnumBody<'a>, const: bool, declare: bool, ) -> TSEnumDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• body
• const: true for const enums
• declare

pub fn alloc_ts_enum_declaration( self, span: Span, id: BindingIdentifier<'a>, body: TSEnumBody<'a>, const: bool, declare: bool, ) -> ArenaBox<'a, TSEnumDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumDeclaration, and store 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
• body
• const: true for const enums
• declare

pub fn ts_enum_body( self, span: Span, members: ArenaVec<'a, TSEnumMember<'a>>, ) -> TSEnumBody<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumBody.

Parameters

• span: The Span covering this node
• members

pub fn ts_enum_body_with_scope_id( self, span: Span, members: ArenaVec<'a, TSEnumMember<'a>>, scope_id: ScopeId, ) -> TSEnumBody<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumBody with scope_id.

Parameters

• span: The Span covering this node
• members
• scope_id

pub fn ts_enum_member( self, span: Span, id: TSEnumMemberName<'a>, initializer: Option<Expression<'a>>, ) -> TSEnumMember<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumMember.

Parameters

• span: The Span covering this node
• id
• initializer

pub fn ts_enum_member_name_identifier<S1>( self, span: Span, name: S1, ) -> TSEnumMemberName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumMemberName::Identifier.

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

Parameters

• span: The Span covering this node
• name

pub fn ts_enum_member_name_string<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> TSEnumMemberName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumMemberName::String.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn ts_enum_member_name_string_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> TSEnumMemberName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumMemberName::String with lone_surrogates.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn ts_enum_member_name_computed_string<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> TSEnumMemberName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumMemberName::ComputedString.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn ts_enum_member_name_computed_string_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> TSEnumMemberName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumMemberName::ComputedString with lone_surrogates.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn ts_enum_member_name_computed_template_string( self, span: Span, quasis: ArenaVec<'a, TemplateElement<'a>>, expressions: ArenaVec<'a, Expression<'a>>, ) -> TSEnumMemberName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSEnumMemberName::ComputedTemplateString.

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_type_annotation( self, span: Span, type_annotation: TSType<'a>, ) -> TSTypeAnnotation<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeAnnotation.

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

Parameters

• span: The Span covering this node
• type_annotation: The actual type in the annotation

pub fn alloc_ts_type_annotation( self, span: Span, type_annotation: TSType<'a>, ) -> ArenaBox<'a, TSTypeAnnotation<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeAnnotation, and store 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: The Span covering this node
• type_annotation: The actual type in the annotation

pub fn ts_literal_type( self, span: Span, literal: TSLiteral<'a>, ) -> TSLiteralType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSLiteralType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSLiteralType, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSLiteral::BooleanLiteral.

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

Parameters

• span: Node location in source code.
• value: The boolean value itself

pub fn ts_literal_numeric_literal( self, span: Span, value: f64, raw: Option<Str<'a>>, base: NumberBase, ) -> TSLiteral<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSLiteral::NumericLiteral.

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

Parameters

• span: Node location in source code.
• value: The value of the number, converted into base 10
• raw: The number as it appears in source code
• base: The base representation used by the literal in source code

pub fn ts_literal_big_int_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, base: BigintBase, ) -> TSLiteral<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSLiteral::BigIntLiteral.

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

Parameters

• span: Node location in source code.
• value: Bigint value in base 10 with no underscores
• raw: The bigint as it appears in source code
• base: The base representation used by the literal in source code

pub fn ts_literal_string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> TSLiteral<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSLiteral::StringLiteral.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn ts_literal_string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> TSLiteral<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSLiteral::StringLiteral with lone_surrogates.

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

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

pub fn ts_literal_template_literal( self, span: Span, quasis: ArenaVec<'a, TemplateElement<'a>>, expressions: ArenaVec<'a, Expression<'a>>, ) -> TSLiteral<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_unary_expression( self, span: Span, operator: UnaryOperator, argument: Expression<'a>, ) -> TSLiteral<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSLiteral::UnaryExpression.

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

Parameters

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

pub fn ts_type_any_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_big_int_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_boolean_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_intrinsic_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_never_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_null_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_number_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_object_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_string_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_symbol_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_undefined_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_unknown_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_void_keyword(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_array_type( self, span: Span, element_type: TSType<'a>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_conditional_type( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The type before extends in the test expression.
• extends_type: The type check_type is being tested against.
• true_type: The type evaluated to if the test is true.
• false_type: The type evaluated to if the test is false.

pub fn ts_type_conditional_type_with_scope_id( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, scope_id: ScopeId, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSConditionalType with scope_id.

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

Parameters

• span: The Span covering this node
• check_type: The type before extends in the test expression.
• extends_type: The type check_type is being tested against.
• true_type: The type evaluated to if the test is true.
• false_type: The type evaluated to if the test is false.
• scope_id

pub fn ts_type_constructor_type<T1, T2, T3>( self, span: Span, abstract: bool, type_parameters: T1, params: T2, return_type: T3, ) -> TSType<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSConstructorType.

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

Parameters

• span: The Span covering this node
• abstract
• type_parameters
• params
• return_type

pub fn ts_type_constructor_type_with_scope_id<T1, T2, T3>( self, span: Span, abstract: bool, type_parameters: T1, params: T2, return_type: T3, scope_id: ScopeId, ) -> TSType<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSConstructorType with scope_id.

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

Parameters

• span: The Span covering this node
• abstract
• type_parameters
• params
• return_type
• scope_id

pub fn ts_type_function_type<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> TSType<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSFunctionType.

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

Parameters

• span: The Span covering this node
• type_parameters: Generic type parameters
• this_param: this parameter
• params: Function parameters. Akin to Function::params.
• return_type: Return type of the function.

pub fn ts_type_function_type_with_scope_id<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> TSType<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSFunctionType with scope_id.

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

Parameters

• span: The Span covering this node
• type_parameters: Generic type parameters
• this_param: this parameter
• params: Function parameters. Akin to Function::params.
• return_type: Return type of the function.
• scope_id

pub fn ts_type_import_type<T1, T2>( self, span: Span, source: StringLiteral<'a>, options: T1, qualifier: Option<TSImportTypeQualifier<'a>>, type_arguments: T2, ) -> TSType<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, ObjectExpression<'a>>>>, T2: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterInstantiation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSImportType.

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

Parameters

• span: The Span covering this node
• source
• options
• qualifier
• type_arguments

pub fn ts_type_indexed_access_type( self, span: Span, object_type: TSType<'a>, index_type: TSType<'a>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_infer_type<T1>( self, span: Span, type_parameter: T1, ) -> TSType<'a>

where T1: IntoIn<'a, ArenaBox<'a, TSTypeParameter<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The type bound when the

pub fn ts_type_intersection_type( self, span: Span, types: ArenaVec<'a, TSType<'a>>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_literal_type( self, span: Span, literal: TSLiteral<'a>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_mapped_type( self, span: Span, key: BindingIdentifier<'a>, constraint: TSType<'a>, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: Option<TSMappedTypeModifierOperator>, readonly: Option<TSMappedTypeModifierOperator>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSMappedType.

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

Parameters

• span: The Span covering this node
• key: Key type parameter, e.g. P in [P in keyof T].
• constraint: Constraint type, e.g. keyof T in [P in keyof T].
• name_type
• type_annotation
• optional: Optional modifier on type annotation
• readonly: Readonly modifier before keyed index signature

pub fn ts_type_mapped_type_with_scope_id( self, span: Span, key: BindingIdentifier<'a>, constraint: TSType<'a>, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: Option<TSMappedTypeModifierOperator>, readonly: Option<TSMappedTypeModifierOperator>, scope_id: ScopeId, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSMappedType with scope_id.

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

Parameters

• span: The Span covering this node
• key: Key type parameter, e.g. P in [P in keyof T].
• constraint: Constraint type, e.g. keyof T in [P in keyof T].
• name_type
• type_annotation
• optional: Optional modifier on type annotation
• readonly: Readonly modifier before keyed index signature
• scope_id

pub fn ts_type_named_tuple_member( self, span: Span, label: IdentifierName<'a>, element_type: TSTupleElement<'a>, optional: bool, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSType::TSNamedTupleMember.

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

Parameters

• span: The Span covering this node
• label
• element_type
• optional

pub fn ts_type_template_literal_type( self, span: Span, quasis: ArenaVec<'a, TemplateElement<'a>>, types: ArenaVec<'a, TSType<'a>>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The string parts of the template literal.
• types: The interpolated expressions in the template literal.

pub fn ts_type_this_type(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_tuple_type( self, span: Span, element_types: ArenaVec<'a, TSTupleElement<'a>>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_type_literal( self, span: Span, members: ArenaVec<'a, TSSignature<'a>>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_type_operator_type( self, span: Span, operator: TSTypeOperatorOperator, type_annotation: TSType<'a>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The type being operated on

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<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The identifier the predicate operates on
• asserts: Does this predicate include an asserts modifier?
• type_annotation

pub fn ts_type_type_query<T1>( self, span: Span, expr_name: TSTypeQueryExprName<'a>, type_arguments: T1, ) -> TSType<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_arguments

pub fn ts_type_type_reference<T1>( self, span: Span, type_name: TSTypeName<'a>, type_arguments: T1, ) -> TSType<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_arguments

pub fn ts_type_union_type( self, span: Span, types: ArenaVec<'a, TSType<'a>>, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The types in the union.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_js_doc_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_js_doc_non_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_js_doc_unknown_type(self, span: Span) -> TSType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_conditional_type( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, ) -> TSConditionalType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The type before extends in the test expression.
• extends_type: The type check_type is being tested against.
• true_type: The type evaluated to if the test is true.
• false_type: The type evaluated to if the test is false.

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>, ) -> ArenaBox<'a, TSConditionalType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConditionalType, and store 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: The type before extends in the test expression.
• extends_type: The type check_type is being tested against.
• true_type: The type evaluated to if the test is true.
• false_type: The type evaluated to if the test is false.

pub fn ts_conditional_type_with_scope_id( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, scope_id: ScopeId, ) -> TSConditionalType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConditionalType with scope_id.

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

Parameters

• span: The Span covering this node
• check_type: The type before extends in the test expression.
• extends_type: The type check_type is being tested against.
• true_type: The type evaluated to if the test is true.
• false_type: The type evaluated to if the test is false.
• scope_id

pub fn alloc_ts_conditional_type_with_scope_id( self, span: Span, check_type: TSType<'a>, extends_type: TSType<'a>, true_type: TSType<'a>, false_type: TSType<'a>, scope_id: ScopeId, ) -> ArenaBox<'a, TSConditionalType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConditionalType with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• check_type: The type before extends in the test expression.
• extends_type: The type check_type is being tested against.
• true_type: The type evaluated to if the test is true.
• false_type: The type evaluated to if the test is false.
• scope_id

pub fn ts_union_type( self, span: Span, types: ArenaVec<'a, TSType<'a>>, ) -> TSUnionType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The types in the union.

pub fn alloc_ts_union_type( self, span: Span, types: ArenaVec<'a, TSType<'a>>, ) -> ArenaBox<'a, TSUnionType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSUnionType, and store 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: The types in the union.

pub fn ts_intersection_type( self, span: Span, types: ArenaVec<'a, TSType<'a>>, ) -> TSIntersectionType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, TSType<'a>>, ) -> ArenaBox<'a, TSIntersectionType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSIntersectionType, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSParenthesizedType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSParenthesizedType, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The type being operated on

pub fn alloc_ts_type_operator( self, span: Span, operator: TSTypeOperatorOperator, type_annotation: TSType<'a>, ) -> ArenaBox<'a, TSTypeOperator<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeOperator, and store 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: The type being operated on

pub fn ts_array_type( self, span: Span, element_type: TSType<'a>, ) -> TSArrayType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSArrayType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSArrayType, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSIndexedAccessType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSIndexedAccessType, and store 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: ArenaVec<'a, TSTupleElement<'a>>, ) -> TSTupleType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, TSTupleElement<'a>>, ) -> ArenaBox<'a, TSTupleType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTupleType, and store 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, label: IdentifierName<'a>, element_type: TSTupleElement<'a>, optional: bool, ) -> TSNamedTupleMember<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• label
• element_type
• optional

pub fn alloc_ts_named_tuple_member( self, span: Span, label: IdentifierName<'a>, element_type: TSTupleElement<'a>, optional: bool, ) -> ArenaBox<'a, TSNamedTupleMember<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSNamedTupleMember, and store 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
• label
• element_type
• optional

pub fn ts_optional_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSOptionalType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSOptionalType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSOptionalType, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSRestType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSRestType, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_rest_type( self, span: Span, type_annotation: TSType<'a>, ) -> TSTupleElement<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_any_keyword(self, span: Span) -> TSAnyKeyword

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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) -> ArenaBox<'a, TSAnyKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSAnyKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSStringKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSStringKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSBooleanKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSBooleanKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSNumberKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSNumberKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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) -> ArenaBox<'a, TSNeverKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSNeverKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSIntrinsicKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSIntrinsicKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSUnknownKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSUnknownKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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) -> ArenaBox<'a, TSNullKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSNullKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSUndefinedKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSUndefinedKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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) -> ArenaBox<'a, TSVoidKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSVoidKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSSymbolKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSSymbolKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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) -> ArenaBox<'a, TSThisType>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSThisType, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSObjectKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSObjectKeyword, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSBigIntKeyword>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSBigIntKeyword, and store 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_arguments: T1, ) -> TSTypeReference<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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_arguments

pub fn alloc_ts_type_reference<T1>( self, span: Span, type_name: TSTypeName<'a>, type_arguments: T1, ) -> ArenaBox<'a, TSTypeReference<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeReference, and store 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_arguments

pub fn ts_type_name_identifier_reference<S1>( self, span: Span, name: S1, ) -> TSTypeName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeName::IdentifierReference.

This node contains an 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_identifier_reference_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> TSTypeName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeName::IdentifierReference with reference_id.

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

Parameters

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

pub fn ts_type_name_qualified_name( self, span: Span, left: TSTypeName<'a>, right: IdentifierName<'a>, ) -> TSTypeName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_this_expression(self, span: Span) -> TSTypeName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeName::ThisExpression.

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

Parameters

• span: The Span covering this node

pub fn ts_qualified_name( self, span: Span, left: TSTypeName<'a>, right: IdentifierName<'a>, ) -> TSQualifiedName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSQualifiedName<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSQualifiedName, and store 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: ArenaVec<'a, TSType<'a>>, ) -> TSTypeParameterInstantiation<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, TSType<'a>>, ) -> ArenaBox<'a, TSTypeParameterInstantiation<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeParameterInstantiation, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The name of the parameter, e.g. T in type Foo<T> = ....
• constraint: Constrains what types can be passed to the type parameter.
• default: Default value of the type parameter if no type is provided when using the type.
• in: Was an in modifier keyword present?
• out: Was an out modifier keyword present?
• const: Was a const modifier keyword present?

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, ) -> ArenaBox<'a, TSTypeParameter<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeParameter, and store 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: The name of the parameter, e.g. T in type Foo<T> = ....
• constraint: Constrains what types can be passed to the type parameter.
• default: Default value of the type parameter if no type is provided when using the type.
• in: Was an in modifier keyword present?
• out: Was an out modifier keyword present?
• const: Was a const modifier keyword present?

pub fn ts_type_parameter_declaration( self, span: Span, params: ArenaVec<'a, TSTypeParameter<'a>>, ) -> TSTypeParameterDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, TSTypeParameter<'a>>, ) -> ArenaBox<'a, TSTypeParameterDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeParameterDeclaration, and store 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<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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 alias’s identifier, e.g. Foo in type Foo = number.
• 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, ) -> ArenaBox<'a, TSTypeAliasDeclaration<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeAliasDeclaration, and store 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 alias’s identifier, e.g. Foo in type Foo = number.
• type_parameters
• type_annotation
• declare

pub fn ts_type_alias_declaration_with_scope_id<T1>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, type_annotation: TSType<'a>, declare: bool, scope_id: ScopeId, ) -> TSTypeAliasDeclaration<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeAliasDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• id: Type alias’s identifier, e.g. Foo in type Foo = number.
• type_parameters
• type_annotation
• declare
• scope_id

pub fn alloc_ts_type_alias_declaration_with_scope_id<T1>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, type_annotation: TSType<'a>, declare: bool, scope_id: ScopeId, ) -> ArenaBox<'a, TSTypeAliasDeclaration<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeAliasDeclaration with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• id: Type alias’s identifier, e.g. Foo in type Foo = number.
• type_parameters
• type_annotation
• declare
• scope_id

pub fn ts_class_implements<T1>( self, span: Span, expression: TSTypeName<'a>, type_arguments: T1, ) -> TSClassImplements<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSClassImplements.

Parameters

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

pub fn ts_interface_declaration<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, extends: ArenaVec<'a, TSInterfaceHeritage<'a>>, body: T2, declare: bool, ) -> TSInterfaceDeclaration<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}

pub fn alloc_ts_interface_declaration<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, extends: ArenaVec<'a, TSInterfaceHeritage<'a>>, body: T2, declare: bool, ) -> ArenaBox<'a, TSInterfaceDeclaration<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSInterfaceDeclaration, and store 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.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}

pub fn ts_interface_declaration_with_scope_id<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, extends: ArenaVec<'a, TSInterfaceHeritage<'a>>, body: T2, declare: bool, scope_id: ScopeId, ) -> TSInterfaceDeclaration<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSInterfaceDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• id: The identifier (name) of the interface.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}
• scope_id

pub fn alloc_ts_interface_declaration_with_scope_id<T1, T2>( self, span: Span, id: BindingIdentifier<'a>, type_parameters: T1, extends: ArenaVec<'a, TSInterfaceHeritage<'a>>, body: T2, declare: bool, scope_id: ScopeId, ) -> ArenaBox<'a, TSInterfaceDeclaration<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSInterfaceDeclaration with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• id: The identifier (name) of the interface.
• type_parameters: Type parameters that get bound to the interface.
• extends: Other interfaces/types this interface extends.
• body
• declare: true for declare interface Foo {}
• scope_id

pub fn ts_interface_body( self, span: Span, body: ArenaVec<'a, TSSignature<'a>>, ) -> TSInterfaceBody<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, TSSignature<'a>>, ) -> ArenaBox<'a, TSInterfaceBody<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSInterfaceBody, and store 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<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSPropertySignature<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSPropertySignature, and store 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: ArenaVec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, static: bool, ) -> TSSignature<'a>

where T1: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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
• static

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<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_call_signature_declaration<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> TSSignature<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSSignature::TSCallSignatureDeclaration.

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

Parameters

• span: The Span covering this node
• type_parameters
• this_param
• params
• return_type

pub fn ts_signature_call_signature_declaration_with_scope_id<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> TSSignature<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSSignature::TSCallSignatureDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• type_parameters
• this_param
• params
• return_type
• scope_id

pub fn ts_signature_construct_signature_declaration<T1, T2, T3>( self, span: Span, type_parameters: T1, params: T2, return_type: T3, ) -> TSSignature<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSSignature::TSConstructSignatureDeclaration.

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

Parameters

• span: The Span covering this node
• type_parameters
• params
• return_type

pub fn ts_signature_construct_signature_declaration_with_scope_id<T1, T2, T3>( self, span: Span, type_parameters: T1, params: T2, return_type: T3, scope_id: ScopeId, ) -> TSSignature<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSSignature::TSConstructSignatureDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• type_parameters
• params
• return_type
• scope_id

pub fn ts_signature_method_signature<T1, T2, T3, T4>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> TSSignature<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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
• type_parameters
• this_param
• params
• return_type

pub fn ts_signature_method_signature_with_scope_id<T1, T2, T3, T4>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> TSSignature<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSSignature::TSMethodSignature with scope_id.

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

Parameters

• span: The Span covering this node
• key
• computed
• optional
• kind
• type_parameters
• this_param
• params
• return_type
• scope_id

pub fn ts_index_signature<T1>( self, span: Span, parameters: ArenaVec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, static: bool, ) -> TSIndexSignature<'a>

where T1: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• static

pub fn alloc_ts_index_signature<T1>( self, span: Span, parameters: ArenaVec<'a, TSIndexSignatureName<'a>>, type_annotation: T1, readonly: bool, static: bool, ) -> ArenaBox<'a, TSIndexSignature<'a>>

where T1: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSIndexSignature, and store 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
• static

pub fn ts_call_signature_declaration<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> TSCallSignatureDeclaration<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• type_parameters
• this_param
• params
• return_type

pub fn alloc_ts_call_signature_declaration<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> ArenaBox<'a, TSCallSignatureDeclaration<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSCallSignatureDeclaration, and store 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
• type_parameters
• this_param
• params
• return_type

pub fn ts_call_signature_declaration_with_scope_id<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> TSCallSignatureDeclaration<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSCallSignatureDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• type_parameters
• this_param
• params
• return_type
• scope_id

pub fn alloc_ts_call_signature_declaration_with_scope_id<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> ArenaBox<'a, TSCallSignatureDeclaration<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSCallSignatureDeclaration with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• type_parameters
• this_param
• params
• return_type
• scope_id

pub fn ts_method_signature<T1, T2, T3, T4>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> TSMethodSignature<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• type_parameters
• this_param
• params
• return_type

pub fn alloc_ts_method_signature<T1, T2, T3, T4>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> ArenaBox<'a, TSMethodSignature<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSMethodSignature, and store 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
• type_parameters
• this_param
• params
• return_type

pub fn ts_method_signature_with_scope_id<T1, T2, T3, T4>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> TSMethodSignature<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSMethodSignature with scope_id.

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

Parameters

• span: The Span covering this node
• key
• computed
• optional
• kind
• type_parameters
• this_param
• params
• return_type
• scope_id

pub fn alloc_ts_method_signature_with_scope_id<T1, T2, T3, T4>( self, span: Span, key: PropertyKey<'a>, computed: bool, optional: bool, kind: TSMethodSignatureKind, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> ArenaBox<'a, TSMethodSignature<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSMethodSignature with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• key
• computed
• optional
• kind
• type_parameters
• this_param
• params
• return_type
• scope_id

pub fn ts_construct_signature_declaration<T1, T2, T3>( self, span: Span, type_parameters: T1, params: T2, return_type: T3, ) -> TSConstructSignatureDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• type_parameters
• params
• return_type

pub fn alloc_ts_construct_signature_declaration<T1, T2, T3>( self, span: Span, type_parameters: T1, params: T2, return_type: T3, ) -> ArenaBox<'a, TSConstructSignatureDeclaration<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConstructSignatureDeclaration, and store 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
• type_parameters
• params
• return_type

pub fn ts_construct_signature_declaration_with_scope_id<T1, T2, T3>( self, span: Span, type_parameters: T1, params: T2, return_type: T3, scope_id: ScopeId, ) -> TSConstructSignatureDeclaration<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConstructSignatureDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• type_parameters
• params
• return_type
• scope_id

pub fn alloc_ts_construct_signature_declaration_with_scope_id<T1, T2, T3>( self, span: Span, type_parameters: T1, params: T2, return_type: T3, scope_id: ScopeId, ) -> ArenaBox<'a, TSConstructSignatureDeclaration<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConstructSignatureDeclaration with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• type_parameters
• params
• return_type
• scope_id

pub fn ts_index_signature_name<S1, T1>( self, span: Span, name: S1, type_annotation: T1, ) -> TSIndexSignatureName<'a>

where S1: Into<Str<'a>>, T1: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSIndexSignatureName.

Parameters

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

pub fn ts_interface_heritage<T1>( self, span: Span, expression: Expression<'a>, type_arguments: T1, ) -> TSInterfaceHeritage<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSInterfaceHeritage.

Parameters

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

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<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The identifier the predicate operates on
• asserts: Does this predicate include an asserts modifier?
• type_annotation

pub fn alloc_ts_type_predicate<T1>( self, span: Span, parameter_name: TSTypePredicateName<'a>, asserts: bool, type_annotation: T1, ) -> ArenaBox<'a, TSTypePredicate<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeAnnotation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypePredicate, and store 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: The identifier the predicate operates on
• asserts: Does this predicate include an asserts modifier?
• type_annotation

pub fn ts_type_predicate_name_identifier<S1>( self, span: Span, name: S1, ) -> TSTypePredicateName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypePredicateName::Identifier.

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

Parameters

• span: The Span covering this node
• name

pub fn ts_type_predicate_name_this(self, span: Span) -> TSTypePredicateName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypePredicateName::This.

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

Parameters

• span: The Span covering this node

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The name of the module/namespace being declared.
• 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, ) -> ArenaBox<'a, TSModuleDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclaration, and store 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: The name of the module/namespace being declared.
• body
• kind: The keyword used to define this module declaration.
• declare

pub fn ts_module_declaration_with_scope_id( self, span: Span, id: TSModuleDeclarationName<'a>, body: Option<TSModuleDeclarationBody<'a>>, kind: TSModuleDeclarationKind, declare: bool, scope_id: ScopeId, ) -> TSModuleDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• id: The name of the module/namespace being declared.
• body
• kind: The keyword used to define this module declaration.
• declare
• scope_id

pub fn alloc_ts_module_declaration_with_scope_id( self, span: Span, id: TSModuleDeclarationName<'a>, body: Option<TSModuleDeclarationBody<'a>>, kind: TSModuleDeclarationKind, declare: bool, scope_id: ScopeId, ) -> ArenaBox<'a, TSModuleDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclaration with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• id: The name of the module/namespace being declared.
• body
• kind: The keyword used to define this module declaration.
• declare
• scope_id

pub fn ts_module_declaration_name_identifier<S1>( self, span: Span, name: S1, ) -> TSModuleDeclarationName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclarationName::Identifier.

Parameters

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

pub fn ts_module_declaration_name_identifier_with_symbol_id<S1>( self, span: Span, name: S1, symbol_id: SymbolId, ) -> TSModuleDeclarationName<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclarationName::Identifier with symbol_id.

Parameters

• span: The Span covering this node
• name: The identifier name being bound.
• symbol_id: Unique identifier for this binding.

pub fn ts_module_declaration_name_string_literal<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, ) -> TSModuleDeclarationName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclarationName::StringLiteral.

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.

pub fn ts_module_declaration_name_string_literal_with_lone_surrogates<S1>( self, span: Span, value: S1, raw: Option<Str<'a>>, lone_surrogates: bool, ) -> TSModuleDeclarationName<'a>

where S1: Into<Str<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclarationName::StringLiteral with lone_surrogates.

Parameters

• span: Node location in source code.
• value: The value of the string.
• raw: The raw string as it appears in source code.
• lone_surrogates: The string value contains lone surrogates.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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: The name of the module/namespace being declared.
• body
• kind: The keyword used to define this module declaration.
• declare

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleDeclarationBody::TSModuleDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• id: The name of the module/namespace being declared.
• body
• kind: The keyword used to define this module declaration.
• declare
• scope_id

pub fn ts_module_declaration_body_module_block( self, span: Span, directives: ArenaVec<'a, Directive<'a>>, body: ArenaVec<'a, Statement<'a>>, ) -> TSModuleDeclarationBody<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_global_declaration( self, span: Span, global_span: Span, body: TSModuleBlock<'a>, declare: bool, ) -> TSGlobalDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSGlobalDeclaration.

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

Parameters

• span: The Span covering this node
• global_span: Span of global keyword
• body
• declare

pub fn alloc_ts_global_declaration( self, span: Span, global_span: Span, body: TSModuleBlock<'a>, declare: bool, ) -> ArenaBox<'a, TSGlobalDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSGlobalDeclaration, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• global_span: Span of global keyword
• body
• declare

pub fn ts_global_declaration_with_scope_id( self, span: Span, global_span: Span, body: TSModuleBlock<'a>, declare: bool, scope_id: ScopeId, ) -> TSGlobalDeclaration<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSGlobalDeclaration with scope_id.

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

Parameters

• span: The Span covering this node
• global_span: Span of global keyword
• body
• declare
• scope_id

pub fn alloc_ts_global_declaration_with_scope_id( self, span: Span, global_span: Span, body: TSModuleBlock<'a>, declare: bool, scope_id: ScopeId, ) -> ArenaBox<'a, TSGlobalDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSGlobalDeclaration with scope_id, and store it in the memory arena.

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

Parameters

• span: The Span covering this node
• global_span: Span of global keyword
• body
• declare
• scope_id

pub fn ts_module_block( self, span: Span, directives: ArenaVec<'a, Directive<'a>>, body: ArenaVec<'a, Statement<'a>>, ) -> TSModuleBlock<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, Directive<'a>>, body: ArenaVec<'a, Statement<'a>>, ) -> ArenaBox<'a, TSModuleBlock<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleBlock, and store 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: ArenaVec<'a, TSSignature<'a>>, ) -> TSTypeLiteral<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: ArenaVec<'a, TSSignature<'a>>, ) -> ArenaBox<'a, TSTypeLiteral<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeLiteral, and store 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, ArenaBox<'a, TSTypeParameter<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The type bound when the

pub fn alloc_ts_infer_type<T1>( self, span: Span, type_parameter: T1, ) -> ArenaBox<'a, TSInferType<'a>>

where T1: IntoIn<'a, ArenaBox<'a, TSTypeParameter<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSInferType, and store 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: The type bound when the

pub fn ts_type_query<T1>( self, span: Span, expr_name: TSTypeQueryExprName<'a>, type_arguments: T1, ) -> TSTypeQuery<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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_arguments

pub fn alloc_ts_type_query<T1>( self, span: Span, expr_name: TSTypeQueryExprName<'a>, type_arguments: T1, ) -> ArenaBox<'a, TSTypeQuery<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeQuery, and store 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_arguments

pub fn ts_type_query_expr_name_import_type<T1, T2>( self, span: Span, source: StringLiteral<'a>, options: T1, qualifier: Option<TSImportTypeQualifier<'a>>, type_arguments: T2, ) -> TSTypeQueryExprName<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, ObjectExpression<'a>>>>, T2: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterInstantiation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeQueryExprName::TSImportType.

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

Parameters

• span: The Span covering this node
• source
• options
• qualifier
• type_arguments

pub fn ts_import_type<T1, T2>( self, span: Span, source: StringLiteral<'a>, options: T1, qualifier: Option<TSImportTypeQualifier<'a>>, type_arguments: T2, ) -> TSImportType<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, ObjectExpression<'a>>>>, T2: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterInstantiation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• source
• options
• qualifier
• type_arguments

pub fn alloc_ts_import_type<T1, T2>( self, span: Span, source: StringLiteral<'a>, options: T1, qualifier: Option<TSImportTypeQualifier<'a>>, type_arguments: T2, ) -> ArenaBox<'a, TSImportType<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, ObjectExpression<'a>>>>, T2: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterInstantiation<'a>>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSImportType, and store 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
• source
• options
• qualifier
• type_arguments

pub fn ts_import_type_qualifier_identifier<S1>( self, span: Span, name: S1, ) -> TSImportTypeQualifier<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSImportTypeQualifier::Identifier.

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

Parameters

• span: The Span covering this node
• name

pub fn ts_import_type_qualifier_qualified_name( self, span: Span, left: TSImportTypeQualifier<'a>, right: IdentifierName<'a>, ) -> TSImportTypeQualifier<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSImportTypeQualifier::QualifiedName.

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

Parameters

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

pub fn ts_import_type_qualified_name( self, span: Span, left: TSImportTypeQualifier<'a>, right: IdentifierName<'a>, ) -> TSImportTypeQualifiedName<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSImportTypeQualifiedName.

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

Parameters

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

pub fn alloc_ts_import_type_qualified_name( self, span: Span, left: TSImportTypeQualifier<'a>, right: IdentifierName<'a>, ) -> ArenaBox<'a, TSImportTypeQualifiedName<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSImportTypeQualifiedName, and store 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_qualified_name instead.

Parameters

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

pub fn ts_function_type<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> TSFunctionType<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• type_parameters: Generic type parameters
• this_param: this parameter
• params: Function parameters. Akin to Function::params.
• return_type: Return type of the function.

pub fn alloc_ts_function_type<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, ) -> ArenaBox<'a, TSFunctionType<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSFunctionType, and store 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
• type_parameters: Generic type parameters
• this_param: this parameter
• params: Function parameters. Akin to Function::params.
• return_type: Return type of the function.

pub fn ts_function_type_with_scope_id<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> TSFunctionType<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSFunctionType with scope_id.

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

Parameters

• span: The Span covering this node
• type_parameters: Generic type parameters
• this_param: this parameter
• params: Function parameters. Akin to Function::params.
• return_type: Return type of the function.
• scope_id

pub fn alloc_ts_function_type_with_scope_id<T1, T2, T3, T4>( self, span: Span, type_parameters: T1, this_param: T2, params: T3, return_type: T4, scope_id: ScopeId, ) -> ArenaBox<'a, TSFunctionType<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSFunctionType with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• type_parameters: Generic type parameters
• this_param: this parameter
• params: Function parameters. Akin to Function::params.
• return_type: Return type of the function.
• scope_id

pub fn ts_constructor_type<T1, T2, T3>( self, span: Span, abstract: bool, type_parameters: T1, params: T2, return_type: T3, ) -> TSConstructorType<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• abstract
• type_parameters
• params
• return_type

pub fn alloc_ts_constructor_type<T1, T2, T3>( self, span: Span, abstract: bool, type_parameters: T1, params: T2, return_type: T3, ) -> ArenaBox<'a, TSConstructorType<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConstructorType, and store 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
• abstract
• type_parameters
• params
• return_type

pub fn ts_constructor_type_with_scope_id<T1, T2, T3>( self, span: Span, abstract: bool, type_parameters: T1, params: T2, return_type: T3, scope_id: ScopeId, ) -> TSConstructorType<'a>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConstructorType with scope_id.

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

Parameters

• span: The Span covering this node
• abstract
• type_parameters
• params
• return_type
• scope_id

pub fn alloc_ts_constructor_type_with_scope_id<T1, T2, T3>( self, span: Span, abstract: bool, type_parameters: T1, params: T2, return_type: T3, scope_id: ScopeId, ) -> ArenaBox<'a, TSConstructorType<'a>>

where T1: IntoIn<'a, Option<ArenaBox<'a, TSTypeParameterDeclaration<'a>>>>, T2: IntoIn<'a, ArenaBox<'a, FormalParameters<'a>>>, T3: IntoIn<'a, ArenaBox<'a, TSTypeAnnotation<'a>>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSConstructorType with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• abstract
• type_parameters
• params
• return_type
• scope_id

pub fn ts_mapped_type( self, span: Span, key: BindingIdentifier<'a>, constraint: TSType<'a>, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: Option<TSMappedTypeModifierOperator>, readonly: Option<TSMappedTypeModifierOperator>, ) -> TSMappedType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• key: Key type parameter, e.g. P in [P in keyof T].
• constraint: Constraint type, e.g. keyof T in [P in keyof T].
• name_type
• type_annotation
• optional: Optional modifier on type annotation
• readonly: Readonly modifier before keyed index signature

pub fn alloc_ts_mapped_type( self, span: Span, key: BindingIdentifier<'a>, constraint: TSType<'a>, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: Option<TSMappedTypeModifierOperator>, readonly: Option<TSMappedTypeModifierOperator>, ) -> ArenaBox<'a, TSMappedType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSMappedType, and store 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
• key: Key type parameter, e.g. P in [P in keyof T].
• constraint: Constraint type, e.g. keyof T in [P in keyof T].
• name_type
• type_annotation
• optional: Optional modifier on type annotation
• readonly: Readonly modifier before keyed index signature

pub fn ts_mapped_type_with_scope_id( self, span: Span, key: BindingIdentifier<'a>, constraint: TSType<'a>, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: Option<TSMappedTypeModifierOperator>, readonly: Option<TSMappedTypeModifierOperator>, scope_id: ScopeId, ) -> TSMappedType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSMappedType with scope_id.

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

Parameters

• span: The Span covering this node
• key: Key type parameter, e.g. P in [P in keyof T].
• constraint: Constraint type, e.g. keyof T in [P in keyof T].
• name_type
• type_annotation
• optional: Optional modifier on type annotation
• readonly: Readonly modifier before keyed index signature
• scope_id

pub fn alloc_ts_mapped_type_with_scope_id( self, span: Span, key: BindingIdentifier<'a>, constraint: TSType<'a>, name_type: Option<TSType<'a>>, type_annotation: Option<TSType<'a>>, optional: Option<TSMappedTypeModifierOperator>, readonly: Option<TSMappedTypeModifierOperator>, scope_id: ScopeId, ) -> ArenaBox<'a, TSMappedType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSMappedType with scope_id, and store 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_with_scope_id instead.

Parameters

• span: The Span covering this node
• key: Key type parameter, e.g. P in [P in keyof T].
• constraint: Constraint type, e.g. keyof T in [P in keyof T].
• name_type
• type_annotation
• optional: Optional modifier on type annotation
• readonly: Readonly modifier before keyed index signature
• scope_id

pub fn ts_template_literal_type( self, span: Span, quasis: ArenaVec<'a, TemplateElement<'a>>, types: ArenaVec<'a, TSType<'a>>, ) -> TSTemplateLiteralType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The string parts of the template literal.
• types: The interpolated expressions in the template literal.

pub fn alloc_ts_template_literal_type( self, span: Span, quasis: ArenaVec<'a, TemplateElement<'a>>, types: ArenaVec<'a, TSType<'a>>, ) -> ArenaBox<'a, TSTemplateLiteralType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTemplateLiteralType, and store 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: The string parts of the template literal.
• types: The interpolated expressions in the template literal.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSAsExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSAsExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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: The value expression being constrained.
• type_annotation: The type expression must satisfy.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSSatisfiesExpression, and store 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: The value expression being constrained.
• type_annotation: The type expression must satisfy.

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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
• type_annotation
• expression

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSTypeAssertion, and store 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
• type_annotation
• expression

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, TSImportEqualsDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSImportEqualsDeclaration, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

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_identifier_reference<S1>( self, span: Span, name: S1, ) -> TSModuleReference<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleReference::IdentifierReference.

This node contains an 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_module_reference_identifier_reference_with_reference_id<S1>( self, span: Span, name: S1, reference_id: ReferenceId, ) -> TSModuleReference<'a>

where S1: Into<Ident<'a>>,

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleReference::IdentifierReference with reference_id.

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

Parameters

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

pub fn ts_module_reference_qualified_name( self, span: Span, left: TSTypeName<'a>, right: IdentifierName<'a>, ) -> TSModuleReference<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSModuleReference::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_external_module_reference( self, span: Span, expression: StringLiteral<'a>, ) -> TSExternalModuleReference<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSExternalModuleReference<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSExternalModuleReference, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSNonNullExpression<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSNonNullExpression, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a Decorator.

Parameters

• span: The Span covering this node
• expression

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSExportAssignment<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSExportAssignment, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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>, ) -> ArenaBox<'a, TSNamespaceExportDeclaration<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSNamespaceExportDeclaration, and store 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_arguments: T1, ) -> TSInstantiationExpression<'a>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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_arguments

pub fn alloc_ts_instantiation_expression<T1>( self, span: Span, expression: Expression<'a>, type_arguments: T1, ) -> ArenaBox<'a, TSInstantiationExpression<'a>>

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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a TSInstantiationExpression, and store 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_arguments

pub fn js_doc_nullable_type( self, span: Span, type_annotation: TSType<'a>, postfix: bool, ) -> JSDocNullableType<'a>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, JSDocNullableType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSDocNullableType, and store 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>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, JSDocNonNullableType<'a>>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSDocNonNullableType, and store 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

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build 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, ) -> ArenaBox<'a, JSDocUnknownType>

👎Deprecated:

Migrate to new AstBuilder interface. See https://github.com/oxc-project/oxc/issues/23043

Build a JSDocUnknownType, and store 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

Trait Implementations

impl<'a> AstBuild<'a> for AstBuilder<'a>

fn node_id(&self) -> NodeId

Get NodeId to assign to an AST node.

AstBuilder does not assign real NodeIds - it always returns NodeId::DUMMY.

impl<'a> Clone for AstBuilder<'a>

fn clone(&self) -> AstBuilder<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for AstBuilder<'a>

impl<'a> GetAllocator<'a> for AstBuilder<'a>

fn allocator(&self) -> &'a Allocator

Get the memory Allocator to allocate AST types in.

impl<'a> GetAstBuilder<'a> for AstBuilder<'a>

AstBuilder implements GetAstBuilder so it can be passed directly to AST build methods.

type Builder = AstBuilder<'a>

The AstBuilder type that this provides access to.

fn builder(&self) -> &Self

Get the AstBuilder.