#include "Nodes.h"
#include "ParserArena.h"
#include "ParserError.h"
+#include "ParserFunctionInfo.h"
#include "ParserTokens.h"
#include "SourceProvider.h"
#include "SourceProviderCache.h"
#include "SourceProviderCacheItem.h"
#include <wtf/Forward.h>
#include <wtf/Noncopyable.h>
-#include <wtf/OwnPtr.h>
#include <wtf/RefPtr.h>
namespace JSC {
struct Scope;
#define TreeArguments typename TreeBuilder::Arguments
#define TreeArgumentsList typename TreeBuilder::ArgumentsList
#define TreeFunctionBody typename TreeBuilder::FunctionBody
+#if ENABLE(ES6_CLASS_SYNTAX)
+#define TreeClassExpression typename TreeBuilder::ClassExpression
+#endif
#define TreeProperty typename TreeBuilder::Property
#define TreePropertyList typename TreeBuilder::PropertyList
+#define TreeDestructuringPattern typename TreeBuilder::DestructuringPattern
COMPILE_ASSERT(LastUntaggedToken < 64, LessThan64UntaggedTokens);
enum SourceElementsMode { CheckForStrictMode, DontCheckForStrictMode };
+#if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
+enum FunctionParseType { StandardFunctionParseType, ArrowFunctionParseType };
+#else
+enum FunctionParseType { StandardFunctionParseType};
+#endif
enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };
+enum FunctionParseMode {
+ FunctionMode,
+ GetterMode,
+ SetterMode,
+ MethodMode,
+#if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
+ ArrowFunctionMode
+#endif
+};
+enum DestructuringKind {
+ DestructureToVariables,
+ DestructureToParameters,
+ DestructureToExpressions
+};
template <typename T> inline bool isEvalNode() { return false; }
template <> inline bool isEvalNode<EvalNode>() { return true; }
-struct DepthManager {
- DepthManager(int* depth)
- : m_originalDepth(*depth)
- , m_depth(depth)
- {
- }
-
- ~DepthManager()
- {
- *m_depth = m_originalDepth;
- }
-
-private:
- int m_originalDepth;
- int* m_depth;
-};
-
struct ScopeLabelInfo {
- ScopeLabelInfo(StringImpl* ident, bool isLoop)
- : m_ident(ident)
- , m_isLoop(isLoop)
- {
- }
-
- StringImpl* m_ident;
- bool m_isLoop;
+ UniquedStringImpl* uid;
+ bool isLoop;
};
struct Scope {
, m_shadowsArguments(false)
, m_usesEval(false)
, m_needsFullActivation(false)
+ , m_hasDirectSuper(false)
+ , m_needsSuperBinding(false)
, m_allowsNewDecls(true)
, m_strictMode(strictMode)
, m_isFunction(isFunction)
, m_shadowsArguments(rhs.m_shadowsArguments)
, m_usesEval(rhs.m_usesEval)
, m_needsFullActivation(rhs.m_needsFullActivation)
+ , m_hasDirectSuper(rhs.m_hasDirectSuper)
+ , m_needsSuperBinding(rhs.m_needsSuperBinding)
, m_allowsNewDecls(rhs.m_allowsNewDecls)
, m_strictMode(rhs.m_strictMode)
, m_isFunction(rhs.m_isFunction)
, m_switchDepth(rhs.m_switchDepth)
{
if (rhs.m_labels) {
- m_labels = adoptPtr(new LabelStack);
+ m_labels = std::make_unique<LabelStack>();
typedef LabelStack::const_iterator iterator;
iterator end = rhs.m_labels->end();
for (iterator it = rhs.m_labels->begin(); it != end; ++it)
- m_labels->append(ScopeLabelInfo(it->m_ident, it->m_isLoop));
+ m_labels->append(ScopeLabelInfo { it->uid, it->isLoop });
}
}
void pushLabel(const Identifier* label, bool isLoop)
{
if (!m_labels)
- m_labels = adoptPtr(new LabelStack);
- m_labels->append(ScopeLabelInfo(label->impl(), isLoop));
+ m_labels = std::make_unique<LabelStack>();
+ m_labels->append(ScopeLabelInfo { label->impl(), isLoop });
}
void popLabel()
if (!m_labels)
return 0;
for (int i = m_labels->size(); i > 0; i--) {
- if (m_labels->at(i - 1).m_ident == label->impl())
+ if (m_labels->at(i - 1).uid == label->impl())
return &m_labels->at(i - 1);
}
return 0;
void declareCallee(const Identifier* ident)
{
- m_declaredVariables.add(ident->string().impl());
+ m_declaredVariables.add(ident->impl());
}
bool declareVariable(const Identifier* ident)
{
bool isValidStrictMode = m_vm->propertyNames->eval != *ident && m_vm->propertyNames->arguments != *ident;
m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
- m_declaredVariables.add(ident->string().impl());
+ m_declaredVariables.add(ident->impl());
return isValidStrictMode;
}
+ bool hasDeclaredVariable(const Identifier& ident)
+ {
+ return m_declaredVariables.contains(ident.impl());
+ }
+
+ bool hasDeclaredParameter(const Identifier& ident)
+ {
+ return m_declaredParameters.contains(ident.impl()) || m_declaredVariables.contains(ident.impl());
+ }
+
void declareWrite(const Identifier* ident)
{
ASSERT(m_strictMode);
bool declareParameter(const Identifier* ident)
{
bool isArguments = m_vm->propertyNames->arguments == *ident;
- bool isValidStrictMode = m_declaredVariables.add(ident->string().impl()).isNewEntry && m_vm->propertyNames->eval != *ident && !isArguments;
+ bool isValidStrictMode = m_declaredVariables.add(ident->impl()).isNewEntry && m_vm->propertyNames->eval != *ident && !isArguments;
m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
+ m_declaredParameters.add(ident->impl());
+
if (isArguments)
m_shadowsArguments = true;
return isValidStrictMode;
}
+
+ enum BindingResult {
+ BindingFailed,
+ StrictBindingFailed,
+ BindingSucceeded
+ };
+ BindingResult declareBoundParameter(const Identifier* ident)
+ {
+ bool isArguments = m_vm->propertyNames->arguments == *ident;
+ bool newEntry = m_declaredVariables.add(ident->impl()).isNewEntry;
+ bool isValidStrictMode = newEntry && m_vm->propertyNames->eval != *ident && !isArguments;
+ m_isValidStrictMode = m_isValidStrictMode && isValidStrictMode;
+
+ if (isArguments)
+ m_shadowsArguments = true;
+ if (!newEntry)
+ return BindingFailed;
+ return isValidStrictMode ? BindingSucceeded : StrictBindingFailed;
+ }
+
+ void getUsedVariables(IdentifierSet& usedVariables)
+ {
+ usedVariables.swap(m_usedVariables);
+ }
void useVariable(const Identifier* ident, bool isEval)
{
m_usesEval |= isEval;
- m_usedVariables.add(ident->string().impl());
+ m_usedVariables.add(ident->impl());
}
void setNeedsFullActivation() { m_needsFullActivation = true; }
+#if ENABLE(ES6_CLASS_SYNTAX)
+ bool hasDirectSuper() { return m_hasDirectSuper; }
+#else
+ bool hasDirectSuper() { return false; }
+#endif
+ void setHasDirectSuper() { m_hasDirectSuper = true; }
+
+#if ENABLE(ES6_CLASS_SYNTAX)
+ bool needsSuperBinding() { return m_needsSuperBinding; }
+#else
+ bool needsSuperBinding() { return false; }
+#endif
+ void setNeedsSuperBinding() { m_needsSuperBinding = true; }
+
bool collectFreeVariables(Scope* nestedScope, bool shouldTrackClosedVariables)
{
if (nestedScope->m_usesEval)
return true;
}
- void getUncapturedWrittenVariables(IdentifierSet& writtenVariables)
- {
- IdentifierSet::iterator end = m_writtenVariables.end();
- for (IdentifierSet::iterator ptr = m_writtenVariables.begin(); ptr != end; ++ptr) {
- if (!m_declaredVariables.contains(*ptr))
- writtenVariables.add(*ptr);
- }
- }
-
- void getCapturedVariables(IdentifierSet& capturedVariables)
+ void getCapturedVariables(IdentifierSet& capturedVariables, bool& modifiedParameter, bool& modifiedArguments)
{
if (m_needsFullActivation || m_usesEval) {
- capturedVariables.swap(m_declaredVariables);
+ modifiedParameter = true;
+ capturedVariables = m_declaredVariables;
return;
}
for (IdentifierSet::iterator ptr = m_closedVariables.begin(); ptr != m_closedVariables.end(); ++ptr) {
continue;
capturedVariables.add(*ptr);
}
+ modifiedParameter = false;
+ if (shadowsArguments())
+ modifiedArguments = true;
+ if (m_declaredParameters.size()) {
+ IdentifierSet::iterator end = m_writtenVariables.end();
+ for (IdentifierSet::iterator ptr = m_writtenVariables.begin(); ptr != end; ++ptr) {
+ if (*ptr == m_vm->propertyNames->arguments.impl())
+ modifiedArguments = true;
+ if (!m_declaredParameters.contains(*ptr))
+ continue;
+ modifiedParameter = true;
+ break;
+ }
+ }
}
void setStrictMode() { m_strictMode = true; }
bool strictMode() const { return m_strictMode; }
bool isValidStrictMode() const { return m_isValidStrictMode; }
bool shadowsArguments() const { return m_shadowsArguments; }
- void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<StringImpl> >& vector)
+ void copyCapturedVariablesToVector(const IdentifierSet& capturedVariables, Vector<RefPtr<UniquedStringImpl>>& vector)
{
IdentifierSet::iterator end = capturedVariables.end();
for (IdentifierSet::iterator it = capturedVariables.begin(); it != end; ++it) {
bool m_shadowsArguments : 1;
bool m_usesEval : 1;
bool m_needsFullActivation : 1;
+ bool m_hasDirectSuper : 1;
+ bool m_needsSuperBinding : 1;
bool m_allowsNewDecls : 1;
bool m_strictMode : 1;
bool m_isFunction : 1;
int m_switchDepth;
typedef Vector<ScopeLabelInfo, 2> LabelStack;
- OwnPtr<LabelStack> m_labels;
+ std::unique_ptr<LabelStack> m_labels;
+ IdentifierSet m_declaredParameters;
IdentifierSet m_declaredVariables;
IdentifierSet m_usedVariables;
IdentifierSet m_closedVariables;
WTF_MAKE_FAST_ALLOCATED;
public:
- Parser(VM*, const SourceCode&, FunctionParameters*, const Identifier&, JSParserStrictness, JSParserMode);
+ Parser(
+ VM*, const SourceCode&, FunctionParameters*, const Identifier&,
+ JSParserBuiltinMode, JSParserStrictMode, JSParserCodeType,
+ ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode = ThisTDZMode::CheckIfNeeded);
~Parser();
template <class ParsedNode>
- PassRefPtr<ParsedNode> parse(ParserError&);
+ std::unique_ptr<ParsedNode> parse(ParserError&);
+
+ JSTextPosition positionBeforeLastNewline() const { return m_lexer->positionBeforeLastNewline(); }
+ JSTokenLocation locationBeforeLastToken() const { return m_lexer->lastTokenLocation(); }
+ Vector<RefPtr<UniquedStringImpl>>&& closedVariables() { return WTF::move(m_closedVariables); }
private:
struct AllowInOverride {
return m_scopeStack[i].declareVariable(ident);
}
+ NEVER_INLINE bool hasDeclaredVariable(const Identifier& ident)
+ {
+ unsigned i = m_scopeStack.size() - 1;
+ ASSERT(i < m_scopeStack.size());
+ while (!m_scopeStack[i].allowsNewDecls()) {
+ i--;
+ ASSERT(i < m_scopeStack.size());
+ }
+ return m_scopeStack[i].hasDeclaredVariable(ident);
+ }
+
+ NEVER_INLINE bool hasDeclaredParameter(const Identifier& ident)
+ {
+ unsigned i = m_scopeStack.size() - 1;
+ ASSERT(i < m_scopeStack.size());
+ while (!m_scopeStack[i].allowsNewDecls()) {
+ i--;
+ ASSERT(i < m_scopeStack.size());
+ }
+ return m_scopeStack[i].hasDeclaredParameter(ident);
+ }
+
void declareWrite(const Identifier* ident)
{
- if (!m_syntaxAlreadyValidated)
+ if (!m_syntaxAlreadyValidated || strictMode())
m_scopeStack.last().declareWrite(ident);
}
Parser();
String parseInner();
- void didFinishParsing(SourceElements*, ParserArenaData<DeclarationStacks::VarStack>*,
- ParserArenaData<DeclarationStacks::FunctionStack>*, CodeFeatures,
- int, int, IdentifierSet&);
+ void didFinishParsing(SourceElements*, DeclarationStacks::VarStack&,
+ DeclarationStacks::FunctionStack&, CodeFeatures, int, IdentifierSet&, const Vector<RefPtr<UniquedStringImpl>>&&);
// Used to determine type of error to report.
bool isFunctionBodyNode(ScopeNode*) { return false; }
ALWAYS_INLINE void next(unsigned lexerFlags = 0)
{
- m_lastLine = m_token.m_location.line;
- m_lastTokenEnd = m_token.m_location.endOffset;
- m_lastTokenLineStart = m_token.m_location.lineStartOffset;
- m_lexer->setLastLineNumber(m_lastLine);
- m_token.m_type = m_lexer->lex(&m_token.m_data, &m_token.m_location, lexerFlags, strictMode());
+ int lastLine = m_token.m_location.line;
+ int lastTokenEnd = m_token.m_location.endOffset;
+ int lastTokenLineStart = m_token.m_location.lineStartOffset;
+ m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
+ m_lexer->setLastLineNumber(lastLine);
+ m_token.m_type = m_lexer->lex(&m_token, lexerFlags, strictMode());
}
ALWAYS_INLINE void nextExpectIdentifier(unsigned lexerFlags = 0)
{
- m_lastLine = m_token.m_location.line;
- m_lastTokenEnd = m_token.m_location.endOffset;
- m_lastTokenLineStart = m_token.m_location.lineStartOffset;
- m_lexer->setLastLineNumber(m_lastLine);
- m_token.m_type = m_lexer->lexExpectIdentifier(&m_token.m_data, &m_token.m_location, lexerFlags, strictMode());
+ int lastLine = m_token.m_location.line;
+ int lastTokenEnd = m_token.m_location.endOffset;
+ int lastTokenLineStart = m_token.m_location.lineStartOffset;
+ m_lastTokenEndPosition = JSTextPosition(lastLine, lastTokenEnd, lastTokenLineStart);
+ m_lexer->setLastLineNumber(lastLine);
+ m_token.m_type = m_lexer->lexExpectIdentifier(&m_token, lexerFlags, strictMode());
}
ALWAYS_INLINE bool nextTokenIsColon()
next(flags);
return result;
}
-
+
+ void printUnexpectedTokenText(WTF::PrintStream&);
ALWAYS_INLINE String getToken() {
SourceProvider* sourceProvider = m_source->provider();
- return sourceProvider->getRange(tokenStart(), tokenEnd());
+ return sourceProvider->getRange(tokenStart(), tokenEndPosition().offset);
}
ALWAYS_INLINE bool match(JSTokenType expected)
return m_token.m_type == expected;
}
+ ALWAYS_INLINE bool isofToken()
+ {
+ return m_token.m_type == IDENT && *m_token.m_data.ident == m_vm->propertyNames->of;
+ }
+
+#if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
+ ALWAYS_INLINE bool isEndOfArrowFunction()
+ {
+ return match(SEMICOLON) || match(COMMA) || match(CLOSEPAREN) || match(CLOSEBRACE) || match(CLOSEBRACKET) || match(EOFTOK) || m_lexer->prevTerminator();
+ }
+
+ ALWAYS_INLINE bool isArrowFunctionParamters()
+ {
+ bool isArrowFunction = false;
+
+ if (match(EOFTOK))
+ return isArrowFunction;
+
+ SavePoint saveArrowFunctionPoint = createSavePoint();
+
+ if (consume(OPENPAREN)) {
+ bool isArrowFunctionParamters = true;
+
+ while (consume(IDENT)) {
+ if (consume(COMMA)) {
+ if (!match(IDENT)) {
+ isArrowFunctionParamters = false;
+ break;
+ }
+ } else
+ break;
+ }
+
+ if (isArrowFunctionParamters) {
+ if (consume(CLOSEPAREN) && match(ARROWFUNCTION))
+ isArrowFunction = true;
+ }
+ } else if (consume(IDENT) && match(ARROWFUNCTION))
+ isArrowFunction = true;
+
+ restoreSavePoint(saveArrowFunctionPoint);
+
+ return isArrowFunction;
+ }
+#endif
+
ALWAYS_INLINE unsigned tokenStart()
{
return m_token.m_location.startOffset;
}
+ ALWAYS_INLINE const JSTextPosition& tokenStartPosition()
+ {
+ return m_token.m_startPosition;
+ }
+
ALWAYS_INLINE int tokenLine()
{
return m_token.m_location.line;
return tokenStart() - tokenLineStart();
}
- ALWAYS_INLINE unsigned tokenEnd()
+ ALWAYS_INLINE const JSTextPosition& tokenEndPosition()
{
- return m_token.m_location.endOffset;
+ return m_token.m_endPosition;
}
ALWAYS_INLINE unsigned tokenLineStart()
return m_token.m_location;
}
- const char* getTokenName(JSTokenType tok)
+ void setErrorMessage(const String& message)
{
- switch (tok) {
- case NULLTOKEN:
- return "null";
- case TRUETOKEN:
- return "true";
- case FALSETOKEN:
- return "false";
- case BREAK:
- return "break";
- case CASE:
- return "case";
- case DEFAULT:
- return "default";
- case FOR:
- return "for";
- case NEW:
- return "new";
- case VAR:
- return "var";
- case CONSTTOKEN:
- return "const";
- case CONTINUE:
- return "continue";
- case FUNCTION:
- return "function";
- case IF:
- return "if";
- case THISTOKEN:
- return "this";
- case DO:
- return "do";
- case WHILE:
- return "while";
- case SWITCH:
- return "switch";
- case WITH:
- return "with";
- case THROW:
- return "throw";
- case TRY:
- return "try";
- case CATCH:
- return "catch";
- case FINALLY:
- return "finally";
- case DEBUGGER:
- return "debugger";
- case ELSE:
- return "else";
- case OPENBRACE:
- return "{";
- case CLOSEBRACE:
- return "}";
- case OPENPAREN:
- return "(";
- case CLOSEPAREN:
- return ")";
- case OPENBRACKET:
- return "[";
- case CLOSEBRACKET:
- return "]";
- case COMMA:
- return ",";
- case QUESTION:
- return "?";
- case SEMICOLON:
- return ";";
- case COLON:
- return ":";
- case DOT:
- return ".";
- case EQUAL:
- return "=";
- case PLUSEQUAL:
- return "+=";
- case MINUSEQUAL:
- return "-=";
- case MULTEQUAL:
- return "*=";
- case DIVEQUAL:
- return "/=";
- case LSHIFTEQUAL:
- return "<<=";
- case RSHIFTEQUAL:
- return ">>=";
- case URSHIFTEQUAL:
- return ">>>=";
- case ANDEQUAL:
- return "&=";
- case MODEQUAL:
- return "%=";
- case XOREQUAL:
- return "^=";
- case OREQUAL:
- return "|=";
- case AUTOPLUSPLUS:
- case PLUSPLUS:
- return "++";
- case AUTOMINUSMINUS:
- case MINUSMINUS:
- return "--";
- case EXCLAMATION:
- return "!";
- case TILDE:
- return "~";
- case TYPEOF:
- return "typeof";
- case VOIDTOKEN:
- return "void";
- case DELETETOKEN:
- return "delete";
- case OR:
- return "||";
- case AND:
- return "&&";
- case BITOR:
- return "|";
- case BITXOR:
- return "^";
- case BITAND:
- return "&";
- case EQEQ:
- return "==";
- case NE:
- return "!=";
- case STREQ:
- return "===";
- case STRNEQ:
- return "!==";
- case LT:
- return "<";
- case GT:
- return ">";
- case LE:
- return "<=";
- case GE:
- return ">=";
- case INSTANCEOF:
- return "instanceof";
- case INTOKEN:
- return "in";
- case LSHIFT:
- return "<<";
- case RSHIFT:
- return ">>";
- case URSHIFT:
- return ">>>";
- case PLUS:
- return "+";
- case MINUS:
- return "-";
- case TIMES:
- return "*";
- case DIVIDE:
- return "/";
- case MOD:
- return "%";
- case RETURN:
- case RESERVED_IF_STRICT:
- case RESERVED:
- case NUMBER:
- case IDENT:
- case STRING:
- case UNTERMINATED_IDENTIFIER_ESCAPE_ERRORTOK:
- case UNTERMINATED_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
- case UNTERMINATED_MULTILINE_COMMENT_ERRORTOK:
- case UNTERMINATED_NUMERIC_LITERAL_ERRORTOK:
- case UNTERMINATED_STRING_LITERAL_ERRORTOK:
- case INVALID_IDENTIFIER_ESCAPE_ERRORTOK:
- case INVALID_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
- case INVALID_NUMERIC_LITERAL_ERRORTOK:
- case INVALID_OCTAL_NUMBER_ERRORTOK:
- case INVALID_STRING_LITERAL_ERRORTOK:
- case ERRORTOK:
- case EOFTOK:
- return 0;
- case LastUntaggedToken:
- break;
- }
- RELEASE_ASSERT_NOT_REACHED();
- return "internal error";
- }
-
- ALWAYS_INLINE void updateErrorMessageSpecialCase(JSTokenType expectedToken)
- {
- switch (expectedToken) {
- case RESERVED_IF_STRICT:
- m_errorMessage = "Use of reserved word '" + getToken() + "' in strict mode";
- return;
- case RESERVED:
- m_errorMessage = "Use of reserved word '" + getToken() + '\'';
- return;
- case NUMBER:
- m_errorMessage = "Unexpected number '" + getToken() + '\'';
- return;
- case IDENT:
- m_errorMessage = "Expected an identifier but found '" + getToken() + "' instead";
- return;
- case STRING:
- m_errorMessage = "Unexpected string " + getToken();
- return;
-
- case UNTERMINATED_IDENTIFIER_ESCAPE_ERRORTOK:
- case UNTERMINATED_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
- m_errorMessage = "Incomplete unicode escape in identifier: '" + getToken() + '\'';
- return;
- case UNTERMINATED_MULTILINE_COMMENT_ERRORTOK:
- m_errorMessage = "Unterminated multiline comment";
- return;
- case UNTERMINATED_NUMERIC_LITERAL_ERRORTOK:
- m_errorMessage = "Unterminated numeric literal '" + getToken() + '\'';
- return;
- case UNTERMINATED_STRING_LITERAL_ERRORTOK:
- m_errorMessage = "Unterminated string literal '" + getToken() + '\'';
- return;
- case INVALID_IDENTIFIER_ESCAPE_ERRORTOK:
- m_errorMessage = "Invalid escape in identifier: '" + getToken() + '\'';
- return;
- case INVALID_IDENTIFIER_UNICODE_ESCAPE_ERRORTOK:
- m_errorMessage = "Invalid unicode escape in identifier: '" + getToken() + '\'';
- return;
- case INVALID_NUMERIC_LITERAL_ERRORTOK:
- m_errorMessage = "Invalid numeric literal: '" + getToken() + '\'';
- return;
- case INVALID_OCTAL_NUMBER_ERRORTOK:
- m_errorMessage = "Invalid use of octal: '" + getToken() + '\'';
- return;
- case INVALID_STRING_LITERAL_ERRORTOK:
- m_errorMessage = "Invalid string literal: '" + getToken() + '\'';
- return;
- case ERRORTOK:
- m_errorMessage = "Unrecognized token '" + getToken() + '\'';
- return;
- case EOFTOK:
- m_errorMessage = ASCIILiteral("Unexpected EOF");
- return;
- case RETURN:
- m_errorMessage = ASCIILiteral("Return statements are only valid inside functions");
- return;
- default:
- RELEASE_ASSERT_NOT_REACHED();
- m_errorMessage = ASCIILiteral("internal error");
- return;
- }
+ m_errorMessage = message;
}
- NEVER_INLINE void updateErrorMessage()
- {
- const char* name = getTokenName(m_token.m_type);
- if (!name)
- updateErrorMessageSpecialCase(m_token.m_type);
- else
- m_errorMessage = String::format("Unexpected token '%s'", name);
- ASSERT(!m_errorMessage.isNull());
- }
+ NEVER_INLINE void logError(bool);
+ template <typename A> NEVER_INLINE void logError(bool, const A&);
+ template <typename A, typename B> NEVER_INLINE void logError(bool, const A&, const B&);
+ template <typename A, typename B, typename C> NEVER_INLINE void logError(bool, const A&, const B&, const C&);
+ template <typename A, typename B, typename C, typename D> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&);
+ template <typename A, typename B, typename C, typename D, typename E> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&);
+ template <typename A, typename B, typename C, typename D, typename E, typename F> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&);
+ template <typename A, typename B, typename C, typename D, typename E, typename F, typename G> NEVER_INLINE void logError(bool, const A&, const B&, const C&, const D&, const E&, const F&, const G&);
- NEVER_INLINE void updateErrorMessage(JSTokenType expectedToken)
+ NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMessage, const String& name, const char* afterMessage)
{
- const char* name = getTokenName(expectedToken);
- if (name)
- m_errorMessage = String::format("Expected token '%s'", name);
- else {
- if (!getTokenName(m_token.m_type))
- updateErrorMessageSpecialCase(m_token.m_type);
- else
- updateErrorMessageSpecialCase(expectedToken);
- }
- ASSERT(!m_errorMessage.isNull());
- }
-
- NEVER_INLINE void updateErrorWithNameAndMessage(const char* beforeMsg, String name, const char* afterMsg)
- {
- m_errorMessage = makeString(beforeMsg, " '", name, "' ", afterMsg);
+ m_errorMessage = makeString(beforeMessage, " '", name, "' ", afterMessage);
}
NEVER_INLINE void updateErrorMessage(const char* msg)
bool strictMode() { return currentScope()->strictMode(); }
bool isValidStrictMode() { return currentScope()->isValidStrictMode(); }
bool declareParameter(const Identifier* ident) { return currentScope()->declareParameter(ident); }
+ Scope::BindingResult declareBoundParameter(const Identifier* ident) { return currentScope()->declareBoundParameter(ident); }
bool breakIsValid()
{
ScopeRef current = currentScope();
}
return result;
}
-
- template <SourceElementsMode mode, class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&);
+
+ template <class TreeBuilder> TreeSourceElements parseSourceElements(TreeBuilder&, SourceElementsMode, FunctionParseType);
+ template <class TreeBuilder> TreeStatement parseStatementListItem(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength);
template <class TreeBuilder> TreeStatement parseStatement(TreeBuilder&, const Identifier*& directive, unsigned* directiveLiteralLength = 0);
+#if ENABLE(ES6_CLASS_SYNTAX)
+ template <class TreeBuilder> TreeStatement parseClassDeclaration(TreeBuilder&);
+#endif
template <class TreeBuilder> TreeStatement parseFunctionDeclaration(TreeBuilder&);
template <class TreeBuilder> TreeStatement parseVarDeclaration(TreeBuilder&);
template <class TreeBuilder> TreeStatement parseConstDeclaration(TreeBuilder&);
template <class TreeBuilder> TreeStatement parseExpressionStatement(TreeBuilder&);
template <class TreeBuilder> TreeStatement parseExpressionOrLabelStatement(TreeBuilder&);
template <class TreeBuilder> TreeStatement parseIfStatement(TreeBuilder&);
- template <class TreeBuilder> ALWAYS_INLINE TreeStatement parseBlockStatement(TreeBuilder&);
+ template <class TreeBuilder> TreeStatement parseBlockStatement(TreeBuilder&);
template <class TreeBuilder> TreeExpression parseExpression(TreeBuilder&);
template <class TreeBuilder> TreeExpression parseAssignmentExpression(TreeBuilder&);
template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseConditionalExpression(TreeBuilder&);
template <class TreeBuilder> ALWAYS_INLINE TreeExpression parsePrimaryExpression(TreeBuilder&);
template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseArrayLiteral(TreeBuilder&);
template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseObjectLiteral(TreeBuilder&);
- template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
- template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&);
- template <bool strict, class TreeBuilder> ALWAYS_INLINE TreeProperty parseProperty(TreeBuilder&);
- template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&);
+ template <class TreeBuilder> NEVER_INLINE TreeExpression parseStrictObjectLiteral(TreeBuilder&);
+ enum SpreadMode { AllowSpread, DontAllowSpread };
+ template <class TreeBuilder> ALWAYS_INLINE TreeArguments parseArguments(TreeBuilder&, SpreadMode);
+ template <class TreeBuilder> TreeProperty parseProperty(TreeBuilder&, bool strict);
+ template <class TreeBuilder> TreeExpression parsePropertyMethod(TreeBuilder& context, const Identifier* methodName);
+ template <class TreeBuilder> TreeProperty parseGetterSetter(TreeBuilder&, bool strict, PropertyNode::Type, unsigned getterOrSetterStartOffset, ConstructorKind = ConstructorKind::None, SuperBinding = SuperBinding::NotNeeded);
+ template <class TreeBuilder> ALWAYS_INLINE TreeFunctionBody parseFunctionBody(TreeBuilder&, int functionKeywordStart, int functionNameStart, int parametersStart, ConstructorKind, FunctionParseType);
template <class TreeBuilder> ALWAYS_INLINE TreeFormalParameterList parseFormalParameters(TreeBuilder&);
- template <class TreeBuilder> ALWAYS_INLINE TreeExpression parseVarDeclarationList(TreeBuilder&, int& declarations, const Identifier*& lastIdent, TreeExpression& lastInitializer, int& identStart, int& initStart, int& initEnd);
- template <class TreeBuilder> ALWAYS_INLINE TreeConstDeclList parseConstDeclarationList(TreeBuilder& context);
- template <FunctionRequirements, bool nameIsInContainingScope, class TreeBuilder> bool parseFunctionInfo(TreeBuilder&, const Identifier*&, TreeFormalParameterList&, TreeFunctionBody&, unsigned& openBraceOffset, unsigned& closeBraceOffset, int& bodyStartLine, unsigned& bodyStartColumn);
+ enum VarDeclarationListContext { ForLoopContext, VarDeclarationContext };
+ template <class TreeBuilder> TreeExpression parseVarDeclarationList(TreeBuilder&, int& declarations, TreeDestructuringPattern& lastPattern, TreeExpression& lastInitializer, JSTextPosition& identStart, JSTextPosition& initStart, JSTextPosition& initEnd, VarDeclarationListContext);
+ template <class TreeBuilder> NEVER_INLINE TreeConstDeclList parseConstDeclarationList(TreeBuilder&);
+
+#if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
+ template <class TreeBuilder> TreeStatement parseArrowFunctionSingleExpressionBody(TreeBuilder&, FunctionParseType);
+ template <class TreeBuilder> TreeExpression parseArrowFunctionExpression(TreeBuilder&);
+#endif
+
+ template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern createBindingPattern(TreeBuilder&, DestructuringKind, const Identifier&, int depth, JSToken);
+ template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern parseDestructuringPattern(TreeBuilder&, DestructuringKind, int depth = 0);
+ template <class TreeBuilder> NEVER_INLINE TreeDestructuringPattern tryParseDestructuringPatternExpression(TreeBuilder&);
+ template <class TreeBuilder> NEVER_INLINE TreeExpression parseDefaultValueForDestructuringPattern(TreeBuilder&);
+
+ template <class TreeBuilder> NEVER_INLINE bool parseFunctionInfo(TreeBuilder&, FunctionRequirements, FunctionParseMode, bool nameIsInContainingScope, ConstructorKind, SuperBinding, int functionKeywordStart, ParserFunctionInfo<TreeBuilder>&, FunctionParseType);
+
+ template <class TreeBuilder> NEVER_INLINE int parseFunctionParameters(TreeBuilder&, FunctionParseMode, ParserFunctionInfo<TreeBuilder>&);
+
+#if ENABLE(ES6_CLASS_SYNTAX)
+ template <class TreeBuilder> NEVER_INLINE TreeClassExpression parseClass(TreeBuilder&, FunctionRequirements, ParserClassInfo<TreeBuilder>&);
+#endif
+
+#if ENABLE(ES6_TEMPLATE_LITERAL_SYNTAX)
+ template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateString parseTemplateString(TreeBuilder& context, bool isTemplateHead, typename LexerType::RawStringsBuildMode, bool& elementIsTail);
+ template <class TreeBuilder> NEVER_INLINE typename TreeBuilder::TemplateLiteral parseTemplateLiteral(TreeBuilder&, typename LexerType::RawStringsBuildMode);
+#endif
+
+ template <class TreeBuilder> ALWAYS_INLINE bool shouldCheckPropertyForUnderscoreProtoDuplicate(TreeBuilder&, const TreeProperty&);
+
ALWAYS_INLINE int isBinaryOperator(JSTokenType);
bool allowAutomaticSemicolon();
return allowAutomaticSemicolon();
}
+
+#if ENABLE(ES6_ARROWFUNCTION_SYNTAX)
+ void setEndOfStatement()
+ {
+ m_lexer->setTokenPosition(&m_token);
+ }
+#endif
+
bool canRecurse()
{
- return m_stack.isSafeToRecurse();
+ return m_vm->isSafeToRecurse();
}
- int lastTokenEnd() const
+ const JSTextPosition& lastTokenEndPosition() const
{
- return m_lastTokenEnd;
+ return m_lastTokenEndPosition;
}
- unsigned lastTokenLine() const
+ bool hasError() const
{
- return m_lastLine;
+ return !m_errorMessage.isNull();
}
- unsigned lastTokenLineStart() const
+ struct SavePoint {
+ int startOffset;
+ unsigned oldLineStartOffset;
+ unsigned oldLastLineNumber;
+ unsigned oldLineNumber;
+ };
+
+ ALWAYS_INLINE SavePoint createSavePoint()
+ {
+ ASSERT(!hasError());
+ SavePoint result;
+ result.startOffset = m_token.m_location.startOffset;
+ result.oldLineStartOffset = m_token.m_location.lineStartOffset;
+ result.oldLastLineNumber = m_lexer->lastLineNumber();
+ result.oldLineNumber = m_lexer->lineNumber();
+ return result;
+ }
+
+ ALWAYS_INLINE void restoreSavePoint(const SavePoint& savePoint)
{
- return m_lastTokenLineStart;
+ m_errorMessage = String();
+ m_lexer->setOffset(savePoint.startOffset, savePoint.oldLineStartOffset);
+ next();
+ m_lexer->setLastLineNumber(savePoint.oldLastLineNumber);
+ m_lexer->setLineNumber(savePoint.oldLineNumber);
}
- bool hasError() const
+ struct ParserState {
+ int assignmentCount;
+ int nonLHSCount;
+ int nonTrivialExpressionCount;
+ };
+
+ ALWAYS_INLINE ParserState saveState()
{
- return !m_errorMessage.isNull();
+ ParserState result;
+ result.assignmentCount = m_assignmentCount;
+ result.nonLHSCount = m_nonLHSCount;
+ result.nonTrivialExpressionCount = m_nonTrivialExpressionCount;
+ return result;
+ }
+
+ ALWAYS_INLINE void restoreState(const ParserState& state)
+ {
+ m_assignmentCount = state.assignmentCount;
+ m_nonLHSCount = state.nonLHSCount;
+ m_nonTrivialExpressionCount = state.nonTrivialExpressionCount;
+
}
+
VM* m_vm;
const SourceCode* m_source;
- ParserArena* m_arena;
- OwnPtr<LexerType> m_lexer;
+ ParserArena m_parserArena;
+ std::unique_ptr<LexerType> m_lexer;
- StackBounds m_stack;
bool m_hasStackOverflow;
String m_errorMessage;
JSToken m_token;
bool m_allowsIn;
- unsigned m_lastLine;
- int m_lastTokenEnd;
- unsigned m_lastTokenLine;
- unsigned m_lastTokenLineStart;
+ JSTextPosition m_lastTokenEndPosition;
int m_assignmentCount;
int m_nonLHSCount;
bool m_syntaxAlreadyValidated;
int m_statementDepth;
int m_nonTrivialExpressionCount;
const Identifier* m_lastIdentifier;
+ const Identifier* m_lastFunctionName;
RefPtr<SourceProviderCache> m_functionCache;
SourceElements* m_sourceElements;
- ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
- ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
+ bool m_parsingBuiltin;
+ ConstructorKind m_defaultConstructorKind;
+ ThisTDZMode m_thisTDZMode;
+ DeclarationStacks::VarStack m_varDeclarations;
+ DeclarationStacks::FunctionStack m_funcDeclarations;
IdentifierSet m_capturedVariables;
+ Vector<RefPtr<UniquedStringImpl>> m_closedVariables;
CodeFeatures m_features;
int m_numConstants;
template <typename LexerType>
template <class ParsedNode>
-
PassRefPtr<ParsedNode> Parser<LexerType>::parse(ParserError& error)
+
std::unique_ptr<ParsedNode> Parser<LexerType>::parse(ParserError& error)
{
int errLine;
String errMsg;
errMsg = String();
JSTokenLocation startLocation(tokenLocation());
- unsigned startColumn = m_source->startColumn();
+ ASSERT(m_source->startColumn() > 0);
+ unsigned startColumn = m_source->startColumn() - 1;
String parseError = parseInner();
m_sourceElements = 0;
}
-
RefPtr<ParsedNode> result;
+
std::unique_ptr<ParsedNode> result;
if (m_sourceElements) {
JSTokenLocation endLocation;
- endLocation.line = m_lexer->lastLineNumber();
+ endLocation.line = m_lexer->lineNumber();
endLocation.lineStartOffset = m_lexer->currentLineStartOffset();
endLocation.startOffset = m_lexer->currentOffset();
- result = ParsedNode::create(m_vm,
+ unsigned endColumn = endLocation.startOffset - endLocation.lineStartOffset;
+ result = std::make_unique<ParsedNode>(m_parserArena,
startLocation,
endLocation,
startColumn,
+ endColumn,
m_sourceElements,
- m_varDeclarations ? &m_varDeclarations->data : 0,
- m_funcDeclarations ? &m_funcDeclarations->data : 0,
+ m_varDeclarations,
+ m_funcDeclarations,
m_capturedVariables,
*m_source,
m_features,
m_numConstants);
- result->setLoc(m_source->firstLine(), m_lastLine, m_lexer->currentOffset(), m_lexer->currentLineStartOffset());
+ result->setLoc(m_source->firstLine(), m_lexer->lineNumber(), m_lexer->currentOffset(), m_lexer->currentLineStartOffset());
+ result->setEndOffset(m_lexer->currentOffset());
} else {
// We can never see a syntax error when reparsing a function, since we should have
// reported the error when parsing the containing program or eval code. So if we're
}
}
- m_arena->reset();
-
- return result.release();
+ return result;
}
template <class ParsedNode>
-PassRefPtr<ParsedNode> parse(VM* vm, const SourceCode& source, FunctionParameters* parameters, const Identifier& name, JSParserStrictness strictness, JSParserMode parserMode, ParserError& error)
+std::unique_ptr<ParsedNode> parse(
+ VM* vm, const SourceCode& source, FunctionParameters* parameters,
+ const Identifier& name, JSParserBuiltinMode builtinMode,
+ JSParserStrictMode strictMode, JSParserCodeType codeType,
+ ParserError& error, JSTextPosition* positionBeforeLastNewline = 0,
+ ConstructorKind defaultConstructorKind = ConstructorKind::None, ThisTDZMode thisTDZMode = ThisTDZMode::CheckIfNeeded)
{
SamplingRegion samplingRegion("Parsing");
ASSERT(!source.provider()->source().isNull());
if (source.provider()->source().is8Bit()) {
- Parser< Lexer<LChar> > parser(vm, source, parameters, name, strictness, parserMode);
- return parser.parse<ParsedNode>(error);
+ Parser<Lexer<LChar>> parser(vm, source, parameters, name, builtinMode, strictMode, codeType, defaultConstructorKind, thisTDZMode);
+ std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error);
+ if (positionBeforeLastNewline)
+ *positionBeforeLastNewline = parser.positionBeforeLastNewline();
+ if (builtinMode == JSParserBuiltinMode::Builtin) {
+ if (!result)
+ WTF::dataLog("Error compiling builtin: ", error.message(), "\n");
+ RELEASE_ASSERT(result);
+ result->setClosedVariables(parser.closedVariables());
+ }
+ return result;
}
- Parser< Lexer<UChar> > parser(vm, source, parameters, name, strictness, parserMode);
- return parser.parse<ParsedNode>(error);
+ ASSERT_WITH_MESSAGE(defaultConstructorKind == ConstructorKind::None, "BuiltinExecutables::createDefaultConstructor should always use a 8-bit string");
+ Parser<Lexer<UChar>> parser(vm, source, parameters, name, builtinMode, strictMode, codeType, defaultConstructorKind, thisTDZMode);
+ std::unique_ptr<ParsedNode> result = parser.parse<ParsedNode>(error);
+ if (positionBeforeLastNewline)
+ *positionBeforeLastNewline = parser.positionBeforeLastNewline();
+ return result;
}
} // namespace
projects / apple / javascriptcore.git / blobdiff