com.oracle.js.parser

Class Parser

java.lang.Object

com.oracle.js.parser.AbstractParser

com.oracle.js.parser.Parser

public class Parser
extends AbstractParser

Builds the IR.

Field Summary

Fields

Modifier and Type	Field and Description
protected Lexer.LineInfoReceiver	lineInfoReceiver to receive line information from Lexer when scanning multiline literals.

Fields inherited from class com.oracle.js.parser.AbstractParser

errors, finish, isStrictMode, k, last, lexer, line, lineOffset, linePosition, previousToken, source, start, stream, token, type

Constructor Summary

Constructors

Constructor and Description
Parser(ScriptEnvironment env, Source source, ErrorManager errors) Constructor
Parser(ScriptEnvironment env, Source source, ErrorManager errors, boolean strict) Constructor
Parser(ScriptEnvironment env, Source source, ErrorManager errors, boolean strict, int lineOffset) Construct a parser.

Method Summary

Modifier and Type	Method and Description
List<Expression>	decoratorList(boolean yield, boolean await) Parse a decorator list.
FunctionNode	parse() Execute parse and return the resulting function node.
FunctionNode	parse(com.oracle.truffle.api.strings.TruffleString scriptName, int startPos, int len, int reparseFlags, Scope parentScope, List<String> argumentNames) Execute parse and return the resulting function node.
FunctionNode	parseEval(boolean functionContext, Scope parentScope) Parse eval code.
Expression	parseExpression() Parse and return an expression.
void	parseFormalParameterList() Parse and return the list of function parameter list.
FunctionNode	parseFunctionBody(boolean generator, boolean async) Execute parse and return the resulting function node.
FunctionNode	parseModule(String moduleName)
FunctionNode	parseModule(String moduleName, int startPos, int len) Parse and return the resulting module.
FunctionNode	parseWithArguments(List<String> argumentNames) Parse code assuming a set of given arguments for the returned FunctionNode.
void	setReparsedFunction(RecompilableScriptFunctionData reparsedFunction) Sets the @link RecompilableScriptFunctionData representing the function being reparsed (when this parser instance is used to reparse a previously parsed function, as part of its on-demand compilation).
String	toString()

Methods inherited from class com.oracle.js.parser.AbstractParser

createIdentNode, error, error, error, error, expect, expectDontAdvance, expectMessage, expectMessage, getIdent, getIdentifierName, getLiteral, getNumberToStringConverter, getToken, getValue, getValue, getValueNoEscape, isIdentifierName, isIdentifierName, isNonStrictModeIdent, message, message, next, nextOrEOL, T, validateLexerToken, warning

Methods inherited from class java.lang.Object

clone, equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

lineInfoReceiver

protected final Lexer.LineInfoReceiver lineInfoReceiver

to receive line information from Lexer when scanning multiline literals.

Constructor Detail

Parser

public Parser(ScriptEnvironment env,
              Source source,
              ErrorManager errors)

Constructor

Parameters:

env - script environment

source - source to parse

errors - error manager

Parser

public Parser(ScriptEnvironment env,
              Source source,
              ErrorManager errors,
              boolean strict)

Constructor

Parameters:

env - script environment

source - source to parse

errors - error manager

strict - strict

Parser

public Parser(ScriptEnvironment env,
              Source source,
              ErrorManager errors,
              boolean strict,
              int lineOffset)

Construct a parser.

Parameters:

env - script environment

source - source to parse

errors - error manager

strict - parser created with strict mode enabled.

lineOffset - line offset to start counting lines from

Method Detail

parse

public FunctionNode parse()

Execute parse and return the resulting function node. Errors will be thrown and the error manager will contain information if parsing should fail This is the default parse call, which will name the function node Parser.PROGRAM_NAME.

Returns:

function node resulting from successful parse

setReparsedFunction

public void setReparsedFunction(RecompilableScriptFunctionData reparsedFunction)

Sets the @link RecompilableScriptFunctionData representing the function being reparsed (when this parser instance is used to reparse a previously parsed function, as part of its on-demand compilation). This will trigger various special behaviors, such as skipping nested function bodies.

Parameters:

reparsedFunction - the function being reparsed.

parse

public FunctionNode parse(com.oracle.truffle.api.strings.TruffleString scriptName,
                          int startPos,
                          int len,
                          int reparseFlags,
                          Scope parentScope,
                          List<String> argumentNames)

Execute parse and return the resulting function node. Errors will be thrown and the error manager will contain information if parsing should fail This should be used to create one and only one function node

Parameters:

scriptName - name for the script, given to the parsed FunctionNode

startPos - start position in source

len - length of parse

reparseFlags - flags provided by RecompilableScriptFunctionData as context for the code being reparsed. This allows us to recognize special forms of functions such as property getters and setters or instances of ES6 method shorthand in object literals.

argumentNames - optional names of arguments assumed by the parsed function node.

Returns:

function node resulting from successful parse

parseModule

public FunctionNode parseModule(String moduleName,
                                int startPos,
                                int len)

Parse and return the resulting module. Errors will be thrown and the error manager will contain information if parsing should fail

Parameters:

moduleName - name for the module, given to the parsed FunctionNode

startPos - start position in source

len - length of parse

Returns:

function node resulting from successful parse

parseModule

public FunctionNode parseModule(String moduleName)

parseEval

public FunctionNode parseEval(boolean functionContext,
                              Scope parentScope)

Parse eval code.

Parameters:

parentScope - optional caller context scope (direct eval)

parseWithArguments

public FunctionNode parseWithArguments(List<String> argumentNames)

Parse code assuming a set of given arguments for the returned FunctionNode.

Parameters:

argumentNames - names of arguments assumed by the parsed function node.

parseFormalParameterList

public void parseFormalParameterList()

Parse and return the list of function parameter list. A comma separated list of function parameter identifiers is expected to be parsed. Errors will be thrown and the error manager will contain information if parsing should fail. This method is used to check if parameter Strings passed to "Function" constructor is a valid or not.

See Also:

Parser.parseFunctionBody(boolean, boolean)

parseFunctionBody

public FunctionNode parseFunctionBody(boolean generator,
                                      boolean async)

Execute parse and return the resulting function node. Errors will be thrown and the error manager will contain information if parsing should fail. This method is used to check if code String passed to "Function" constructor is a valid function body or not.

Returns:

function node resulting from successful parse

See Also:

Parser.parseFormalParameterList()

toString

public String toString()

Overrides:

toString in class Object

decoratorList

public List<Expression> decoratorList(boolean yield,
                                      boolean await)

Parse a decorator list.

 DecoratorList[Yield, Await] :
      DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]

 Decorator[Yield, Await] :
       @ DecoratorMemberExpression[?Yield, ?Await]
       @ DecoratorParenthesizedExpression[?Yield, ?Await]
       @ DecoratorCallExpression[?Yield, ?Await]

 DecoratorMemberExpression[Yield, Await] :
      IdentifierReference[?Yield, ?Await]
      PrivateIdentifier
      DecoratorMemberExpression[?Yield, ?Await] . IdentifierName

 DecoratorCallExpression[Yield, Await] :
      DecoratorMemberExpression[?Yield, ?Await] Arguments[?Yield, ?Await]

 DecoratorParenthesizedExpression[Yield, Await] :
      ( Expression[+In, ?Yield, ?Await] )

 ClassDeclaration[Yield, Await, Default] :
      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
 

parseExpression

public Expression parseExpression()

Parse and return an expression. Errors will be thrown and the error manager will contain information if parsing should fail.

Returns:

expression node resulting from successful parse