qmljs: update parser

Update the qtcreator qmljs parser to the
one of Qt 5.12. It supports EcmaScript 7.

Task-number: QTCREATORBUG-20341
Change-Id: I0d1cff71402ba17e22cde6b46c65614e162280de
Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>

1 files changed, 2874 insertions, 1417 deletions

diff --git a/src/libs/qmljs/parser/qmljsparser.cpp b/src/libs/qmljs/parser/qmljsparser.cpp
index 5ab7114400..d7f23855b8 100644
--- a/src/libs/qmljs/parser/qmljsparser.cpp
+++ b/src/libs/qmljs/parser/qmljsparser.cpp
@@ -1,10 +1,13 @@
+
+#line 127 "qmljs.g"
 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
-** This file is part of Qt Creator.
+** This file is part of the QtQml module of the Qt Toolkit.
 **
+** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
 ** Licensees holding valid commercial Qt licenses may use this file in
 ** accordance with the commercial license agreement provided with the
@@ -13,13 +16,26 @@
 ** and conditions see https://www.qt.io/terms-conditions. For further
 ** information use the contact form at https://www.qt.io/contact-us.
 **
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
 ** 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
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
 ** 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.
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
 **
 ****************************************************************************/
 
@@ -34,6 +50,8 @@
 #include <string.h>
 
 
+#line 461 "qmljs.g"
+
 
 #include "qmljsparser_p.h"
 
@@ -51,6 +69,8 @@
 //    qlalr --no-debug --no-lines --qt qmljs.g
 //
 
+#define UNIMPLEMENTED syntaxError(loc(1), "Unimplemented"); return false
+
 using namespace QmlJS;
 
 QT_QML_BEGIN_NAMESPACE
@@ -65,22 +85,12 @@ void Parser::reallocateStack()
     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<AST::SourceLocation*> (realloc(location_stack, stack_size * sizeof(AST::SourceLocation)));
-    string_stack = reinterpret_cast<QStringRef*> (realloc(string_stack, stack_size * sizeof(QStringRef)));
+    string_stack.resize(stack_size);
 }
 
 Parser::Parser(Engine *engine):
     driver(engine),
-    pool(engine->pool()),
-    tos(0),
-    stack_size(0),
-    sym_stack(0),
-    state_stack(0),
-    location_stack(0),
-    string_stack(0),
-    program(0),
-    yylval(0),
-    first_token(0),
-    last_token(0)
+    pool(engine->pool())
 {
 }
 
@@ -90,7 +100,6 @@ Parser::~Parser()
         free(sym_stack);
         free(state_stack);
         free(location_stack);
-        free(string_stack);
     }
 }
 
@@ -132,29 +141,39 @@ AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
     return 0;
 }
 
-AST::UiQualifiedPragmaId *Parser::reparseAsQualifiedPragmaId(AST::ExpressionNode *expr)
+void Parser::pushToken(int token)
 {
-    if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(expr)) {
-        AST::UiQualifiedPragmaId *q = new (pool) AST::UiQualifiedPragmaId(idExpr->name);
-        q->identifierToken = idExpr->identifierToken;
+    last_token->token = yytoken;
+    last_token->dval = yylval;
+    last_token->spell = yytokenspell;
+    last_token->loc = yylloc;
+    ++last_token;
+    yytoken = token;
+}
 
-        return q->finish();
+int Parser::lookaheadToken(Lexer *lexer)
+{
+    if (yytoken < 0) {
+        yytoken = lexer->lex();
+        yylval = lexer->tokenValue();
+        yytokenspell = lexer->tokenSpell();
+        yylloc = location(lexer);
     }
-
-    return 0;
+    return yytoken;
 }
 
+//#define PARSER_DEBUG
 
 bool Parser::parse(int startToken)
 {
     Lexer *lexer = driver->lexer();
     bool hadErrors = false;
-    int yytoken = -1;
+    yytoken = -1;
     int action = 0;
 
     token_buffer[0].token = startToken;
     first_token = &token_buffer[0];
-    if (startToken == T_FEED_JS_PROGRAM && !lexer->qmlMode()) {
+    if (startToken == T_FEED_JS_SCRIPT && !lexer->qmlMode()) {
         Directives ignoreDirectives;
         Directives *directives = driver->directives();
         if (!directives)
@@ -197,10 +216,19 @@ bool Parser::parse(int startToken)
                 yytokenspell = first_token->spell;
                 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;
@@ -215,1667 +243,3097 @@ bool Parser::parse(int startToken)
           const int r = -action - 1;
           tos -= rhs[r];
 
+#ifdef PARSER_DEBUG
+          qDebug() << "        reducing through rule " << -action;
+#endif
+
           switch (r) {
 
-case 0: {
-  sym(1).Node = sym(2).Node;
-  program = sym(1).Node;
-} break;
+#line 665 "qmljs.g"
 
-case 1: {
-  sym(1).Node = sym(2).Node;
-  program = sym(1).Node;
-} break;
+    case 0: {
+        sym(1).Node = sym(2).Node;
+        program = sym(1).Node;
+    } break;
 
-case 2: {
-  sym(1).Node = sym(2).Node;
-  program = sym(1).Node;
-} break;
+#line 673 "qmljs.g"
 
-case 3: {
-  sym(1).Node = sym(2).Node;
-  program = sym(1).Node;
-} break;
+    case 1: {
+        sym(1).Node = sym(2).Node;
+        program = sym(1).Node;
+    } break;
 
-case 4: {
-  sym(1).Node = sym(2).Node;
-  program = sym(1).Node;
-} break;
+#line 681 "qmljs.g"
 
-case 5: {
-  sym(1).Node = sym(2).Node;
-  program = sym(1).Node;
-} break;
+    case 2: {
+        sym(1).Node = sym(2).Node;
+        program = sym(1).Node;
+    } break;
 
-case 6: {
-  sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiHeaderItemList,
-        sym(2).UiObjectMemberList->finish());
-} break;
+#line 689 "qmljs.g"
 
-case 8: {
-    sym(1).Node = sym(1).UiHeaderItemList->finish();
-} break;
+    case 3: {
+        sym(1).Node = sym(2).Node;
+        program = sym(1).Node;
+    } break;
 
-case 9: {
-    sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiPragma);
-} break;
+#line 697 "qmljs.g"
 
-case 10: {
-    sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiImport);
-} break;
+    case 4: {
+        sym(1).Node = sym(2).Node;
+        program = sym(1).Node;
+    } break;
 
-case 11: {
-    sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiPragma);
-} break;
+#line 705 "qmljs.g"
 
-case 12: {
-    sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiImport);
-} break;
+    case 5: {
+        sym(1).Node = sym(2).Node;
+        program = sym(1).Node;
+    } break;
 
-case 16: {
-    sym(1).UiPragma->semicolonToken = loc(2);
-} break;
+#line 714 "qmljs.g"
 
-case 18: {
-    sym(1).UiImport->semicolonToken = loc(2);
-} break;
+    case 6: {
+        sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiHeaderItemList, sym(2).UiObjectMemberList->finish());
+    } break;
 
-case 20: {
-    sym(1).UiImport->versionToken = loc(2);
-    sym(1).UiImport->semicolonToken = loc(3);
-} break;
+#line 722 "qmljs.g"
 
-case 22: {
-    sym(1).UiImport->versionToken = loc(2);
-    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;
+    case 8: {
+        sym(1).Node = sym(1).UiHeaderItemList->finish();
+    } break;
 
-case 24: {
-    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 729 "qmljs.g"
 
-case 25: {
-    AST::UiPragma *node = 0;
+    case 9: {
+        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiPragma);
+    } break;
 
-    if (AST::UiQualifiedPragmaId *qualifiedId = reparseAsQualifiedPragmaId(sym(2).Expression)) {
-        node = new (pool) AST::UiPragma(qualifiedId);
-    }
+#line 736 "qmljs.g"
 
-    sym(1).Node = node;
+    case 10: {
+        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiImport);
+    } break;
 
-    if (node) {
-        node->pragmaToken = loc(1);
-    } else {
-       diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1),
-         QLatin1String("Expected a qualified name id")));
+#line 743 "qmljs.g"
 
-        return false; // ### remove me
-    }
-} break;
+    case 11: {
+        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiPragma);
+    } break;
 
-case 26: {
-    AST::UiImport *node = 0;
+#line 750 "qmljs.g"
 
-    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);
-    }
+    case 12: {
+        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiImport);
+    } break;
 
-    sym(1).Node = node;
+#line 760 "qmljs.g"
 
-    if (node) {
-        node->importToken = loc(1);
-    } else {
-       diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1),
-         QLatin1String("Expected a qualified name id or a string literal")));
+    case 15: {
+        AST::UiPragma *pragma = new (pool) AST::UiPragma(stringRef(2));
+        pragma->pragmaToken = loc(1);
+        pragma->semicolonToken = loc(3);
+        sym(1).Node = pragma;
+    } break;
 
-        return false; // ### remove me
-    }
-} break;
+#line 773 "qmljs.g"
 
-case 27: {
-    sym(1).Node = 0;
-} break;
+    case 18: {
+        sym(1).UiImport->semicolonToken = loc(2);
+    } break;
 
-case 28: {
-    sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
-} break;
+#line 781 "qmljs.g"
 
-case 29: {
-    sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
-} break;
+    case 20: {
+        sym(1).UiImport->versionToken = loc(2);
+        sym(1).UiImport->semicolonToken = loc(3);
+    } break;
 
-case 30: {
-    AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(
-        sym(1).UiObjectMemberList, sym(2).UiObjectMember);
-    sym(1).Node = node;
-} break;
+#line 790 "qmljs.g"
 
-case 31: {
-    sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
-} break;
+    case 22: {
+        sym(1).UiImport->versionToken = loc(2);
+        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;
 
-case 32: {
-    AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(
-        sym(1).UiArrayMemberList, sym(3).UiObjectMember);
-    node->commaToken = loc(2);
-    sym(1).Node = node;
-} break;
+#line 802 "qmljs.g"
 
-case 33: {
-    AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
-    node->lbraceToken = loc(1);
-    node->rbraceToken = loc(2);
-    sym(1).Node = node;
-}   break;
+    case 24: {
+        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;
 
-case 34: {
-    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 812 "qmljs.g"
 
-case 35: {
-    AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId,
-        sym(2).UiObjectInitializer);
-    sym(1).Node = node;
-}   break;
+    case 25: {
+        AST::UiImport *node = 0;
 
-case 37: {
-    AST::UiArrayBinding *node = new (pool) AST::UiArrayBinding(
-        sym(1).UiQualifiedId, sym(4).UiArrayMemberList->finish());
-    node->colonToken = loc(2);
-    node->lbracketToken = loc(3);
-    node->rbracketToken = loc(5);
-    sym(1).Node = node;
-}   break;
+        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);
+        }
 
-case 38: {
-    AST::UiObjectBinding *node = new (pool) AST::UiObjectBinding(
-      sym(1).UiQualifiedId, sym(3).UiQualifiedId, sym(4).UiObjectInitializer);
-    node->colonToken = loc(2);
-    sym(1).Node = node;
-} break;
+        sym(1).Node = node;
 
-case 39: {
-    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;
+        if (node) {
+            node->importToken = loc(1);
+        } else {
+           diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1),
+             QLatin1String("Expected a qualified name id or a string literal")));
+
+            return false; // ### remove me
+        }
+    } break;
 
