FunctionNode

How the function was written: a plain function, an accessor, or a method.

The absolute document position, computed by adding this node's relative position to the relative positions of all its parents.

The AstRoot at the top of this node's parent chain, or null if there is none.

Base (starting) line number for this script or function. Setting it is a one-time operation and fails if the line number is already set.

Only valid when type == Token.BIGINT.

The function body: normally a Block, or a plain AstNode for a function closure. Null only when the AST is malformed.

The scopes whose parent is this scope, or null if there are none.

The column where this node is defined in source, one-based. -1 means it was never initialized. May be overridden by subclasses.

Only valid when type == Token.NUMBER.

The innermost enclosing function, or null. The search begins with the parent.

The innermost enclosing Scope, or null. The search begins with the parent. This is not the same as the defining scope for a Name.

Sets the function name and reparents it to this node. Null means an anonymous function.

The function type: statement, expression, or expression statement.

IR block for default parameter init in generators.

Comments on the same line as the statement, for example the trailing comment in if (x == 2) // note.

The JsDoc comment string attached to this node, or null.

The JsDoc Comment attached to this node, or null.

Number of characters spanned by this node in the source text.

The line number recorded for this node. If none was recorded, searches the parent chain and returns -1 when nothing is found.

Left paren position, -1 if missing.

Rhino supports a nonstandard extension letting you write function a.b.c(arg) {...}, rewritten at codegen time to a.b.c = function(arg) {...}. When the parser sees an expression other than a simple Name where the function name belongs, it records that expression here. Enabled by the allowMemberExprAsFunctionName compiler option.

The function name as a string, or "" if anonymous.

Number of parameters, counted as Token.LP symbols arrive.

The parameter list, or an empty list if there are no parameters.

The node parent, or null. Setting it adjusts this node's start position to be relative to the new parent.

Relative position in the parent.

The raw source, or null if it was not recorded. Used by the code generator.

End offset of the raw source. Only valid when rawSource is non-null.

Start offset of the raw source. Only valid when rawSource is non-null.

True when this function requires an Ecma-262 Activation object. The activation is expensive to create, so the interpreter uses a plain call frame when it can. A lexical closure is one of several situations that force one.

Right paren position, -1 if missing.

Only valid when the node has String context.

The URI, path or descriptive text naming the origin of this script's source.

A copy of the child list, with each child cast to an AstNode. Throws once the code generator has begun the tree transformation and non-AstNode children appear.

Only valid when the node has String context.

Every symbol in this script or function, in declaration order.

Insertion-ordered so that iteration follows declaration order.

The current script or function scope.

The node type, e.g. Token.NAME.

Adds a child to the end of the block. Sets the child's parent to this node, rewrites the child position to be relative, and grows this node to include the child.

Add newChild after node.

Add newChild before node.

Adds a scope to the child list and sets the child's parent scope to this scope.

Adds a FunctionNode to the functions table for codegen. Does not set the parent of the node.

Adds a parameter and reparents it to this node.

Called by IRFactory to add a RegExp to the regexp table.

Called by IRFactory to add a template literal to the table.

Used only for code generation.

Sorts by start position, then by length, then arbitrarily by hash code. Lets Comment and error nodes be mixed into a sorted collection of other AST nodes.

A debugging representation of the parse tree starting at this node. Each line reads abs-pos name position length [identifier].

The depth of this node. The root is depth 0, its children depth 1, and so on.

Assigns every symbol a unique integer index and builds the name and constness arrays that can be indexed by it.

The scope in which name is defined: this scope, one of its parents, or null when the name is not defined anywhere in this scope chain.

Looks up a symbol in this scope, or null if it is not there.

Checks that every return usage in a function body is consistent with strict mode. See the END_* flags for what the analysis reports.

True when node is a parameter of this function. Lets a traversal tell the function name node apart from the parameter nodes.

Constructs an indentation string of indent steps.

Enters a symbol into this scope.

Used by the parser. Repoints this scope's child scopes at newScope and copies this scope's symbols into it.

Recursively unlabel every TARGET or YIELD node in the tree. Used only for inlining finally blocks where jsr instructions used to be.

Sets the start and end positions; the length becomes end - position.

Sets the parameter list and reparents every element. Null means no parameters.

Sets both paren positions.

Used by the code generator.

Makes this node's position relative to a parent. The current position is assumed to be absolute and is decremented by parentPosition.

A short, descriptive name for the node, such as "ArrayComprehension".

Jumps are only used during code generation and cannot render source.

Visits this node, the function name if present, the parameters and the body. A member-expr node is visited last.