## org.mozilla.javascript.ast
Class FunctionNode

    java.lang.Object
      org.mozilla.javascript.Node
          org.mozilla.javascript.ast.AstNode
              org.mozilla.javascript.ast.Jump
                  org.mozilla.javascript.ast.Scope
                      org.mozilla.javascript.ast.ScriptNode
                          org.mozilla.javascript.ast.FunctionNode

All Implemented Interfaces:
  java.lang.Comparable<AstNode>, java.lang.Iterable<Node>

    public class FunctionNode

extends ScriptNode

A JavaScript function declaration or expression.

Node type is `Token.FUNCTION`.

    FunctionDeclaration :
            function Identifier ( FormalParameterListopt ) { FunctionBody }
     FunctionExpression :
            function Identifieropt ( FormalParameterListopt ) { FunctionBody }
     FormalParameterList :
            Identifier
            FormalParameterList , Identifier
     FunctionBody :
            SourceElements
     Program :
            SourceElements
     SourceElements :
            SourceElement
            SourceElements SourceElement
     SourceElement :
            Statement
            FunctionDeclaration

JavaScript 1.8 introduces "function closures" of the form

    function ([params] ) Expression

In this case the FunctionNode node will have no body but will have an expression.

Nested Class Summary
`static class` `FunctionNode.Form`

Nested classes/interfaces inherited from class org.mozilla.javascript.ast.AstNode
`AstNode.DebugPrintVisitor, AstNode.PositionComparator`

Nested classes/interfaces inherited from class org.mozilla.javascript.Node
`Node.NodeIterator`

Field Summary
`static int` `FUNCTION_EXPRESSION`
`static int` `FUNCTION_EXPRESSION_STATEMENT`
`static int` `FUNCTION_STATEMENT` There are three types of functions that can be defined.

Fields inherited from class org.mozilla.javascript.ast.Scope
`parentScope, symbolTable, top`

Fields inherited from class org.mozilla.javascript.ast.Jump
`target`

Fields inherited from class org.mozilla.javascript.ast.AstNode
`length, parent, position`

Fields inherited from class org.mozilla.javascript.Node

`ATTRIBUTE_FLAG, BOTH, CASEARRAY_PROP, CATCH_SCOPE_PROP, CONTROL_BLOCK_PROP, DECR_FLAG, DESCENDANTS_FLAG, DESTRUCTURING_ARRAY_LENGTH, DESTRUCTURING_NAMES, DESTRUCTURING_PARAMS, DESTRUCTURING_SHORTHAND, DIRECTCALL_PROP, END_DROPS_OFF, END_RETURNS, END_RETURNS_VALUE, END_UNREACHED, END_YIELDS, EXPRESSION_CLOSURE_PROP, first, FUNCTION_PROP, GENERATOR_END_PROP, INCRDECR_PROP, ISNUMBER_PROP, JSDOC_PROP, LABEL_ID_PROP, last, LAST_PROP, LEFT, lineno, LOCAL_BLOCK_PROP, LOCAL_PROP, MEMBER_TYPE_PROP, NAME_PROP, next, NON_SPECIALCALL, OBJECT_IDS_PROP, PARENTHESIZED_PROP, POST_FLAG, PROPERTY_FLAG, propListHead, REGEXP_PROP, RIGHT, SKIP_INDEXES_PROP, SPECIALCALL_EVAL, SPECIALCALL_PROP, SPECIALCALL_WITH, TARGETBLOCK_PROP, type, VARIABLE_PROP`

Constructor Summary
`FunctionNode()`
`FunctionNode(int pos)`
`FunctionNode(int pos, Name name)`

Method Summary
`int` `addFunction(FunctionNode fnNode)` Adds a `FunctionNode` to the functions table for codegen.
`void` `addLiveLocals(Node node, int[] locals)`
`void` `addParam(AstNode param)` Adds a parameter to the function parameter list.
`void` `addResumptionPoint(Node target)`
`AstNode` `getBody()` Returns function body.
`Name` `getFunctionName()` Returns function name
`int` `getFunctionType()` Returns the function type (statement, expr, statement expr)
`boolean` `getIgnoreDynamicScope()`
`java.util.Map<Node,int[]>` `getLiveLocals()`
`int` `getLp()` Returns left paren position, -1 if missing
`AstNode` `getMemberExprNode()`
`java.lang.String` `getName()` Returns the function name as a string
`java.util.List<AstNode>` `getParams()` Returns the function parameter list
`java.util.List<Node>` `getResumptionPoints()`
`int` `getRp()` Returns right paren position, -1 if missing
`boolean` `isExpressionClosure()` Returns whether this is a 1.8 function closure
`boolean` `isGenerator()`
`boolean` `isGetter()`
`boolean` `isGetterOrSetter()`
`boolean` `isParam(AstNode node)` Returns true if the specified `AstNode` node is a parameter of this Function node.
`boolean` `isSetter()`
`boolean` `requiresActivation()` Return true if this function requires an Ecma-262 Activation object.
`void` `setBody(AstNode body)` Sets function body, and sets its parent to this node.
`void` `setFunctionIsGetter()`
`void` `setFunctionIsSetter()`
`void` `setFunctionName(Name name)` Sets function name, and sets its parent to this node.
`void` `setFunctionType(int type)`
`void` `setIgnoreDynamicScope()`
`void` `setIsExpressionClosure(boolean isExpressionClosure)` Sets whether this is a 1.8 function closure
`void` `setIsGenerator()`
`void` `setLp(int lp)` Sets left paren position
`void` `setMemberExprNode(AstNode node)` Rhino supports a nonstandard Ecma extension that allows you to say, for instance, function a.b.c(arg1, arg) {...}, and it will be rewritten at codegen time to: a.b.c = function(arg1, arg2) {...} If we detect an expression other than a simple Name in the position where a function name was expected, we record that expression here.
`void` `setParams(java.util.List<AstNode> params)` Sets the function parameter list, and sets the parent for each element of the list.
`void` `setParens(int lp, int rp)` Sets both paren positions
`void` `setRequiresActivation()`
`void` `setRp(int rp)` Sets right paren position
`java.lang.String` `toSource(int depth)` Emits source code for this node.
`void` `visit(NodeVisitor v)` Visits this node, the function name node if supplied, the parameters, and the body.