-case 47:
+#line 838 "qmljs.g"
+
+    case 26: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 845 "qmljs.g"
+
+    case 27: {
+        sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
+    } break;
+
+#line 852 "qmljs.g"
+
+    case 28: {
+        sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
+    } break;
+
+#line 859 "qmljs.g"
+
+    case 29: {
+        AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(sym(1).UiObjectMemberList, sym(2).UiObjectMember);
+        sym(1).Node = node;
+    } break;
+
+#line 867 "qmljs.g"
+
+    case 30: {
+        sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
+    } break;
+
+#line 874 "qmljs.g"
+
+    case 31: {
+        AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(sym(1).UiArrayMemberList, sym(3).UiObjectMember);
+        node->commaToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 883 "qmljs.g"
+
+    case 32: {
+        AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
+        node->lbraceToken = loc(1);
+        node->rbraceToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 893 "qmljs.g"
+
+    case 33: {
+        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 903 "qmljs.g"
+
+    case 34: {
+        AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId, sym(2).UiObjectInitializer);
+        sym(1).Node = node;
+    } break;
+
+#line 913 "qmljs.g"
+
+    case 36: {
+        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 924 "qmljs.g"
+
+    case 37: {
+        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 934 "qmljs.g"
+
+    case 38: {
+        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 946 "qmljs.g"
+  case 39: Q_FALLTHROUGH();
+#line 948 "qmljs.g"
+
+    case 40: {
+        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);
+        sym(1).Node = node;
+    } break;
+
+#line 960 "qmljs.g"
+  case 41: Q_FALLTHROUGH();
+#line 962 "qmljs.g"
+  case 42: Q_FALLTHROUGH();
+#line 964 "qmljs.g"
+
+    case 43: {
+        sym(1).Node = sym(3).Node;
+    } break;
+
+#line 972 "qmljs.g"
+  case 44: Q_FALLTHROUGH();
+#line 974 "qmljs.g"
+  case 45: Q_FALLTHROUGH();
+#line 976 "qmljs.g"
+  case 46: Q_FALLTHROUGH();
+#line 978 "qmljs.g"
+  case 47: Q_FALLTHROUGH();
+#line 980 "qmljs.g"
+  case 48: Q_FALLTHROUGH();
+#line 982 "qmljs.g"
+
+    case 49: {
+        sym(1).Node = sym(2).Node;
+    } break;
+
+#line 989 "qmljs.g"
+
+case 50:
 {
-    AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(
-        sym(1).UiQualifiedId, sym(3).Statement);
+    AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(sym(1).UiQualifiedId, sym(3).Statement);
     node->colonToken = loc(2);
     sym(1).Node = node;
-}   break;
+    } break;
+
+#line 999 "qmljs.g"
+  case 51: Q_FALLTHROUGH();
+#line 1001 "qmljs.g"
+  case 52: Q_FALLTHROUGH();
+#line 1003 "qmljs.g"
+
+    case 53: {
+        AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(stringRef(1));
+        node->identifierToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1012 "qmljs.g"
+
+    case 54: {
+        AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(sym(1).UiQualifiedId, stringRef(3));
+        node->identifierToken = loc(3);
+        sym(1).Node = node;
+    } break;
+
+#line 1021 "qmljs.g"
+
+    case 55: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 1028 "qmljs.g"
+
+    case 56: {
+        sym(1).Node = sym(1).UiParameterList->finish();
+    } break;
+
+#line 1035 "qmljs.g"
+
+    case 57: {
+        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 1045 "qmljs.g"
+
+    case 58: {
+        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 1057 "qmljs.g"
+
+    case 60: {
+        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 1072 "qmljs.g"
+
+    case 62: {
+        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 1086 "qmljs.g"
+
+    case 64: {
+        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 1101 "qmljs.g"
+
+    case 66: {
+        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 1114 "qmljs.g"
+
+    case 68: {
+        AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4));
+        node->isDefaultMember = true;
+        node->defaultToken = loc(1);
+        node->propertyToken = loc(2);
+        node->typeToken = loc(3);
+        node->identifierToken = loc(4);
+        node->semicolonToken = loc(5);
+        sym(1).Node = node;
+    } break;
+
+#line 1129 "qmljs.g"
+
+    case 70: {
+        AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(5).UiQualifiedId->finish(), stringRef(7));
+        node->isDefaultMember = true;
+        node->defaultToken = loc(1);
+        node->typeModifier = stringRef(3);
+        node->propertyToken = loc(2);
+        node->typeModifierToken = loc(2);
+        node->typeToken = loc(4);
+        node->identifierToken = loc(7);
+        node->semicolonToken = loc(8);
+        sym(1).Node = node;
+    } break;
+
+#line 1145 "qmljs.g"
+
+    case 71: {
+        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 1157 "qmljs.g"
+
+    case 72: {
+        AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4), sym(6).Statement);
+        node->isReadonlyMember = true;
+        node->readonlyToken = loc(1);
+        node->propertyToken = loc(2);
+        node->typeToken = loc(3);
+        node->identifierToken = loc(4);
+        node->colonToken = loc(5);
+        sym(1).Node = node;
+    } break;
+
+#line 1171 "qmljs.g"
+
+    case 73: {
+        AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4), sym(6).Statement);
+        node->isDefaultMember = true;
+        node->defaultToken = loc(1);
+        node->propertyToken = loc(2);
+        node->typeToken = loc(3);
+        node->identifierToken = loc(4);
+        node->colonToken = loc(5);
+        sym(1).Node = node;
+    } break;
+
+#line 1185 "qmljs.g"
+
+    case 74: {
+        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 1211 "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); // 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 1234 "qmljs.g"
+
+    case 76: {
+        AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4));
+        node->isReadonlyMember = true;
+        node->readonlyToken = loc(1);
+        node->propertyToken = loc(2);
+        node->typeToken = loc(3);
+        node->identifierToken = loc(4);
+        node->semicolonToken = loc(5); // insert a fake ';' before ':'
+
+        AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(4));
+        propertyName->identifierToken = loc(4);
+        propertyName->next = 0;
+
+        AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
+          propertyName, sym(7).UiQualifiedId, sym(8).UiObjectInitializer);
+        binding->colonToken = loc(5);
+
+        node->binding = binding;
+
+        sym(1).Node = node;
+    } break;
+
+#line 1259 "qmljs.g"
+
+    case 77: {
+        sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
+    } break;
+
+#line 1266 "qmljs.g"
+
+    case 78: {
+        sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
+    } break;
 
-case 48: {
-  AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(stringRef(1));
-  node->identifierToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 1273 "qmljs.g"
 
-case 49: {
-  AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(stringRef(1));
-  node->identifierToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 79: {
+      if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
+        diagnostic_messages.append(DiagnosticMessage(Severity::Warning, mem->lbracketToken,
+          QLatin1String("Ignored annotation")));
+
+        sym(1).Expression = mem->base;
+      }
 
-case 50: {
-  AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(stringRef(1));
-  node->identifierToken = loc(1);
-  sym(1).Node = node;
-} break;
+      if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
+        sym(1).UiQualifiedId = qualifiedId;
+      } else {
+        sym(1).UiQualifiedId = 0;
 
-case 51: {
-  AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(sym(1).UiQualifiedId, stringRef(3));
-  node->identifierToken = loc(3);
-  sym(1).Node = node;
-} break;
+        diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1),
+          QLatin1String("Expected a qualified name id")));
 
-case 52: {
-  sym(1).Node = 0;
-} break;
+        return false; // ### recover
+      }
+    } break;
 
-case 53: {
-  sym(1).Node = sym(1).UiParameterList->finish ();
-} break;
+#line 1296 "qmljs.g"
 
-case 54: {
-  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;
+    case 80: {
+        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;
+    }
 
-case 55: {
-  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 1307 "qmljs.g"
 
-case 57: {
-    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;
-
-case 59: {
-    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;
-
-case 61: {
-    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;
-
-case 63: {
-    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;
-
-case 65: {
-    AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4));
-    node->isDefaultMember = true;
-    node->defaultToken = loc(1);
-    node->propertyToken = loc(2);
-    node->typeToken = loc(3);
-    node->identifierToken = loc(4);
-    node->semicolonToken = loc(5);
-    sym(1).Node = node;
-}   break;
-
-case 67: {
-    AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(5).UiQualifiedId->finish(), stringRef(7));
-    node->isDefaultMember = true;
-    node->defaultToken = loc(1);
-    node->typeModifier = stringRef(3);
-    node->propertyToken = loc(2);
-    node->typeModifierToken = loc(2);
-    node->typeToken = loc(4);
-    node->identifierToken = loc(7);
-    node->semicolonToken = loc(8);
-    sym(1).Node = node;
-}   break;
-
-case 68: {
-    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;
-
-case 69: {
-    AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4),
-        sym(6).Statement);
-    node->isReadonlyMember = true;
-    node->readonlyToken = loc(1);
-    node->propertyToken = loc(2);
-    node->typeToken = loc(3);
-    node->identifierToken = loc(4);
-    node->colonToken = loc(5);
-    sym(1).Node = node;
-}   break;
-
-case 70: {
-    AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4),
-        sym(6).Statement);
-    node->isDefaultMember = true;
-    node->defaultToken = loc(1);
-    node->propertyToken = loc(2);
-    node->typeToken = loc(3);
-    node->identifierToken = loc(4);
-    node->colonToken = loc(5);
-    sym(1).Node = node;
-}   break;
+    case 81: {
+        AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(stringRef(1));
+        node->memberToken = loc(1);
+        sym(1).Node = node;
+        break;
+    }
 
-case 71: {
-    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 ':'
+#line 1317 "qmljs.g"
 
-    AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(6));
-    propertyName->identifierToken = loc(6);
-    propertyName->next = 0;
+    case 82: {
+        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;
+    }
 
-    AST::UiArrayBinding *binding = new (pool) AST::UiArrayBinding(
-        propertyName, sym(9).UiArrayMemberList->finish());
-    binding->colonToken = loc(7);
-    binding->lbracketToken = loc(8);
-    binding->rbracketToken = loc(10);
+#line 1328 "qmljs.g"
 
-    node->binding = binding;
+    case 83: {
+        AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(sym(1).UiEnumMemberList, stringRef(3));
+        node->memberToken = loc(3);
+        sym(1).Node = node;
+        break;
+    }
 
