Struct ArrowFunctionExpression 

#[repr(C)]
pub struct ArrowFunctionExpression<'a> {
    pub span: Span,
    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
    pub params: Box<'a, FormalParameters<'a>>,
    pub return_type: Option<Box<'a, TSTypeAnnotation<'a>>>,
    pub body: Box<'a, FunctionBody<'a>>,
    pub scope_id: Cell<Option<ScopeId>>,
    pub expression: bool,
    pub async: bool,
    pub pure: bool,
    pub pife: bool,
}

Arrow Function Definitions

Fields

span: Span

type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>

params: Box<'a, FormalParameters<'a>>

return_type: Option<Box<'a, TSTypeAnnotation<'a>>>

body: Box<'a, FunctionBody<'a>>

See expression for whether this arrow expression returns an expression.

scope_id: Cell<Option<ScopeId>>

expression: bool

Is the function body an arrow expression? i.e. () => expr instead of () => {}

async: bool

pure: bool

true if the function is marked with a /*#__NO_SIDE_EFFECTS__*/ comment

pife: bool

true if the function should be marked as “Possibly-Invoked Function Expression” (PIFE).

References:

• v8 blog post about PIFEs: https://v8.dev/blog/preparser#pife
• introduced PR: https://github.com/oxc-project/oxc/pull/12353

Implementations

impl<'a> ArrowFunctionExpression<'a>

pub fn get_expression(&self) -> Option<&Expression<'a>>

Get expression part of ArrowFunctionExpression: () => expression_part.

pub fn get_expression_mut(&mut self) -> Option<&mut Expression<'a>>

Get expression part of ArrowFunctionExpression: () => expression_part.

pub fn has_use_strict_directive(&self) -> bool

Returns true if this arrow function’s body has a "use strict" directive.

impl ArrowFunctionExpression<'_>

pub fn scope_id(&self) -> ScopeId

Get ScopeId of ArrowFunctionExpression.

Only use this method on a post-semantic AST where ScopeIds are always defined.

Panics

Panics if scope_id is None.

pub fn set_scope_id(&self, scope_id: ScopeId)

Set ScopeId of ArrowFunctionExpression.

Trait Implementations

impl<'new_alloc> CloneIn<'new_alloc> for ArrowFunctionExpression<'_>

type Cloned = ArrowFunctionExpression<'new_alloc>

The type of the cloned object.

fn clone_in( &self, allocator: &'new_alloc Allocator, ) -> <ArrowFunctionExpression<'_> as CloneIn<'new_alloc>>::Cloned

Clone self into the given allocator. allocator may be the same one that self is already in.

fn clone_in_with_semantic_ids( &self, allocator: &'new_alloc Allocator, ) -> <ArrowFunctionExpression<'_> as CloneIn<'new_alloc>>::Cloned

Almost identical as clone_in, but for some special type, it will also clone the semantic ids. Please use this method only if you make sure semantic info is synced with the ast node.

impl ContentEq for ArrowFunctionExpression<'_>

fn content_eq(&self, other: &ArrowFunctionExpression<'_>) -> bool

This method tests for contents of self and other to be equal.

fn content_ne(&self, other: &Self) -> bool

This method tests for contents of self and other not to be equal. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Debug for ArrowFunctionExpression<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> Dummy<'a> for ArrowFunctionExpression<'a>

fn dummy(allocator: &'a Allocator) -> ArrowFunctionExpression<'a>

Create a dummy ArrowFunctionExpression.

Has cost of making 2 allocations (104 bytes).

impl GenExpr for ArrowFunctionExpression<'_>

fn gen_expr(&self, p: &mut Codegen<'_>, precedence: Precedence, ctx: Context)

Generate code for an expression, respecting operator precedence.

fn print_expr(&self, p: &mut Codegen<'_>, precedence: Precedence, ctx: Context)

Generate code for an expression, respecting operator precedence. Alias for gen_expr.

impl GetSpan for ArrowFunctionExpression<'_>

fn span(&self) -> Span

Get the Span for an AST node.

impl GetSpanMut for ArrowFunctionExpression<'_>

fn span_mut(&mut self) -> &mut Span

Get a mutable reference to an AST node’s Span.

impl<'a> TakeIn<'a> for ArrowFunctionExpression<'a>

fn take_in<A>(&mut self, allocator_accessor: A) -> Self

where A: AllocatorAccessor<'a>,

Replace node with a dummy.

fn take_in_box<A>(&mut self, allocator_accessor: A) -> Box<'a, Self>

where A: AllocatorAccessor<'a>,

Replace node with a boxed dummy.

impl UnstableAddress for ArrowFunctionExpression<'_>

fn unstable_address(&self) -> Address

Get the memory Address of a reference to an AST node in arena, which is not necessarily stable.