Methods inherited from class org.mozilla.javascript.ast.ScriptNode

`addRegExp, flattenSymbolTable, getBaseLineno, getCompilerData, getEncodedSource, getEncodedSourceEnd, getEncodedSourceStart, getEndLineno, getFunctionCount, getFunctionNode, getFunctions, getIndexForNameNode, getNextTempName, getParamAndVarConst, getParamAndVarCount, getParamAndVarNames, getParamCount, getParamOrVarName, getRegexpCount, getRegexpFlags, getRegexpString, getSourceName, getSymbols, setBaseLineno, setCompilerData, setEncodedSource, setEncodedSourceBounds, setEncodedSourceEnd, setEncodedSourceStart, setEndLineno, setSourceName, setSymbols`

Methods inherited from class org.mozilla.javascript.ast.Scope
`addChildScope, clearParentScope, getChildScopes, getDefiningScope, getParentScope, getStatements, getSymbol, getSymbolTable, getTop, joinScopes, putSymbol, replaceWith, setParentScope, setSymbolTable, setTop, splitScope`

Methods inherited from class org.mozilla.javascript.ast.Jump
`getContinue, getDefault, getFinally, getJumpStatement, getLoop, setContinue, setDefault, setFinally, setJumpStatement, setLoop`

Methods inherited from class org.mozilla.javascript.ast.AstNode
`addChild, assertNotNull, codeBug, compareTo, debugPrint, depth, getAbsolutePosition, getAstRoot, getEnclosingFunction, getEnclosingScope, getLength, getLineno, getParent, getPosition, hasSideEffects, makeIndent, operatorToString, printList, setBounds, setLength, setParent, setPosition, setRelative, shortName, toSource`

Methods inherited from class org.mozilla.javascript.Node

`addChildAfter, addChildBefore, addChildrenToBack, addChildrenToFront, addChildToBack, addChildToFront, getChildBefore, getDouble, getExistingIntProp, getFirstChild, getIntProp, getJsDoc, getLastChild, getLastSibling, getNext, getProp, getScope, getString, getType, hasChildren, hasConsistentReturnUsage, iterator, labelId, labelId, newNumber, newString, newString, newTarget, putIntProp, putProp, removeChild, removeChildren, removeProp, replaceChild, replaceChildAfter, setDouble, setJsDoc, setLineno, setScope, setString, setType, toString, toStringTree`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

### FUNCTION_STATEMENT

    public static final int FUNCTION_STATEMENT

  There are three types of functions that can be defined. The first is a function statement. This is a function appearing as a top-level statement (i.e., not nested inside some other statement) in either a script or a function.

  The second is a function expression, which is a function appearing in an expression except for the third type, which is...

  The third type is a function expression where the expression is the top-level expression in an expression statement.

  The three types of functions have different treatment and must be distinguished.

  See Also:
    Constant Field Values

### FUNCTION_EXPRESSION

    public static final int FUNCTION_EXPRESSION

See Also:
  Constant Field Values

### FUNCTION_EXPRESSION_STATEMENT

    public static final int FUNCTION_EXPRESSION_STATEMENT

See Also:
  Constant Field Values

Constructor Detail

### FunctionNode

    public FunctionNode()

### FunctionNode

    public FunctionNode(int pos)

### FunctionNode

    public FunctionNode(int pos,
                        Name name)

Method Detail

### getFunctionName

    public Name getFunctionName()

  Returns function name

  Returns:
    function name, `null` for anonymous functions

### setFunctionName

    public void setFunctionName(Name name)

  Sets function name, and sets its parent to this node.

  Parameters:
    `name` - function name, `null` for anonymous functions

### getName

    public java.lang.String getName()

  Returns the function name as a string

  Returns:
    the function name, `""` if anonymous

### getParams

    public java.util.List<AstNode> getParams()

  Returns the function parameter list

  Returns:
    the function parameter list. Returns an immutable empty list if there are no parameters.