-    sym(1).Node = node;
-}   break;
+#line 1338 "qmljs.g"
 
-case 72: {
-    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 ':'
+    case 84: {
+        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;
+    }
 
-    AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(3));
-    propertyName->identifierToken = loc(3);
-    propertyName->next = 0;
+#line 1378 "qmljs.g"
 
-    AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
-      propertyName, sym(5).UiQualifiedId, sym(6).UiObjectInitializer);
-    binding->colonToken = loc(4);
+    case 107: {
+        AST::ThisExpression *node = new (pool) AST::ThisExpression();
+        node->thisToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-    node->binding = binding;
+#line 1387 "qmljs.g"
 
-    sym(1).Node = node;
-}   break;
+    case 108: {
+        AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
+        node->identifierToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 73: {
-    AST::UiPublicMember *node = new (pool) AST::UiPublicMember(sym(3).UiQualifiedId->finish(), stringRef(4));
-    node->isReadonlyMember = true;
-    node->readonlyToken = loc(1);
-    node->propertyToken = loc(2);
-    node->typeToken = loc(3);
-    node->identifierToken = loc(4);
-    node->semicolonToken = loc(5); // insert a fake ';' before ':'
+#line 1405 "qmljs.g"
 
-    AST::UiQualifiedId *propertyName = new (pool) AST::UiQualifiedId(stringRef(4));
-    propertyName->identifierToken = loc(4);
-    propertyName->next = 0;
+    case 117: {
+        if (coverExpressionType != CE_ParenthesizedExpression) {
+            syntaxError(coverExpressionErrorLocation, "Expected token ')'.");
+            return false;
+        }
+    } break;
 
-    AST::UiObjectBinding *binding = new (pool) AST::UiObjectBinding(
-      propertyName, sym(6).UiQualifiedId, sym(7).UiObjectInitializer);
-    binding->colonToken = loc(5);
+#line 1416 "qmljs.g"
 
-    node->binding = binding;
+    case 118: {
+        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;
 
-    sym(1).Node = node;
-}   break;
-
-case 74: {
-    sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
-}   break;
-
-case 75: {
-    sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
-}   break;
-
-case 76: {
-    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 1427 "qmljs.g"
 
-case 77: {
-    AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(stringRef(1));
-    node->memberToken = loc(1);
-    sym(1).Node = node;
-    break;
-}
+    case 119: {
+        sym(1).Node = nullptr;
+        coverExpressionErrorLocation = loc(2);
+        coverExpressionType = CE_FormalParameterList;
+    } break;
 
-case 78: {
-    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 1436 "qmljs.g"
 
-case 79: {
-    AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(sym(1).UiEnumMemberList, stringRef(3));
-    node->memberToken = loc(3);
-    sym(1).Node = node;
-    break;
-}
+    case 120: {
+        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(2).PatternElement))->finish(pool);
+        sym(1).Node = node;
+        coverExpressionErrorLocation = loc(2);
+        coverExpressionType = CE_FormalParameterList;
+    } break;
 
-case 80: {
-    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 1446 "qmljs.g"
+
+    case 121: {
+        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 1463 "qmljs.g"
+
+    case 122: {
+        AST::NullExpression *node = new (pool) AST::NullExpression();
+        node->nullToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1472 "qmljs.g"
+
+    case 123: {
+        AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
+        node->trueToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1481 "qmljs.g"
+
+    case 124: {
+        AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
+        node->falseToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1490 "qmljs.g"
+
+    case 125: {
+        AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
+        node->literalToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1499 "qmljs.g"
+  case 126: Q_FALLTHROUGH();
+#line 1502 "qmljs.g"
+
+    case 127: {
+        AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
+        node->literalToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1514 "qmljs.g"
+
+{
+    Lexer::RegExpBodyPrefix prefix;
+    case 128:
+        prefix = Lexer::NoPrefix;
+        goto scan_regexp;
+
+#line 1526 "qmljs.g"
+
+    case 129:
+        prefix = Lexer::EqualPrefix;
+        goto scan_regexp;
+
+    scan_regexp: {
+        bool rx = lexer->scanRegExp(prefix);
+        if (!rx) {
+            diagnostic_messages.append(DiagnosticMessage(Severity::Error, 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;
 }
 
-case 88: {
-  AST::ThisExpression *node = new (pool) AST::ThisExpression();
-  node->thisToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 1550 "qmljs.g"
+
+    case 130: {
+        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 1563 "qmljs.g"
+
+    case 131: {
+        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 1573 "qmljs.g"
+
+    case 132: {
+        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;
 
-case 89: {
-  AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
-  node->identifierToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 1590 "qmljs.g"
 
-case 90: {
-  AST::NullExpression *node = new (pool) AST::NullExpression();
-  node->nullToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 133: {
+        AST::PatternElement *e = new (pool) AST::PatternElement(sym(1).Expression);
+        sym(1).Node = new (pool) AST::PatternElementList(nullptr, e);
+    } break;
 
-case 91: {
-  AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
-  node->trueToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 1598 "qmljs.g"
 
-case 92: {
-  AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
-  node->falseToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 134: {
+        AST::PatternElement *e = new (pool) AST::PatternElement(sym(2).Expression);
+        sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision->finish(), e);
+    } break;
 
-case 93: {
-  AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
-  node->literalToken = loc(1);
-  sym(1).Node = node;
-} break;
-case 94:
-case 95: {
-  AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
-  node->literalToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 1606 "qmljs.g"
 
-case 96: {
-  bool rx = lexer->scanRegExp(Lexer::NoPrefix);
-  if (!rx) {
-    diagnostic_messages.append(DiagnosticMessage(Severity::Error, location(lexer), lexer->errorMessage()));
-    return false; // ### remove me
-  }
+    case 135: {
+        AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement);
+        sym(1).Node = node;
+    } break;
 
-  loc(1).length = lexer->tokenLength();
-  yylloc = loc(1); // adjust the location of the current token
+#line 1614 "qmljs.g"
 
-  AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
-    driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
-  node->literalToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 136: {
+        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;
 
-case 97: {
-  bool rx = lexer->scanRegExp(Lexer::EqualPrefix);
-  if (!rx) {
-    diagnostic_messages.append(DiagnosticMessage(Severity::Error, location(lexer), lexer->errorMessage()));
-    return false;
-  }
+#line 1623 "qmljs.g"
 
-  loc(1).length = lexer->tokenLength();
-  yylloc = loc(1); // adjust the location of the current token
+    case 137: {
+        AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(3).Elision, sym(4).PatternElement);
+        sym(1).Node = sym(1).PatternElementList->append(node);
+    } break;
+
+#line 1631 "qmljs.g"
+
+    case 138: {
+        AST::Elision *node = new (pool) AST::Elision();
+        node->commaToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1640 "qmljs.g"
+
+    case 139: {
+        AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
+        node->commaToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 1649 "qmljs.g"
+
+    case 140: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 1656 "qmljs.g"
+
+    case 141: {
+        sym(1).Node = sym(1).Elision->finish();
+    } break;
+
+#line 1663 "qmljs.g"
+
+    case 142: {
+        AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Expression, AST::PatternElement::SpreadElement);
+        sym(1).Node = node;
+    } break;
+
+#line 1671 "qmljs.g"
+
+    case 143: {
+        AST::ObjectPattern *node = new (pool) AST::ObjectPattern();
+        node->lbraceToken = loc(1);
+        node->rbraceToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 1681 "qmljs.g"
+
+    case 144: {
+        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 1691 "qmljs.g"
+
+    case 145: {
+        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 1702 "qmljs.g"
+  case 146: Q_FALLTHROUGH();
+#line 1704 "qmljs.g"
+
+    case 147: {
+      sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty);
+    } break;
+
+#line 1711 "qmljs.g"
+  case 148: Q_FALLTHROUGH();
+#line 1713 "qmljs.g"
+
+    case 149: {
+        AST::PatternPropertyList *node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty);
+        sym(1).Node = node;
+    } break;
+
+#line 1721 "qmljs.g"
+
+    case 150: {
+        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 1737 "qmljs.g"
+
+    case 152: {
+        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 1757 "qmljs.g"
+  case 153: Q_FALLTHROUGH();
+#line 1759 "qmljs.g"
+
+    case 154: {
+        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Expression);
+        if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) {
+            if (!AST::cast<AST::ComputedPropertyName *>(sym(1).PropertyName))
+                f->name = driver->newStringRef(sym(1).PropertyName->asString());
+        }
+        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 1781 "qmljs.g"
+
+    case 158: {
+        AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
+        node->propertyNameToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1790 "qmljs.g"
+  case 159: Q_FALLTHROUGH();
+#line 1792 "qmljs.g"
+
+    case 160: {
+        AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
+        node->propertyNameToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1801 "qmljs.g"
+  case 161: Q_FALLTHROUGH();
+#line 1803 "qmljs.g"
+
+    case 162: {
+        AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
+        node->propertyNameToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1854 "qmljs.g"
+
+    case 203: {
+        AST::ComputedPropertyName *node = new (pool) AST::ComputedPropertyName(sym(2).Expression);
+        node->propertyNameToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1863 "qmljs.g"
+  case 204: Q_FALLTHROUGH();
+#line 1865 "qmljs.g"
+
+case 205: {
+    sym(1) = sym(2);
+} break;
+
+#line 1873 "qmljs.g"
+  case 206: Q_FALLTHROUGH();
+#line 1875 "qmljs.g"
+
+    case 207: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 1885 "qmljs.g"
+  case 210: Q_FALLTHROUGH();
+#line 1888 "qmljs.g"
+
+    case 211: {
+        AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), nullptr);
+        node->literalToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1897 "qmljs.g"
+  case 212: Q_FALLTHROUGH();
+#line 1900 "qmljs.g"
+
+    case 213: {
+        AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), sym(2).Expression);
+        node->next = sym(3).Template;
+        node->literalToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1913 "qmljs.g"
+
+    case 215: {
+        AST::SuperLiteral *node = new (pool) AST::SuperLiteral();
+        node->superToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1923 "qmljs.g"
+  case 216: Q_FALLTHROUGH();
+#line 1925 "qmljs.g"
+
+    case 217: {
+        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 1937 "qmljs.g"
+  case 218:
+    {
+        AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
+        node->identifierToken= loc(1);
+        sym(1).Node = node;
+    } Q_FALLTHROUGH();
+
+#line 1945 "qmljs.g"
+  case 219: Q_FALLTHROUGH();
+#line 1947 "qmljs.g"
+
+    case 220: {
+        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 1959 "qmljs.g"
+
+    case 222: {
+        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 1975 "qmljs.g"
+
+    case 225: {
+        AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
+        node->newToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 1985 "qmljs.g"
+  case 226: Q_FALLTHROUGH();
+#line 1987 "qmljs.g"
+
+    case 227: {
+        AST::TaggedTemplate *node = new (pool) AST::TaggedTemplate(sym(1).Expression, sym(2).Template);
+        sym(1).Node = node;
+    } break;
+
+#line 1995 "qmljs.g"
+
+    case 228: {
+        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 2005 "qmljs.g"
+  case 229: Q_FALLTHROUGH();
+#line 2007 "qmljs.g"
+
+    case 230: {
+        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 2017 "qmljs.g"
+
+    case 231: {
+        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 2027 "qmljs.g"
+
+    case 232: {
+        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 2037 "qmljs.g"
+
+    case 233: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 2044 "qmljs.g"
+  case 234: Q_FALLTHROUGH();
+#line 2046 "qmljs.g"
+
+    case 235: {
+        sym(1).Node = sym(1).ArgumentList->finish();
+    } break;
+
+#line 2053 "qmljs.g"
+
+    case 236: {
+        sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
+    } break;
+
+#line 2060 "qmljs.g"
+
+    case 237: {
+        AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(2).Expression);
+        node->isSpreadElement = true;
+        sym(1).Node = node;
+    } break;
+
+#line 2069 "qmljs.g"
+
+    case 238: {
+        AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
+        node->commaToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 2078 "qmljs.g"
+
+    case 239: {
+        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;
 
-  AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(
-    driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
-  node->literalToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2093 "qmljs.g"
+
+    case 243: {
+        AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
+        node->incrementToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 98: {
-  AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral((AST::Elision *) 0);
-  node->lbracketToken = loc(1);
-  node->rbracketToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2102 "qmljs.g"
 
-case 99: {
-  AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).Elision->finish());
-  node->lbracketToken = loc(1);
-  node->rbracketToken = loc(3);
-  sym(1).Node = node;
-} break;
+    case 244: {
+        AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
+        node->decrementToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 100: {
-  AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish ());
-  node->lbracketToken = loc(1);
-  node->rbracketToken = loc(3);
-  sym(1).Node = node;
-} break;
+#line 2111 "qmljs.g"
 
-case 101: {
-  AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
-    (AST::Elision *) 0);
-  node->lbracketToken = loc(1);
-  node->commaToken = loc(3);
-  node->rbracketToken = loc(4);
-  sym(1).Node = node;
-} break;
+    case 245: {
+        AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
+        node->incrementToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 102: {
-  AST::ArrayLiteral *node = new (pool) AST::ArrayLiteral(sym(2).ElementList->finish (),
-    sym(4).Elision->finish());
-  node->lbracketToken = loc(1);
-  node->commaToken = loc(3);
-  node->rbracketToken = loc(5);
-  sym(1).Node = node;
-} break;
+#line 2120 "qmljs.g"
 
-case 103: {
-  AST::ObjectLiteral *node = 0;
-  if (sym(2).Node)
-    node = new (pool) AST::ObjectLiteral(
-        sym(2).PropertyAssignmentList->finish ());
-  else
-    node = new (pool) AST::ObjectLiteral();
-  node->lbraceToken = loc(1);
-  node->rbraceToken = loc(3);
-  sym(1).Node = node;
-} break;
+    case 246: {
+        AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
+        node->decrementToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 104: {
-  AST::ObjectLiteral *node = new (pool) AST::ObjectLiteral(
-    sym(2).PropertyAssignmentList->finish ());
-  node->lbraceToken = loc(1);
-  node->rbraceToken = loc(4);
-  sym(1).Node = node;
-} break;
+#line 2131 "qmljs.g"
 
-case 105: {
-  AST::NestedExpression *node = new (pool) AST::NestedExpression(sym(2).Expression);
-  node->lparenToken = loc(1);
-  node->rparenToken = loc(3);
-  sym(1).Node = node;
-} break;
+    case 248: {
+        AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
+        node->deleteToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 106: {
-  if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
-    diagnostic_messages.append(DiagnosticMessage(Severity::Warning, mem->lbracketToken,
-      QLatin1String("Ignored annotation")));
+#line 2140 "qmljs.g"
 
-    sym(1).Expression = mem->base;
-  }
+    case 249: {
+        AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
+        node->voidToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-  if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
-    sym(1).UiQualifiedId = qualifiedId;
-  } else {
-    sym(1).UiQualifiedId = 0;
+#line 2149 "qmljs.g"
 
-    diagnostic_messages.append(DiagnosticMessage(Severity::Error, loc(1),
-      QLatin1String("Expected a qualified name id")));
+    case 250: {
+        AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
+        node->typeofToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-    return false; // ### recover
-  }
-} break;
+#line 2158 "qmljs.g"
 
-case 107: {
-  sym(1).Node = new (pool) AST::ElementList((AST::Elision *) 0, sym(1).Expression);
-} break;
+    case 251: {
+        AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
+        node->plusToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 108: {
-  sym(1).Node = new (pool) AST::ElementList(sym(1).Elision->finish(), sym(2).Expression);
-} break;
+#line 2167 "qmljs.g"
 
-case 109: {
-  AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList,
-    (AST::Elision *) 0, sym(3).Expression);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 252: {
+        AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
+        node->minusToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 110: {
-  AST::ElementList *node = new (pool) AST::ElementList(sym(1).ElementList, sym(3).Elision->finish(),
-    sym(4).Expression);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2176 "qmljs.g"
 
-case 111: {
-  AST::Elision *node = new (pool) AST::Elision();
-  node->commaToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 253: {
+        AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
+        node->tildeToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 112: {
-  AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2185 "qmljs.g"
 
-case 113: {
-  AST::PropertyNameAndValue *node = new (pool) AST::PropertyNameAndValue(
-      sym(1).PropertyName, sym(3).Expression);
-  node->colonToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 254: {
+        AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
+        node->notToken = loc(1);
+        sym(1).Node = node;
+    } break;
 
-case 114: {
-  AST::PropertyGetterSetter *node = new (pool) AST::PropertyGetterSetter(
-      sym(2).PropertyName, sym(6).FunctionBody);
-  node->getSetToken = loc(1);
-  node->lparenToken = loc(3);
-  node->rparenToken = loc(4);
-  node->lbraceToken = loc(5);
-  node->rbraceToken = loc(7);
-  sym(1).Node = node;
-} break;
+#line 2196 "qmljs.g"
 
-case 115: {
-  AST::PropertyGetterSetter *node = new (pool) AST::PropertyGetterSetter(
-      sym(2).PropertyName, sym(4).FormalParameterList, sym(7).FunctionBody);
-  node->getSetToken = loc(1);
-  node->lparenToken = loc(3);
-  node->rparenToken = loc(5);
-  node->lbraceToken = loc(6);
-  node->rbraceToken = loc(8);
-  sym(1).Node = node;
-} break;
+    case 256: {
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Exp, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 116: {
-  sym(1).Node = new (pool) AST::PropertyAssignmentList(sym(1).PropertyAssignment);
-} break;
+#line 2207 "qmljs.g"
 
-case 117: {
-  AST::PropertyAssignmentList *node = new (pool) AST::PropertyAssignmentList(
-    sym(1).PropertyAssignmentList, sym(3).PropertyAssignment);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 258: {
+        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;
 
-case 118: {
-  AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
-  node->propertyNameToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2216 "qmljs.g"
 
-case 119: {
-  AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
-  node->propertyNameToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 259: {
+        sym(1).ival = QSOperator::Mul;
+    } break;
 
-case 120: {
-  AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
-  node->propertyNameToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2223 "qmljs.g"
 
-case 121: {
-  AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
-  node->propertyNameToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 260: {
+        sym(1).ival = QSOperator::Div;
+    } break;
 
-case 159: {
-  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 2230 "qmljs.g"
 
-case 160: {
-  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;
+    case 261: {
+        sym(1).ival = QSOperator::Mod;
+    } break;
 
-case 161: {
-  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 2239 "qmljs.g"
 
-case 163: {
-  AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
-  node->newToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 263: {
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Add, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 164: {
-  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 2248 "qmljs.g"
 
-case 165: {
-  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;
+    case 264: {
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Sub, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 166: {
-  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 2259 "qmljs.g"
 
-case 167: {
-  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;
+    case 266: {
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::LShift, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 168: {
-  sym(1).Node = 0;
-} break;
+#line 2268 "qmljs.g"
 
-case 169: {
-  sym(1).Node = sym(1).ArgumentList->finish();
-} break;
+    case 267: {
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::RShift, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 170: {
-  sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
-} break;
+#line 2277 "qmljs.g"
 
-case 171: {
-  AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 268: {
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::URShift, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 175: {
-  AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
-  node->incrementToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2289 "qmljs.g"
+  case 271: Q_FALLTHROUGH();
+#line 2291 "qmljs.g"
 
-case 176: {
-  AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
-  node->decrementToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 272: {
+        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;
 
-case 178: {
-  AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
-  node->deleteToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2300 "qmljs.g"
 
-case 179: {
-  AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
-  node->voidToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 273: {
+        sym(1).ival = QSOperator::Lt;
+    } break;
 
-case 180: {
-  AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
-  node->typeofToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2306 "qmljs.g"
 
-case 181: {
-  AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
-  node->incrementToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 274: {
+        sym(1).ival = QSOperator::Gt;
+    } break;
 
-case 182: {
-  AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
-  node->decrementToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2312 "qmljs.g"
 
-case 183: {
-  AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
-  node->plusToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 275: {
+        sym(1).ival = QSOperator::Le;
+    } break;
 
-case 184: {
-  AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
-  node->minusToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2318 "qmljs.g"
 
-case 185: {
-  AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
-  node->tildeToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 276: {
+        sym(1).ival = QSOperator::Ge;
+    } break;
 
-case 186: {
-  AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
-  node->notToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 2324 "qmljs.g"
 
-case 188: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Mul, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 277: {
+        sym(1).ival = QSOperator::InstanceOf;
+    } break;
 
-case 189: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Div, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2331 "qmljs.g"
 
-case 190: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Mod, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 278: {
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::In, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 192: {
-  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 2343 "qmljs.g"
+  case 281: Q_FALLTHROUGH();
+#line 2345 "qmljs.g"
 
-case 193: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Sub, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 282: {
+        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 2354 "qmljs.g"
+
+    case 283: {
+        sym(1).ival = QSOperator::Equal;
+    } break;
+
+#line 2360 "qmljs.g"
+
+    case 284: {
+        sym(1).ival = QSOperator::NotEqual;
+    } break;
+
+#line 2366 "qmljs.g"
+
+    case 285: {
+        sym(1).ival = QSOperator::StrictEqual;
+    } break;
+
+#line 2372 "qmljs.g"
+
+    case 286: {
+        sym(1).ival = QSOperator::StrictNotEqual;
+    } break;
+
+#line 2383 "qmljs.g"
+  case 289: Q_FALLTHROUGH();
+#line 2385 "qmljs.g"
+
+    case 290: {
+        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 2398 "qmljs.g"
+  case 293: Q_FALLTHROUGH();
+#line 2400 "qmljs.g"
+
+    case 294: {
+        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 2412 "qmljs.g"
+  case 297: Q_FALLTHROUGH();
+#line 2414 "qmljs.g"
+
+    case 298: {
+        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 2426 "qmljs.g"
+  case 301: Q_FALLTHROUGH();
+#line 2428 "qmljs.g"
+
+    case 302: {
+        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 2440 "qmljs.g"
+  case 305: Q_FALLTHROUGH();
+#line 2442 "qmljs.g"
+
+    case 306: {
+        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 2455 "qmljs.g"
+  case 309: Q_FALLTHROUGH();
+#line 2457 "qmljs.g"
+
+    case 310: {
+        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 2476 "qmljs.g"
+  case 317: Q_FALLTHROUGH();
+#line 2478 "qmljs.g"
+
+    case 318: {
+        // need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral
+        if (AST::Pattern *p = sym(1).Expression->patternCast()) {
+            AST::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;
+        }
 
-case 195: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::LShift, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Assign, sym(3).Expression);
+        node->operatorToken = loc(2);
+        sym(1).Node = node;
+    } break;
 
-case 196: {
-  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 2506 "qmljs.g"
+  case 319: Q_FALLTHROUGH();
+#line 2508 "qmljs.g"
 
-case 197: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::URShift, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 320: {
+        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;
 
-case 199: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Lt, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2517 "qmljs.g"
 
-case 200: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Gt, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 321: {
+        sym(1).ival = QSOperator::InplaceMul;
+    } break;
 
-case 201: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Le, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2524 "qmljs.g"
 
-case 202: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Ge, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 322: {
+        sym(1).ival = QSOperator::InplaceExp;
+    } break;
 
-case 203: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::InstanceOf, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2531 "qmljs.g"
 
-case 204: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::In, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 323: {
+        sym(1).ival = QSOperator::InplaceDiv;
+    } break;
 
-case 206: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Lt, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2538 "qmljs.g"
 
-case 207: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Gt, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 324: {
+        sym(1).ival = QSOperator::InplaceMod;
+    } break;
 
-case 208: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Le, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2545 "qmljs.g"
 
-case 209: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-   QSOperator::Ge, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 325: {
+        sym(1).ival = QSOperator::InplaceAdd;
+    } break;
 
-case 210: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::InstanceOf, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2552 "qmljs.g"
 
-case 212: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Equal, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 326: {
+        sym(1).ival = QSOperator::InplaceSub;
+    } break;
 
-case 213: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::NotEqual, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2559 "qmljs.g"
 
-case 214: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::StrictEqual, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 327: {
+        sym(1).ival = QSOperator::InplaceLeftShift;
+    } break;
 
-case 215: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::StrictNotEqual, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2566 "qmljs.g"
 
-case 217: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Equal, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 328: {
+        sym(1).ival = QSOperator::InplaceRightShift;
+    } break;
 
-case 218: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::NotEqual, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2573 "qmljs.g"
 
-case 219: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::StrictEqual, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 329: {
+        sym(1).ival = QSOperator::InplaceURightShift;
+    } break;
 
-case 220: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::StrictNotEqual, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 2580 "qmljs.g"
 
-case 222: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::BitAnd, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 330: {
+        sym(1).ival = QSOperator::InplaceAnd;
+    } break;
 
-case 224: {
-  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 2587 "qmljs.g"
 
-case 226: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::BitXor, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 331: {
+        sym(1).ival = QSOperator::InplaceXor;
+    } break;
 
-case 228: {
-  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 2594 "qmljs.g"
 
-case 230: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::BitOr, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 332: {
+        sym(1).ival = QSOperator::InplaceOr;
+    } break;
 
-case 232: {
-  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 2604 "qmljs.g"
+  case 335: Q_FALLTHROUGH();
+#line 2606 "qmljs.g"
 
-case 234: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::And, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 336: {
+          AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
+          node->commaToken = loc(2);
+          sym(1).Node = node;
+    } break;
 
-case 236: {
-  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 2615 "qmljs.g"
+  case 337: Q_FALLTHROUGH();
+#line 2617 "qmljs.g"
 
-case 238: {
-  AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression,
-    QSOperator::Or, sym(3).Expression);
-  node->operatorToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 338: {
+      sym(1).Node = nullptr;
+    } break;
 
-case 240: {
-  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 2629 "qmljs.g"
 
-case 242: {
-  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;
+    case 341: {
+        sym(1).Node = sym(3).Node;
+    } break;
 
-case 244: {
-  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 2636 "qmljs.g"
+  case 342: Q_FALLTHROUGH();
+#line 2638 "qmljs.g"
+  case 343: Q_FALLTHROUGH();
+#line 2640 "qmljs.g"
+  case 344: Q_FALLTHROUGH();
+#line 2642 "qmljs.g"
+  case 345: Q_FALLTHROUGH();
+#line 2644 "qmljs.g"
+  case 346: Q_FALLTHROUGH();
+#line 2646 "qmljs.g"
+  case 347: Q_FALLTHROUGH();
+#line 2648 "qmljs.g"
+  case 348: Q_FALLTHROUGH();
+#line 2650 "qmljs.g"
+  case 349: Q_FALLTHROUGH();
+#line 2652 "qmljs.g"
+  case 350: Q_FALLTHROUGH();
+#line 2654 "qmljs.g"
+  case 351: Q_FALLTHROUGH();
+#line 2656 "qmljs.g"
+  case 352: Q_FALLTHROUGH();
+#line 2658 "qmljs.g"
+  case 353: Q_FALLTHROUGH();
+#line 2660 "qmljs.g"
+
+    case 354: {
+        sym(1).Node = sym(2).Node;
+    } break;
+
+#line 2682 "qmljs.g"
+
+    case 365: {
+        AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
+        node->lbraceToken = loc(1);
+        node->rbraceToken = loc(3);
+        sym(1).Node = node;
+    } break;
+
+#line 2694 "qmljs.g"
+
+    case 367: {
+        sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList);
+    } break;
+
+#line 2701 "qmljs.g"
+
+    case 368: {
+        sym(1).StatementList = new (pool) AST::StatementList(sym(1).Statement);
+    } break;
+
+#line 2709 "qmljs.g"
+
+    case 370: {
+        sym(1).Node = new (pool) AST::StatementList(sym(3).FunctionDeclaration);
+    } break;
+
+#line 2716 "qmljs.g"
+
+    case 371: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 2723 "qmljs.g"
+
+    case 372: {
+        sym(1).Node = sym(1).StatementList->finish();
+    } break;
+
+#line 2730 "qmljs.g"
+
+    case 373: {
+        sym(1).scope = AST::VariableScope::Let;
+    } break;
+
+#line 2736 "qmljs.g"
+
+    case 374: {
+        sym(1).scope = AST::VariableScope::Const;
+    } break;
+
+#line 2743 "qmljs.g"
+
+    case 375: {
+        sym(1).scope = AST::VariableScope::Var;
+    } break;
+
+#line 2750 "qmljs.g"
+  case 376: Q_FALLTHROUGH();
+#line 2752 "qmljs.g"
+  case 377: Q_FALLTHROUGH();
+#line 2754 "qmljs.g"
+  case 378: Q_FALLTHROUGH();
+#line 2756 "qmljs.g"
+
+    case 379: {
+        AST::VariableStatement *node = new (pool) AST::VariableStatement(sym(2).VariableDeclarationList->finish(sym(1).scope));
+        node->declarationKindToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 2768 "qmljs.g"
+  case 382: Q_FALLTHROUGH();
+#line 2770 "qmljs.g"
+  case 383: Q_FALLTHROUGH();
+#line 2772 "qmljs.g"
+  case 384: Q_FALLTHROUGH();
+#line 2774 "qmljs.g"
+
+    case 385: {
+  sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).PatternElement);
+    } break;
+
+#line 2781 "qmljs.g"
+  case 386: Q_FALLTHROUGH();
+#line 2783 "qmljs.g"
+  case 387: Q_FALLTHROUGH();
+#line 2785 "qmljs.g"
+  case 388: Q_FALLTHROUGH();
+#line 2787 "qmljs.g"
+
+    case 389: {
+        AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).PatternElement);
+        node->commaToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 2796 "qmljs.g"
+  case 390: Q_FALLTHROUGH();
+#line 2798 "qmljs.g"
+  case 391: Q_FALLTHROUGH();
+#line 2800 "qmljs.g"
+  case 392: Q_FALLTHROUGH();
+#line 2802 "qmljs.g"
+
+    case 393: {
+        auto *node = new (pool) AST::PatternElement(stringRef(1), sym(2).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(2).Expression))
+            f->name = stringRef(1);
+        if (auto *c = asAnonymousClassDefinition(sym(2).Expression))
+            c->name = stringRef(1);
+    } break;
+
+#line 2816 "qmljs.g"
+  case 394: Q_FALLTHROUGH();
+#line 2818 "qmljs.g"
+  case 395: Q_FALLTHROUGH();
+#line 2820 "qmljs.g"
+  case 396: Q_FALLTHROUGH();
+#line 2822 "qmljs.g"
+
+    case 397: {
+        auto *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression);
+        node->identifierToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 2831 "qmljs.g"
+
+    case 398: {
+        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 2842 "qmljs.g"
+
+    case 399: {
+        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 2853 "qmljs.g"
+
+    case 400: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 2860 "qmljs.g"
+ case 401:
+#line 2862 "qmljs.g"
+
+    case 402: {
+        sym(1).Node = sym(1).PatternPropertyList->finish();
+    } break;
+
+#line 2869 "qmljs.g"
+
+    case 403: {
+        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;
 
-case 246: {
-  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 2881 "qmljs.g"
 
-case 248: {
-  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;
+    case 404: {
+        sym(1).Node = sym(1).PatternElementList->finish();
+    } break;
 
-case 249: {
-  sym(1).ival = QSOperator::Assign;
-} break;
+#line 2888 "qmljs.g"
 
-case 250: {
-  sym(1).ival = QSOperator::InplaceMul;
-} break;
+    case 405: {
+        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;
 
-case 251: {
-  sym(1).ival = QSOperator::InplaceDiv;
-} break;
+#line 2900 "qmljs.g"
 
-case 252: {
-  sym(1).ival = QSOperator::InplaceMod;
-} break;
+    case 406: {
+        sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty);
+    } break;
 
-case 253: {
-  sym(1).ival = QSOperator::InplaceAdd;
-} break;
+#line 2907 "qmljs.g"
 
-case 254: {
-  sym(1).ival = QSOperator::InplaceSub;
-} break;
+    case 407: {
+        sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty);
+    } break;
 
-case 255: {
-  sym(1).ival = QSOperator::InplaceLeftShift;
-} break;
+#line 2916 "qmljs.g"
 
-case 256: {
-  sym(1).ival = QSOperator::InplaceRightShift;
-} break;
+    case 409: {
+        sym(1).PatternElementList = sym(1).PatternElementList->append(sym(3).PatternElementList);
+    } break;
 
-case 257: {
-  sym(1).ival = QSOperator::InplaceURightShift;
-} break;
+#line 2923 "qmljs.g"
 
-case 258: {
-  sym(1).ival = QSOperator::InplaceAnd;
-} break;
+    case 410: {
+        sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement);
+    } break;
 
-case 259: {
-  sym(1).ival = QSOperator::InplaceXor;
-} break;
+#line 2931 "qmljs.g"
 
-case 260: {
-  sym(1).ival = QSOperator::InplaceOr;
-} break;
+    case 411: {
+        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 2945 "qmljs.g"
 
-case 262: {
-  AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+    case 412: {
+        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, stringRef(3), sym(4).Expression);
+        sym(1).Node = node;
+    } break;
 
-case 263: {
-  sym(1).Node = 0;
-} break;
+#line 2953 "qmljs.g"
+
+    case 413: {
+        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Pattern, sym(4).Expression);
+        sym(1).Node = node;
+    } break;
+
+#line 2961 "qmljs.g"
+
+    case 414: {
+      AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1), sym(2).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(2).Expression))
+          f->name = stringRef(1);
+      if (auto *c = asAnonymousClassDefinition(sym(2).Expression))
+          c->name = stringRef(1);
+      sym(1).Node = node;
+    } break;
+
+#line 2975 "qmljs.g"
+
+    case 415: {
+        AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression);
+        sym(1).Node = node;
+    } break;
+
+#line 2983 "qmljs.g"
+
+    case 416: {
+        AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(2), nullptr, AST::PatternElement::RestElement);
+        node->identifierToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 2992 "qmljs.g"
+
+    case 417: {
+        AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr, AST::PatternElement::RestElement);
+        sym(1).Node = node;
+    } break;
+
+#line 3000 "qmljs.g"
+
+    case 418: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 3010 "qmljs.g"
+
+    case 420: {
+        AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
+        node->semicolonToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 3025 "qmljs.g"
+
+    case 421: {
+        int token = lookaheadToken(lexer);
+        if (token == T_LBRACE)
+            pushToken(T_FORCE_BLOCK);
+        else if (token == T_FUNCTION || token == T_CLASS || token == T_LET || token == T_CONST)
+            pushToken(T_FORCE_DECLARATION);
+    } break;
+
+#line 3037 "qmljs.g"
+
+    case 423: {
+        AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
+        node->semicolonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3046 "qmljs.g"
+
+    case 424: {
+        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 3058 "qmljs.g"
+
+    case 425: {
+        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 3072 "qmljs.g"
+
+    case 428: {
+        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 3085 "qmljs.g"
+
+    case 429: {
+        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 3096 "qmljs.g"
+
+    case 430: {
+        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 3109 "qmljs.g"
+  case 431: Q_FALLTHROUGH();
+#line 3111 "qmljs.g"
+
+    case 432: {
+        // ### 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 3127 "qmljs.g"
+
+    case 433: {
+        sym(1).forEachType = AST::ForEachType::In;
+    } break;
+
+#line 3134 "qmljs.g"
+
+    case 434: {
+        sym(1).forEachType = AST::ForEachType::Of;
+    } break;
+
+#line 3141 "qmljs.g"
+
+    case 435: {
+        // need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral
+        if (AST::Pattern *p = sym(3).Expression->patternCast()) {
+            AST::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 3163 "qmljs.g"
+
+    case 436: {
+        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 3176 "qmljs.g"
+  case 437: Q_FALLTHROUGH();
+#line 3178 "qmljs.g"
+
+    case 438: {
+        auto *node = new (pool) AST::PatternElement(stringRef(2), nullptr);
+        node->identifierToken = loc(2);
+        node->scope = sym(1).scope;
+        node->isForDeclaration = true;
+        sym(1).Node = node;
+    } break;
+
+#line 3189 "qmljs.g"
+  case 439: Q_FALLTHROUGH();
+#line 3191 "qmljs.g"
+
+    case 440: {
+        auto *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr);
+        node->scope = sym(1).scope;
+        node->isForDeclaration = true;
+        sym(1).Node = node;
+    } break;
+
+#line 3202 "qmljs.g"
+
+    case 442: {
+        AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
+        node->continueToken = loc(1);
+        node->semicolonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3213 "qmljs.g"
+
+    case 444: {
+        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 3225 "qmljs.g"
+
+    case 446: {
+        AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
+        node->breakToken = loc(1);
+        node->semicolonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3236 "qmljs.g"
+
+    case 448: {
+        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 3248 "qmljs.g"
+
+    case 450: {
+        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;
 
-case 266: {
-  AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 3262 "qmljs.g"
+
+    case 451: {
+        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 3273 "qmljs.g"
+
+    case 452: {
+        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 3284 "qmljs.g"
+
+    case 453: {
+        AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
+        node->lbraceToken = loc(1);
+        node->rbraceToken = loc(3);
+        sym(1).Node = node;
+    } break;
 
-case 267: {
-  sym(1).Node = 0;
-} break;
+#line 3294 "qmljs.g"
 
-case 284: {
-  AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
-  node->lbraceToken = loc(1);
-  node->rbraceToken = loc(3);
-  sym(1).Node = node;
-} break;
+    case 454: {
+        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 3304 "qmljs.g"
+
+    case 455: {
+        sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
+    } break;
+
+#line 3311 "qmljs.g"
+
+    case 456: {
+        sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
+    } break;
+
+#line 3318 "qmljs.g"
+
+    case 457: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 3325 "qmljs.g"
+
+    case 458: {
+        sym(1).Node = sym(1).CaseClauses->finish();
+    } break;
+
+#line 3332 "qmljs.g"
+
+    case 459: {
+        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 3342 "qmljs.g"
+
+    case 460: {
+        AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
+        node->defaultToken = loc(1);
+        node->colonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3352 "qmljs.g"
+
+    case 461: {
+        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 3364 "qmljs.g"
+
+    case 463: {
+        syntaxError(loc(3), "FunctionDeclarations are not allowed after a label.");
+        return false;
+    } break;
+
+#line 3373 "qmljs.g"
+
+    case 465: {
+        AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
+        node->throwToken = loc(1);
+        node->semicolonToken = loc(3);
+        sym(1).Node = node;
+    } break;
+
+#line 3383 "qmljs.g"
+
+    case 466: {
+        AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
+        node->tryToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 3392 "qmljs.g"
+
+    case 467: {
+        AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
+        node->tryToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 3401 "qmljs.g"
+
+    case 468: {
+        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 3410 "qmljs.g"
+
+    case 469: {
+        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 3422 "qmljs.g"
+
+    case 470: {
+        AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
+        node->finallyToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 3431 "qmljs.g"
+
+    case 471: {
+        AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1));
+        node->identifierToken = loc(1);
+        node->scope = AST::VariableScope::Let;
+        sym(1).Node = node;
+    } break;
+
+#line 3441 "qmljs.g"
+
+    case 472: {
+        AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern);
+        node->scope = AST::VariableScope::Let;
+        sym(1).Node = node;
+    } break;
+
+#line 3451 "qmljs.g"
+
+    case 474: {
+        AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
+        node->debuggerToken = loc(1);
+        node->semicolonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3468 "qmljs.g"
+
+    case 476: {
+        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);
+        sym(1).Node = node;
+    } break;
+
+#line 3484 "qmljs.g"
+
+    case 478: {
+        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);
+        sym(1).Node = node;
+    } break;
+
+#line 3497 "qmljs.g"
+
+    case 479: {
+        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);
+        sym(1).Node = node;
+    } break;
+
+#line 3512 "qmljs.g"
+
+    case 480: {
+        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);
+        sym(1).Node = node;
+    } break;
+
+#line 3527 "qmljs.g"
+
+    case 482: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 3534 "qmljs.g"
+
+    case 483: {
+        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);
+        sym(1).Node = node;
+    } break;
+
+#line 3542 "qmljs.g"
+ case 484:
+#line 3544 "qmljs.g"
+
+    case 485: {
+        sym(1).Node = sym(1).FormalParameterList->finish(pool);
+    } break;
+
+#line 3551 "qmljs.g"
+
+    case 486: {
+        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement))->finish(pool);
+        sym(1).Node = node;
+    } break;
+
+#line 3559 "qmljs.g"
+
+    case 487: {
+        AST::FormalParameterList *node = new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement);
+        sym(1).Node = node;
+    } break;
+
+#line 3568 "qmljs.g"
+
+    case 488: {
+        AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement);
+        sym(1).Node = node;
+    } break;
+
+#line 3578 "qmljs.g"
+
+    case 490: {
+        ++functionNestingLevel;
+    } break;
+
+#line 3585 "qmljs.g"
+
+    case 491: {
+        --functionNestingLevel;
+    } break;
+
+#line 3595 "qmljs.g"
+  case 493: Q_FALLTHROUGH();
+#line 3597 "qmljs.g"
+
+    case 494: {
+        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 3613 "qmljs.g"
+  case 495: Q_FALLTHROUGH();
+#line 3615 "qmljs.g"
+
+    case 496: {
+        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 3627 "qmljs.g"
+
+    case 497: {
+        AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), nullptr, AST::PatternElement::Binding);
+        e->identifierToken = loc(1);
+        sym(1).FormalParameterList = (new (pool) AST::FormalParameterList(nullptr, e))->finish(pool);
+    } break;
+
+#line 3638 "qmljs.g"
+
+    case 498: {
+        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 3656 "qmljs.g"
+
+    case 499: {
+        if (lookaheadToken(lexer) == T_LBRACE)
+            pushToken(T_FORCE_BLOCK);
+    } break;
+
+#line 3664 "qmljs.g"
+
+    case 500: {
+        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(6).StatementList);
+        f->functionToken = sym(1).PropertyName->firstSourceLocation();
+        f->lparenToken = loc(2);
+        f->rparenToken = loc(4);
+        f->lbraceToken = loc(5);
+        f->rbraceToken = loc(7);
+        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f);
+        node->colonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3679 "qmljs.g"
+
+    case 501: {
+        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);
+        f->functionToken = sym(2).PropertyName->firstSourceLocation();
+        f->lparenToken = loc(3);
+        f->rparenToken = loc(5);
+        f->lbraceToken = loc(6);
+        f->rbraceToken = loc(8);
+        f->isGenerator = true;
+        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f);
+        node->colonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3696 "qmljs.g"
+
+    case 502: {
+        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(6).StatementList);
+        f->functionToken = sym(2).PropertyName->firstSourceLocation();
+        f->lparenToken = loc(3);
+        f->rparenToken = loc(4);
+        f->lbraceToken = loc(5);
+        f->rbraceToken = loc(7);
+        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Getter);
+        node->colonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3711 "qmljs.g"
+
+    case 503: {
+        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);
+        f->functionToken = sym(2).PropertyName->firstSourceLocation();
+        f->lparenToken = loc(3);
+        f->rparenToken = loc(5);
+        f->lbraceToken = loc(6);
+        f->rbraceToken = loc(8);
+        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Setter);
+        node->colonToken = loc(2);
+        sym(1).Node = node;
+    } break;
+
+#line 3727 "qmljs.g"
+
+    case 504: {
+        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);
+        sym(1).Node = node;
+    } break;
+
+#line 3735 "qmljs.g"
+
+    case 505: {
+        lexer->enterGeneratorBody();
+    } break;
+
+#line 3742 "qmljs.g"
+
+    case 506: {
+        --functionNestingLevel;
+        lexer->leaveGeneratorBody();
+    } break;
+
+#line 3750 "qmljs.g"
+
+    case 507: {
+        AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList);
+        node->functionToken = loc(1);
+        node->identifierToken = loc(3);
+        node->lparenToken = loc(4);
+        node->rparenToken = loc(6);
+        node->lbraceToken = loc(7);
+        node->rbraceToken = loc(9);
+        node->isGenerator = true;
+        sym(1).Node = node;
+    } break;
+
+#line 3766 "qmljs.g"
+
+    case 509: {
+        AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(4).FormalParameterList, sym(7).StatementList);
+        node->functionToken = loc(1);
+        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 3780 "qmljs.g"
+
+    case 510: {
+        AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(3), sym(5).FormalParameterList, sym(8).StatementList);
+        node->functionToken = loc(1);
+        if (!stringRef(3).isNull())
+          node->identifierToken = loc(3);
+        node->lparenToken = loc(4);
+        node->rparenToken = loc(6);
+        node->lbraceToken = loc(7);
+        node->rbraceToken = loc(9);
+        node->isGenerator = true;
+        sym(1).Node = node;
+    } break;
+
+#line 3796 "qmljs.g"
+
+    case 511: {
+        AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(4).FormalParameterList, sym(7).StatementList);
+        node->functionToken = loc(1);
+        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 3812 "qmljs.g"
+  case 513: Q_FALLTHROUGH();
+#line 3814 "qmljs.g"
+
+    case 514: {
+        AST::YieldExpression *node = new (pool) AST::YieldExpression();
+        node->yieldToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 3823 "qmljs.g"
+  case 515: Q_FALLTHROUGH();
+#line 3825 "qmljs.g"
+
+    case 516: {
+        AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(3).Expression);
+        node->yieldToken = loc(1);
+        node->isYieldStar = true;
+        sym(1).Node = node;
+    } break;
+
+#line 3835 "qmljs.g"
+  case 517: Q_FALLTHROUGH();
+#line 3837 "qmljs.g"
+
+    case 518: {
+        AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(2).Expression);
+        node->yieldToken = loc(1);
+        sym(1).Node = node;
+    } break;
+
+#line 3847 "qmljs.g"
+
+    case 519: {
+        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 3859 "qmljs.g"
+
+    case 520: {
+        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 3871 "qmljs.g"
+
+    case 521: {
+        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 3882 "qmljs.g"
+
+    case 522: {
+        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 3895 "qmljs.g"
+
+    case 524: {
+        lexer->setStaticIsKeyword(true);
+    } break;
+
+#line 3902 "qmljs.g"
+ case 525:
+#line 3904 "qmljs.g"
+
+    case 526: {
+        lexer->setStaticIsKeyword(false);
+    } break;
 
-case 285: {
-  sym(1).Node = new (pool) AST::StatementList(sym(1).Statement);
-} break;
+#line 3911 "qmljs.g"
 
-case 286: {
-  sym(1).Node = new (pool) AST::StatementList(sym(1).StatementList, sym(2).Statement);
-} break;
+    case 527: {
+        sym(1).Node = nullptr;
+    } break;
+
+#line 3918 "qmljs.g"
 
-case 287: {
-  sym(1).Node = 0;
-} break;
+    case 528: {
+        sym(1).Node = sym(2).Node;
+    } break;
 
-case 288: {
-  sym(1).Node = sym(1).StatementList->finish ();
-} break;
+#line 3925 "qmljs.g"
 
-case 290: {
-  AST::VariableDeclaration::VariableScope s = AST::VariableDeclaration::FunctionScope;
-  if (sym(1).ival == T_LET)
-    s = AST::VariableDeclaration::BlockScope;
-  else if (sym(1).ival == T_CONST)
-    s = AST::VariableDeclaration::ReadOnlyBlockScope;
-
-  AST::VariableStatement *node = new (pool) AST::VariableStatement(sym(2).VariableDeclarationList->finish(s));
-  node->declarationKindToken = loc(1);
-  node->semicolonToken = loc(3);
-  sym(1).Node = node;
-} break;
+    case 529: {
+        sym(1).Node = nullptr;
+    } break;
 
-case 291: {
-  sym(1).ival = T_LET;
-} break;
+#line 3932 "qmljs.g"
 
-case 292: {
-  sym(1).ival = T_CONST;
-} break;
+    case 530: {
+        if (sym(1).Node)
+            sym(1).Node = sym(1).ClassElementList->finish();
+    } break;
 
-case 293: {
-  sym(1).ival = T_VAR;
-} break;
+#line 3942 "qmljs.g"
 
-case 294: {
-  sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
-} break;
+    case 532: {
+        if (sym(2).Node)
+            sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList);
+    } break;
 
-case 295: {
-  AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(
-    sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
-  node->commaToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 3950 "qmljs.g"
 
-case 296: {
-  sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclaration);
-} break;
+    case 533: {
+        AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(1).PatternProperty, false);
+        sym(1).Node = node;
+    } break;
 
-case 297: {
-  sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).VariableDeclaration);
-} break;
+#line 3958 "qmljs.g"
 
-case 298: {
-  AST::VariableDeclaration::VariableScope s = AST::VariableDeclaration::FunctionScope;
-  AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression, s);
-  node->identifierToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 534: {
+        lexer->setStaticIsKeyword(true);
+        AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(2).PatternProperty, true);
+        sym(1).Node = node;
+    } break;
 
-case 299: {
-  AST::VariableDeclaration::VariableScope s = AST::VariableDeclaration::FunctionScope;
-  AST::VariableDeclaration *node = new (pool) AST::VariableDeclaration(stringRef(1), sym(2).Expression, s);
-  node->identifierToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 3967 "qmljs.g"
 
-case 300: {
-  // ### TODO: AST for initializer
-  sym(1) = sym(2);
-} break;
+    case 535: {
+        sym(1).Node = nullptr;
+    } break;
 
-case 301: {
-  sym(1).Node = 0;
-} break;
+#line 3976 "qmljs.g"
 
-case 303: {
-  // ### TODO: AST for initializer
-  sym(1) = sym(2);
-} break;
+    case 536: {
+        sym(1).Node = nullptr;
+    } break;
 
-case 304: {
-  sym(1).Node = 0;
-} break;
+#line 3985 "qmljs.g"
 
-case 306: {
-  AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
-  node->semicolonToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 538: {
+        sym(1).Node = new (pool) AST::Program(sym(1).StatementList->finish());
+    } break;
 
-case 308: {
-  AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
-  node->semicolonToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 3992 "qmljs.g"
+  case 539: {
+        sym(1).Node = new (pool) AST::ESModule(sym(1).StatementList);
+    } break;
 
-case 309: {
-  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 3998 "qmljs.g"
 
-case 310: {
-  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;
+    case 540: {
+        sym(1).StatementList = sym(1).StatementList->finish();
+    } break;
 
-case 313: {
-  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 4005 "qmljs.g"
 
-case 314: {
-  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;
+    case 541: {
+        sym(1).StatementList = nullptr;
+    } break;
 
-case 315: {
-  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 4015 "qmljs.g"
 
-case 316: {
-  AST::VariableDeclaration::VariableScope s = AST::VariableDeclaration::FunctionScope;
-  AST::LocalForStatement *node = new (pool) AST::LocalForStatement(
-     sym(4).VariableDeclarationList->finish(s), sym(6).Expression,
-     sym(8).Expression, sym(10).Statement);
-  node->forToken = loc(1);
-  node->lparenToken = loc(2);
-  node->varToken = loc(3);
-  node->firstSemicolonToken = loc(5);
-  node->secondSemicolonToken = loc(7);
-  node->rparenToken = loc(9);
-  sym(1).Node = node;
-} break;
+    case 544: {
+        sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList);
+    } break;
 
-case 317: {
-  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->inToken = loc(4);
-  node->rparenToken = loc(6);
-  sym(1).Node = node;
-} break;
+#line 4022 "qmljs.g"
+ case 545:  Q_FALLTHROUGH();
+#line 4024 "qmljs.g"
+ case 546:  Q_FALLTHROUGH();
+#line 4026 "qmljs.g"
+ case 547:  Q_FALLTHROUGH();
+#line 4028 "qmljs.g"
 
-case 318: {
-  AST::LocalForEachStatement *node = new (pool) AST::LocalForEachStatement(
-    sym(4).VariableDeclaration, sym(6).Expression, sym(8).Statement);
-  node->forToken = loc(1);
-  node->lparenToken = loc(2);
-  node->varToken = loc(3);
-  node->inToken = loc(5);
-  node->rparenToken = loc(7);
-  sym(1).Node = node;
-} break;
+    case 548: {
+        sym(1).StatementList = new (pool) AST::StatementList(sym(1).Node);
+    } break;
 
-case 320: {
-  AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
-  node->continueToken = loc(1);
-  node->semicolonToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 4037 "qmljs.g"
 
-case 322: {
-  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;
+    case 550: {
+        auto decl = new (pool) AST::ImportDeclaration(sym(2).ImportClause, sym(3).FromClause);
+        decl->importToken = loc(1);
+        sym(1).Node = decl;
+    } break;
 
-case 324: {
-  AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
-  node->breakToken = loc(1);
-  node->semicolonToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 4045 "qmljs.g"
 
-case 326: {
-  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;
+    case 551: {
+        auto decl = new (pool) AST::ImportDeclaration(stringRef(2));
+        decl->importToken = loc(1);
+        decl->moduleSpecifierToken = loc(2);
+        sym(1).Node = decl;
+    } break;
 
-case 328: {
-  AST::ReturnStatement *node = new (pool) AST::ReturnStatement(sym(2).Expression);
-  node->returnToken = loc(1);
-  node->semicolonToken = loc(3);
-  sym(1).Node = node;
-} break;
+#line 4055 "qmljs.g"
 
-case 329: {
-  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;
+    case 552: {
+        auto clause = new (pool) AST::ImportClause(stringRef(1));
+        clause->importedDefaultBindingToken = loc(1);
+        sym(1).ImportClause = clause;
+    } break;
 
-case 330: {
-  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 4063 "qmljs.g"
 
-case 331: {
-  AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
-  node->lbraceToken = loc(1);
-  node->rbraceToken = loc(3);
-  sym(1).Node = node;
-} break;
+    case 553: {
+        sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NameSpaceImport);
+    } break;
 
-case 332: {
-  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 4069 "qmljs.g"
 
-case 333: {
-  sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
-} break;
+    case 554: {
+        sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NamedImports);
+    } break;
 
-case 334: {
-  sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
-} break;
+#line 4075 "qmljs.g"
 
-case 335: {
-  sym(1).Node = 0;
-} break;
+    case 555: {
+        auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NameSpaceImport);
+        importClause->importedDefaultBindingToken = loc(1);
+        sym(1).ImportClause = importClause;
+    } break;
 
-case 336: {
-  sym(1).Node = sym(1).CaseClauses->finish ();
-} break;
+#line 4083 "qmljs.g"
 
-case 337: {
-  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;
+    case 556: {
+        auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NamedImports);
+        importClause->importedDefaultBindingToken = loc(1);
+        sym(1).ImportClause = importClause;
+    } break;
 
-case 338: {
-  AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
-  node->defaultToken = loc(1);
-  node->colonToken = loc(2);
-  sym(1).Node = node;
-} break;
+#line 4094 "qmljs.g"
 
-case 339: {
-  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;
+    case 558: {
+        auto import = new (pool) AST::NameSpaceImport(stringRef(3));
+        import->starToken = loc(1);
+        import->importedBindingToken = loc(3);
+        sym(1).NameSpaceImport = import;
+    } break;
+
+#line 4104 "qmljs.g"
 
-case 341: {
-  AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
-  node->throwToken = loc(1);
-  node->semicolonToken = loc(3);
-  sym(1).Node = node;
-} break;
+    case 559: {
+        auto namedImports = new (pool) AST::NamedImports();
+        namedImports->leftBraceToken = loc(1);
+        namedImports->rightBraceToken = loc(2);
+        sym(1).NamedImports = namedImports;
+    } break;
+
+#line 4113 "qmljs.g"
+
+    case 560: {
+        auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish());
+        namedImports->leftBraceToken = loc(1);
+        namedImports->rightBraceToken = loc(3);
+        sym(1).NamedImports = namedImports;
+    } break;
+
+#line 4122 "qmljs.g"
+
+    case 561: {
+        auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish());
+        namedImports->leftBraceToken = loc(1);
+        namedImports->rightBraceToken = loc(4);
+        sym(1).NamedImports = namedImports;
+    } break;
+
+#line 4132 "qmljs.g"
+
+    case 562: {
+        auto clause = new (pool) AST::FromClause(stringRef(2));
+        clause->fromToken = loc(1);
+        clause->moduleSpecifierToken = loc(2);
+        sym(1).FromClause = clause;
+    } break;
+
+#line 4142 "qmljs.g"
+
+    case 563: {
+        auto importsList = new (pool) AST::ImportsList(sym(1).ImportSpecifier);
+        importsList->importSpecifierToken = loc(1);
+        sym(1).ImportsList = importsList;
+    } break;
+
+#line 4150 "qmljs.g"
+
+    case 564: {
+        auto importsList = new (pool) AST::ImportsList(sym(1).ImportsList, sym(3).ImportSpecifier);
+        importsList->importSpecifierToken = loc(3);
+        sym(1).ImportsList = importsList;
+    } break;
+
+#line 4159 "qmljs.g"
+
+    case 565: {
+        auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1));
+        importSpecifier->importedBindingToken = loc(1);
+        sym(1).ImportSpecifier = importSpecifier;
+    } break;
+
+#line 4167 "qmljs.g"
+
+    case 566: {
+    auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1), stringRef(3));
+    importSpecifier->identifierToken = loc(1);
+    importSpecifier->importedBindingToken = loc(3);
+    sym(1).ImportSpecifier = importSpecifier;
+    } break;
+
+#line 4184 "qmljs.g"
+
+    case 569: {
+        int token = lookaheadToken(lexer);
+        if (token == T_FUNCTION || token == T_CLASS)
+            pushToken(T_FORCE_DECLARATION);
+    } break;
+
+#line 4193 "qmljs.g"
+
+    case 570: {
+        auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(3).FromClause);
+        exportDeclaration->exportToken = loc(1);
+        sym(1).ExportDeclaration = exportDeclaration;
+    } break;
+
+#line 4201 "qmljs.g"
+
+    case 571: {
+        auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause, sym(3).FromClause);
+        exportDeclaration->exportToken = loc(1);
+        sym(1).ExportDeclaration = exportDeclaration;
+    } break;
+
+#line 4209 "qmljs.g"
+
+    case 572: {
+        auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause);
+        exportDeclaration->exportToken = loc(1);
+        sym(1).ExportDeclaration = exportDeclaration;
+    } break;
+
+#line 4217 "qmljs.g"
+ case 573:  Q_FALLTHROUGH();
+#line 4219 "qmljs.g"
+
+    case 574: {
+        auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/false, sym(2).Node);
+        exportDeclaration->exportToken = loc(1);
+        sym(1).ExportDeclaration = exportDeclaration;
+    } break;
+
+#line 4227 "qmljs.g"
+
+    case 575: {
+        if (auto *f = AST::cast<AST::FunctionDeclaration*>(sym(5).Node)) {
+            if (f->name.isEmpty()) {
+                f->name = stringRef(2);
+                f->identifierToken = loc(2);
+            }
+        }
+    } Q_FALLTHROUGH();
 
-case 342: {
-  AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
-  node->tryToken = loc(1);
-  sym(1).Node = node;
-} break;
+#line 4238 "qmljs.g"
 
-case 343: {
-  AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
-  node->tryToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 576: {
+        // 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);
+            }
+        }
 
-case 344: {
-  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;
+        auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/true, sym(5).Node);
+        exportDeclaration->exportToken = loc(1);
+        sym(1).ExportDeclaration = exportDeclaration;
+    } break;
 
-case 345: {
-  AST::Catch *node = new (pool) AST::Catch(stringRef(3), 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 4254 "qmljs.g"
 
-case 346: {
-  AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
-  node->finallyToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 577: {
+        // 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);
+        }
 
-case 348: {
-  AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
-  node->debuggerToken = loc(1);
-  node->semicolonToken = loc(2);
-  sym(1).Node = node;
-} break;
+        auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/true, sym(4).Node);
+        exportDeclaration->exportToken = loc(1);
+        sym(1).ExportDeclaration = exportDeclaration;
+    } break;
 
-case 350: {
-  AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
-  node->functionToken = loc(1);
-  node->identifierToken = loc(2);
-  node->lparenToken = loc(3);
-  node->rparenToken = loc(5);
-  node->lbraceToken = loc(6);
-  node->rbraceToken = loc(8);
-  sym(1).Node = node;
-} break;
+#line 4271 "qmljs.g"
 
-case 351: {
-  AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).FunctionBody);
-  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);
-  sym(1).Node = node;
-} break;
+    case 578: {
+        auto exportClause = new (pool) AST::ExportClause();
+        exportClause->leftBraceToken = loc(1);
+        exportClause->rightBraceToken = loc(2);
+        sym(1).ExportClause = exportClause;
+    } break;
 
-case 352: {
-  AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).FunctionBody);
-  node->functionToken = loc(1);
-  node->lparenToken = loc(2);
-  node->rparenToken = loc(4);
-  node->lbraceToken = loc(5);
-  node->rbraceToken = loc(7);
-  sym(1).Node = node;
-} break;
+#line 4280 "qmljs.g"
 
-case 353: {
-  AST::FormalParameterList *node = new (pool) AST::FormalParameterList(stringRef(1));
-  node->identifierToken = loc(1);
-  sym(1).Node = node;
-} break;
+    case 579: {
+        auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish());
+        exportClause->leftBraceToken = loc(1);
+        exportClause->rightBraceToken = loc(3);
+        sym(1).ExportClause = exportClause;
+    } break;
 
-case 354: {
-  AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, stringRef(3));
-  node->commaToken = loc(2);
-  node->identifierToken = loc(3);
-  sym(1).Node = node;
-} break;
+#line 4289 "qmljs.g"
 
-case 355: {
-  sym(1).Node = 0;
-} break;
+    case 580: {
+        auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish());
+        exportClause->leftBraceToken = loc(1);
+        exportClause->rightBraceToken = loc(4);
+        sym(1).ExportClause = exportClause;
+    } break;
 
-case 356: {
-  sym(1).Node = sym(1).FormalParameterList->finish ();
-} break;
+#line 4299 "qmljs.g"
 
-case 357: {
-  sym(1).Node = 0;
-} break;
+    case 581: {
+        sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportSpecifier);
+    } break;
 
-case 359: {
-  sym(1).Node = new (pool) AST::FunctionBody(sym(1).SourceElements->finish ());
-} break;
+#line 4305 "qmljs.g"
 
-case 361: {
-  sym(1).Node = new (pool) AST::Program(sym(1).SourceElements->finish ());
-} break;
+    case 582: {
+        sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportsList, sym(3).ExportSpecifier);
+    } break;
 
-case 362: {
-  sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElement);
-} break;
+#line 4312 "qmljs.g"
 
-case 363: {
-  sym(1).Node = new (pool) AST::SourceElements(sym(1).SourceElements, sym(2).SourceElement);
-} break;
+    case 583: {
+        auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1));
+        exportSpecifier->identifierToken = loc(1);
+        sym(1).ExportSpecifier = exportSpecifier;
+    } break;
 
-case 364: {
-  sym(1).Node = new (pool) AST::StatementSourceElement(sym(1).Statement);
-} break;
+#line 4320 "qmljs.g"
 
-case 365: {
-  sym(1).Node = new (pool) AST::FunctionSourceElement(sym(1).FunctionDeclaration);
-} break;
+    case 584: {
+        auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1), stringRef(3));
+        exportSpecifier->identifierToken = loc(1);
+        exportSpecifier->exportedIdentifierToken = loc(3);
+        sym(1).ExportSpecifier = exportSpecifier;
+    } break;
 
-case 366: {
-  sym(1).Node = 0;
-} break;
+#line 4331 "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;
@@ -1965,8 +3423,7 @@ case 366: {
 
         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 ||
-                tk == T_FEED_JS_SOURCE_ELEMENT)
+                tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION)
                continue;
 
             int a = t_action(errorState, tk);