Struct Function 

#[repr(C)]
pub struct Function<'a> {

    pub span: Span,
    pub id: Option<BindingIdentifier<'a>>,
    pub type_parameters: Option<Box<'a, TSTypeParameterDeclaration<'a>>>,
    pub this_param: Option<Box<'a, TSThisParameter<'a>>>,
    pub params: Box<'a, FormalParameters<'a>>,
    pub return_type: Option<Box<'a, TSTypeAnnotation<'a>>>,
    pub body: Option<Box<'a, FunctionBody<'a>>>,
    pub scope_id: Cell<Option<ScopeId>>,
    pub type: FunctionType,
    pub generator: bool,
    pub async: bool,
    pub declare: bool,
    pub pure: bool,
    pub pife: bool,
}

Function Statement or Expression

Includes generator functions and function-valued class properties. Arrow functions are represented by ArrowFunctionExpression.

Examples

//    id ___             ____ return_type
function foo(a: number): void {
//           ^^^^^^^^^ params
    console.log(a);
}

// `async` and `generator` are true
async function* foo() {
    yield 1;
}

// function.id is None
// use function.r#type to check if a node is a function expression.
const foo = function() { }

// Function overloads will not have a body
function add(a: number, b: number): number; // <-- No body
function add(a: string, b: string): string; // <-- No body
function add(a: any, b: any): any {         // <-- Body is between `{}`, inclusive.
   return a + b;
}

Fields

span: Span

id: Option<BindingIdentifier<'a>>

The function identifier. None for anonymous function expressions.

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

this_param: Option<Box<'a, TSThisParameter<'a>>>

Declaring this in a Function https://www.typescriptlang.org/docs/handbook/2/functions.html#declaring-this-in-a-function

The JavaScript specification states that you cannot have a parameter called this, and so TypeScript uses that syntax space to let you declare the type for this in the function body.

interface DB {
    filterUsers(filter: (this: User) => boolean): User[];
    //                   ^^^^
}

const db = getDB();
const admins = db.filterUsers(function (this: User) {
    return this.admin;
});

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

Function parameters.

Does not include this parameters used by some TypeScript functions.

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

The TypeScript return type annotation.

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

The function body.

None for function declarations, e.g.

// TypeScript function declarations have no body
declare function foo(a: number): number;

function bar(a: number): number; // <- overloads have no body
function bar(a: number): number {
    return a;
}

scope_id: Cell<Option<ScopeId>>

type: FunctionType

generator: bool

Is this a generator function?

function* foo() { } // <- generator: true
function bar() { }  // <- generator: false

async: bool

declare: 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).

This only affects FunctionExpressions.

References:

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

Implementations

impl<'a> Function<'a>

pub fn name(&self) -> Option<Atom<'a>>

Returns this Function’s name, if it has one.

pub fn is_typescript_syntax(&self) -> bool

Returns true if this function uses overload signatures or declare function statements.

pub fn is_expression(&self) -> bool

true for both function expressions and typescript empty body function expressions

pub fn is_function_declaration(&self) -> bool

true for function declarations

pub fn is_ts_declare_function(&self) -> bool

true for declare function statements

pub fn is_declaration(&self) -> bool

true for non-expression functions

pub fn has_use_strict_directive(&self) -> bool

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

impl Function<'_>

pub fn scope_id(&self) -> ScopeId

Get ScopeId of Function.

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 Function.

Trait Implementations

impl<'a> BoundNames<'a> for Function<'a>

fn bound_names<F>(&self, f: &mut F)

where F: FnMut(&BindingIdentifier<'a>),

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

type Cloned = Function<'new_alloc>

The type of the cloned object.

fn clone_in( &self, allocator: &'new_alloc Allocator, ) -> <Function<'_> 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, ) -> <Function<'_> 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 Function<'_>

fn content_eq(&self, other: &Function<'_>) -> 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 Function<'a>

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

Formats the value using the given formatter.

impl<'a> Dummy<'a> for Function<'a>

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

Create a dummy Function.

Has cost of making 1 allocation (48 bytes).

impl Gen for Function<'_>

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

Generate code for an AST node.

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

Generate code for an AST node. Alias for gen.

impl GetSpan for Function<'_>

fn span(&self) -> Span

Get the Span for an AST node.

impl GetSpanMut for Function<'_>

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

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

impl<'a> TakeIn<'a> for Function<'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.