forked from qt-creator/qt-creator
2ad89747c4
Support required list properties The corresponding rules were missing so far. Fixes: QTBUG-85716 Change-Id: Iaf0cbfbb8736929a213bd6bf329bb2ebdde652c4 Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>
3784 lines
105 KiB
C++
3784 lines
105 KiB
C++
|
|
#line 134 "qmljs.g"
|
|
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of Qt Creator.
|
|
**
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qmljs/parser/qmljsengine_p.h"
|
|
#include "qmljs/parser/qmljslexer_p.h"
|
|
#include "qmljs/parser/qmljsast_p.h"
|
|
#include "qmljs/parser/qmljsmemorypool_p.h"
|
|
|
|
#include <QtCore/qdebug.h>
|
|
#include <QtCore/qcoreapplication.h>
|
|
|
|
#include <string.h>
|
|
|
|
|
|
#line 493 "qmljs.g"
|
|
|
|
|
|
#include "qmljsparser_p.h"
|
|
|
|
#include <QtCore/qvarlengtharray.h>
|
|
|
|
//
|
|
// W A R N I N G
|
|
// -------------
|
|
//
|
|
// This file is automatically generated from qmljs.g.
|
|
// Changes should be made to that file, not here. Any change to this file will
|
|
// be lost!
|
|
//
|
|
// To regenerate this file, run:
|
|
// qlalr --no-debug --no-lines --qt qmljs.g
|
|
//
|
|
|
|
#define UNIMPLEMENTED syntaxError(loc(1), "Unimplemented"); return false
|
|
|
|
using namespace QmlJS;
|
|
|
|
QT_QML_BEGIN_NAMESPACE
|
|
|
|
void Parser::reallocateStack()
|
|
{
|
|
if (! stack_size)
|
|
stack_size = 128;
|
|
else
|
|
stack_size <<= 1;
|
|
|
|
sym_stack = reinterpret_cast<Value*> (realloc(sym_stack, stack_size * sizeof(Value)));
|
|
state_stack = reinterpret_cast<int*> (realloc(state_stack, stack_size * sizeof(int)));
|
|
location_stack = reinterpret_cast<SourceLocation*> (realloc(location_stack, stack_size * sizeof(SourceLocation)));
|
|
string_stack.resize(stack_size);
|
|
rawString_stack.resize(stack_size);
|
|
}
|
|
|
|
Parser::Parser(Engine *engine):
|
|
driver(engine),
|
|
pool(engine->pool())
|
|
{
|
|
}
|
|
|
|
Parser::~Parser()
|
|
{
|
|
if (stack_size) {
|
|
free(sym_stack);
|
|
free(state_stack);
|
|
free(location_stack);
|
|
}
|
|
}
|
|
|
|
static inline SourceLocation location(Lexer *lexer)
|
|
{
|
|
SourceLocation loc;
|
|
loc.offset = lexer->tokenOffset();
|
|
loc.length = lexer->tokenLength();
|
|
loc.startLine = lexer->tokenStartLine();
|
|
loc.startColumn = lexer->tokenStartColumn();
|
|
return loc;
|
|
}
|
|
|
|
AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
|
|
{
|
|
QVarLengthArray<QStringRef, 4> nameIds;
|
|
QVarLengthArray<SourceLocation, 4> locations;
|
|
|
|
AST::ExpressionNode *it = expr;
|
|
while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
|
|
nameIds.append(m->name);
|
|
locations.append(m->identifierToken);
|
|
it = m->base;
|
|
}
|
|
|
|
if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
|
|
AST::UiQualifiedId *q = new (pool) AST::UiQualifiedId(idExpr->name);
|
|
q->identifierToken = idExpr->identifierToken;
|
|
|
|
AST::UiQualifiedId *currentId = q;
|
|
for (int i = nameIds.size() - 1; i != -1; --i) {
|
|
currentId = new (pool) AST::UiQualifiedId(currentId, nameIds[i]);
|
|
currentId->identifierToken = locations[i];
|
|
}
|
|
|
|
return currentId->finish();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void Parser::pushToken(int token)
|
|
{
|
|
Q_ASSERT(last_token);
|
|
Q_ASSERT(last_token < &token_buffer[TOKEN_BUFFER_SIZE]);
|
|
last_token->token = yytoken;
|
|
last_token->dval = yylval;
|
|
last_token->spell = yytokenspell;
|
|
last_token->raw = yytokenraw;
|
|
last_token->loc = yylloc;
|
|
++last_token;
|
|
yytoken = token;
|
|
}
|
|
|
|
int Parser::lookaheadToken(Lexer *lexer)
|
|
{
|
|
if (yytoken < 0) {
|
|
yytoken = lexer->lex();
|
|
yylval = lexer->tokenValue();
|
|
yytokenspell = lexer->tokenSpell();
|
|
yytokenraw = lexer->rawString();
|
|
yylloc = location(lexer);
|
|
}
|
|
return yytoken;
|
|
}
|
|
|
|
bool Parser::ensureNoFunctionTypeAnnotations(AST::TypeAnnotation *returnValueAnnotation, AST::FormalParameterList *formals)
|
|
{
|
|
for (auto formal = formals; formal; formal = formal->next) {
|
|
if (formal->element && formal->element->typeAnnotation) {
|
|
syntaxError(formal->element->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in function parameters in JavaScript functions");
|
|
return false;
|
|
}
|
|
}
|
|
if (returnValueAnnotation) {
|
|
syntaxError(returnValueAnnotation->firstSourceLocation(), "Type annotations are not permitted for the return value of JavaScript functions");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//#define PARSER_DEBUG
|
|
|
|
bool Parser::parse(int startToken)
|
|
{
|
|
Lexer *lexer = driver->lexer();
|
|
bool hadErrors = false;
|
|
yytoken = -1;
|
|
int action = 0;
|
|
|
|
token_buffer[0].token = startToken;
|
|
first_token = &token_buffer[0];
|
|
if (startToken == T_FEED_JS_SCRIPT && !lexer->qmlMode()) {
|
|
Directives ignoreDirectives;
|
|
Directives *directives = driver->directives();
|
|
if (!directives)
|
|
directives = &ignoreDirectives;
|
|
DiagnosticMessage error;
|
|
if (!lexer->scanDirectives(directives, &error)) {
|
|
diagnostic_messages.append(error);
|
|
return false;
|
|
}
|
|
token_buffer[1].token = lexer->tokenKind();
|
|
token_buffer[1].dval = lexer->tokenValue();
|
|
token_buffer[1].loc = location(lexer);
|
|
token_buffer[1].spell = lexer->tokenSpell();
|
|
last_token = &token_buffer[2];
|
|
} else {
|
|
last_token = &token_buffer[1];
|
|
}
|
|
|
|
tos = -1;
|
|
program = 0;
|
|
|
|
do {
|
|
if (++tos == stack_size)
|
|
reallocateStack();
|
|
|
|
state_stack[tos] = action;
|
|
|
|
_Lcheck_token:
|
|
if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
|
|
yyprevlloc = yylloc;
|
|
|
|
if (first_token == last_token) {
|
|
yytoken = lexer->lex();
|
|
yylval = lexer->tokenValue();
|
|
yytokenspell = lexer->tokenSpell();
|
|
yytokenraw = lexer->rawString();
|
|
yylloc = location(lexer);
|
|
} else {
|
|
yytoken = first_token->token;
|
|
yylval = first_token->dval;
|
|
yytokenspell = first_token->spell;
|
|
yytokenraw = first_token->raw;
|
|
yylloc = first_token->loc;
|
|
++first_token;
|
|
if (first_token == last_token)
|
|
first_token = last_token = &token_buffer[0];
|
|
}
|
|
}
|
|
|
|
#ifdef PARSER_DEBUG
|
|
qDebug() << " in state" << action;
|
|
#endif
|
|
|
|
action = t_action(action, yytoken);
|
|
#ifdef PARSER_DEBUG
|
|
qDebug() << " current token" << yytoken << (yytoken >= 0 ? spell[yytoken] : "(null)") << "new state" << action;
|
|
#endif
|
|
if (action > 0) {
|
|
if (action != ACCEPT_STATE) {
|
|
yytoken = -1;
|
|
sym(1).dval = yylval;
|
|
stringRef(1) = yytokenspell;
|
|
rawStringRef(1) = yytokenraw;
|
|
loc(1) = yylloc;
|
|
} else {
|
|
--tos;
|
|
return ! hadErrors;
|
|
}
|
|
} else if (action < 0) {
|
|
const int r = -action - 1;
|
|
tos -= rhs[r];
|
|
|
|
#ifdef PARSER_DEBUG
|
|
qDebug() << " reducing through rule " << -action;
|
|
#endif
|
|
|
|
switch (r) {
|
|
|
|
#line 720 "qmljs.g"
|
|
|
|
case 0: {
|
|
sym(1).Node = sym(2).Node;
|
|
program = sym(1).Node;
|
|
} break;
|
|
|
|
#line 728 "qmljs.g"
|
|
|
|
case 1: {
|
|
sym(1).Node = sym(2).Node;
|
|
program = sym(1).Node;
|
|
} break;
|
|
|
|
#line 736 "qmljs.g"
|
|
|
|
case 2: {
|
|
sym(1).Node = sym(2).Node;
|
|
program = sym(1).Node;
|
|
} break;
|
|
|
|
#line 744 "qmljs.g"
|
|
|
|
case 3: {
|
|
sym(1).Node = sym(2).Node;
|
|
program = sym(1).Node;
|
|
} break;
|
|
|
|
#line 752 "qmljs.g"
|
|
|
|
case 4: {
|
|
sym(1).Node = sym(2).Node;
|
|
program = sym(1).Node;
|
|
} break;
|
|
|
|
#line 760 "qmljs.g"
|
|
|
|
case 5: {
|
|
sym(1).Node = sym(2).Node;
|
|
program = sym(1).Node;
|
|
} break;
|
|
|
|
#line 769 "qmljs.g"
|
|
|
|
case 6: {
|
|
sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiHeaderItemList, sym(2).UiObjectMemberList->finish());
|
|
} break;
|
|
|
|
#line 777 "qmljs.g"
|
|
|
|
case 8: {
|
|
sym(1).Node = sym(1).UiHeaderItemList->finish();
|
|
} break;
|
|
|
|
#line 784 "qmljs.g"
|
|
|
|
case 9: {
|
|
sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiPragma);
|
|
} break;
|
|
|
|
#line 791 "qmljs.g"
|
|
|
|
case 10: {
|
|
sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiImport);
|
|
} break;
|
|
|
|
#line 798 "qmljs.g"
|
|
|
|
case 11: {
|
|
sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiPragma);
|
|
} break;
|
|
|
|
#line 805 "qmljs.g"
|
|
|
|
case 12: {
|
|
sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiImport);
|
|
} break;
|
|
|
|
#line 817 "qmljs.g"
|
|
|
|
case 16: {
|
|
AST::UiPragma *pragma = new (pool) AST::UiPragma(stringRef(2));
|
|
pragma->pragmaToken = loc(1);
|
|
pragma->semicolonToken = loc(3);
|
|
sym(1).Node = pragma;
|
|
} break;
|
|
|
|
#line 829 "qmljs.g"
|
|
|
|
case 18: {
|
|
sym(1).UiImport->semicolonToken = loc(2);
|
|
} break;
|
|
|
|
#line 836 "qmljs.g"
|
|
|
|
case 19: {
|
|
auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, sym(3).dval);
|
|
version->majorToken = loc(1);
|
|
version->minorToken = loc(3);
|
|
sym(1).UiVersionSpecifier = version;
|
|
} break;
|
|
|
|
#line 847 "qmljs.g"
|
|
|
|
case 20: {
|
|
auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, 0);
|
|
version->majorToken = loc(1);
|
|
sym(1).UiVersionSpecifier = version;
|
|
} break;
|
|
|
|
#line 856 "qmljs.g"
|
|
|
|
case 21: {
|
|
sym(1).UiImport->version = sym(2).UiVersionSpecifier;
|
|
sym(1).UiImport->semicolonToken = loc(3);
|
|
} break;
|
|
|
|
#line 864 "qmljs.g"
|
|
|
|
case 22: {
|
|
sym(1).UiImport->version = sym(2).UiVersionSpecifier;
|
|
sym(1).UiImport->asToken = loc(3);
|
|
sym(1).UiImport->importIdToken = loc(4);
|
|
sym(1).UiImport->importId = stringRef(4);
|
|
sym(1).UiImport->semicolonToken = loc(5);
|
|
} break;
|
|
|
|
#line 875 "qmljs.g"
|
|
|
|
case 23: {
|
|
sym(1).UiImport->asToken = loc(2);
|
|
sym(1).UiImport->importIdToken = loc(3);
|
|
sym(1).UiImport->importId = stringRef(3);
|
|
sym(1).UiImport->semicolonToken = loc(4);
|
|
} break;
|
|
|
|
#line 885 "qmljs.g"
|
|
|
|
case 24: {
|
|
AST::UiImport *node = 0;
|
|
|
|
if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
|
|
node = new (pool) AST::UiImport(importIdLiteral->value);
|
|
node->fileNameToken = loc(2);
|
|
} else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
|
|
node = new (pool) AST::UiImport(qualifiedId);
|
|
node->fileNameToken = loc(2);
|
|
}
|
|
|
|
sym(1).Node = node;
|
|
|
|
if (node) {
|
|
node->importToken = loc(1);
|
|
} else {
|
|
diagnostic_messages.append(compileError(loc(1),
|
|
QLatin1String("Expected a qualified name id or a string literal")));
|
|
|
|
return false; // ### remove me
|
|
}
|
|
} break;
|
|
|
|
#line 911 "qmljs.g"
|
|
|
|
case 25: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 918 "qmljs.g"
|
|
|
|
case 26: {
|
|
sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
|
|
} break;
|
|
|
|
#line 925 "qmljs.g"
|
|
|
|
case 27: {
|
|
AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
|
|
node->identifierToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 934 "qmljs.g"
|
|
|
|
case 28: {
|
|
AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
|
|
node->dotToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 944 "qmljs.g"
|
|
|
|
case 29: {
|
|
if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
|
|
sym(1).UiQualifiedId = qualifiedId;
|
|
} else {
|
|
sym(1).UiQualifiedId = 0;
|
|
|
|
diagnostic_messages.append(compileError(loc(1),
|
|
QLatin1String("Expected a qualified name id")));
|
|
|
|
return false;
|
|
}
|
|
AST::UiAnnotation *node = new (pool) AST::UiAnnotation(sym(1).UiQualifiedId, sym(2).UiObjectInitializer);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 962 "qmljs.g"
|
|
|
|
case 30: {
|
|
sym(1).Node = sym(2).Node;
|
|
} break;
|
|
|
|
#line 970 "qmljs.g"
|
|
|
|
case 31: {
|
|
sym(1).Node = new (pool) AST::UiAnnotationList(sym(1).UiAnnotation);
|
|
} break;
|
|
|
|
#line 977 "qmljs.g"
|
|
|
|
case 32: {
|
|
AST::UiAnnotationList *node = new (pool) AST::UiAnnotationList(sym(1).UiAnnotationList, sym(2).UiAnnotation);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 985 "qmljs.g"
|
|
|
|
case 33: {
|
|
AST::UiObjectDefinition *node = sym(2).UiObjectDefinition;
|
|
node->annotations = sym(1).UiAnnotationList->finish();
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 996 "qmljs.g"
|
|
|
|
case 35: {
|
|
sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
|
|
} break;
|
|
|
|
#line 1003 "qmljs.g"
|
|
|
|
case 36: {
|
|
AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(sym(1).UiObjectMemberList, sym(2).UiObjectMember);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1011 "qmljs.g"
|
|
|
|
case 37: {
|
|
sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
|
|
} break;
|
|
|
|
#line 1018 "qmljs.g"
|
|
|
|
case 38: {
|
|
AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(sym(1).UiArrayMemberList, sym(3).UiObjectMember);
|
|
node->commaToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1027 "qmljs.g"
|
|
|
|
case 39: {
|
|
AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1037 "qmljs.g"
|
|
|
|
case 40: {
|
|
AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer(sym(2).UiObjectMemberList->finish());
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1047 "qmljs.g"
|
|
|
|
case 41: {
|
|
AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId, sym(2).UiObjectInitializer);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1055 "qmljs.g"
|
|
|
|
case 42: {
|
|
AST::UiObjectMember *node = sym(2).UiObjectMember;
|
|
node->annotations = sym(1).UiAnnotationList->finish();
|
|
sym(1).Node = sym(2).Node;
|
|
} break;
|
|
|
|
#line 1068 "qmljs.g"
|
|
|
|
case 45: {
|
|
AST::UiArrayBinding *node = new (pool) AST::UiArrayBinding(sym(1).UiQualifiedId, sym(5).UiArrayMemberList->finish());
|
|
node->colonToken = loc(2);
|
|
node->lbracketToken = loc(4);
|
|
node->rbracketToken = loc(6);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1079 "qmljs.g"
|
|
|
|
case 46: {
|
|
AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
|
|
sym(1).UiQualifiedId, sym(4).UiQualifiedId, sym(5).UiObjectInitializer);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1089 "qmljs.g"
|
|
|
|
case 47: {
|
|
AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
|
|
sym(3).UiQualifiedId, sym(1).UiQualifiedId, sym(4).UiObjectInitializer);
|
|
node->colonToken = loc(2);
|
|
node->hasOnToken = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1101 "qmljs.g"
|
|
|
|
case 48: {
|
|
AST::ObjectPattern *l = new (pool) AST::ObjectPattern(sym(3).PatternPropertyList->finish());
|
|
l->lbraceToken = loc(1);
|
|
l->rbraceToken = loc(4);
|
|
AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(l);
|
|
node->semicolonToken = loc(5);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1114 "qmljs.g"
|
|
|
|
case 49: {
|
|
AST::ObjectPattern *l = new (pool) AST::ObjectPattern(sym(3).PatternPropertyList->finish());
|
|
l->lbraceToken = loc(1);
|
|
l->rbraceToken = loc(5);
|
|
AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(l);
|
|
node->semicolonToken = loc(6);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1127 "qmljs.g"
|
|
case 50: Q_FALLTHROUGH();
|
|
#line 1129 "qmljs.g"
|
|
case 51: Q_FALLTHROUGH();
|
|
#line 1131 "qmljs.g"
|
|
|
|
case 52: {
|
|
sym(1).Node = sym(3).Node;
|
|
} break;
|
|
|
|
#line 1139 "qmljs.g"
|
|
case 53: Q_FALLTHROUGH();
|
|
#line 1141 "qmljs.g"
|
|
case 54: Q_FALLTHROUGH();
|
|
#line 1143 "qmljs.g"
|
|
case 55: Q_FALLTHROUGH();
|
|
#line 1145 "qmljs.g"
|
|
case 56: Q_FALLTHROUGH();
|
|
#line 1147 "qmljs.g"
|
|
case 57: Q_FALLTHROUGH();
|
|
#line 1149 "qmljs.g"
|
|
|
|
case 58: {
|
|
sym(1).Node = sym(2).Node;
|
|
} break;
|
|
|
|
#line 1156 "qmljs.g"
|
|
|
|
case 59:
|
|
{
|
|
AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(sym(1).UiQualifiedId, sym(3).Statement);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1166 "qmljs.g"
|
|
case 60: Q_FALLTHROUGH();
|
|
#line 1168 "qmljs.g"
|
|
case 61: Q_FALLTHROUGH();
|
|
#line 1170 "qmljs.g"
|
|
|
|
case 62: {
|
|
AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(stringRef(1));
|
|
node->identifierToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1179 "qmljs.g"
|
|
|
|
case 63: {
|
|
AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(sym(1).UiQualifiedId, stringRef(3));
|
|
node->identifierToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1188 "qmljs.g"
|
|
|
|
case 64: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 1195 "qmljs.g"
|
|
|
|
case 65: {
|
|
sym(1).Node = sym(1).UiParameterList->finish();
|
|
} break;
|
|
|
|
#line 1202 "qmljs.g"
|
|
|
|
case 66: {
|
|
AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(3).UiQualifiedId->finish(), stringRef(1));
|
|
node->identifierToken = loc(1);
|
|
node->colonToken = loc(2);
|
|
node->propertyTypeToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1213 "qmljs.g"
|
|
|
|
case 67: {
|
|
AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiQualifiedId->finish(), stringRef(2));
|
|
node->propertyTypeToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1223 "qmljs.g"
|
|
|
|
case 68: {
|
|
AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, sym(5).UiQualifiedId->finish(), stringRef(3));
|
|
node->propertyTypeToken = loc(5);
|
|
node->commaToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
node->colonToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1235 "qmljs.g"
|
|
|
|
case 69: {
|
|
AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, sym(3).UiQualifiedId->finish(), stringRef(4));
|
|
node->propertyTypeToken = loc(3);
|
|
node->commaToken = loc(2);
|
|
node->identifierToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1246 "qmljs.g"
|
|
|
|
case 70: {
|
|
AST::UiPublicMember *node = new (pool) AST::UiPublicMember(nullptr, stringRef(2));
|
|
node->type = AST::UiPublicMember::Signal;
|
|
node->propertyToken = loc(1);
|
|
node->typeToken = loc(2);
|
|
node->identifierToken = loc(2);
|
|
node->parameters = sym(4).UiParameterList;
|
|
node->semicolonToken = loc(6);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1260 "qmljs.g"
|
|
|
|
case 71: {
|
|
AST::UiPublicMember *node = new (pool) AST::UiPublicMember(nullptr, stringRef(2));
|
|
node->type = AST::UiPublicMember::Signal;
|
|
node->propertyToken = loc(1);
|
|
node->typeToken = loc(2);
|
|
node->identifierToken = loc(2);
|
|
node->semicolonToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1273 "qmljs.g"
|
|
|
|
case 72: {
|
|
AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(4).UiQualifiedId->finish(), stringRef(6));
|
|
node->typeModifier = stringRef(2);
|
|
node->propertyToken = loc(1);
|
|
node->typeModifierToken = loc(2);
|
|
node->typeToken = loc(4);
|
|
node->identifierToken = loc(6);
|
|
node->semicolonToken = loc(7);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1289 "qmljs.g"
|
|
|
|
case 74: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isReadonlyMember = true;
|
|
node->readonlyToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1299 "qmljs.g"
|
|
|
|
case 75: {
|
|
AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3));
|
|
node->propertyToken = loc(1);
|
|
node->typeToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
node->semicolonToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1314 "qmljs.g"
|
|
|
|
case 77: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isDefaultMember = true;
|
|
node->defaultToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1324 "qmljs.g"
|
|
|
|
case 78: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isRequired = true;
|
|
node->requiredToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1334 "qmljs.g"
|
|
|
|
case 79: {
|
|
AST::UiPublicMember *node = sym(3).UiPublicMember;
|
|
node->isRequired = true;
|
|
node->requiredToken = loc(2);
|
|
node->isDefaultMember = true;
|
|
node->defaultToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1346 "qmljs.g"
|
|
|
|
case 80: {
|
|
AST::UiPublicMember *node = sym(3).UiPublicMember;
|
|
node->isRequired = true;
|
|
node->requiredToken = loc(1);
|
|
node->isDefaultMember = true;
|
|
node->defaultToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1358 "qmljs.g"
|
|
|
|
case 81: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isDefaultMember = true;
|
|
node->defaultToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1368 "qmljs.g"
|
|
|
|
case 82: {
|
|
AST::UiPublicMember *node = sym(3).UiPublicMember;
|
|
node->isDefaultMember = true;
|
|
node->defaultToken = loc(1);
|
|
node->isRequired = true;
|
|
node->requiredToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1381 "qmljs.g"
|
|
|
|
case 83: {
|
|
AST::UiPublicMember *node = sym(3).UiPublicMember;
|
|
node->isDefaultMember = true;
|
|
node->defaultToken = loc(2);
|
|
node->isRequired = true;
|
|
node->requiredToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1393 "qmljs.g"
|
|
|
|
/* we need OptionalSemicolon because UiScriptStatement might already parse the last semicolon
|
|
and then we would miss a semicolon (see tests/auto/quick/qquickvisualdatamodel/data/objectlist.qml)*/
|
|
|
|
#line 1399 "qmljs.g"
|
|
|
|
case 86: {
|
|
AST::UiRequired *node = new (pool) AST::UiRequired(stringRef(2));
|
|
node->requiredToken = loc(1);
|
|
node->semicolonToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1411 "qmljs.g"
|
|
|
|
case 88: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->requiredToken = loc(1);
|
|
node->isRequired = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1421 "qmljs.g"
|
|
|
|
case 89: {
|
|
AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3), sym(5).Statement);
|
|
node->propertyToken = loc(1);
|
|
node->typeToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
node->colonToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1435 "qmljs.g"
|
|
|
|
case 91: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isReadonlyMember = true;
|
|
node->readonlyToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1445 "qmljs.g"
|
|
|
|
case 92: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isDefaultMember = true;
|
|
node->defaultToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1455 "qmljs.g"
|
|
|
|
case 93: {
|
|
AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(4).UiQualifiedId->finish(), stringRef(6));
|
|
node->typeModifier = stringRef(2);
|
|
node->propertyToken = loc(1);
|
|
node->typeModifierToken = loc(2);
|
|
node->typeToken = loc(4);
|
|
node->identifierToken = loc(6);
|
|
node->semicolonToken = loc(7); // insert a fake ';' before ':'
|
|
|
|
AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(6));
|
|
propertyName->identifierToken = loc(6);
|
|
propertyName->next = 0;
|
|
|
|
AST::UiArrayBinding *binding = new (pool) AST::UiArrayBinding(propertyName, sym(9).UiArrayMemberList->finish());
|
|
binding->colonToken = loc(7);
|
|
binding->lbracketToken = loc(8);
|
|
binding->rbracketToken = loc(10);
|
|
|
|
node->binding = binding;
|
|
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1483 "qmljs.g"
|
|
|
|
case 95: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isReadonlyMember = true;
|
|
node->readonlyToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1493 "qmljs.g"
|
|
|
|
case 96: {
|
|
AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(2).UiQualifiedId->finish(), stringRef(3));
|
|
node->propertyToken = loc(1);
|
|
node->typeToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
node->semicolonToken = loc(4); // insert a fake ';' before ':'
|
|
|
|
AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(3));
|
|
propertyName->identifierToken = loc(3);
|
|
propertyName->next = 0;
|
|
|
|
AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
|
|
propertyName, sym(6).UiQualifiedId, sym(7).UiObjectInitializer);
|
|
binding->colonToken = loc(4);
|
|
|
|
node->binding = binding;
|
|
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1518 "qmljs.g"
|
|
|
|
case 98: {
|
|
AST::UiPublicMember *node = sym(2).UiPublicMember;
|
|
node->isReadonlyMember = true;
|
|
node->readonlyToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1528 "qmljs.g"
|
|
|
|
case 99: {
|
|
auto node = new (pool) AST::UiSourceElement(sym(1).Node);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1536 "qmljs.g"
|
|
|
|
case 100: {
|
|
sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
|
|
} break;
|
|
|
|
#line 1543 "qmljs.g"
|
|
|
|
case 101: {
|
|
sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
|
|
} break;
|
|
|
|
#line 1550 "qmljs.g"
|
|
|
|
case 102: {
|
|
if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
|
|
diagnostic_messages.append(compileError(mem->lbracketToken,
|
|
QLatin1String("Ignored annotation"), QtWarningMsg));
|
|
|
|
sym(1).Expression = mem->base;
|
|
}
|
|
|
|
if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
|
|
sym(1).UiQualifiedId = qualifiedId;
|
|
} else {
|
|
sym(1).UiQualifiedId = 0;
|
|
|
|
diagnostic_messages.append(compileError(loc(1),
|
|
QLatin1String("Expected a qualified name id")));
|
|
|
|
return false; // ### recover
|
|
}
|
|
} break;
|
|
|
|
#line 1573 "qmljs.g"
|
|
|
|
case 103: {
|
|
AST::UiEnumDeclaration *enumDeclaration = new (pool) AST::UiEnumDeclaration(stringRef(2), sym(4).UiEnumMemberList->finish());
|
|
enumDeclaration->enumToken = loc(1);
|
|
enumDeclaration->rbraceToken = loc(5);
|
|
sym(1).Node = enumDeclaration;
|
|
break;
|
|
}
|
|
|
|
#line 1584 "qmljs.g"
|
|
|
|
case 104: {
|
|
if (!stringRef(2).front().isUpper()) {
|
|
diagnostic_messages.append(compileError(loc(2),
|
|
QLatin1String("Type name must be upper case"), QtWarningMsg));
|
|
}
|
|
auto inlineComponent = new (pool) AST::UiInlineComponent(stringRef(2), sym(4).UiObjectDefinition);
|
|
inlineComponent->componentToken = loc(1);
|
|
sym(1).Node = inlineComponent;
|
|
} break;
|
|
|
|
#line 1597 "qmljs.g"
|
|
|
|
case 105: {
|
|
AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(stringRef(1));
|
|
node->memberToken = loc(1);
|
|
sym(1).Node = node;
|
|
break;
|
|
}
|
|
|
|
#line 1607 "qmljs.g"
|
|
|
|
case 106: {
|
|
AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(stringRef(1), sym(3).dval);
|
|
node->memberToken = loc(1);
|
|
node->valueToken = loc(3);
|
|
sym(1).Node = node;
|
|
break;
|
|
}
|
|
|
|
#line 1618 "qmljs.g"
|
|
|
|
case 107: {
|
|
AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(sym(1).UiEnumMemberList, stringRef(3));
|
|
node->memberToken = loc(3);
|
|
sym(1).Node = node;
|
|
break;
|
|
}
|
|
|
|
#line 1628 "qmljs.g"
|
|
|
|
case 108: {
|
|
AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(sym(1).UiEnumMemberList, stringRef(3), sym(5).dval);
|
|
node->memberToken = loc(3);
|
|
node->valueToken = loc(5);
|
|
sym(1).Node = node;
|
|
break;
|
|
}
|
|
|
|
#line 1672 "qmljs.g"
|
|
|
|
case 135: {
|
|
sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).Type);
|
|
} break;
|
|
|
|
#line 1679 "qmljs.g"
|
|
|
|
case 136: {
|
|
sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).TypeArgumentList, sym(3).Type);
|
|
} break;
|
|
|
|
#line 1686 "qmljs.g"
|
|
|
|
case 137: {
|
|
sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId, sym(3).TypeArgumentList->finish());
|
|
} break;
|
|
|
|
#line 1693 "qmljs.g"
|
|
|
|
case 138: {
|
|
AST::UiQualifiedId *id = new (pool) AST::UiQualifiedId(stringRef(1));
|
|
id->identifierToken = loc(1);
|
|
sym(1).Type = new (pool) AST::Type(id->finish());
|
|
} break;
|
|
|
|
#line 1702 "qmljs.g"
|
|
|
|
case 139: {
|
|
sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId);
|
|
} break;
|
|
|
|
#line 1709 "qmljs.g"
|
|
|
|
case 140: {
|
|
sym(1).TypeAnnotation = new (pool) AST::TypeAnnotation(sym(2).Type);
|
|
sym(1).TypeAnnotation->colonToken = loc(1);
|
|
} break;
|
|
|
|
#line 1718 "qmljs.g"
|
|
|
|
case 142: {
|
|
sym(1).TypeAnnotation = nullptr;
|
|
} break;
|
|
|
|
#line 1729 "qmljs.g"
|
|
|
|
case 143: {
|
|
AST::ThisExpression *node = new (pool) AST::ThisExpression();
|
|
node->thisToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1738 "qmljs.g"
|
|
|
|
case 144: {
|
|
AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
|
|
node->identifierToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1756 "qmljs.g"
|
|
|
|
case 153: {
|
|
if (coverExpressionType != CE_ParenthesizedExpression) {
|
|
syntaxError(coverExpressionErrorLocation, "Expected token ')'.");
|
|
return false;
|
|
}
|
|
} break;
|
|
|
|
#line 1767 "qmljs.g"
|
|
|
|
case 154: {
|
|
AST::NestedExpression *node = new (pool) AST::NestedExpression(sym(2).Expression);
|
|
node->lparenToken = loc(1);
|
|
node->rparenToken = loc(3);
|
|
sym(1).Node = node;
|
|
coverExpressionType = CE_ParenthesizedExpression;
|
|
} break;
|
|
|
|
#line 1778 "qmljs.g"
|
|
|
|
case 155: {
|
|
sym(1).Node = nullptr;
|
|
coverExpressionErrorLocation = loc(2);
|
|
coverExpressionType = CE_FormalParameterList;
|
|
} break;
|
|
|
|
#line 1787 "qmljs.g"
|
|
|
|
case 156: {
|
|
AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(2).PatternElement))->finish(pool);
|
|
sym(1).Node = node;
|
|
coverExpressionErrorLocation = loc(2);
|
|
coverExpressionType = CE_FormalParameterList;
|
|
} break;
|
|
|
|
#line 1797 "qmljs.g"
|
|
|
|
case 157: {
|
|
AST::FormalParameterList *list = sym(2).Expression->reparseAsFormalParameterList(pool);
|
|
if (!list) {
|
|
syntaxError(loc(1), "Invalid Arrow parameter list.");
|
|
return false;
|
|
}
|
|
if (sym(4).Node) {
|
|
list = new (pool) AST::FormalParameterList(list, sym(4).PatternElement);
|
|
}
|
|
coverExpressionErrorLocation = loc(4);
|
|
coverExpressionType = CE_FormalParameterList;
|
|
sym(1).Node = list->finish(pool);
|
|
} break;
|
|
|
|
#line 1814 "qmljs.g"
|
|
|
|
case 158: {
|
|
AST::NullExpression *node = new (pool) AST::NullExpression();
|
|
node->nullToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1823 "qmljs.g"
|
|
|
|
case 159: {
|
|
AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
|
|
node->trueToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1832 "qmljs.g"
|
|
|
|
case 160: {
|
|
AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
|
|
node->falseToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1841 "qmljs.g"
|
|
|
|
case 161: {
|
|
AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
|
|
node->literalToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1850 "qmljs.g"
|
|
case 162: Q_FALLTHROUGH();
|
|
#line 1853 "qmljs.g"
|
|
|
|
case 163: {
|
|
AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
|
|
node->literalToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1865 "qmljs.g"
|
|
|
|
{
|
|
Lexer::RegExpBodyPrefix prefix;
|
|
case 164:
|
|
prefix = Lexer::NoPrefix;
|
|
goto scan_regexp;
|
|
|
|
#line 1877 "qmljs.g"
|
|
|
|
case 165:
|
|
prefix = Lexer::EqualPrefix;
|
|
goto scan_regexp;
|
|
|
|
scan_regexp: {
|
|
bool rx = lexer->scanRegExp(prefix);
|
|
if (!rx) {
|
|
diagnostic_messages.append(compileError(location(lexer), lexer->errorMessage()));
|
|
return false;
|
|
}
|
|
|
|
loc(1).length = lexer->tokenLength();
|
|
yylloc = loc(1); // adjust the location of the current token
|
|
|
|
AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
|
|
node->literalToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
}
|
|
|
|
#line 1901 "qmljs.g"
|
|
|
|
case 166: {
|
|
AST::PatternElementList *list = nullptr;
|
|
if (sym(2).Elision)
|
|
list = (new (pool) AST::PatternElementList(sym(2).Elision, nullptr))->finish();
|
|
AST::ArrayPattern *node = new (pool) AST::ArrayPattern(list);
|
|
node->lbracketToken = loc(1);
|
|
node->rbracketToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1914 "qmljs.g"
|
|
|
|
case 167: {
|
|
AST::ArrayPattern *node = new (pool) AST::ArrayPattern(sym(2).PatternElementList->finish());
|
|
node->lbracketToken = loc(1);
|
|
node->rbracketToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1924 "qmljs.g"
|
|
|
|
case 168: {
|
|
auto *list = sym(2).PatternElementList;
|
|
if (sym(4).Elision) {
|
|
AST::PatternElementList *l = new (pool) AST::PatternElementList(sym(4).Elision, nullptr);
|
|
list = list->append(l);
|
|
}
|
|
AST::ArrayPattern *node = new (pool) AST::ArrayPattern(list->finish());
|
|
node->lbracketToken = loc(1);
|
|
node->commaToken = loc(3);
|
|
node->rbracketToken = loc(5);
|
|
sym(1).Node = node;
|
|
Q_ASSERT(node->isValidArrayLiteral());
|
|
} break;
|
|
|
|
#line 1941 "qmljs.g"
|
|
|
|
case 169: {
|
|
AST::PatternElement *e = new (pool) AST::PatternElement(sym(1).Expression);
|
|
sym(1).Node = new (pool) AST::PatternElementList(nullptr, e);
|
|
} break;
|
|
|
|
#line 1949 "qmljs.g"
|
|
|
|
case 170: {
|
|
AST::PatternElement *e = new (pool) AST::PatternElement(sym(2).Expression);
|
|
sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision->finish(), e);
|
|
} break;
|
|
|
|
#line 1957 "qmljs.g"
|
|
|
|
case 171: {
|
|
AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1965 "qmljs.g"
|
|
|
|
case 172: {
|
|
AST::PatternElement *e = new (pool) AST::PatternElement(sym(4).Expression);
|
|
AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(3).Elision, e);
|
|
sym(1).Node = sym(1).PatternElementList->append(node);
|
|
} break;
|
|
|
|
#line 1974 "qmljs.g"
|
|
|
|
case 173: {
|
|
AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(3).Elision, sym(4).PatternElement);
|
|
sym(1).Node = sym(1).PatternElementList->append(node);
|
|
} break;
|
|
|
|
#line 1982 "qmljs.g"
|
|
|
|
case 174: {
|
|
AST::Elision *node = new (pool) AST::Elision();
|
|
node->commaToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 1991 "qmljs.g"
|
|
|
|
case 175: {
|
|
AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
|
|
node->commaToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2000 "qmljs.g"
|
|
|
|
case 176: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 2007 "qmljs.g"
|
|
|
|
case 177: {
|
|
sym(1).Node = sym(1).Elision->finish();
|
|
} break;
|
|
|
|
#line 2014 "qmljs.g"
|
|
|
|
case 178: {
|
|
AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Expression, AST::PatternElement::SpreadElement);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2022 "qmljs.g"
|
|
|
|
case 179: {
|
|
AST::ObjectPattern *node = new (pool) AST::ObjectPattern();
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2032 "qmljs.g"
|
|
|
|
case 180: {
|
|
AST::ObjectPattern *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList->finish());
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2042 "qmljs.g"
|
|
|
|
case 181: {
|
|
AST::ObjectPattern *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList->finish());
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2053 "qmljs.g"
|
|
case 182: Q_FALLTHROUGH();
|
|
#line 2055 "qmljs.g"
|
|
|
|
case 183: {
|
|
sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty);
|
|
} break;
|
|
|
|
#line 2062 "qmljs.g"
|
|
case 184: Q_FALLTHROUGH();
|
|
#line 2064 "qmljs.g"
|
|
|
|
case 185: {
|
|
AST::PatternPropertyList *node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2072 "qmljs.g"
|
|
|
|
case 186: {
|
|
AST::IdentifierPropertyName *name = new (pool) AST::IdentifierPropertyName(stringRef(1));
|
|
name->propertyNameToken = loc(1);
|
|
AST::IdentifierExpression *expr = new (pool) AST::IdentifierExpression(stringRef(1));
|
|
expr->identifierToken = loc(1);
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(name, expr);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2088 "qmljs.g"
|
|
|
|
case 188: {
|
|
AST::IdentifierPropertyName *name = new (pool) AST::IdentifierPropertyName(stringRef(1));
|
|
name->propertyNameToken = loc(1);
|
|
AST::IdentifierExpression *left = new (pool) AST::IdentifierExpression(stringRef(1));
|
|
left->identifierToken = loc(1);
|
|
// if initializer is an anonymous function expression, we need to assign identifierref as it's name
|
|
if (auto *f = asAnonymousFunctionDefinition(sym(2).Expression))
|
|
f->name = stringRef(1);
|
|
if (auto *c = asAnonymousClassDefinition(sym(2).Expression))
|
|
c->name = stringRef(1);
|
|
AST::BinaryExpression *assignment = new (pool) AST::BinaryExpression(left, QSOperator::Assign, sym(2).Expression);
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(name, assignment);
|
|
node->colonToken = loc(1);
|
|
sym(1).Node = node;
|
|
|
|
} break;
|
|
|
|
#line 2108 "qmljs.g"
|
|
case 189: Q_FALLTHROUGH();
|
|
#line 2110 "qmljs.g"
|
|
|
|
case 190: {
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Expression);
|
|
if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) {
|
|
if (!AST::cast<AST::ComputedPropertyName *>(sym(1).PropertyName))
|
|
c->name = driver->newStringRef(sym(1).PropertyName->asString());
|
|
}
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2128 "qmljs.g"
|
|
|
|
case 194: {
|
|
AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
|
|
node->propertyNameToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2137 "qmljs.g"
|
|
case 195: Q_FALLTHROUGH();
|
|
#line 2139 "qmljs.g"
|
|
|
|
case 196: {
|
|
AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
|
|
node->propertyNameToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2148 "qmljs.g"
|
|
case 197: Q_FALLTHROUGH();
|
|
#line 2150 "qmljs.g"
|
|
|
|
case 198: {
|
|
AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
|
|
node->propertyNameToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2201 "qmljs.g"
|
|
|
|
case 239: {
|
|
AST::ComputedPropertyName *node = new (pool) AST::ComputedPropertyName(sym(2).Expression);
|
|
node->propertyNameToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2210 "qmljs.g"
|
|
case 240: Q_FALLTHROUGH();
|
|
#line 2212 "qmljs.g"
|
|
|
|
case 241: {
|
|
sym(1) = sym(2);
|
|
} break;
|
|
|
|
#line 2220 "qmljs.g"
|
|
case 242: Q_FALLTHROUGH();
|
|
#line 2222 "qmljs.g"
|
|
|
|
case 243: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 2232 "qmljs.g"
|
|
case 246: Q_FALLTHROUGH();
|
|
#line 2235 "qmljs.g"
|
|
|
|
case 247: {
|
|
AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), nullptr);
|
|
node->literalToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2244 "qmljs.g"
|
|
case 248: Q_FALLTHROUGH();
|
|
#line 2247 "qmljs.g"
|
|
|
|
case 249: {
|
|
AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), sym(2).Expression);
|
|
node->next = sym(3).Template;
|
|
node->literalToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2260 "qmljs.g"
|
|
|
|
case 251: {
|
|
AST::SuperLiteral *node = new (pool) AST::SuperLiteral();
|
|
node->superToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2270 "qmljs.g"
|
|
case 252: Q_FALLTHROUGH();
|
|
#line 2272 "qmljs.g"
|
|
|
|
case 253: {
|
|
AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
|
|
node->lbracketToken = loc(2);
|
|
node->rbracketToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2284 "qmljs.g"
|
|
case 254:
|
|
{
|
|
AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
|
|
node->identifierToken= loc(1);
|
|
sym(1).Node = node;
|
|
} Q_FALLTHROUGH();
|
|
|
|
#line 2292 "qmljs.g"
|
|
case 255: Q_FALLTHROUGH();
|
|
#line 2294 "qmljs.g"
|
|
|
|
case 256: {
|
|
AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
|
|
node->dotToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2306 "qmljs.g"
|
|
|
|
case 258: {
|
|
AST::NewMemberExpression *node = new (pool) AST::NewMemberExpression(sym(2).Expression, sym(4).ArgumentList);
|
|
node->newToken = loc(1);
|
|
node->lparenToken = loc(3);
|
|
node->rparenToken = loc(5);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2322 "qmljs.g"
|
|
|
|
case 261: {
|
|
AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
|
|
node->newToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2332 "qmljs.g"
|
|
case 262: Q_FALLTHROUGH();
|
|
#line 2334 "qmljs.g"
|
|
|
|
case 263: {
|
|
AST::TaggedTemplate *node = new (pool) AST::TaggedTemplate(sym(1).Expression, sym(2).Template);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2342 "qmljs.g"
|
|
|
|
case 264: {
|
|
AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2352 "qmljs.g"
|
|
case 265: Q_FALLTHROUGH();
|
|
#line 2354 "qmljs.g"
|
|
|
|
case 266: {
|
|
AST::CallExpression *node = new (pool) AST::CallExpression(sym(1).Expression, sym(3).ArgumentList);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2364 "qmljs.g"
|
|
|
|
case 267: {
|
|
AST::ArrayMemberExpression *node = new (pool) AST::ArrayMemberExpression(sym(1).Expression, sym(3).Expression);
|
|
node->lbracketToken = loc(2);
|
|
node->rbracketToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2374 "qmljs.g"
|
|
|
|
case 268: {
|
|
AST::FieldMemberExpression *node = new (pool) AST::FieldMemberExpression(sym(1).Expression, stringRef(3));
|
|
node->dotToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2384 "qmljs.g"
|
|
|
|
case 269: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 2391 "qmljs.g"
|
|
case 270: Q_FALLTHROUGH();
|
|
#line 2393 "qmljs.g"
|
|
|
|
case 271: {
|
|
sym(1).Node = sym(1).ArgumentList->finish();
|
|
} break;
|
|
|
|
#line 2400 "qmljs.g"
|
|
|
|
case 272: {
|
|
sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
|
|
} break;
|
|
|
|
#line 2407 "qmljs.g"
|
|
|
|
case 273: {
|
|
AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(2).Expression);
|
|
node->isSpreadElement = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2416 "qmljs.g"
|
|
|
|
case 274: {
|
|
AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
|
|
node->commaToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2425 "qmljs.g"
|
|
|
|
case 275: {
|
|
AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(4).Expression);
|
|
node->commaToken = loc(2);
|
|
node->isSpreadElement = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2440 "qmljs.g"
|
|
|
|
case 279: {
|
|
AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
|
|
node->incrementToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2449 "qmljs.g"
|
|
|
|
case 280: {
|
|
AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
|
|
node->decrementToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2458 "qmljs.g"
|
|
|
|
case 281: {
|
|
AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
|
|
node->incrementToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2467 "qmljs.g"
|
|
|
|
case 282: {
|
|
AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
|
|
node->decrementToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2478 "qmljs.g"
|
|
|
|
case 284: {
|
|
AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
|
|
node->deleteToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2487 "qmljs.g"
|
|
|
|
case 285: {
|
|
AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
|
|
node->voidToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2496 "qmljs.g"
|
|
|
|
case 286: {
|
|
AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
|
|
node->typeofToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2505 "qmljs.g"
|
|
|
|
case 287: {
|
|
AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
|
|
node->plusToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2514 "qmljs.g"
|
|
|
|
case 288: {
|
|
AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
|
|
node->minusToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2523 "qmljs.g"
|
|
|
|
case 289: {
|
|
AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
|
|
node->tildeToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2532 "qmljs.g"
|
|
|
|
case 290: {
|
|
AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
|
|
node->notToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2543 "qmljs.g"
|
|
|
|
case 292: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Exp, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2554 "qmljs.g"
|
|
|
|
case 294: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2563 "qmljs.g"
|
|
|
|
case 295: {
|
|
sym(1).ival = QSOperator::Mul;
|
|
} break;
|
|
|
|
#line 2570 "qmljs.g"
|
|
|
|
case 296: {
|
|
sym(1).ival = QSOperator::Div;
|
|
} break;
|
|
|
|
#line 2577 "qmljs.g"
|
|
|
|
case 297: {
|
|
sym(1).ival = QSOperator::Mod;
|
|
} break;
|
|
|
|
#line 2586 "qmljs.g"
|
|
|
|
case 299: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Add, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2595 "qmljs.g"
|
|
|
|
case 300: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Sub, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2606 "qmljs.g"
|
|
|
|
case 302: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::LShift, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2615 "qmljs.g"
|
|
|
|
case 303: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::RShift, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2624 "qmljs.g"
|
|
|
|
case 304: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::URShift, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2636 "qmljs.g"
|
|
case 307: Q_FALLTHROUGH();
|
|
#line 2638 "qmljs.g"
|
|
|
|
case 308: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2647 "qmljs.g"
|
|
|
|
case 309: {
|
|
sym(1).ival = QSOperator::Lt;
|
|
} break;
|
|
|
|
#line 2653 "qmljs.g"
|
|
|
|
case 310: {
|
|
sym(1).ival = QSOperator::Gt;
|
|
} break;
|
|
|
|
#line 2659 "qmljs.g"
|
|
|
|
case 311: {
|
|
sym(1).ival = QSOperator::Le;
|
|
} break;
|
|
|
|
#line 2665 "qmljs.g"
|
|
|
|
case 312: {
|
|
sym(1).ival = QSOperator::Ge;
|
|
} break;
|
|
|
|
#line 2671 "qmljs.g"
|
|
|
|
case 313: {
|
|
sym(1).ival = QSOperator::InstanceOf;
|
|
} break;
|
|
|
|
#line 2678 "qmljs.g"
|
|
|
|
case 314: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::In, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2687 "qmljs.g"
|
|
case 315: Q_FALLTHROUGH();
|
|
#line 2689 "qmljs.g"
|
|
|
|
case 316: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::As, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2704 "qmljs.g"
|
|
case 321: Q_FALLTHROUGH();
|
|
#line 2706 "qmljs.g"
|
|
|
|
case 322: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2715 "qmljs.g"
|
|
|
|
case 323: {
|
|
sym(1).ival = QSOperator::Equal;
|
|
} break;
|
|
|
|
#line 2721 "qmljs.g"
|
|
|
|
case 324: {
|
|
sym(1).ival = QSOperator::NotEqual;
|
|
} break;
|
|
|
|
#line 2727 "qmljs.g"
|
|
|
|
case 325: {
|
|
sym(1).ival = QSOperator::StrictEqual;
|
|
} break;
|
|
|
|
#line 2733 "qmljs.g"
|
|
|
|
case 326: {
|
|
sym(1).ival = QSOperator::StrictNotEqual;
|
|
} break;
|
|
|
|
#line 2744 "qmljs.g"
|
|
case 329: Q_FALLTHROUGH();
|
|
#line 2746 "qmljs.g"
|
|
|
|
case 330: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitAnd, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2759 "qmljs.g"
|
|
case 333: Q_FALLTHROUGH();
|
|
#line 2761 "qmljs.g"
|
|
|
|
case 334: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitXor, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2773 "qmljs.g"
|
|
case 337: Q_FALLTHROUGH();
|
|
#line 2775 "qmljs.g"
|
|
|
|
case 338: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitOr, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2787 "qmljs.g"
|
|
case 341: Q_FALLTHROUGH();
|
|
#line 2789 "qmljs.g"
|
|
|
|
case 342: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::And, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2801 "qmljs.g"
|
|
case 345: Q_FALLTHROUGH();
|
|
#line 2803 "qmljs.g"
|
|
|
|
case 346: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Or, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2815 "qmljs.g"
|
|
case 349: Q_FALLTHROUGH();
|
|
#line 2817 "qmljs.g"
|
|
|
|
case 350: {
|
|
|
|
auto *lhs = sym(1).Expression;
|
|
auto *rhs = sym(3).Expression;
|
|
|
|
// Check if lhs or rhs contain || or &&
|
|
|
|
if (lhs->binaryExpressionCast() != nullptr) {
|
|
auto *binaryExpr = lhs->binaryExpressionCast();
|
|
if (binaryExpr->op == QSOperator::And || binaryExpr->op == QSOperator::Or) {
|
|
syntaxError(binaryExpr->operatorToken, "Left-hand side may not contain || or &&");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (rhs->binaryExpressionCast() != nullptr) {
|
|
auto *binaryExpr = rhs->binaryExpressionCast();
|
|
if (binaryExpr->op == QSOperator::And || binaryExpr->op == QSOperator::Or) {
|
|
syntaxError(binaryExpr->operatorToken, "Right-hand side may not contain || or &&");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(lhs, QSOperator::Coalesce, rhs);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2851 "qmljs.g"
|
|
case 353: Q_FALLTHROUGH();
|
|
#line 2853 "qmljs.g"
|
|
|
|
case 354: {
|
|
AST::ConditionalExpression *node = new (pool) AST::ConditionalExpression(sym(1).Expression, sym(3).Expression, sym(5).Expression);
|
|
node->questionToken = loc(2);
|
|
node->colonToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2872 "qmljs.g"
|
|
case 361: Q_FALLTHROUGH();
|
|
#line 2874 "qmljs.g"
|
|
|
|
case 362: {
|
|
// need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral
|
|
if (AST::Pattern *p = sym(1).Expression->patternCast()) {
|
|
SourceLocation errorLoc;
|
|
QString errorMsg;
|
|
if (!p->convertLiteralToAssignmentPattern(pool, &errorLoc, &errorMsg)) {
|
|
syntaxError(errorLoc, errorMsg);
|
|
return false;
|
|
}
|
|
}
|
|
// if lhs is an identifier expression and rhs is an anonymous function expression, we need to assign the name of lhs to the function
|
|
if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) {
|
|
if (auto *id = AST::cast<AST::IdentifierExpression *>(sym(1).Expression))
|
|
f->name = id->name;
|
|
}
|
|
if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) {
|
|
if (auto *id = AST::cast<AST::IdentifierExpression *>(sym(1).Expression))
|
|
c->name = id->name;
|
|
}
|
|
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Assign, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2902 "qmljs.g"
|
|
case 363: Q_FALLTHROUGH();
|
|
#line 2904 "qmljs.g"
|
|
|
|
case 364: {
|
|
AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, sym(2).ival, sym(3).Expression);
|
|
node->operatorToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 2913 "qmljs.g"
|
|
|
|
case 365: {
|
|
sym(1).ival = QSOperator::InplaceMul;
|
|
} break;
|
|
|
|
#line 2920 "qmljs.g"
|
|
|
|
case 366: {
|
|
sym(1).ival = QSOperator::InplaceExp;
|
|
} break;
|
|
|
|
#line 2927 "qmljs.g"
|
|
|
|
case 367: {
|
|
sym(1).ival = QSOperator::InplaceDiv;
|
|
} break;
|
|
|
|
#line 2934 "qmljs.g"
|
|
|
|
case 368: {
|
|
sym(1).ival = QSOperator::InplaceMod;
|
|
} break;
|
|
|
|
#line 2941 "qmljs.g"
|
|
|
|
case 369: {
|
|
sym(1).ival = QSOperator::InplaceAdd;
|
|
} break;
|
|
|
|
#line 2948 "qmljs.g"
|
|
|
|
case 370: {
|
|
sym(1).ival = QSOperator::InplaceSub;
|
|
} break;
|
|
|
|
#line 2955 "qmljs.g"
|
|
|
|
case 371: {
|
|
sym(1).ival = QSOperator::InplaceLeftShift;
|
|
} break;
|
|
|
|
#line 2962 "qmljs.g"
|
|
|
|
case 372: {
|
|
sym(1).ival = QSOperator::InplaceRightShift;
|
|
} break;
|
|
|
|
#line 2969 "qmljs.g"
|
|
|
|
case 373: {
|
|
sym(1).ival = QSOperator::InplaceURightShift;
|
|
} break;
|
|
|
|
#line 2976 "qmljs.g"
|
|
|
|
case 374: {
|
|
sym(1).ival = QSOperator::InplaceAnd;
|
|
} break;
|
|
|
|
#line 2983 "qmljs.g"
|
|
|
|
case 375: {
|
|
sym(1).ival = QSOperator::InplaceXor;
|
|
} break;
|
|
|
|
#line 2990 "qmljs.g"
|
|
|
|
case 376: {
|
|
sym(1).ival = QSOperator::InplaceOr;
|
|
} break;
|
|
|
|
#line 3000 "qmljs.g"
|
|
case 379: Q_FALLTHROUGH();
|
|
#line 3002 "qmljs.g"
|
|
|
|
case 380: {
|
|
AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
|
|
node->commaToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3011 "qmljs.g"
|
|
case 381: Q_FALLTHROUGH();
|
|
#line 3013 "qmljs.g"
|
|
|
|
case 382: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 3025 "qmljs.g"
|
|
|
|
case 385: {
|
|
sym(1).Node = sym(3).Node;
|
|
} break;
|
|
|
|
#line 3032 "qmljs.g"
|
|
case 386: Q_FALLTHROUGH();
|
|
#line 3034 "qmljs.g"
|
|
case 387: Q_FALLTHROUGH();
|
|
#line 3036 "qmljs.g"
|
|
case 388: Q_FALLTHROUGH();
|
|
#line 3038 "qmljs.g"
|
|
case 389: Q_FALLTHROUGH();
|
|
#line 3040 "qmljs.g"
|
|
case 390: Q_FALLTHROUGH();
|
|
#line 3042 "qmljs.g"
|
|
case 391: Q_FALLTHROUGH();
|
|
#line 3044 "qmljs.g"
|
|
case 392: Q_FALLTHROUGH();
|
|
#line 3046 "qmljs.g"
|
|
case 393: Q_FALLTHROUGH();
|
|
#line 3048 "qmljs.g"
|
|
case 394: Q_FALLTHROUGH();
|
|
#line 3050 "qmljs.g"
|
|
case 395: Q_FALLTHROUGH();
|
|
#line 3052 "qmljs.g"
|
|
case 396: Q_FALLTHROUGH();
|
|
#line 3054 "qmljs.g"
|
|
case 397: Q_FALLTHROUGH();
|
|
#line 3056 "qmljs.g"
|
|
|
|
case 398: {
|
|
sym(1).Node = sym(2).Node;
|
|
} break;
|
|
|
|
#line 3078 "qmljs.g"
|
|
|
|
case 409: {
|
|
AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3090 "qmljs.g"
|
|
|
|
case 411: {
|
|
sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList);
|
|
} break;
|
|
|
|
#line 3097 "qmljs.g"
|
|
|
|
case 412: {
|
|
sym(1).StatementList = new (pool) AST::StatementList(sym(1).Statement);
|
|
} break;
|
|
|
|
#line 3104 "qmljs.g"
|
|
|
|
case 413: {
|
|
sym(1).Node = new (pool) AST::StatementList(sym(3).FunctionDeclaration);
|
|
} break;
|
|
|
|
#line 3111 "qmljs.g"
|
|
|
|
case 414: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 3118 "qmljs.g"
|
|
|
|
case 415: {
|
|
sym(1).Node = sym(1).StatementList->finish();
|
|
} break;
|
|
|
|
#line 3125 "qmljs.g"
|
|
|
|
case 416: {
|
|
sym(1).scope = AST::VariableScope::Let;
|
|
} break;
|
|
|
|
#line 3131 "qmljs.g"
|
|
|
|
case 417: {
|
|
sym(1).scope = AST::VariableScope::Const;
|
|
} break;
|
|
|
|
#line 3138 "qmljs.g"
|
|
|
|
case 418: {
|
|
sym(1).scope = AST::VariableScope::Var;
|
|
} break;
|
|
|
|
#line 3145 "qmljs.g"
|
|
case 419: Q_FALLTHROUGH();
|
|
#line 3147 "qmljs.g"
|
|
case 420: Q_FALLTHROUGH();
|
|
#line 3149 "qmljs.g"
|
|
case 421: Q_FALLTHROUGH();
|
|
#line 3151 "qmljs.g"
|
|
|
|
case 422: {
|
|
AST::VariableDeclarationList *declarations = sym(2).VariableDeclarationList->finish(sym(1).scope);
|
|
for (auto it = declarations; it; it = it->next) {
|
|
if (it->declaration && it->declaration->typeAnnotation) {
|
|
syntaxError(it->declaration->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations");
|
|
return false;
|
|
}
|
|
}
|
|
AST::VariableStatement *node = new (pool) AST::VariableStatement(declarations);
|
|
node->declarationKindToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3169 "qmljs.g"
|
|
case 424: Q_FALLTHROUGH();
|
|
#line 3171 "qmljs.g"
|
|
case 425: Q_FALLTHROUGH();
|
|
#line 3173 "qmljs.g"
|
|
case 426: Q_FALLTHROUGH();
|
|
#line 3175 "qmljs.g"
|
|
|
|
case 427: {
|
|
sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).PatternElement);
|
|
} break;
|
|
|
|
#line 3182 "qmljs.g"
|
|
case 428: Q_FALLTHROUGH();
|
|
#line 3184 "qmljs.g"
|
|
case 429: Q_FALLTHROUGH();
|
|
#line 3186 "qmljs.g"
|
|
case 430: Q_FALLTHROUGH();
|
|
#line 3188 "qmljs.g"
|
|
|
|
case 431: {
|
|
AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).PatternElement);
|
|
node->commaToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3197 "qmljs.g"
|
|
case 432: Q_FALLTHROUGH();
|
|
#line 3199 "qmljs.g"
|
|
case 433: Q_FALLTHROUGH();
|
|
#line 3201 "qmljs.g"
|
|
case 434: Q_FALLTHROUGH();
|
|
#line 3203 "qmljs.g"
|
|
|
|
case 435: {
|
|
auto *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression);
|
|
node->identifierToken = loc(1);
|
|
sym(1).Node = node;
|
|
// if initializer is an anonymous function expression, we need to assign identifierref as it's name
|
|
if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression))
|
|
f->name = stringRef(1);
|
|
if (auto *c = asAnonymousClassDefinition(sym(3).Expression))
|
|
c->name = stringRef(1);
|
|
} break;
|
|
|
|
#line 3217 "qmljs.g"
|
|
case 436: Q_FALLTHROUGH();
|
|
#line 3219 "qmljs.g"
|
|
case 437: Q_FALLTHROUGH();
|
|
#line 3221 "qmljs.g"
|
|
case 438: Q_FALLTHROUGH();
|
|
#line 3223 "qmljs.g"
|
|
|
|
case 439: {
|
|
auto *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression);
|
|
node->identifierToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3232 "qmljs.g"
|
|
|
|
case 440: {
|
|
auto *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList);
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(3);
|
|
node->parseMode = AST::Pattern::Binding;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3243 "qmljs.g"
|
|
|
|
case 441: {
|
|
auto *node = new (pool) AST::ArrayPattern(sym(2).PatternElementList);
|
|
node->lbracketToken = loc(1);
|
|
node->rbracketToken = loc(3);
|
|
node->parseMode = AST::Pattern::Binding;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3254 "qmljs.g"
|
|
|
|
case 442: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 3261 "qmljs.g"
|
|
case 443:
|
|
#line 3263 "qmljs.g"
|
|
|
|
case 444: {
|
|
sym(1).Node = sym(1).PatternPropertyList->finish();
|
|
} break;
|
|
|
|
#line 3270 "qmljs.g"
|
|
|
|
case 445: {
|
|
if (sym(1).Elision || sym(2).Node) {
|
|
auto *l = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement);
|
|
sym(1).Node = l->finish();
|
|
} else {
|
|
sym(1).Node = nullptr;
|
|
}
|
|
} break;
|
|
|
|
#line 3282 "qmljs.g"
|
|
|
|
case 446: {
|
|
sym(1).Node = sym(1).PatternElementList->finish();
|
|
} break;
|
|
|
|
#line 3289 "qmljs.g"
|
|
|
|
case 447: {
|
|
if (sym(3).Elision || sym(4).Node) {
|
|
auto *l = new (pool) AST::PatternElementList(sym(3).Elision, sym(4).PatternElement);
|
|
l = sym(1).PatternElementList->append(l);
|
|
sym(1).Node = l;
|
|
}
|
|
sym(1).Node = sym(1).PatternElementList->finish();
|
|
} break;
|
|
|
|
#line 3301 "qmljs.g"
|
|
|
|
case 448: {
|
|
sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty);
|
|
} break;
|
|
|
|
#line 3308 "qmljs.g"
|
|
|
|
case 449: {
|
|
sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty);
|
|
} break;
|
|
|
|
#line 3317 "qmljs.g"
|
|
|
|
case 451: {
|
|
sym(1).PatternElementList = sym(1).PatternElementList->append(sym(3).PatternElementList);
|
|
} break;
|
|
|
|
#line 3324 "qmljs.g"
|
|
|
|
case 452: {
|
|
sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement);
|
|
} break;
|
|
|
|
#line 3332 "qmljs.g"
|
|
|
|
case 453: {
|
|
AST::StringLiteralPropertyName *name = new (pool) AST::StringLiteralPropertyName(stringRef(1));
|
|
name->propertyNameToken = loc(1);
|
|
// if initializer is an anonymous function expression, we need to assign identifierref as it's name
|
|
if (auto *f = asAnonymousFunctionDefinition(sym(2).Expression))
|
|
f->name = stringRef(1);
|
|
if (auto *c = asAnonymousClassDefinition(sym(2).Expression))
|
|
c->name = stringRef(1);
|
|
sym(1).Node = new (pool) AST::PatternProperty(name, stringRef(1), sym(2).Expression);
|
|
} break;
|
|
|
|
#line 3346 "qmljs.g"
|
|
|
|
case 454: {
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, stringRef(3), sym(4).Expression);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3354 "qmljs.g"
|
|
|
|
case 455: {
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Pattern, sym(4).Expression);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3362 "qmljs.g"
|
|
|
|
case 456: {
|
|
AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression);
|
|
node->identifierToken = loc(1);
|
|
// if initializer is an anonymous function expression, we need to assign identifierref as it's name
|
|
if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression))
|
|
f->name = stringRef(1);
|
|
if (auto *c = asAnonymousClassDefinition(sym(3).Expression))
|
|
c->name = stringRef(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3376 "qmljs.g"
|
|
|
|
case 457: {
|
|
AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3384 "qmljs.g"
|
|
|
|
case 458: {
|
|
AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(2), /*type annotation*/nullptr, nullptr, AST::PatternElement::RestElement);
|
|
node->identifierToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3393 "qmljs.g"
|
|
|
|
case 459: {
|
|
AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr, AST::PatternElement::RestElement);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3401 "qmljs.g"
|
|
|
|
case 460: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 3411 "qmljs.g"
|
|
|
|
case 462: {
|
|
AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
|
|
node->semicolonToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3426 "qmljs.g"
|
|
|
|
case 463: {
|
|
int token = lookaheadToken(lexer);
|
|
if (token == T_LBRACE)
|
|
pushToken(T_FORCE_BLOCK);
|
|
else if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS || token == T_LET || token == T_CONST)
|
|
pushToken(T_FORCE_DECLARATION);
|
|
} break;
|
|
|
|
#line 3437 "qmljs.g"
|
|
|
|
case 464: {
|
|
AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
|
|
node->semicolonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3446 "qmljs.g"
|
|
|
|
case 465: {
|
|
AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement, sym(7).Statement);
|
|
node->ifToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
node->elseToken = loc(6);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3458 "qmljs.g"
|
|
|
|
case 466: {
|
|
AST::IfStatement *node = new (pool) AST::IfStatement(sym(3).Expression, sym(5).Statement);
|
|
node->ifToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3471 "qmljs.g"
|
|
|
|
case 468: {
|
|
AST::DoWhileStatement *node = new (pool) AST::DoWhileStatement(sym(2).Statement, sym(5).Expression);
|
|
node->doToken = loc(1);
|
|
node->whileToken = loc(3);
|
|
node->lparenToken = loc(4);
|
|
node->rparenToken = loc(6);
|
|
node->semicolonToken = loc(7);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3484 "qmljs.g"
|
|
|
|
case 469: {
|
|
AST::WhileStatement *node = new (pool) AST::WhileStatement(sym(3).Expression, sym(5).Statement);
|
|
node->whileToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3495 "qmljs.g"
|
|
|
|
case 470: {
|
|
AST::ForStatement *node = new (pool) AST::ForStatement(sym(3).Expression, sym(5).Expression, sym(7).Expression, sym(9).Statement);
|
|
node->forToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->firstSemicolonToken = loc(4);
|
|
node->secondSemicolonToken = loc(6);
|
|
node->rparenToken = loc(8);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3508 "qmljs.g"
|
|
case 471: Q_FALLTHROUGH();
|
|
#line 3510 "qmljs.g"
|
|
|
|
case 472: {
|
|
// ### get rid of the static_cast!
|
|
AST::ForStatement *node = new (pool) AST::ForStatement(
|
|
static_cast<AST::VariableStatement *>(sym(3).Node)->declarations, sym(5).Expression,
|
|
sym(7).Expression, sym(9).Statement);
|
|
node->forToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->firstSemicolonToken = loc(4);
|
|
node->secondSemicolonToken = loc(6);
|
|
node->rparenToken = loc(8);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3526 "qmljs.g"
|
|
|
|
case 473: {
|
|
sym(1).forEachType = AST::ForEachType::In;
|
|
} break;
|
|
|
|
#line 3533 "qmljs.g"
|
|
|
|
case 474: {
|
|
sym(1).forEachType = AST::ForEachType::Of;
|
|
} break;
|
|
|
|
#line 3540 "qmljs.g"
|
|
|
|
case 475: {
|
|
// need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral
|
|
if (AST::Pattern *p = sym(3).Expression->patternCast()) {
|
|
SourceLocation errorLoc;
|
|
QString errorMsg;
|
|
if (!p->convertLiteralToAssignmentPattern(pool, &errorLoc, &errorMsg)) {
|
|
syntaxError(errorLoc, errorMsg);
|
|
return false;
|
|
}
|
|
}
|
|
AST::ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).Expression, sym(5).Expression, sym(7).Statement);
|
|
node->forToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->inOfToken = loc(4);
|
|
node->rparenToken = loc(6);
|
|
node->type = sym(4).forEachType;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3562 "qmljs.g"
|
|
|
|
case 476: {
|
|
AST::ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).PatternElement, sym(5).Expression, sym(7).Statement);
|
|
node->forToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->inOfToken = loc(4);
|
|
node->rparenToken = loc(6);
|
|
node->type = sym(4).forEachType;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3575 "qmljs.g"
|
|
case 477: Q_FALLTHROUGH();
|
|
#line 3577 "qmljs.g"
|
|
|
|
case 478: {
|
|
if (auto typeAnnotation = sym(3).TypeAnnotation) {
|
|
syntaxError(typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations");
|
|
return false;
|
|
}
|
|
auto *node = new (pool) AST::PatternElement(stringRef(2), sym(3).TypeAnnotation, nullptr);
|
|
node->identifierToken = loc(2);
|
|
node->scope = sym(1).scope;
|
|
node->isForDeclaration = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3592 "qmljs.g"
|
|
case 479: Q_FALLTHROUGH();
|
|
#line 3594 "qmljs.g"
|
|
|
|
case 480: {
|
|
auto *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr);
|
|
node->scope = sym(1).scope;
|
|
node->isForDeclaration = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3604 "qmljs.g"
|
|
|
|
case 481: {
|
|
AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
|
|
node->continueToken = loc(1);
|
|
node->semicolonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3614 "qmljs.g"
|
|
|
|
case 482: {
|
|
AST::ContinueStatement *node = new (pool) AST::ContinueStatement(stringRef(2));
|
|
node->continueToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
node->semicolonToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3625 "qmljs.g"
|
|
|
|
case 483: {
|
|
AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
|
|
node->breakToken = loc(1);
|
|
node->semicolonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3635 "qmljs.g"
|
|
|
|
case 484: {
|
|
AST::BreakStatement *node = new (pool) AST::BreakStatement(stringRef(2));
|
|
node->breakToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
node->semicolonToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3646 "qmljs.g"
|
|
|
|
case 485: {
|
|
if (!functionNestingLevel) {
|
|
syntaxError(loc(1), "Return statement not allowed outside of Function declaration.");
|
|
return false;
|
|
}
|
|
AST::ReturnStatement *node = new (pool) AST::ReturnStatement(sym(2).Expression);
|
|
node->returnToken = loc(1);
|
|
node->semicolonToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3660 "qmljs.g"
|
|
|
|
case 486: {
|
|
AST::WithStatement *node = new (pool) AST::WithStatement(sym(3).Expression, sym(5).Statement);
|
|
node->withToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3671 "qmljs.g"
|
|
|
|
case 487: {
|
|
AST::SwitchStatement *node = new (pool) AST::SwitchStatement(sym(3).Expression, sym(5).CaseBlock);
|
|
node->switchToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3682 "qmljs.g"
|
|
|
|
case 488: {
|
|
AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3692 "qmljs.g"
|
|
|
|
case 489: {
|
|
AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses, sym(3).DefaultClause, sym(4).CaseClauses);
|
|
node->lbraceToken = loc(1);
|
|
node->rbraceToken = loc(5);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3702 "qmljs.g"
|
|
|
|
case 490: {
|
|
sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
|
|
} break;
|
|
|
|
#line 3709 "qmljs.g"
|
|
|
|
case 491: {
|
|
sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
|
|
} break;
|
|
|
|
#line 3716 "qmljs.g"
|
|
|
|
case 492: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 3723 "qmljs.g"
|
|
|
|
case 493: {
|
|
sym(1).Node = sym(1).CaseClauses->finish();
|
|
} break;
|
|
|
|
#line 3730 "qmljs.g"
|
|
|
|
case 494: {
|
|
AST::CaseClause *node = new (pool) AST::CaseClause(sym(2).Expression, sym(4).StatementList);
|
|
node->caseToken = loc(1);
|
|
node->colonToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3740 "qmljs.g"
|
|
|
|
case 495: {
|
|
AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
|
|
node->defaultToken = loc(1);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3750 "qmljs.g"
|
|
|
|
case 496: {
|
|
AST::LabelledStatement *node = new (pool) AST::LabelledStatement(stringRef(1), sym(3).Statement);
|
|
node->identifierToken = loc(1);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3762 "qmljs.g"
|
|
|
|
case 498: {
|
|
syntaxError(loc(3), "FunctionDeclarations are not allowed after a label.");
|
|
return false;
|
|
} break;
|
|
|
|
#line 3770 "qmljs.g"
|
|
|
|
case 499: {
|
|
AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
|
|
node->throwToken = loc(1);
|
|
node->semicolonToken = loc(3);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3780 "qmljs.g"
|
|
|
|
case 500: {
|
|
AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
|
|
node->tryToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3789 "qmljs.g"
|
|
|
|
case 501: {
|
|
AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
|
|
node->tryToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3798 "qmljs.g"
|
|
|
|
case 502: {
|
|
AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch, sym(4).Finally);
|
|
node->tryToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3807 "qmljs.g"
|
|
|
|
case 503: {
|
|
AST::Catch *node = new (pool) AST::Catch(sym(3).PatternElement, sym(5).Block);
|
|
node->catchToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->identifierToken = loc(3);
|
|
node->rparenToken = loc(4);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3819 "qmljs.g"
|
|
|
|
case 504: {
|
|
AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
|
|
node->finallyToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3828 "qmljs.g"
|
|
|
|
case 505: {
|
|
AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1));
|
|
node->identifierToken = loc(1);
|
|
node->scope = AST::VariableScope::Let;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3838 "qmljs.g"
|
|
|
|
case 506: {
|
|
AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern);
|
|
node->scope = AST::VariableScope::Let;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3847 "qmljs.g"
|
|
|
|
case 507: {
|
|
AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
|
|
node->debuggerToken = loc(1);
|
|
node->semicolonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3864 "qmljs.g"
|
|
|
|
case 509: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
|
|
return false;
|
|
AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList,
|
|
/*type annotation*/nullptr);
|
|
node->functionToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
node->lparenToken = loc(3);
|
|
node->rparenToken = loc(5);
|
|
node->lbraceToken = loc(7);
|
|
node->rbraceToken = loc(9);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3881 "qmljs.g"
|
|
|
|
case 510: {
|
|
AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList,
|
|
sym(6).TypeAnnotation);
|
|
node->functionToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
node->lparenToken = loc(3);
|
|
node->rparenToken = loc(5);
|
|
node->lbraceToken = loc(7);
|
|
node->rbraceToken = loc(9);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3897 "qmljs.g"
|
|
|
|
case 512: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList))
|
|
return false;
|
|
AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList,
|
|
/*type annotation*/nullptr);
|
|
node->functionToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
node->lbraceToken = loc(6);
|
|
node->rbraceToken = loc(8);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3913 "qmljs.g"
|
|
|
|
case 513: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
|
|
return false;
|
|
AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList,
|
|
/*type annotation*/nullptr);
|
|
node->functionToken = loc(1);
|
|
if (! stringRef(2).isNull())
|
|
node->identifierToken = loc(2);
|
|
node->lparenToken = loc(3);
|
|
node->rparenToken = loc(5);
|
|
node->lbraceToken = loc(7);
|
|
node->rbraceToken = loc(9);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3931 "qmljs.g"
|
|
|
|
case 514: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList))
|
|
return false;
|
|
AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList,
|
|
/*type annotation*/nullptr);
|
|
node->functionToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
node->lbraceToken = loc(6);
|
|
node->rbraceToken = loc(8);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3949 "qmljs.g"
|
|
|
|
case 516: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 3956 "qmljs.g"
|
|
|
|
case 517: {
|
|
AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3964 "qmljs.g"
|
|
case 518:
|
|
#line 3966 "qmljs.g"
|
|
|
|
case 519: {
|
|
sym(1).Node = sym(1).FormalParameterList->finish(pool);
|
|
} break;
|
|
|
|
#line 3973 "qmljs.g"
|
|
|
|
case 520: {
|
|
AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement))->finish(pool);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3981 "qmljs.g"
|
|
|
|
case 521: {
|
|
AST::FormalParameterList *node = new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 3990 "qmljs.g"
|
|
|
|
case 522: {
|
|
AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4000 "qmljs.g"
|
|
|
|
case 524: {
|
|
++functionNestingLevel;
|
|
} break;
|
|
|
|
#line 4007 "qmljs.g"
|
|
|
|
case 525: {
|
|
--functionNestingLevel;
|
|
} break;
|
|
|
|
#line 4017 "qmljs.g"
|
|
case 527: Q_FALLTHROUGH();
|
|
#line 4019 "qmljs.g"
|
|
|
|
case 528: {
|
|
AST::ReturnStatement *ret = new (pool) AST::ReturnStatement(sym(4).Expression);
|
|
ret->returnToken = sym(4).Node->firstSourceLocation();
|
|
ret->semicolonToken = sym(4).Node->lastSourceLocation();
|
|
AST::StatementList *statements = (new (pool) AST::StatementList(ret))->finish();
|
|
AST::FunctionExpression *f = new (pool) AST::FunctionExpression(QStringRef(), sym(1).FormalParameterList, statements);
|
|
f->isArrowFunction = true;
|
|
f->functionToken = sym(1).Node ? sym(1).Node->firstSourceLocation() : loc(1);
|
|
f->lbraceToken = sym(4).Node->firstSourceLocation();
|
|
f->rbraceToken = sym(4).Node->lastSourceLocation();
|
|
sym(1).Node = f;
|
|
} break;
|
|
|
|
#line 4035 "qmljs.g"
|
|
case 529: Q_FALLTHROUGH();
|
|
#line 4037 "qmljs.g"
|
|
|
|
case 530: {
|
|
AST::FunctionExpression *f = new (pool) AST::FunctionExpression(QStringRef(), sym(1).FormalParameterList, sym(6).StatementList);
|
|
f->isArrowFunction = true;
|
|
f->functionToken = sym(1).Node ? sym(1).Node->firstSourceLocation() : loc(1);
|
|
f->lbraceToken = loc(6);
|
|
f->rbraceToken = loc(7);
|
|
sym(1).Node = f;
|
|
} break;
|
|
|
|
#line 4049 "qmljs.g"
|
|
|
|
case 531: {
|
|
AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), /*type annotation*/nullptr, nullptr, AST::PatternElement::Binding);
|
|
e->identifierToken = loc(1);
|
|
sym(1).FormalParameterList = (new (pool) AST::FormalParameterList(nullptr, e))->finish(pool);
|
|
} break;
|
|
|
|
#line 4060 "qmljs.g"
|
|
|
|
case 532: {
|
|
if (coverExpressionType != CE_FormalParameterList) {
|
|
AST::NestedExpression *ne = static_cast<AST::NestedExpression *>(sym(1).Node);
|
|
AST::FormalParameterList *list = ne->expression->reparseAsFormalParameterList(pool);
|
|
if (!list) {
|
|
syntaxError(loc(1), "Invalid Arrow parameter list.");
|
|
return false;
|
|
}
|
|
sym(1).Node = list->finish(pool);
|
|
}
|
|
} break;
|
|
|
|
#line 4078 "qmljs.g"
|
|
|
|
case 533: {
|
|
if (lookaheadToken(lexer) == T_LBRACE)
|
|
pushToken(T_FORCE_BLOCK);
|
|
} break;
|
|
|
|
#line 4086 "qmljs.g"
|
|
|
|
case 534: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList))
|
|
return false;
|
|
AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(7).StatementList);
|
|
f->functionToken = sym(1).PropertyName->firstSourceLocation();
|
|
f->lparenToken = loc(2);
|
|
f->rparenToken = loc(4);
|
|
f->lbraceToken = loc(6);
|
|
f->rbraceToken = loc(8);
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f, AST::PatternProperty::Method);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4103 "qmljs.g"
|
|
|
|
case 535: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
|
|
return false;
|
|
AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList);
|
|
f->functionToken = sym(2).PropertyName->firstSourceLocation();
|
|
f->lparenToken = loc(3);
|
|
f->rparenToken = loc(5);
|
|
f->lbraceToken = loc(7);
|
|
f->rbraceToken = loc(9);
|
|
f->isGenerator = true;
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Method);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4122 "qmljs.g"
|
|
|
|
case 536: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, /*formals*/nullptr))
|
|
return false;
|
|
AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(7).StatementList);
|
|
f->functionToken = sym(2).PropertyName->firstSourceLocation();
|
|
f->lparenToken = loc(3);
|
|
f->rparenToken = loc(4);
|
|
f->lbraceToken = loc(6);
|
|
f->rbraceToken = loc(8);
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Getter);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4139 "qmljs.g"
|
|
|
|
case 537: {
|
|
if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
|
|
return false;
|
|
AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList);
|
|
f->functionToken = sym(2).PropertyName->firstSourceLocation();
|
|
f->lparenToken = loc(3);
|
|
f->rparenToken = loc(5);
|
|
f->lbraceToken = loc(7);
|
|
f->rbraceToken = loc(9);
|
|
AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Setter);
|
|
node->colonToken = loc(2);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4157 "qmljs.g"
|
|
|
|
case 538: {
|
|
AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4165 "qmljs.g"
|
|
|
|
case 539: {
|
|
lexer->enterGeneratorBody();
|
|
} break;
|
|
|
|
#line 4172 "qmljs.g"
|
|
|
|
case 540: {
|
|
--functionNestingLevel;
|
|
lexer->leaveGeneratorBody();
|
|
} break;
|
|
|
|
#line 4182 "qmljs.g"
|
|
|
|
case 542: {
|
|
AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);
|
|
node->functionToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
node->lparenToken = loc(3);
|
|
node->rparenToken = loc(5);
|
|
node->lbraceToken = loc(6);
|
|
node->rbraceToken = loc(8);
|
|
node->isGenerator = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4198 "qmljs.g"
|
|
|
|
case 544: {
|
|
AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList);
|
|
node->functionToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
node->lbraceToken = loc(5);
|
|
node->rbraceToken = loc(7);
|
|
node->isGenerator = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4212 "qmljs.g"
|
|
|
|
case 545: {
|
|
AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);
|
|
node->functionToken = loc(1);
|
|
if (!stringRef(2).isNull())
|
|
node->identifierToken = loc(2);
|
|
node->lparenToken = loc(3);
|
|
node->rparenToken = loc(5);
|
|
node->lbraceToken = loc(6);
|
|
node->rbraceToken = loc(8);
|
|
node->isGenerator = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4228 "qmljs.g"
|
|
|
|
case 546: {
|
|
AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList);
|
|
node->functionToken = loc(1);
|
|
node->lparenToken = loc(2);
|
|
node->rparenToken = loc(4);
|
|
node->lbraceToken = loc(5);
|
|
node->rbraceToken = loc(7);
|
|
node->isGenerator = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4244 "qmljs.g"
|
|
case 548: Q_FALLTHROUGH();
|
|
#line 4246 "qmljs.g"
|
|
|
|
case 549: {
|
|
AST::YieldExpression *node = new (pool) AST::YieldExpression();
|
|
node->yieldToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4255 "qmljs.g"
|
|
case 550: Q_FALLTHROUGH();
|
|
#line 4257 "qmljs.g"
|
|
|
|
case 551: {
|
|
AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(3).Expression);
|
|
node->yieldToken = loc(1);
|
|
node->isYieldStar = true;
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4267 "qmljs.g"
|
|
case 552: Q_FALLTHROUGH();
|
|
#line 4269 "qmljs.g"
|
|
|
|
case 553: {
|
|
AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(2).Expression);
|
|
node->yieldToken = loc(1);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4279 "qmljs.g"
|
|
|
|
case 554: {
|
|
AST::ClassDeclaration *node = new (pool) AST::ClassDeclaration(stringRef(2), sym(3).Expression, sym(5).ClassElementList);
|
|
node->classToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
node->lbraceToken = loc(4);
|
|
node->rbraceToken = loc(6);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4291 "qmljs.g"
|
|
|
|
case 555: {
|
|
AST::ClassExpression *node = new (pool) AST::ClassExpression(stringRef(2), sym(3).Expression, sym(5).ClassElementList);
|
|
node->classToken = loc(1);
|
|
node->identifierToken = loc(2);
|
|
node->lbraceToken = loc(4);
|
|
node->rbraceToken = loc(6);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4303 "qmljs.g"
|
|
|
|
case 556: {
|
|
AST::ClassDeclaration *node = new (pool) AST::ClassDeclaration(QStringRef(), sym(2).Expression, sym(4).ClassElementList);
|
|
node->classToken = loc(1);
|
|
node->lbraceToken = loc(3);
|
|
node->rbraceToken = loc(5);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4314 "qmljs.g"
|
|
|
|
case 557: {
|
|
AST::ClassExpression *node = new (pool) AST::ClassExpression(QStringRef(), sym(2).Expression, sym(4).ClassElementList);
|
|
node->classToken = loc(1);
|
|
node->lbraceToken = loc(3);
|
|
node->rbraceToken = loc(5);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4327 "qmljs.g"
|
|
|
|
case 559: {
|
|
lexer->setStaticIsKeyword(true);
|
|
} break;
|
|
|
|
#line 4334 "qmljs.g"
|
|
case 560:
|
|
#line 4336 "qmljs.g"
|
|
|
|
case 561: {
|
|
lexer->setStaticIsKeyword(false);
|
|
} break;
|
|
|
|
#line 4343 "qmljs.g"
|
|
|
|
case 562: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 4350 "qmljs.g"
|
|
|
|
case 563: {
|
|
sym(1).Node = sym(2).Node;
|
|
} break;
|
|
|
|
#line 4357 "qmljs.g"
|
|
|
|
case 564: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 4364 "qmljs.g"
|
|
|
|
case 565: {
|
|
if (sym(1).Node)
|
|
sym(1).Node = sym(1).ClassElementList->finish();
|
|
} break;
|
|
|
|
#line 4374 "qmljs.g"
|
|
|
|
case 567: {
|
|
if (sym(1).Node) {
|
|
if (sym(2).Node)
|
|
sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList);
|
|
} else if (sym(2).Node) {
|
|
sym(1).Node = sym(2).Node;
|
|
}
|
|
} break;
|
|
|
|
#line 4386 "qmljs.g"
|
|
|
|
case 568: {
|
|
AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(1).PatternProperty, false);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4394 "qmljs.g"
|
|
|
|
case 569: {
|
|
lexer->setStaticIsKeyword(true);
|
|
AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(2).PatternProperty, true);
|
|
sym(1).Node = node;
|
|
} break;
|
|
|
|
#line 4403 "qmljs.g"
|
|
|
|
case 570: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 4412 "qmljs.g"
|
|
|
|
case 571: {
|
|
sym(1).Node = nullptr;
|
|
} break;
|
|
|
|
#line 4421 "qmljs.g"
|
|
|
|
case 573: {
|
|
sym(1).Node = new (pool) AST::Program(sym(1).StatementList->finish());
|
|
} break;
|
|
|
|
#line 4428 "qmljs.g"
|
|
case 574: {
|
|
sym(1).Node = new (pool) AST::ESModule(sym(1).StatementList);
|
|
} break;
|
|
|
|
#line 4434 "qmljs.g"
|
|
|
|
case 575: {
|
|
sym(1).StatementList = sym(1).StatementList->finish();
|
|
} break;
|
|
|
|
#line 4441 "qmljs.g"
|
|
|
|
case 576: {
|
|
sym(1).StatementList = nullptr;
|
|
} break;
|
|
|
|
#line 4451 "qmljs.g"
|
|
|
|
case 579: {
|
|
sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList);
|
|
} break;
|
|
|
|
#line 4459 "qmljs.g"
|
|
case 580: Q_FALLTHROUGH();
|
|
#line 4461 "qmljs.g"
|
|
|
|
case 581: {
|
|
sym(1).StatementList = new (pool) AST::StatementList(sym(1).Node);
|
|
} break;
|
|
|
|
#line 4470 "qmljs.g"
|
|
|
|
case 583: {
|
|
auto decl = new (pool) AST::ImportDeclaration(sym(2).ImportClause, sym(3).FromClause);
|
|
decl->importToken = loc(1);
|
|
sym(1).Node = decl;
|
|
} break;
|
|
|
|
#line 4478 "qmljs.g"
|
|
|
|
case 584: {
|
|
auto decl = new (pool) AST::ImportDeclaration(stringRef(2));
|
|
decl->importToken = loc(1);
|
|
decl->moduleSpecifierToken = loc(2);
|
|
sym(1).Node = decl;
|
|
} break;
|
|
|
|
#line 4488 "qmljs.g"
|
|
|
|
case 585: {
|
|
auto clause = new (pool) AST::ImportClause(stringRef(1));
|
|
clause->importedDefaultBindingToken = loc(1);
|
|
sym(1).ImportClause = clause;
|
|
} break;
|
|
|
|
#line 4496 "qmljs.g"
|
|
|
|
case 586: {
|
|
sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NameSpaceImport);
|
|
} break;
|
|
|
|
#line 4502 "qmljs.g"
|
|
|
|
case 587: {
|
|
sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NamedImports);
|
|
} break;
|
|
|
|
#line 4508 "qmljs.g"
|
|
|
|
case 588: {
|
|
auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NameSpaceImport);
|
|
importClause->importedDefaultBindingToken = loc(1);
|
|
sym(1).ImportClause = importClause;
|
|
} break;
|
|
|
|
#line 4516 "qmljs.g"
|
|
|
|
case 589: {
|
|
auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NamedImports);
|
|
importClause->importedDefaultBindingToken = loc(1);
|
|
sym(1).ImportClause = importClause;
|
|
} break;
|
|
|
|
#line 4527 "qmljs.g"
|
|
|
|
case 591: {
|
|
auto import = new (pool) AST::NameSpaceImport(stringRef(3));
|
|
import->starToken = loc(1);
|
|
import->importedBindingToken = loc(3);
|
|
sym(1).NameSpaceImport = import;
|
|
} break;
|
|
|
|
#line 4537 "qmljs.g"
|
|
|
|
case 592: {
|
|
auto namedImports = new (pool) AST::NamedImports();
|
|
namedImports->leftBraceToken = loc(1);
|
|
namedImports->rightBraceToken = loc(2);
|
|
sym(1).NamedImports = namedImports;
|
|
} break;
|
|
|
|
#line 4546 "qmljs.g"
|
|
|
|
case 593: {
|
|
auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish());
|
|
namedImports->leftBraceToken = loc(1);
|
|
namedImports->rightBraceToken = loc(3);
|
|
sym(1).NamedImports = namedImports;
|
|
} break;
|
|
|
|
#line 4555 "qmljs.g"
|
|
|
|
case 594: {
|
|
auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish());
|
|
namedImports->leftBraceToken = loc(1);
|
|
namedImports->rightBraceToken = loc(4);
|
|
sym(1).NamedImports = namedImports;
|
|
} break;
|
|
|
|
#line 4565 "qmljs.g"
|
|
|
|
case 595: {
|
|
auto clause = new (pool) AST::FromClause(stringRef(2));
|
|
clause->fromToken = loc(1);
|
|
clause->moduleSpecifierToken = loc(2);
|
|
sym(1).FromClause = clause;
|
|
} break;
|
|
|
|
#line 4575 "qmljs.g"
|
|
|
|
case 596: {
|
|
auto importsList = new (pool) AST::ImportsList(sym(1).ImportSpecifier);
|
|
importsList->importSpecifierToken = loc(1);
|
|
sym(1).ImportsList = importsList;
|
|
} break;
|
|
|
|
#line 4583 "qmljs.g"
|
|
|
|
case 597: {
|
|
auto importsList = new (pool) AST::ImportsList(sym(1).ImportsList, sym(3).ImportSpecifier);
|
|
importsList->importSpecifierToken = loc(3);
|
|
sym(1).ImportsList = importsList;
|
|
} break;
|
|
|
|
#line 4595 "qmljs.g"
|
|
|
|
case 598: {
|
|
auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1));
|
|
importSpecifier->importedBindingToken = loc(1);
|
|
sym(1).ImportSpecifier = importSpecifier;
|
|
} break;
|
|
|
|
#line 4603 "qmljs.g"
|
|
|
|
case 599: {
|
|
auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1), stringRef(3));
|
|
importSpecifier->identifierToken = loc(1);
|
|
importSpecifier->importedBindingToken = loc(3);
|
|
sym(1).ImportSpecifier = importSpecifier;
|
|
} break;
|
|
|
|
#line 4620 "qmljs.g"
|
|
|
|
case 602: {
|
|
int token = lookaheadToken(lexer);
|
|
if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS)
|
|
pushToken(T_FORCE_DECLARATION);
|
|
} break;
|
|
|
|
#line 4629 "qmljs.g"
|
|
|
|
case 603: {
|
|
auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(3).FromClause);
|
|
exportDeclaration->exportToken = loc(1);
|
|
sym(1).ExportDeclaration = exportDeclaration;
|
|
} break;
|
|
|
|
#line 4637 "qmljs.g"
|
|
|
|
case 604: {
|
|
auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause, sym(3).FromClause);
|
|
exportDeclaration->exportToken = loc(1);
|
|
sym(1).ExportDeclaration = exportDeclaration;
|
|
} break;
|
|
|
|
#line 4645 "qmljs.g"
|
|
|
|
case 605: {
|
|
auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause);
|
|
exportDeclaration->exportToken = loc(1);
|
|
sym(1).ExportDeclaration = exportDeclaration;
|
|
} break;
|
|
|
|
#line 4653 "qmljs.g"
|
|
case 606: Q_FALLTHROUGH();
|
|
#line 4655 "qmljs.g"
|
|
|
|
case 607: {
|
|
auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/false, sym(2).Node);
|
|
exportDeclaration->exportToken = loc(1);
|
|
sym(1).ExportDeclaration = exportDeclaration;
|
|
} break;
|
|
|
|
#line 4663 "qmljs.g"
|
|
|
|
case 608: {
|
|
if (auto *f = AST::cast<AST::FunctionDeclaration*>(sym(5).Node)) {
|
|
if (f->name.isEmpty()) {
|
|
f->name = stringRef(2);
|
|
f->identifierToken = loc(2);
|
|
}
|
|
}
|
|
} Q_FALLTHROUGH();
|
|
|
|
#line 4674 "qmljs.g"
|
|
|
|
case 609: {
|
|
// Emulate 15.2.3.11
|
|
if (auto *cls = AST::cast<AST::ClassDeclaration*>(sym(5).Node)) {
|
|
if (cls->name.isEmpty()) {
|
|
cls->name = stringRef(2);
|
|
cls->identifierToken = loc(2);
|
|
}
|
|
}
|
|
|
|
auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/true, sym(5).Node);
|
|
exportDeclaration->exportToken = loc(1);
|
|
sym(1).ExportDeclaration = exportDeclaration;
|
|
} break;
|
|
|
|
#line 4690 "qmljs.g"
|
|
|
|
case 610: {
|
|
// if lhs is an identifier expression and rhs is an anonymous function expression, we need to assign the name of lhs to the function
|
|
if (auto *f = asAnonymousFunctionDefinition(sym(4).Node)) {
|
|
f->name = stringRef(2);
|
|
}
|
|
if (auto *c = asAnonymousClassDefinition(sym(4).Expression)) {
|
|
c->name = stringRef(2);
|
|
}
|
|
|
|
auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/true, sym(4).Node);
|
|
exportDeclaration->exportToken = loc(1);
|
|
sym(1).ExportDeclaration = exportDeclaration;
|
|
} break;
|
|
|
|
#line 4707 "qmljs.g"
|
|
|
|
case 611: {
|
|
auto exportClause = new (pool) AST::ExportClause();
|
|
exportClause->leftBraceToken = loc(1);
|
|
exportClause->rightBraceToken = loc(2);
|
|
sym(1).ExportClause = exportClause;
|
|
} break;
|
|
|
|
#line 4716 "qmljs.g"
|
|
|
|
case 612: {
|
|
auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish());
|
|
exportClause->leftBraceToken = loc(1);
|
|
exportClause->rightBraceToken = loc(3);
|
|
sym(1).ExportClause = exportClause;
|
|
} break;
|
|
|
|
#line 4725 "qmljs.g"
|
|
|
|
case 613: {
|
|
auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish());
|
|
exportClause->leftBraceToken = loc(1);
|
|
exportClause->rightBraceToken = loc(4);
|
|
sym(1).ExportClause = exportClause;
|
|
} break;
|
|
|
|
#line 4735 "qmljs.g"
|
|
|
|
case 614: {
|
|
sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportSpecifier);
|
|
} break;
|
|
|
|
#line 4741 "qmljs.g"
|
|
|
|
case 615: {
|
|
sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportsList, sym(3).ExportSpecifier);
|
|
} break;
|
|
|
|
#line 4748 "qmljs.g"
|
|
|
|
case 616: {
|
|
auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1));
|
|
exportSpecifier->identifierToken = loc(1);
|
|
sym(1).ExportSpecifier = exportSpecifier;
|
|
} break;
|
|
|
|
#line 4756 "qmljs.g"
|
|
|
|
case 617: {
|
|
auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1), stringRef(3));
|
|
exportSpecifier->identifierToken = loc(1);
|
|
exportSpecifier->exportedIdentifierToken = loc(3);
|
|
sym(1).ExportSpecifier = exportSpecifier;
|
|
} break;
|
|
|
|
#line 4767 "qmljs.g"
|
|
|
|
// ------------ end of switch statement
|
|
} // switch
|
|
action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
|
|
} // if
|
|
} while (action != 0);
|
|
|
|
#ifdef PARSER_DEBUG
|
|
qDebug() << "Done or error.";
|
|
#endif
|
|
|
|
if (first_token == last_token) {
|
|
const int errorState = state_stack[tos];
|
|
|
|
// automatic insertion of `;'
|
|
if (yytoken != -1 && ((t_action(errorState, T_AUTOMATIC_SEMICOLON) && lexer->canInsertAutomaticSemicolon(yytoken))
|
|
|| t_action(errorState, T_COMPATIBILITY_SEMICOLON))) {
|
|
#ifdef PARSER_DEBUG
|
|
qDebug() << "Inserting automatic semicolon.";
|
|
#endif
|
|
SavedToken &tk = token_buffer[0];
|
|
tk.token = yytoken;
|
|
tk.dval = yylval;
|
|
tk.spell = yytokenspell;
|
|
tk.raw = yytokenraw;
|
|
tk.loc = yylloc;
|
|
|
|
yylloc = yyprevlloc;
|
|
yylloc.offset += yylloc.length;
|
|
yylloc.startColumn += yylloc.length;
|
|
yylloc.length = 0;
|
|
|
|
//const QString msg = QCoreApplication::translate("QmlParser", "Missing `;'");
|
|
//diagnostic_messages.append(compileError(yyloc, msg, QtWarningMsg));
|
|
|
|
first_token = &token_buffer[0];
|
|
last_token = &token_buffer[1];
|
|
|
|
yytoken = T_SEMICOLON;
|
|
yylval = 0;
|
|
|
|
action = errorState;
|
|
|
|
goto _Lcheck_token;
|
|
}
|
|
|
|
hadErrors = true;
|
|
|
|
token_buffer[0].token = yytoken;
|
|
token_buffer[0].dval = yylval;
|
|
token_buffer[0].spell = yytokenspell;
|
|
token_buffer[0].raw = yytokenraw;
|
|
token_buffer[0].loc = yylloc;
|
|
|
|
token_buffer[1].token = yytoken = lexer->lex();
|
|
token_buffer[1].dval = yylval = lexer->tokenValue();
|
|
token_buffer[1].spell = yytokenspell = lexer->tokenSpell();
|
|
token_buffer[1].raw = yytokenraw = lexer->rawString();
|
|
token_buffer[1].loc = yylloc = location(lexer);
|
|
|
|
if (t_action(errorState, yytoken)) {
|
|
#ifdef PARSER_DEBUG
|
|
qDebug() << "Parse error, trying to recover.";
|
|
#endif
|
|
QString msg;
|
|
int token = token_buffer[0].token;
|
|
if (token < 0 || token >= TERMINAL_COUNT)
|
|
msg = QCoreApplication::translate("QmlParser", "Syntax error");
|
|
else
|
|
msg = QCoreApplication::translate("QmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
|
|
diagnostic_messages.append(compileError(token_buffer[0].loc, msg));
|
|
|
|
action = errorState;
|
|
goto _Lcheck_token;
|
|
}
|
|
|
|
static int tokens[] = {
|
|
T_PLUS,
|
|
T_EQ,
|
|
|
|
T_COMMA,
|
|
T_COLON,
|
|
T_SEMICOLON,
|
|
|
|
T_RPAREN, T_RBRACKET, T_RBRACE,
|
|
|
|
T_NUMERIC_LITERAL,
|
|
T_IDENTIFIER,
|
|
|
|
T_LPAREN, T_LBRACKET, T_LBRACE,
|
|
|
|
EOF_SYMBOL
|
|
};
|
|
|
|
for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
|
|
int a = t_action(errorState, *tk);
|
|
if (a > 0 && t_action(a, yytoken)) {
|
|
#ifdef PARSER_DEBUG
|
|
qDebug() << "Parse error, trying to recover (2).";
|
|
#endif
|
|
const QString msg = QCoreApplication::translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
|
|
diagnostic_messages.append(compileError(token_buffer[0].loc, msg));
|
|
|
|
pushToken(*tk);
|
|
goto _Lcheck_token;
|
|
}
|
|
}
|
|
|
|
for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
|
|
if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM ||
|
|
tk == T_FEED_JS_STATEMENT || tk == T_FEED_JS_EXPRESSION)
|
|
continue;
|
|
|
|
int a = t_action(errorState, tk);
|
|
if (a > 0 && t_action(a, yytoken)) {
|
|
const QString msg = QCoreApplication::translate("QmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
|
|
diagnostic_messages.append(compileError(token_buffer[0].loc, msg));
|
|
|
|
pushToken(tk);
|
|
goto _Lcheck_token;
|
|
}
|
|
}
|
|
|
|
const QString msg = QCoreApplication::translate("QmlParser", "Syntax error");
|
|
diagnostic_messages.append(compileError(token_buffer[0].loc, msg));
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
QT_QML_END_NAMESPACE
|
|
|
|
|