### setParams

    public void setParams(java.util.List<AstNode> params)

  Sets the function parameter list, and sets the parent for each element of the list.

  Parameters:
    `params` - the function parameter list, or `null` if no params

### addParam

    public void addParam(AstNode param)

  Adds a parameter to the function parameter list. Sets the parent of the param node to this node.

  Parameters:
    `param` - the parameter
  Throws:
    `java.lang.IllegalArgumentException` - if param is `null`

### isParam

    public boolean isParam(AstNode node)

  Returns true if the specified `AstNode` node is a parameter of this Function node. This provides a way during AST traversal to disambiguate the function name node from the parameter nodes.

### getBody

    public AstNode getBody()

  Returns function body. Normally a `Block`, but can be a plain `AstNode` if it's a function closure.

  Returns:
    the body. Can be `null` only if the AST is malformed.

### setBody

    public void setBody(AstNode body)

  Sets function body, and sets its parent to this node. Also sets the encoded source bounds based on the body bounds. Assumes the function node absolute position has already been set, and the body node's absolute position and length are set.

  Parameters:
    `body` - function body. Its parent is set to this node, and its position is updated to be relative to this node.
  Throws:
    `java.lang.IllegalArgumentException` - if body is `null`

### getLp

    public int getLp()

  Returns left paren position, -1 if missing

### setLp

    public void setLp(int lp)

  Sets left paren position

### getRp

    public int getRp()

  Returns right paren position, -1 if missing

### setRp

    public void setRp(int rp)

  Sets right paren position

### setParens

    public void setParens(int lp,
                          int rp)

  Sets both paren positions

### isExpressionClosure

    public boolean isExpressionClosure()

  Returns whether this is a 1.8 function closure

### setIsExpressionClosure

    public void setIsExpressionClosure(boolean isExpressionClosure)

  Sets whether this is a 1.8 function closure

### requiresActivation

    public boolean requiresActivation()

  Return true if this function requires an Ecma-262 Activation object. The Activation object is implemented by `NativeCall`, and is fairly expensive to create, so when possible, the interpreter attempts to use a plain call frame instead.

  Returns:
    true if this function needs activation. It could be needed if there is a lexical closure, or dynamic scope, or in a number of other situations.

### setRequiresActivation

    public void setRequiresActivation()

### getIgnoreDynamicScope

    public boolean getIgnoreDynamicScope()

### setIgnoreDynamicScope

    public void setIgnoreDynamicScope()

### isGenerator

    public boolean isGenerator()

### setIsGenerator

    public void setIsGenerator()

### addResumptionPoint

    public void addResumptionPoint(Node target)

### getResumptionPoints

    public java.util.List<Node> getResumptionPoints()

### getLiveLocals

    public java.util.Map<Node,int[]> getLiveLocals()

### addLiveLocals

    public void addLiveLocals(Node node,
                              int[] locals)

### addFunction

    public int addFunction(FunctionNode fnNode)

  Description copied from class: `ScriptNode`
  Adds a `FunctionNode` to the functions table for codegen. Does not set the parent of the node.

  Overrides:
    `addFunction` in class `ScriptNode`
  Returns:
    the index of the function within its parent

### getFunctionType

    public int getFunctionType()

  Returns the function type (statement, expr, statement expr)

### setFunctionType

    public void setFunctionType(int type)

### isGetterOrSetter

    public boolean isGetterOrSetter()

### isGetter

    public boolean isGetter()

### isSetter

    public boolean isSetter()

### setFunctionIsGetter

    public void setFunctionIsGetter()

### setFunctionIsSetter

    public void setFunctionIsSetter()

### setMemberExprNode

    public void setMemberExprNode(AstNode node)

  Rhino supports a nonstandard Ecma extension that allows you to say, for instance, function a.b.c(arg1, arg) {...}, and it will be rewritten at codegen time to: a.b.c = function(arg1, arg2) {...} If we detect an expression other than a simple Name in the position where a function name was expected, we record that expression here.

  This extension is only available by setting the CompilerEnv option "isAllowMemberExprAsFunctionName" in the Parser.

### getMemberExprNode

    public AstNode getMemberExprNode()

### toSource

    public java.lang.String toSource(int depth)

  Description copied from class: `AstNode`
  Emits source code for this node. Callee is responsible for calling this function recursively on children, incrementing indent as appropriate.

  Note: if the parser was in error-recovery mode, some AST nodes may have `null` children that are expected to be non-`null` when no errors are present. In this situation, the behavior of the `toSource` method is undefined: `toSource` implementations may assume that the AST node is error-free, since it is intended to be invoked only at runtime after a successful parse.

  Overrides:
    `toSource` in class `Scope`
  Parameters:
    `depth` - the current recursion depth, typically beginning at 0 when called on the root node.

### visit

    public void visit(NodeVisitor v)

  Visits this node, the function name node if supplied, the parameters, and the body. If there is a member-expr node, it is visited last.

  Overrides:
    `visit` in class `ScriptNode`
  Parameters:
    `v` - the object to call with this node and its children