----------------------------------------------------------------------------
--
-- Copyright (C) 2016 The Qt Company Ltd.
-- Contact: http://www.qt.io/licensing/
--
-- 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
-- Software or, alternatively, in accordance with the terms contained in
-- a written agreement between you and The Qt Company. For licensing terms
-- and conditions see https://www.qt.io/terms-conditions. For further
-- information use the contact form at https://www.qt.io/contact-us.
--
-- GNU 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 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-2.0.html and
-- https://www.gnu.org/licenses/gpl-3.0.html.
--
-- $QT_END_LICENSE$
--
----------------------------------------------------------------------------

%parser         QQmlJSGrammar
%decl           qqmljsparser_p.h
%impl           qqmljsparser.cpp
%expect         1

%token T_AND "&"                T_AND_AND "&&"              T_AND_EQ "&="
%token T_BREAK "break"          T_CASE "case"               T_CATCH "catch"
%token T_COLON ":"              T_COMMA ","                 T_CONTINUE "continue"
%token T_DEFAULT "default"      T_DELETE "delete"           T_DIVIDE_ "/"
%token T_DIVIDE_EQ "/="         T_DO "do"                   T_DOT "."
%token T_ELSE "else"            T_EQ "="                    T_EQ_EQ "=="
%token T_EQ_EQ_EQ "==="         T_FINALLY "finally"         T_FOR "for"
%token T_FUNCTION_STAR "function *"
%token T_FUNCTION "function"    T_GE ">="                   T_GT ">"
%token T_GT_GT ">>"             T_GT_GT_EQ ">>="            T_GT_GT_GT ">>>"
%token T_GT_GT_GT_EQ ">>>="     T_IDENTIFIER "identifier"   T_IF "if"
%token T_IN "in"                T_INSTANCEOF "instanceof"   T_LBRACE "{"
%token T_LBRACKET "["           T_LE "<="                   T_LPAREN "("
%token T_LT "<"                 T_LT_LT "<<"                T_LT_LT_EQ "<<="
%token T_MINUS "-"              T_MINUS_EQ "-="             T_MINUS_MINUS "--"
%token T_NEW "new"              T_NOT "!"                   T_NOT_EQ "!="
%token T_NOT_EQ_EQ "!=="        T_NUMERIC_LITERAL "numeric literal"     T_OR "|"
%token T_VERSION_NUMBER "version number"
%token T_OR_EQ "|="             T_OR_OR "||"                T_PLUS "+"
%token T_PLUS_EQ "+="           T_PLUS_PLUS "++"            T_QUESTION "?"
%token T_RBRACE "}"             T_RBRACKET "]"              T_REMAINDER "%"
%token T_REMAINDER_EQ "%="      T_RETURN "return"           T_RPAREN ")"
%token T_SEMICOLON ";"          T_AUTOMATIC_SEMICOLON       T_STAR "*"
%token T_STAR_STAR "**"         T_STAR_STAR_EQ "**="        T_STAR_EQ "*="
%token T_STRING_LITERAL "string literal"
%token T_PROPERTY "property"    T_SIGNAL "signal"           T_READONLY "readonly"
%token T_SWITCH "switch"        T_THIS "this"               T_THROW "throw"
%token T_TILDE "~"              T_TRY "try"                 T_TYPEOF "typeof"
%token T_VAR "var"              T_VOID "void"               T_WHILE "while"
%token T_WITH "with"            T_XOR "^"                   T_XOR_EQ "^="
%token T_NULL "null"            T_TRUE "true"               T_FALSE "false"
%token T_CONST "const"          T_LET "let"                 T_AT "@"
%token T_DEBUGGER "debugger"
%token T_RESERVED_WORD "reserved word"
%token T_MULTILINE_STRING_LITERAL "multiline string literal"
%token T_COMMENT "comment"
%token T_COMPATIBILITY_SEMICOLON
%token T_ARROW "=>"
%token T_QUESTION_QUESTION "??"
%token T_ENUM "enum"
%token T_ELLIPSIS "..."
%token T_YIELD "yield"
%token T_SUPER "super"
%token T_CLASS "class"
%token T_EXTENDS "extends"
%token T_STATIC "static"
%token T_EXPORT "export"
%token T_FROM "from"
%token T_REQUIRED "required"
%token T_COMPONENT "component"

--- template strings
%token T_NO_SUBSTITUTION_TEMPLATE"(no subst template)"
%token T_TEMPLATE_HEAD "(template head)"
%token T_TEMPLATE_MIDDLE "(template middle)"
%token T_TEMPLATE_TAIL "(template tail)"

--- context keywords.
%token T_PUBLIC "public"
%token T_IMPORT "import"
%token T_PRAGMA "pragma"
%token T_AS "as"
%token T_OF "of"
%token T_GET "get"
%token T_SET "set"

%token T_ERROR

--- feed tokens
%token T_FEED_UI_PROGRAM
%token T_FEED_UI_OBJECT_MEMBER
%token T_FEED_JS_STATEMENT
%token T_FEED_JS_EXPRESSION
%token T_FEED_JS_SCRIPT
%token T_FEED_JS_MODULE

--- Lookahead handling
%token T_FORCE_DECLARATION "(force decl)"
%token T_FORCE_BLOCK "(force block)"
%token T_FOR_LOOKAHEAD_OK "(for lookahead ok)"

--%left T_PLUS T_MINUS
%nonassoc T_IDENTIFIER T_COLON T_SIGNAL T_PROPERTY T_READONLY T_ON T_SET T_GET T_OF T_STATIC T_FROM T_AS T_REQUIRED T_COMPONENT
%nonassoc REDUCE_HERE
%right T_THEN T_ELSE
%right T_WITHOUTAS T_AS

%start TopLevel

/./****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** 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
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU 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 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-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include <private/qqmljsengine_p.h>
#include <private/qqmljslexer_p.h>
#include <private/qqmljsast_p.h>
#include <private/qqmljsmemorypool_p.h>

#include <QtCore/qdebug.h>
#include <QtCore/qcoreapplication.h>

#include <string.h>

./

/:/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** 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
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU 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 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-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/


//
//  W A R N I N G
//  -------------
//
// This file is not part of the Qt API.  It exists purely as an
// implementation detail.  This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//

//
//  W A R N I N G
//  -------------
//
// This file is automatically generated from qqmljs.g.
// Changes should be made to that file, not here. Any change to this file will
// be lost!
//
// To regenerate this file, run:
//    qlalr --no-debug --no-lines --qt qqmljs.g
//

#ifndef QQMLJSPARSER_P_H
#define QQMLJSPARSER_P_H

#include <private/qqmljsglobal_p.h>
#include <private/qqmljsgrammar_p.h>
#include <private/qqmljsast_p.h>
#include <private/qqmljsengine_p.h>
#include <private/qqmljsdiagnosticmessage_p.h>

#include <QtCore/qlist.h>
#include <QtCore/qstring.h>

QT_BEGIN_NAMESPACE

namespace QQmlJS {

class Engine;

class QML_PARSER_EXPORT Parser: protected $table
{
public:
    union Value {
      int ival;
      double dval;
      AST::VariableScope scope;
      AST::ForEachType forEachType;
      AST::ArgumentList *ArgumentList;
      AST::CaseBlock *CaseBlock;
      AST::CaseClause *CaseClause;
      AST::CaseClauses *CaseClauses;
      AST::Catch *Catch;
      AST::DefaultClause *DefaultClause;
      AST::Elision *Elision;
      AST::ExpressionNode *Expression;
      AST::TemplateLiteral *Template;
      AST::Finally *Finally;
      AST::FormalParameterList *FormalParameterList;
      AST::FunctionDeclaration *FunctionDeclaration;
      AST::Node *Node;
      AST::PropertyName *PropertyName;
      AST::Statement *Statement;
      AST::StatementList *StatementList;
      AST::Block *Block;
      AST::VariableDeclarationList *VariableDeclarationList;
      AST::Pattern *Pattern;
      AST::PatternElement *PatternElement;
      AST::PatternElementList *PatternElementList;
      AST::PatternProperty *PatternProperty;
      AST::PatternPropertyList *PatternPropertyList;
      AST::ClassElementList *ClassElementList;
      AST::ImportClause *ImportClause;
      AST::FromClause *FromClause;
      AST::NameSpaceImport *NameSpaceImport;
      AST::ImportsList *ImportsList;
      AST::NamedImports *NamedImports;
      AST::ImportSpecifier *ImportSpecifier;
      AST::ExportSpecifier *ExportSpecifier;
      AST::ExportsList *ExportsList;
      AST::ExportClause *ExportClause;
      AST::ExportDeclaration *ExportDeclaration;
      AST::TypeAnnotation *TypeAnnotation;
      AST::TypeArgumentList *TypeArgumentList;
      AST::Type *Type;

      AST::UiProgram *UiProgram;
      AST::UiHeaderItemList *UiHeaderItemList;
      AST::UiPragma *UiPragma;
      AST::UiImport *UiImport;
      AST::UiParameterList *UiParameterList;
      AST::UiPublicMember *UiPublicMember;
      AST::UiObjectDefinition *UiObjectDefinition;
      AST::UiObjectInitializer *UiObjectInitializer;
      AST::UiObjectBinding *UiObjectBinding;
      AST::UiScriptBinding *UiScriptBinding;
      AST::UiArrayBinding *UiArrayBinding;
      AST::UiObjectMember *UiObjectMember;
      AST::UiObjectMemberList *UiObjectMemberList;
      AST::UiArrayMemberList *UiArrayMemberList;
      AST::UiQualifiedId *UiQualifiedId;
      AST::UiEnumMemberList *UiEnumMemberList;
      AST::UiVersionSpecifier *UiVersionSpecifier;
      AST::UiAnnotation *UiAnnotation;
      AST::UiAnnotationList *UiAnnotationList;
    };

public:
    Parser(Engine *engine);
    ~Parser();

    // parse a UI program
    bool parse() { ++functionNestingLevel; bool r = parse(T_FEED_UI_PROGRAM); --functionNestingLevel; return r; }
    bool parseStatement() { return parse(T_FEED_JS_STATEMENT); }
    bool parseExpression() { return parse(T_FEED_JS_EXPRESSION); }
    bool parseUiObjectMember() { ++functionNestingLevel; bool r = parse(T_FEED_UI_OBJECT_MEMBER); --functionNestingLevel; return r; }
    bool parseProgram() { return parse(T_FEED_JS_SCRIPT); }
    bool parseScript() { return parse(T_FEED_JS_SCRIPT); }
    bool parseModule() { return parse(T_FEED_JS_MODULE); }

    AST::UiProgram *ast() const
    { return AST::cast<AST::UiProgram *>(program); }

    AST::Statement *statement() const
    {
        if (! program)
            return 0;

        return program->statementCast();
    }

    AST::ExpressionNode *expression() const
    {
        if (! program)
            return 0;

        return program->expressionCast();
    }

    AST::UiObjectMember *uiObjectMember() const
    {
        if (! program)
            return 0;

        return program->uiObjectMemberCast();
    }

    AST::Node *rootNode() const
    { return program; }

    QList<DiagnosticMessage> diagnosticMessages() const
    { return diagnostic_messages; }

    inline DiagnosticMessage diagnosticMessage() const
    {
        for (const DiagnosticMessage &d : diagnostic_messages) {
            if (d.type != QtWarningMsg)
                return d;
        }

        return DiagnosticMessage();
    }

    inline QString errorMessage() const
    { return diagnosticMessage().message; }

    inline int errorLineNumber() const
    { return diagnosticMessage().loc.startLine; }

    inline int errorColumnNumber() const
    { return diagnosticMessage().loc.startColumn; }

protected:
    bool parse(int startToken);

    void reallocateStack();

    inline Value &sym(int index)
    { return sym_stack [tos + index - 1]; }

    inline QStringRef &stringRef(int index)
    { return string_stack [tos + index - 1]; }

    inline QStringRef &rawStringRef(int index)
    { return rawString_stack [tos + index - 1]; }

    inline SourceLocation &loc(int index)
    { return location_stack [tos + index - 1]; }

    AST::UiQualifiedId *reparseAsQualifiedId(AST::ExpressionNode *expr);

    void pushToken(int token);
    int lookaheadToken(Lexer *lexer);

    static DiagnosticMessage compileError(const SourceLocation &location,
                                          const QString &message, QtMsgType kind = QtCriticalMsg)
    {
        DiagnosticMessage error;
        error.loc = location;
        error.message = message;
        error.type = kind;
        return error;
    }

    void syntaxError(const SourceLocation &location, const char *message) {
        diagnostic_messages.append(compileError(location, QLatin1String(message)));
     }
     void syntaxError(const SourceLocation &location, const QString &message) {
        diagnostic_messages.append(compileError(location, message));
      }

    bool ensureNoFunctionTypeAnnotations(AST::TypeAnnotation *returnTypeAnnotation, AST::FormalParameterList *formals);

protected:
    Engine *driver;
    MemoryPool *pool;
    int tos = 0;
    int stack_size = 0;
    Value *sym_stack = nullptr;
    int *state_stack = nullptr;
    SourceLocation *location_stack = nullptr;
    QVector<QStringRef> string_stack;
    QVector<QStringRef> rawString_stack;

    AST::Node *program = nullptr;

    // error recovery and lookahead handling
    enum { TOKEN_BUFFER_SIZE = 5 };

    struct SavedToken {
       int token;
       double dval;
       SourceLocation loc;
       QStringRef spell;
       QStringRef raw;
    };

    int yytoken = -1;
    double yylval = 0.;
    QStringRef yytokenspell;
    QStringRef yytokenraw;
    SourceLocation yylloc;
    SourceLocation yyprevlloc;

    SavedToken token_buffer[TOKEN_BUFFER_SIZE];
    SavedToken *first_token = nullptr;
    SavedToken *last_token = nullptr;

    int functionNestingLevel = 0;

    enum CoverExpressionType {
        CE_Invalid,
        CE_ParenthesizedExpression,
        CE_FormalParameterList
    };
    SourceLocation coverExpressionErrorLocation;
    CoverExpressionType coverExpressionType = CE_Invalid;

    QList<DiagnosticMessage> diagnostic_messages;
};

} // end of namespace QQmlJS


:/


/.

#include "qqmljsparser_p.h"

#include <QtCore/qvarlengtharray.h>

//
//  W A R N I N G
//  -------------
//
// This file is automatically generated from qqmljs.g.
// Changes should be made to that file, not here. Any change to this file will
// be lost!
//
// To regenerate this file, run:
//    qlalr --no-debug --no-lines --qt qqmljs.g
//

#define UNIMPLEMENTED syntaxError(loc(1), "Unimplemented"); return false

using namespace QQmlJS;

QT_BEGIN_NAMESPACE

void Parser::reallocateStack()
{
    if (! stack_size)
        stack_size = 128;
    else
        stack_size <<= 1;

    sym_stack = reinterpret_cast<Value*> (realloc(sym_stack, stack_size * sizeof(Value)));
    state_stack = reinterpret_cast<int*> (realloc(state_stack, stack_size * sizeof(int)));
    location_stack = reinterpret_cast<SourceLocation*> (realloc(location_stack, stack_size * sizeof(SourceLocation)));
    string_stack.resize(stack_size);
    rawString_stack.resize(stack_size);
}

Parser::Parser(Engine *engine):
    driver(engine),
    pool(engine->pool())
{
}

Parser::~Parser()
{
    if (stack_size) {
        free(sym_stack);
        free(state_stack);
        free(location_stack);
    }
}

static inline SourceLocation location(Lexer *lexer)
{
    SourceLocation loc;
    loc.offset = lexer->tokenOffset();
    loc.length = lexer->tokenLength();
    loc.startLine = lexer->tokenStartLine();
    loc.startColumn = lexer->tokenStartColumn();
    return loc;
}

AST::UiQualifiedId *Parser::reparseAsQualifiedId(AST::ExpressionNode *expr)
{
    QVarLengthArray<QStringRef, 4> nameIds;
    QVarLengthArray<SourceLocation, 4> locations;

    AST::ExpressionNode *it = expr;
    while (AST::FieldMemberExpression *m = AST::cast<AST::FieldMemberExpression *>(it)) {
        nameIds.append(m->name);
        locations.append(m->identifierToken);
        it = m->base;
    }

    if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(it)) {
        AST::UiQualifiedId *q = new (pool) AST::UiQualifiedId(idExpr->name);
        q->identifierToken = idExpr->identifierToken;

        AST::UiQualifiedId *currentId = q;
        for (int i = nameIds.size() - 1; i != -1; --i) {
            currentId = new (pool) AST::UiQualifiedId(currentId, nameIds[i]);
            currentId->identifierToken = locations[i];
        }

        return currentId->finish();
    }

    return 0;
}

void Parser::pushToken(int token)
{
    Q_ASSERT(last_token);
    Q_ASSERT(last_token < &token_buffer[TOKEN_BUFFER_SIZE]);
    last_token->token = yytoken;
    last_token->dval = yylval;
    last_token->spell = yytokenspell;
    last_token->raw = yytokenraw;
    last_token->loc = yylloc;
    ++last_token;
    yytoken = token;
}

int Parser::lookaheadToken(Lexer *lexer)
{
    if (yytoken < 0) {
        yytoken = lexer->lex();
        yylval = lexer->tokenValue();
        yytokenspell = lexer->tokenSpell();
        yytokenraw = lexer->rawString();
        yylloc = location(lexer);
    }
    return yytoken;
}

bool Parser::ensureNoFunctionTypeAnnotations(AST::TypeAnnotation *returnValueAnnotation, AST::FormalParameterList *formals)
{
    for (auto formal = formals; formal; formal = formal->next) {
        if (formal->element && formal->element->typeAnnotation) {
            syntaxError(formal->element->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in function parameters in JavaScript functions");
            return false;
        }
    }
    if (returnValueAnnotation) {
        syntaxError(returnValueAnnotation->firstSourceLocation(), "Type annotations are not permitted for the return value of JavaScript functions");
        return false;
    }
    return true;
}

//#define PARSER_DEBUG

bool Parser::parse(int startToken)
{
    Lexer *lexer = driver->lexer();
    bool hadErrors = false;
    yytoken = -1;
    int action = 0;

    token_buffer[0].token = startToken;
    first_token = &token_buffer[0];
    if (startToken == T_FEED_JS_SCRIPT && !lexer->qmlMode()) {
        Directives ignoreDirectives;
        Directives *directives = driver->directives();
        if (!directives)
            directives = &ignoreDirectives;
        DiagnosticMessage error;
        if (!lexer->scanDirectives(directives, &error)) {
            diagnostic_messages.append(error);
            return false;
        }
        token_buffer[1].token = lexer->tokenKind();
        token_buffer[1].dval = lexer->tokenValue();
        token_buffer[1].loc = location(lexer);
        token_buffer[1].spell = lexer->tokenSpell();
        last_token = &token_buffer[2];
    } else {
        last_token = &token_buffer[1];
    }

    tos = -1;
    program = 0;

    do {
        if (++tos == stack_size)
            reallocateStack();

        state_stack[tos] = action;

    _Lcheck_token:
        if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
            yyprevlloc = yylloc;

            if (first_token == last_token) {
                yytoken = lexer->lex();
                yylval = lexer->tokenValue();
                yytokenspell = lexer->tokenSpell();
                yytokenraw = lexer->rawString();
                yylloc = location(lexer);
            } else {
                yytoken = first_token->token;
                yylval = first_token->dval;
                yytokenspell = first_token->spell;
                yytokenraw = first_token->raw;
                yylloc = first_token->loc;
                ++first_token;
                if (first_token == last_token)
                    first_token = last_token = &token_buffer[0];
            }
        }

#ifdef PARSER_DEBUG
       qDebug() << "   in state" << action;
#endif

        action = t_action(action, yytoken);
#ifdef PARSER_DEBUG
       qDebug() << "   current token" << yytoken << (yytoken >= 0 ? spell[yytoken] : "(null)") << "new state" << action;
#endif
        if (action > 0) {
            if (action != ACCEPT_STATE) {
                yytoken = -1;
                sym(1).dval = yylval;
                stringRef(1) = yytokenspell;
                rawStringRef(1) = yytokenraw;
                loc(1) = yylloc;
            } else {
              --tos;
              return ! hadErrors;
            }
        } else if (action < 0) {
          const int r = -action - 1;
          tos -= rhs[r];

#ifdef PARSER_DEBUG
          qDebug() << "        reducing through rule " << -action;
#endif

          switch (r) {
./

--------------------------------------------------------------------------------------------------------
-- Declarative UI
--------------------------------------------------------------------------------------------------------

TopLevel: T_FEED_UI_PROGRAM UiProgram;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
        program = sym(1).Node;
    } break;
./

TopLevel: T_FEED_JS_STATEMENT Statement;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
        program = sym(1).Node;
    } break;
./

TopLevel: T_FEED_JS_EXPRESSION Expression;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
        program = sym(1).Node;
    } break;
./

TopLevel: T_FEED_UI_OBJECT_MEMBER UiAnnotatedObjectMember;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
        program = sym(1).Node;
    } break;
./

TopLevel: T_FEED_JS_SCRIPT Script;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
        program = sym(1).Node;
    } break;
./

TopLevel: T_FEED_JS_MODULE Module;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
        program = sym(1).Node;
    } break;
./


UiProgram: UiHeaderItemListOpt UiRootMember;
/.
    case $rule_number: {
        sym(1).UiProgram = new (pool) AST::UiProgram(sym(1).UiHeaderItemList, sym(2).UiObjectMemberList->finish());
    } break;
./

UiHeaderItemListOpt: Empty;
UiHeaderItemListOpt: UiHeaderItemList;
/.
    case $rule_number: {
        sym(1).Node = sym(1).UiHeaderItemList->finish();
    } break;
./

UiHeaderItemList: UiPragma;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiPragma);
    } break;
./

UiHeaderItemList: UiImport;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiImport);
    } break;
./

UiHeaderItemList: UiHeaderItemList UiPragma;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiPragma);
    } break;
./

UiHeaderItemList: UiHeaderItemList UiImport;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiHeaderItemList(sym(1).UiHeaderItemList, sym(2).UiImport);
    } break;
./

PragmaId: JsIdentifier;

Semicolon: T_AUTOMATIC_SEMICOLON;
Semicolon: T_SEMICOLON;

UiPragma: T_PRAGMA PragmaId Semicolon;
/.
    case $rule_number: {
        AST::UiPragma *pragma = new (pool) AST::UiPragma(stringRef(2));
        pragma->pragmaToken = loc(1);
        pragma->semicolonToken = loc(3);
        sym(1).Node = pragma;
    } break;
./

ImportId: MemberExpression;

UiImport: UiImportHead Semicolon;
/.
    case $rule_number: {
        sym(1).UiImport->semicolonToken = loc(2);
    } break;
./

UiVersionSpecifier: T_VERSION_NUMBER T_DOT T_VERSION_NUMBER;
/.
    case $rule_number: {
        auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, sym(3).dval);
        version->majorToken = loc(1);
        version->minorToken = loc(3);
        sym(1).UiVersionSpecifier = version;
    } break;
./


UiVersionSpecifier: T_VERSION_NUMBER;
/.
    case $rule_number: {
        auto version = new (pool) AST::UiVersionSpecifier(sym(1).dval, 0);
        version->majorToken = loc(1);
        sym(1).UiVersionSpecifier = version;
    } break;
./

UiImport: UiImportHead UiVersionSpecifier Semicolon;
/.
    case $rule_number: {
        sym(1).UiImport->version = sym(2).UiVersionSpecifier;
        sym(1).UiImport->semicolonToken = loc(3);
    } break;
./

UiImport: UiImportHead UiVersionSpecifier  T_AS QmlIdentifier Semicolon;
/.
    case $rule_number: {
        sym(1).UiImport->version = sym(2).UiVersionSpecifier;
        sym(1).UiImport->asToken = loc(3);
        sym(1).UiImport->importIdToken = loc(4);
        sym(1).UiImport->importId = stringRef(4);
        sym(1).UiImport->semicolonToken = loc(5);
    } break;
./

UiImport: UiImportHead T_AS QmlIdentifier Semicolon;
/.
    case $rule_number: {
        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;
./

UiImportHead: T_IMPORT ImportId;
/.
    case $rule_number: {
        AST::UiImport *node = 0;

        if (AST::StringLiteral *importIdLiteral = AST::cast<AST::StringLiteral *>(sym(2).Expression)) {
            node = new (pool) AST::UiImport(importIdLiteral->value);
            node->fileNameToken = loc(2);
        } else if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(2).Expression)) {
            node = new (pool) AST::UiImport(qualifiedId);
            node->fileNameToken = loc(2);
        }

        sym(1).Node = node;

        if (node) {
            node->importToken = loc(1);
        } else {
            diagnostic_messages.append(compileError(loc(1),
             QLatin1String("Expected a qualified name id or a string literal")));

            return false; // ### remove me
        }
    } break;
./

Empty: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

UiRootMember: UiAnnotatedObject;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
    } break;
./

UiSimpleQualifiedId: T_IDENTIFIER;
/.
    case $rule_number: {
        AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
        node->identifierToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiSimpleQualifiedId: UiSimpleQualifiedId T_DOT T_IDENTIFIER;
/.
    case $rule_number: {
        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;
./

UiAnnotationObjectDefinition: UiSimpleQualifiedId UiObjectInitializer;
/.
    case $rule_number: {
        if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
            sym(1).UiQualifiedId = qualifiedId;
        } else {
            sym(1).UiQualifiedId = 0;

            diagnostic_messages.append(compileError(loc(1),
            QLatin1String("Expected a qualified name id")));

            return false;
        }
        AST::UiAnnotation *node = new (pool) AST::UiAnnotation(sym(1).UiQualifiedId, sym(2).UiObjectInitializer);
        sym(1).Node = node;
    } break;
./

UiAnnotation: T_AT UiAnnotationObjectDefinition;
/.
case $rule_number: {
    sym(1).Node = sym(2).Node;
} break;
./


UiAnnotationList: UiAnnotation;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiAnnotationList(sym(1).UiAnnotation);
    } break;
./

UiAnnotationList: UiAnnotationList UiAnnotation;
/.
    case $rule_number: {
        AST::UiAnnotationList *node = new (pool) AST::UiAnnotationList(sym(1).UiAnnotationList, sym(2).UiAnnotation);
        sym(1).Node = node;
    } break;
./

UiAnnotatedObject: UiAnnotationList UiObjectDefinition;
/.
   case $rule_number: {
       AST::UiObjectDefinition *node = sym(2).UiObjectDefinition;
       node->annotations = sym(1).UiAnnotationList->finish();
       sym(1).Node = node;
   } break;
./

UiAnnotatedObject: UiObjectDefinition;

UiObjectMemberList: UiAnnotatedObjectMember;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiObjectMemberList(sym(1).UiObjectMember);
    } break;
./

UiObjectMemberList: UiObjectMemberList UiAnnotatedObjectMember;
/.
    case $rule_number: {
        AST::UiObjectMemberList *node = new (pool) AST:: UiObjectMemberList(sym(1).UiObjectMemberList, sym(2).UiObjectMember);
        sym(1).Node = node;
    } break;
./

UiArrayMemberList: UiObjectDefinition;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiArrayMemberList(sym(1).UiObjectMember);
    } break;
./

UiArrayMemberList: UiArrayMemberList T_COMMA UiObjectDefinition;
/.
    case $rule_number: {
        AST::UiArrayMemberList *node = new (pool) AST::UiArrayMemberList(sym(1).UiArrayMemberList, sym(3).UiObjectMember);
        node->commaToken = loc(2);
        sym(1).Node = node;
    } break;
./

UiObjectInitializer: T_LBRACE T_RBRACE;
/.
    case $rule_number: {
        AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer((AST::UiObjectMemberList*)0);
        node->lbraceToken = loc(1);
        node->rbraceToken = loc(2);
        sym(1).Node = node;
    } break;
./

UiObjectInitializer: T_LBRACE UiObjectMemberList T_RBRACE;
/.
    case $rule_number: {
        AST::UiObjectInitializer *node = new (pool) AST::UiObjectInitializer(sym(2).UiObjectMemberList->finish());
        node->lbraceToken = loc(1);
        node->rbraceToken = loc(3);
        sym(1).Node = node;
    } break;
./

UiObjectDefinition: UiQualifiedId UiObjectInitializer;
/.
    case $rule_number: {
        AST::UiObjectDefinition *node = new (pool) AST::UiObjectDefinition(sym(1).UiQualifiedId, sym(2).UiObjectInitializer);
        sym(1).Node = node;
    } break;
./

UiAnnotatedObjectMember: UiAnnotationList UiObjectMember;
/.
   case $rule_number: {
       AST::UiObjectMember *node = sym(2).UiObjectMember;
       node->annotations = sym(1).UiAnnotationList->finish();
       sym(1).Node = sym(2).Node;
   } break;
./

UiAnnotatedObjectMember: UiObjectMember;

UiObjectMember: UiObjectDefinition;

UiObjectMember: UiQualifiedId T_COLON ExpressionStatementLookahead T_LBRACKET UiArrayMemberList T_RBRACKET;
/.
    case $rule_number: {
        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;
./

UiObjectMember: UiQualifiedId T_COLON ExpressionStatementLookahead UiQualifiedId UiObjectInitializer;
/.
    case $rule_number: {
        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;
./

UiObjectMember: UiQualifiedId T_ON UiQualifiedId  UiObjectInitializer;
/.
    case $rule_number: {
        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;
./


UiObjectLiteral: T_LBRACE ExpressionStatementLookahead UiPropertyDefinitionList T_RBRACE Semicolon;
/.
    case $rule_number: {
        AST::ObjectPattern *l = new (pool) AST::ObjectPattern(sym(3).PatternPropertyList->finish());
        l->lbraceToken = loc(1);
        l->rbraceToken = loc(4);
        AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(l);
        node->semicolonToken = loc(5);
        sym(1).Node = node;
    } break;
./


UiObjectLiteral: T_LBRACE ExpressionStatementLookahead UiPropertyDefinitionList T_COMMA T_RBRACE Semicolon;
/.
    case $rule_number: {
        AST::ObjectPattern *l = new (pool) AST::ObjectPattern(sym(3).PatternPropertyList->finish());
        l->lbraceToken = loc(1);
        l->rbraceToken = loc(5);
        AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(l);
        node->semicolonToken = loc(6);
        sym(1).Node = node;
    } break;
./


UiScriptStatement: ExpressionStatementLookahead T_FORCE_DECLARATION ExpressionStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiScriptStatement: ExpressionStatementLookahead T_FORCE_BLOCK Block;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiScriptStatement: ExpressionStatementLookahead T_FORCE_BLOCK UiObjectLiteral;
/.
    case $rule_number: {
        sym(1).Node = sym(3).Node;
    } break;
./


UiScriptStatement: ExpressionStatementLookahead EmptyStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiScriptStatement: ExpressionStatementLookahead ExpressionStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiScriptStatement: ExpressionStatementLookahead IfStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiScriptStatement: ExpressionStatementLookahead WithStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiScriptStatement: ExpressionStatementLookahead SwitchStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiScriptStatement: ExpressionStatementLookahead TryStatement;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
    } break;
./

UiObjectMember: UiQualifiedId T_COLON UiScriptStatement;
/.
case $rule_number:
{
    AST::UiScriptBinding *node = new (pool) AST::UiScriptBinding(sym(1).UiQualifiedId, sym(3).Statement);
    node->colonToken = loc(2);
    sym(1).Node = node;
    } break;
./

UiPropertyType: T_VAR;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiPropertyType: T_RESERVED_WORD;
/.  case $rule_number: Q_FALLTHROUGH(); ./
UiPropertyType: T_IDENTIFIER;
/.
    case $rule_number: {
        AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(stringRef(1));
        node->identifierToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiPropertyType: UiPropertyType T_DOT T_IDENTIFIER;
/.
    case $rule_number: {
        AST::UiQualifiedId *node = new (pool) AST::UiQualifiedId(sym(1).UiQualifiedId, stringRef(3));
        node->identifierToken = loc(3);
        sym(1).Node = node;
    } break;
./

UiParameterListOpt: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

UiParameterListOpt: UiParameterList;
/.
    case $rule_number: {
        sym(1).Node = sym(1).UiParameterList->finish();
    } break;
./

UiParameterList: QmlIdentifier T_COLON UiPropertyType;
/.
    case $rule_number: {
        AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(3).UiQualifiedId->finish(), stringRef(1));
        node->identifierToken = loc(1);
        node->colonToken = loc(2);
        node->propertyTypeToken = loc(3);
        sym(1).Node = node;
    } break;
./

UiParameterList: UiPropertyType QmlIdentifier;
/.
    case $rule_number: {
        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;
./

UiParameterList: UiParameterList T_COMMA QmlIdentifier T_COLON UiPropertyType;
/.
    case $rule_number: {
        AST::UiParameterList *node = new (pool) AST::UiParameterList(sym(1).UiParameterList, sym(5).UiQualifiedId->finish(), stringRef(3));
        node->propertyTypeToken = loc(5);
        node->commaToken = loc(2);
        node->identifierToken = loc(3);
        node->colonToken = loc(4);
        sym(1).Node = node;
    } break;
./

UiParameterList: UiParameterList T_COMMA UiPropertyType QmlIdentifier;
/.
    case $rule_number: {
        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;
./

UiObjectMember: T_SIGNAL T_IDENTIFIER T_LPAREN UiParameterListOpt T_RPAREN Semicolon;
/.
    case $rule_number: {
        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;
./

UiObjectMember: T_SIGNAL T_IDENTIFIER Semicolon;
/.
    case $rule_number: {
        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;
./

UiObjectMemberListPropertyNoInitialiser: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier Semicolon;
/.
    case $rule_number: {
        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;
./

UiObjectMember: UiObjectMemberListPropertyNoInitialiser;

UiObjectMember: T_READONLY UiObjectMemberListPropertyNoInitialiser;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->isReadonlyMember = true;
        node->readonlyToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiObjectMemberPropertyNoInitialiser: T_PROPERTY UiPropertyType QmlIdentifier Semicolon;
/.
    case $rule_number: {
        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;
./


UiObjectMember: UiObjectMemberPropertyNoInitialiser;

UiObjectMember: T_DEFAULT UiObjectMemberPropertyNoInitialiser;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->isDefaultMember = true;
        node->defaultToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiObjectMember: T_DEFAULT UiObjectMemberListPropertyNoInitialiser;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->isDefaultMember = true;
        node->defaultToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiObjectMember: T_DEFAULT T_REQUIRED UiObjectMemberPropertyNoInitialiser;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(3).UiPublicMember;
        node->isDefaultMember = true;
        node->defaultToken = loc(1);
        node->isRequired = true;
        node->requiredToken = loc(2);
        sym(1).Node = node;
    } break;
./


UiObjectMember: T_REQUIRED T_DEFAULT UiObjectMemberPropertyNoInitialiser;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(3).UiPublicMember;
        node->isDefaultMember = true;
        node->defaultToken = loc(2);
        node->isRequired = true;
        node->requiredToken = loc(1);
        sym(1).Node = node;
    } break;
./

OptionalSemicolon: | Semicolon;
/.
/* we need OptionalSemicolon because UiScriptStatement might already parse the last semicolon
  and then we would miss a semicolon (see tests/auto/quick/qquickvisualdatamodel/data/objectlist.qml)*/
 ./

UiRequired: T_REQUIRED QmlIdentifier Semicolon;
/.
    case $rule_number: {
        AST::UiRequired *node = new (pool) AST::UiRequired(stringRef(2));
        node->requiredToken = loc(1);
        node->semicolonToken = loc(3);
        sym(1).Node = node;
    } break;
./

UiObjectMember: UiRequired;

UiObjectMember: T_REQUIRED UiObjectMemberPropertyNoInitialiser;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->requiredToken = loc(1);
        node->isRequired = true;
        sym(1).Node = node;
    } break;
./

UiObjectMemberWithScriptStatement: T_PROPERTY UiPropertyType QmlIdentifier T_COLON UiScriptStatement OptionalSemicolon;
/.
    case $rule_number: {
        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;
./

UiObjectMember: UiObjectMemberWithScriptStatement;

UiObjectMember: T_READONLY UiObjectMemberWithScriptStatement;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->isReadonlyMember = true;
        node->readonlyToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiObjectMember: T_DEFAULT UiObjectMemberWithScriptStatement;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->isDefaultMember = true;
        node->defaultToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiObjectMemberWithArray: T_PROPERTY T_IDENTIFIER T_LT UiPropertyType T_GT QmlIdentifier T_COLON T_LBRACKET UiArrayMemberList T_RBRACKET Semicolon;
/.
    case $rule_number: {
        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;
./

UiObjectMember: UiObjectMemberWithArray;

UiObjectMember: T_READONLY UiObjectMemberWithArray;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->isReadonlyMember = true;
        node->readonlyToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiObjectMemberExpressionStatementLookahead: T_PROPERTY UiPropertyType QmlIdentifier T_COLON ExpressionStatementLookahead UiQualifiedId UiObjectInitializer Semicolon;
/.
    case $rule_number: {
        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;
./

UiObjectMember: UiObjectMemberExpressionStatementLookahead;

UiObjectMember: T_READONLY UiObjectMemberExpressionStatementLookahead;
/.
    case $rule_number: {
        AST::UiPublicMember *node = sym(2).UiPublicMember;
        node->isReadonlyMember = true;
        node->readonlyToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiObjectMember: GeneratorDeclaration;
/.
    case $rule_number: {
        auto node = new (pool) AST::UiSourceElement(sym(1).Node);
        sym(1).Node = node;
    } break;
./

UiObjectMember: FunctionDeclarationWithTypes;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
    } break;
./

UiObjectMember: VariableStatement;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::UiSourceElement(sym(1).Node);
    } break;
./

UiQualifiedId: MemberExpression;
/.
    case $rule_number: {
      if (AST::ArrayMemberExpression *mem = AST::cast<AST::ArrayMemberExpression *>(sym(1).Expression)) {
        diagnostic_messages.append(compileError(mem->lbracketToken,
          QLatin1String("Ignored annotation"), QtWarningMsg));

        sym(1).Expression = mem->base;
      }

      if (AST::UiQualifiedId *qualifiedId = reparseAsQualifiedId(sym(1).Expression)) {
        sym(1).UiQualifiedId = qualifiedId;
      } else {
        sym(1).UiQualifiedId = 0;

        diagnostic_messages.append(compileError(loc(1),
          QLatin1String("Expected a qualified name id")));

        return false; // ### recover
      }
    } break;
./

UiObjectMember: T_ENUM T_IDENTIFIER T_LBRACE EnumMemberList T_RBRACE;
/.
    case $rule_number: {
        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;
    }
./

UiObjectMember: T_COMPONENT T_IDENTIFIER T_COLON UiObjectDefinition;
/.
    case $rule_number: {
        if (!stringRef(2).front().isUpper()) {
            diagnostic_messages.append(compileError(loc(2),
                QLatin1String("Type name must be upper case"), QtWarningMsg));
        }
        auto inlineComponent = new (pool) AST::UiInlineComponent(stringRef(2), sym(4).UiObjectDefinition);
        inlineComponent->componentToken = loc(1);
        sym(1).Node = inlineComponent;
    } break;
./

EnumMemberList: T_IDENTIFIER;
/.
    case $rule_number: {
        AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(stringRef(1));
        node->memberToken = loc(1);
        sym(1).Node = node;
        break;
    }
./

EnumMemberList: T_IDENTIFIER T_EQ T_NUMERIC_LITERAL;
/.
    case $rule_number: {
        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;
    }
./

EnumMemberList: EnumMemberList T_COMMA T_IDENTIFIER;
/.
    case $rule_number: {
        AST::UiEnumMemberList *node = new (pool) AST::UiEnumMemberList(sym(1).UiEnumMemberList, stringRef(3));
        node->memberToken = loc(3);
        sym(1).Node = node;
        break;
    }
./

EnumMemberList: EnumMemberList T_COMMA T_IDENTIFIER T_EQ T_NUMERIC_LITERAL;
/.
    case $rule_number: {
        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;
    }
./

QmlIdentifier: T_IDENTIFIER
             | T_PROPERTY
             | T_SIGNAL
             | T_READONLY
             | T_ON
             | T_GET
             | T_SET
             | T_FROM
             | T_OF
             | T_REQUIRED
             | T_COMPONENT;

JsIdentifier: T_IDENTIFIER
            | T_PROPERTY
            | T_SIGNAL
            | T_READONLY
            | T_ON
            | T_GET
            | T_SET
            | T_FROM
            | T_STATIC
            | T_OF
            | T_AS
            | T_REQUIRED
            | T_COMPONENT;

IdentifierReference: JsIdentifier;
BindingIdentifier: IdentifierReference;

--------------------------------------------------------------------------------------------------------
-- Types
--------------------------------------------------------------------------------------------------------

TypeArguments: Type;
/.
    case $rule_number: {
        sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).Type);
    } break;
./

TypeArguments: TypeArguments T_COMMA Type;
/.
    case $rule_number: {
        sym(1).TypeArgumentList = new (pool) AST::TypeArgumentList(sym(1).TypeArgumentList, sym(3).Type);
    } break;
./

Type: UiQualifiedId T_LT TypeArguments T_GT;
/.
    case $rule_number: {
        sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId, sym(3).TypeArgumentList->finish());
    } break;
./

Type: T_RESERVED_WORD;
/.
    case $rule_number: {
        AST::UiQualifiedId *id = new (pool) AST::UiQualifiedId(stringRef(1));
        id->identifierToken = loc(1);
        sym(1).Type = new (pool) AST::Type(id->finish());
    } break;
./

Type: UiQualifiedId;
/.
    case $rule_number: {
        sym(1).Type = new (pool) AST::Type(sym(1).UiQualifiedId);
    } break;
./

TypeAnnotation: T_COLON Type;
/.
    case $rule_number: {
        sym(1).TypeAnnotation = new (pool) AST::TypeAnnotation(sym(2).Type);
        sym(1).TypeAnnotation->colonToken = loc(1);
    } break;
./

TypeAnnotationOpt: TypeAnnotation;
TypeAnnotationOpt: ;
/.
    case $rule_number: {
        sym(1).TypeAnnotation = nullptr;
    } break;
./

--------------------------------------------------------------------------------------------------------
-- Expressions
--------------------------------------------------------------------------------------------------------

PrimaryExpression: T_THIS;
/.
    case $rule_number: {
        AST::ThisExpression *node = new (pool) AST::ThisExpression();
        node->thisToken = loc(1);
        sym(1).Node = node;
    } break;
./

PrimaryExpression: IdentifierReference;
/.
    case $rule_number: {
        AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
        node->identifierToken = loc(1);
        sym(1).Node = node;
    } break;
./

PrimaryExpression: Literal;
PrimaryExpression: ArrayLiteral;
PrimaryExpression: ObjectLiteral;
PrimaryExpression: FunctionExpression;
PrimaryExpression: ClassExpression;
PrimaryExpression: GeneratorExpression;
PrimaryExpression: RegularExpressionLiteral;
PrimaryExpression: TemplateLiteral;

PrimaryExpression: CoverParenthesizedExpressionAndArrowParameterList;
/.
    case $rule_number: {
        if (coverExpressionType != CE_ParenthesizedExpression) {
            syntaxError(coverExpressionErrorLocation, "Expected token ')'.");
            return false;
        }
    } break;
./

-- Parsing of the CoverParenthesizedExpressionAndArrowParameterList is restricted to the one rule below when this is parsed as a primary expression
CoverParenthesizedExpressionAndArrowParameterList: T_LPAREN Expression_In T_RPAREN;
/.
    case $rule_number: {
        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;
./

CoverParenthesizedExpressionAndArrowParameterList: T_LPAREN T_RPAREN;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
        coverExpressionErrorLocation = loc(2);
        coverExpressionType = CE_FormalParameterList;
    } break;
./

CoverParenthesizedExpressionAndArrowParameterList: T_LPAREN BindingRestElement T_RPAREN;
/.
    case $rule_number: {
        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(2).PatternElement))->finish(pool);
        sym(1).Node = node;
        coverExpressionErrorLocation = loc(2);
        coverExpressionType = CE_FormalParameterList;
    } break;
./

CoverParenthesizedExpressionAndArrowParameterList: T_LPAREN Expression_In T_COMMA BindingRestElementOpt T_RPAREN;
/.
    case $rule_number: {
        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;
./

Literal: T_NULL;
/.
    case $rule_number: {
        AST::NullExpression *node = new (pool) AST::NullExpression();
        node->nullToken = loc(1);
        sym(1).Node = node;
    } break;
./

Literal: T_TRUE;
/.
    case $rule_number: {
        AST::TrueLiteral *node = new (pool) AST::TrueLiteral();
        node->trueToken = loc(1);
        sym(1).Node = node;
    } break;
./

Literal: T_FALSE;
/.
    case $rule_number: {
        AST::FalseLiteral *node = new (pool) AST::FalseLiteral();
        node->falseToken = loc(1);
        sym(1).Node = node;
    } break;
./

Literal: T_NUMERIC_LITERAL;
/.
    case $rule_number: {
        AST::NumericLiteral *node = new (pool) AST::NumericLiteral(sym(1).dval);
        node->literalToken = loc(1);
        sym(1).Node = node;
    } break;
./

Literal: T_MULTILINE_STRING_LITERAL;
/.  case $rule_number: Q_FALLTHROUGH(); ./

Literal: T_STRING_LITERAL;
/.
    case $rule_number: {
        AST::StringLiteral *node = new (pool) AST::StringLiteral(stringRef(1));
        node->literalToken = loc(1);
        sym(1).Node = node;
    } break;
./

RegularExpressionLiteral: T_DIVIDE_;
/:
#define J_SCRIPT_REGEXPLITERAL_RULE1 $rule_number
:/
/.
{
    Lexer::RegExpBodyPrefix prefix;
    case $rule_number:
        prefix = Lexer::NoPrefix;
        goto scan_regexp;
./

RegularExpressionLiteral: T_DIVIDE_EQ;
/:
#define J_SCRIPT_REGEXPLITERAL_RULE2 $rule_number
:/
/.
    case $rule_number:
        prefix = Lexer::EqualPrefix;
        goto scan_regexp;

    scan_regexp: {
        bool rx = lexer->scanRegExp(prefix);
        if (!rx) {
            diagnostic_messages.append(compileError(location(lexer), lexer->errorMessage()));
            return false;
        }

        loc(1).length = lexer->tokenLength();
        yylloc = loc(1); // adjust the location of the current token

        AST::RegExpLiteral *node = new (pool) AST::RegExpLiteral(driver->newStringRef(lexer->regExpPattern()), lexer->regExpFlags());
        node->literalToken = loc(1);
        sym(1).Node = node;
    } break;
}
./


ArrayLiteral: T_LBRACKET ElisionOpt T_RBRACKET;
/.
    case $rule_number: {
        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;
./

ArrayLiteral: T_LBRACKET ElementList T_RBRACKET;
/.
    case $rule_number: {
        AST::ArrayPattern *node = new (pool) AST::ArrayPattern(sym(2).PatternElementList->finish());
        node->lbracketToken = loc(1);
        node->rbracketToken = loc(3);
        sym(1).Node = node;
    } break;
./

ArrayLiteral: T_LBRACKET ElementList T_COMMA ElisionOpt T_RBRACKET;
/.
    case $rule_number: {
        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;
./

ElementList: AssignmentExpression_In;
/.
    case $rule_number: {
        AST::PatternElement *e = new (pool) AST::PatternElement(sym(1).Expression);
        sym(1).Node = new (pool) AST::PatternElementList(nullptr, e);
    } break;
./

ElementList: Elision AssignmentExpression_In;
/.
    case $rule_number: {
        AST::PatternElement *e = new (pool) AST::PatternElement(sym(2).Expression);
        sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision->finish(), e);
    } break;
./

ElementList: ElisionOpt SpreadElement;
/.
    case $rule_number: {
        AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement);
        sym(1).Node = node;
    } break;
./

ElementList: ElementList T_COMMA ElisionOpt AssignmentExpression_In;
/.
    case $rule_number: {
        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;
./

ElementList: ElementList T_COMMA ElisionOpt SpreadElement;
/.
    case $rule_number: {
        AST::PatternElementList *node = new (pool) AST::PatternElementList(sym(3).Elision, sym(4).PatternElement);
        sym(1).Node = sym(1).PatternElementList->append(node);
    } break;
./

Elision: T_COMMA;
/.
    case $rule_number: {
        AST::Elision *node = new (pool) AST::Elision();
        node->commaToken = loc(1);
        sym(1).Node = node;
    } break;
./

Elision: Elision T_COMMA;
/.
    case $rule_number: {
        AST::Elision *node = new (pool) AST::Elision(sym(1).Elision);
        node->commaToken = loc(2);
        sym(1).Node = node;
    } break;
./

ElisionOpt: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

ElisionOpt: Elision;
/.
    case $rule_number: {
        sym(1).Node = sym(1).Elision->finish();
    } break;
./

SpreadElement: T_ELLIPSIS AssignmentExpression;
/.
    case $rule_number: {
        AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Expression, AST::PatternElement::SpreadElement);
        sym(1).Node = node;
    } break;
./

ObjectLiteral: T_LBRACE T_RBRACE;
/.
    case $rule_number: {
        AST::ObjectPattern *node = new (pool) AST::ObjectPattern();
        node->lbraceToken = loc(1);
        node->rbraceToken = loc(2);
        sym(1).Node = node;
    } break;
./

ObjectLiteral: T_LBRACE PropertyDefinitionList T_RBRACE;
/.
    case $rule_number: {
        AST::ObjectPattern *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList->finish());
        node->lbraceToken = loc(1);
        node->rbraceToken = loc(3);
        sym(1).Node = node;
    } break;
./

ObjectLiteral: T_LBRACE PropertyDefinitionList T_COMMA T_RBRACE;
/.
    case $rule_number: {
        AST::ObjectPattern *node = new (pool) AST::ObjectPattern(sym(2).PatternPropertyList->finish());
        node->lbraceToken = loc(1);
        node->rbraceToken = loc(4);
        sym(1).Node = node;
    } break;
./


UiPropertyDefinitionList: UiPropertyDefinition;
/.  case $rule_number: Q_FALLTHROUGH(); ./
PropertyDefinitionList: PropertyDefinition;
/.
    case $rule_number: {
      sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty);
    } break;
./

UiPropertyDefinitionList: UiPropertyDefinitionList T_COMMA UiPropertyDefinition;
/.  case $rule_number: Q_FALLTHROUGH(); ./
PropertyDefinitionList: PropertyDefinitionList T_COMMA PropertyDefinition;
/.
    case $rule_number: {
        AST::PatternPropertyList *node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty);
        sym(1).Node = node;
    } break;
./

PropertyDefinition: IdentifierReference;
/.
    case $rule_number: {
        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;
./

-- Using this production should result in a syntax error when used in an ObjectLiteral
PropertyDefinition: CoverInitializedName;

CoverInitializedName: IdentifierReference Initializer_In;
/.
    case $rule_number: {
        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;
./

UiPropertyDefinition: UiPropertyName T_COLON AssignmentExpression_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
PropertyDefinition: PropertyName T_COLON AssignmentExpression_In;
/.
    case $rule_number: {
        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Expression);
        if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) {
            if (!AST::cast<AST::ComputedPropertyName *>(sym(1).PropertyName))
                c->name = driver->newStringRef(sym(1).PropertyName->asString());
        }
        node->colonToken = loc(2);
        sym(1).Node = node;
    } break;
./

PropertyDefinition: MethodDefinition;

PropertyName: LiteralPropertyName;
PropertyName: ComputedPropertyName;

LiteralPropertyName: IdentifierName;
/.
    case $rule_number: {
        AST::IdentifierPropertyName *node = new (pool) AST::IdentifierPropertyName(stringRef(1));
        node->propertyNameToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiPropertyName: T_STRING_LITERAL;
/.  case $rule_number: Q_FALLTHROUGH(); ./
LiteralPropertyName: T_STRING_LITERAL;
/.
    case $rule_number: {
        AST::StringLiteralPropertyName *node = new (pool) AST::StringLiteralPropertyName(stringRef(1));
        node->propertyNameToken = loc(1);
        sym(1).Node = node;
    } break;
./

UiPropertyName: T_NUMERIC_LITERAL;
/.  case $rule_number: Q_FALLTHROUGH(); ./
LiteralPropertyName: T_NUMERIC_LITERAL;
/.
    case $rule_number: {
        AST::NumericLiteralPropertyName *node = new (pool) AST::NumericLiteralPropertyName(sym(1).dval);
        node->propertyNameToken = loc(1);
        sym(1).Node = node;
    } break;
./

IdentifierName: IdentifierReference;
IdentifierName: ReservedIdentifier;

ReservedIdentifier: T_BREAK;
ReservedIdentifier: T_CASE;
ReservedIdentifier: T_CATCH;
ReservedIdentifier: T_CONTINUE;
ReservedIdentifier: T_DEFAULT;
ReservedIdentifier: T_DELETE;
ReservedIdentifier: T_DO;
ReservedIdentifier: T_ELSE;
ReservedIdentifier: T_ENUM;
ReservedIdentifier: T_FALSE;
ReservedIdentifier: T_FINALLY;
ReservedIdentifier: T_FOR;
ReservedIdentifier: T_FUNCTION;
ReservedIdentifier: T_IF;
ReservedIdentifier: T_IN;
ReservedIdentifier: T_INSTANCEOF;
ReservedIdentifier: T_NEW;
ReservedIdentifier: T_NULL;
ReservedIdentifier: T_RETURN;
ReservedIdentifier: T_SWITCH;
ReservedIdentifier: T_THIS;
ReservedIdentifier: T_THROW;
ReservedIdentifier: T_TRUE;
ReservedIdentifier: T_TRY;
ReservedIdentifier: T_TYPEOF;
ReservedIdentifier: T_VAR;
ReservedIdentifier: T_VOID;
ReservedIdentifier: T_WHILE;
ReservedIdentifier: T_CONST;
ReservedIdentifier: T_LET;
ReservedIdentifier: T_DEBUGGER;
ReservedIdentifier: T_RESERVED_WORD;
ReservedIdentifier: T_SUPER;
ReservedIdentifier: T_WITH;
ReservedIdentifier: T_CLASS;
ReservedIdentifier: T_EXTENDS;
ReservedIdentifier: T_EXPORT;
ReservedIdentifier: T_IMPORT;

ComputedPropertyName: T_LBRACKET AssignmentExpression_In T_RBRACKET;
/.
    case $rule_number: {
        AST::ComputedPropertyName *node = new (pool) AST::ComputedPropertyName(sym(2).Expression);
        node->propertyNameToken = loc(1);
        sym(1).Node = node;
    } break;
./

Initializer: T_EQ AssignmentExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Initializer_In: T_EQ AssignmentExpression_In;
/.
case $rule_number: {
    sym(1) = sym(2);
} break;
./


InitializerOpt: ;
/.  case $rule_number: Q_FALLTHROUGH(); ./
InitializerOpt_In: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

InitializerOpt: Initializer;
InitializerOpt_In: Initializer_In;

TemplateLiteral: T_NO_SUBSTITUTION_TEMPLATE;
/.  case $rule_number: Q_FALLTHROUGH(); ./

TemplateSpans: T_TEMPLATE_TAIL;
/.
    case $rule_number: {
        AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), nullptr);
        node->literalToken = loc(1);
        sym(1).Node = node;
    } break;
./

TemplateSpans: T_TEMPLATE_MIDDLE Expression TemplateSpans;
/.  case $rule_number: Q_FALLTHROUGH(); ./

TemplateLiteral: T_TEMPLATE_HEAD Expression TemplateSpans;
/.
    case $rule_number: {
        AST::TemplateLiteral *node = new (pool) AST::TemplateLiteral(stringRef(1), rawStringRef(1), sym(2).Expression);
        node->next = sym(3).Template;
        node->literalToken = loc(1);
        sym(1).Node = node;
    } break;
./


MemberExpression: PrimaryExpression;

Super: T_SUPER;
/.
    case $rule_number: {
        AST::SuperLiteral *node = new (pool) AST::SuperLiteral();
        node->superToken = loc(1);
        sym(1).Node = node;
    } break;
./


MemberExpression: Super T_LBRACKET Expression_In T_RBRACKET;
/.  case $rule_number: Q_FALLTHROUGH(); ./
MemberExpression: MemberExpression T_LBRACKET Expression_In T_RBRACKET;
/.
    case $rule_number: {
        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;
./


-- the identifier has to be "target", catched at codegen time
NewTarget: T_NEW T_DOT T_IDENTIFIER;
/.  case $rule_number:
    {
        AST::IdentifierExpression *node = new (pool) AST::IdentifierExpression(stringRef(1));
        node->identifierToken= loc(1);
        sym(1).Node = node;
    } Q_FALLTHROUGH();
./
MemberExpression: Super T_DOT IdentifierName;
/.  case $rule_number: Q_FALLTHROUGH(); ./
MemberExpression: MemberExpression T_DOT IdentifierName;
/.
    case $rule_number: {
        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;
./

MemberExpression: MetaProperty;

MemberExpression: T_NEW MemberExpression T_LPAREN Arguments T_RPAREN;
/.
    case $rule_number: {
        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;
./

MetaProperty: NewTarget;


NewExpression: MemberExpression;

NewExpression: T_NEW NewExpression;
/.
    case $rule_number: {
        AST::NewExpression *node = new (pool) AST::NewExpression(sym(2).Expression);
        node->newToken = loc(1);
        sym(1).Node = node;
    } break;
./


CallExpression: CallExpression TemplateLiteral;
/.  case $rule_number: Q_FALLTHROUGH(); ./
MemberExpression: MemberExpression TemplateLiteral;
/.
    case $rule_number: {
        AST::TaggedTemplate *node = new (pool) AST::TaggedTemplate(sym(1).Expression, sym(2).Template);
        sym(1).Node = node;
    } break;
./

CallExpression: MemberExpression T_LPAREN Arguments T_RPAREN;
/.
    case $rule_number: {
        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;
./

CallExpression: Super T_LPAREN Arguments T_RPAREN;
/.  case $rule_number: Q_FALLTHROUGH(); ./
CallExpression: CallExpression T_LPAREN Arguments T_RPAREN;
/.
    case $rule_number: {
        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;
./

CallExpression: CallExpression T_LBRACKET Expression_In T_RBRACKET;
/.
    case $rule_number: {
        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;
./

CallExpression: CallExpression T_DOT IdentifierName;
/.
    case $rule_number: {
        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;
./

Arguments: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

Arguments: ArgumentList;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Arguments: ArgumentList T_COMMA;
/.
    case $rule_number: {
        sym(1).Node = sym(1).ArgumentList->finish();
    } break;
./

ArgumentList: AssignmentExpression_In;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::ArgumentList(sym(1).Expression);
    } break;
./

ArgumentList: T_ELLIPSIS AssignmentExpression_In;
/.
    case $rule_number: {
        AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(2).Expression);
        node->isSpreadElement = true;
        sym(1).Node = node;
    } break;
./

ArgumentList: ArgumentList T_COMMA AssignmentExpression_In;
/.
    case $rule_number: {
        AST::ArgumentList *node = new (pool) AST::ArgumentList(sym(1).ArgumentList, sym(3).Expression);
        node->commaToken = loc(2);
        sym(1).Node = node;
    } break;
./

ArgumentList: ArgumentList T_COMMA T_ELLIPSIS AssignmentExpression_In;
/.
    case $rule_number: {
        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;
./

LeftHandSideExpression: NewExpression;
LeftHandSideExpression: CallExpression;

UpdateExpression: LeftHandSideExpression;

UpdateExpression: LeftHandSideExpression T_PLUS_PLUS;
/.
    case $rule_number: {
        AST::PostIncrementExpression *node = new (pool) AST::PostIncrementExpression(sym(1).Expression);
        node->incrementToken = loc(2);
        sym(1).Node = node;
    } break;
./

UpdateExpression: LeftHandSideExpression T_MINUS_MINUS;
/.
    case $rule_number: {
        AST::PostDecrementExpression *node = new (pool) AST::PostDecrementExpression(sym(1).Expression);
        node->decrementToken = loc(2);
        sym(1).Node = node;
    } break;
./

UpdateExpression: T_PLUS_PLUS UnaryExpression;
/.
    case $rule_number: {
        AST::PreIncrementExpression *node = new (pool) AST::PreIncrementExpression(sym(2).Expression);
        node->incrementToken = loc(1);
        sym(1).Node = node;
    } break;
./

UpdateExpression: T_MINUS_MINUS UnaryExpression;
/.
    case $rule_number: {
        AST::PreDecrementExpression *node = new (pool) AST::PreDecrementExpression(sym(2).Expression);
        node->decrementToken = loc(1);
        sym(1).Node = node;
    } break;
./

UnaryExpression: UpdateExpression;

UnaryExpression: T_DELETE UnaryExpression;
/.
    case $rule_number: {
        AST::DeleteExpression *node = new (pool) AST::DeleteExpression(sym(2).Expression);
        node->deleteToken = loc(1);
        sym(1).Node = node;
    } break;
./

UnaryExpression: T_VOID UnaryExpression;
/.
    case $rule_number: {
        AST::VoidExpression *node = new (pool) AST::VoidExpression(sym(2).Expression);
        node->voidToken = loc(1);
        sym(1).Node = node;
    } break;
./

UnaryExpression: T_TYPEOF UnaryExpression;
/.
    case $rule_number: {
        AST::TypeOfExpression *node = new (pool) AST::TypeOfExpression(sym(2).Expression);
        node->typeofToken = loc(1);
        sym(1).Node = node;
    } break;
./

UnaryExpression: T_PLUS UnaryExpression;
/.
    case $rule_number: {
        AST::UnaryPlusExpression *node = new (pool) AST::UnaryPlusExpression(sym(2).Expression);
        node->plusToken = loc(1);
        sym(1).Node = node;
    } break;
./

UnaryExpression: T_MINUS UnaryExpression;
/.
    case $rule_number: {
        AST::UnaryMinusExpression *node = new (pool) AST::UnaryMinusExpression(sym(2).Expression);
        node->minusToken = loc(1);
        sym(1).Node = node;
    } break;
./

UnaryExpression: T_TILDE UnaryExpression;
/.
    case $rule_number: {
        AST::TildeExpression *node = new (pool) AST::TildeExpression(sym(2).Expression);
        node->tildeToken = loc(1);
        sym(1).Node = node;
    } break;
./

UnaryExpression: T_NOT UnaryExpression;
/.
    case $rule_number: {
        AST::NotExpression *node = new (pool) AST::NotExpression(sym(2).Expression);
        node->notToken = loc(1);
        sym(1).Node = node;
    } break;
./

ExponentiationExpression: UnaryExpression;

ExponentiationExpression: UpdateExpression T_STAR_STAR ExponentiationExpression;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Exp, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

MultiplicativeExpression: ExponentiationExpression;

MultiplicativeExpression: MultiplicativeExpression MultiplicativeOperator ExponentiationExpression;
/.
    case $rule_number: {
        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;
./

MultiplicativeOperator: T_STAR;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Mul;
    } break;
./

MultiplicativeOperator: T_DIVIDE_;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Div;
    } break;
./

MultiplicativeOperator: T_REMAINDER;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Mod;
    } break;
./

AdditiveExpression: MultiplicativeExpression;

AdditiveExpression: AdditiveExpression T_PLUS MultiplicativeExpression;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Add, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

AdditiveExpression: AdditiveExpression T_MINUS MultiplicativeExpression;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Sub, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

ShiftExpression: AdditiveExpression;

ShiftExpression: ShiftExpression T_LT_LT AdditiveExpression;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::LShift, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

ShiftExpression: ShiftExpression T_GT_GT AdditiveExpression;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::RShift, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

ShiftExpression: ShiftExpression T_GT_GT_GT AdditiveExpression;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::URShift, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

RelationalExpression_In: ShiftExpression;
RelationalExpression: ShiftExpression;

RelationalExpression_In: RelationalExpression_In RelationalOperator ShiftExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
RelationalExpression: RelationalExpression RelationalOperator ShiftExpression;
/.
    case $rule_number: {
        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;
./

RelationalOperator: T_LT;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Lt;
    } break;
./
RelationalOperator: T_GT;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Gt;
    } break;
./
RelationalOperator: T_LE;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Le;
    } break;
./
RelationalOperator: T_GE;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Ge;
    } break;
./
RelationalOperator: T_INSTANCEOF;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InstanceOf;
    } break;
./

RelationalExpression_In: RelationalExpression_In T_IN ShiftExpression;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::In, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

TypeAssertExpression_In: RelationalExpression_In T_AS Type;
/.  case $rule_number: Q_FALLTHROUGH(); ./
TypeAssertExpression: RelationalExpression T_AS Type;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::As, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

RelationalExpression_In: TypeAssertExpression_In;
RelationalExpression: TypeAssertExpression;

EqualityExpression_In: RelationalExpression_In;
EqualityExpression: RelationalExpression;

EqualityExpression_In: EqualityExpression_In EqualityOperator RelationalExpression_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
EqualityExpression: EqualityExpression EqualityOperator RelationalExpression;
/.
    case $rule_number: {
        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;
./

EqualityOperator: T_EQ_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::Equal;
    } break;
./
EqualityOperator: T_NOT_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::NotEqual;
    } break;
./
EqualityOperator: T_EQ_EQ_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::StrictEqual;
    } break;
./
EqualityOperator: T_NOT_EQ_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::StrictNotEqual;
    } break;
./


BitwiseANDExpression: EqualityExpression;
BitwiseANDExpression_In: EqualityExpression_In;

BitwiseANDExpression: BitwiseANDExpression T_AND EqualityExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
BitwiseANDExpression_In: BitwiseANDExpression_In T_AND EqualityExpression_In;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitAnd, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./


BitwiseXORExpression: BitwiseANDExpression;
BitwiseXORExpression_In: BitwiseANDExpression_In;

BitwiseXORExpression: BitwiseXORExpression T_XOR BitwiseANDExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
BitwiseXORExpression_In: BitwiseXORExpression_In T_XOR BitwiseANDExpression_In;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitXor, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

BitwiseORExpression: BitwiseXORExpression;
BitwiseORExpression_In: BitwiseXORExpression_In;

BitwiseORExpression: BitwiseORExpression T_OR BitwiseXORExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
BitwiseORExpression_In: BitwiseORExpression_In T_OR BitwiseXORExpression_In;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::BitOr, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

LogicalANDExpression: BitwiseORExpression;
LogicalANDExpression_In: BitwiseORExpression_In;

LogicalANDExpression: LogicalANDExpression T_AND_AND BitwiseORExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
LogicalANDExpression_In: LogicalANDExpression_In T_AND_AND BitwiseORExpression_In;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::And, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

LogicalORExpression: LogicalANDExpression;
LogicalORExpression_In: LogicalANDExpression_In;

LogicalORExpression: LogicalORExpression T_OR_OR LogicalANDExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
LogicalORExpression_In: LogicalORExpression_In T_OR_OR LogicalANDExpression_In;
/.
    case $rule_number: {
        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Or, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

CoalesceExpression: LogicalORExpression;
CoalesceExpression_In: LogicalORExpression_In;

CoalesceExpression: CoalesceExpression T_QUESTION_QUESTION LogicalORExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
CoalesceExpression_In: CoalesceExpression_In T_QUESTION_QUESTION LogicalORExpression_In;
/.
    case $rule_number: {

        auto *lhs = sym(1).Expression;
        auto *rhs = sym(3).Expression;

        // Check if lhs or rhs contain || or &&

        if (lhs->binaryExpressionCast() != nullptr) {
            auto *binaryExpr = lhs->binaryExpressionCast();
            if (binaryExpr->op == QSOperator::And || binaryExpr->op == QSOperator::Or) {
                syntaxError(binaryExpr->operatorToken, "Left-hand side may not contain || or &&");
                return false;
            }
        }

        if (rhs->binaryExpressionCast() != nullptr) {
            auto *binaryExpr = rhs->binaryExpressionCast();
            if (binaryExpr->op == QSOperator::And || binaryExpr->op == QSOperator::Or) {
                syntaxError(binaryExpr->operatorToken, "Right-hand side may not contain || or &&");
                return false;
            }
        }

        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(lhs, QSOperator::Coalesce, rhs);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

ConditionalExpression: CoalesceExpression;
ConditionalExpression_In: CoalesceExpression_In;

ConditionalExpression: CoalesceExpression T_QUESTION AssignmentExpression_In T_COLON AssignmentExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
ConditionalExpression_In: CoalesceExpression_In T_QUESTION AssignmentExpression_In T_COLON AssignmentExpression_In;
/.
    case $rule_number: {
        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;
./

AssignmentExpression: ConditionalExpression;
AssignmentExpression_In: ConditionalExpression_In;

AssignmentExpression: YieldExpression;
AssignmentExpression_In: YieldExpression_In;

AssignmentExpression: ArrowFunction;
AssignmentExpression_In: ArrowFunction_In;

AssignmentExpression: LeftHandSideExpression T_EQ AssignmentExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
AssignmentExpression_In: LeftHandSideExpression T_EQ AssignmentExpression_In;
/.
    case $rule_number: {
        // need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral
        if (AST::Pattern *p = sym(1).Expression->patternCast()) {
            SourceLocation errorLoc;
            QString errorMsg;
            if (!p->convertLiteralToAssignmentPattern(pool, &errorLoc, &errorMsg)) {
                syntaxError(errorLoc, errorMsg);
                return false;
            }
        }
        // if lhs is an identifier expression and rhs is an anonymous function expression, we need to assign the name of lhs to the function
        if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression)) {
            if (auto *id = AST::cast<AST::IdentifierExpression *>(sym(1).Expression))
                f->name = id->name;
        }
        if (auto *c = asAnonymousClassDefinition(sym(3).Expression)) {
            if (auto *id = AST::cast<AST::IdentifierExpression *>(sym(1).Expression))
                c->name = id->name;
        }

        AST::BinaryExpression *node = new (pool) AST::BinaryExpression(sym(1).Expression, QSOperator::Assign, sym(3).Expression);
        node->operatorToken = loc(2);
        sym(1).Node = node;
    } break;
./

AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
AssignmentExpression_In: LeftHandSideExpression AssignmentOperator AssignmentExpression_In;
/.
    case $rule_number: {
        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;
./

AssignmentOperator: T_STAR_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceMul;
    } break;
./

AssignmentOperator: T_STAR_STAR_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceExp;
    } break;
./

AssignmentOperator: T_DIVIDE_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceDiv;
    } break;
./

AssignmentOperator: T_REMAINDER_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceMod;
    } break;
./

AssignmentOperator: T_PLUS_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceAdd;
    } break;
./

AssignmentOperator: T_MINUS_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceSub;
    } break;
./

AssignmentOperator: T_LT_LT_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceLeftShift;
    } break;
./

AssignmentOperator: T_GT_GT_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceRightShift;
    } break;
./

AssignmentOperator: T_GT_GT_GT_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceURightShift;
    } break;
./

AssignmentOperator: T_AND_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceAnd;
    } break;
./

AssignmentOperator: T_XOR_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceXor;
    } break;
./

AssignmentOperator: T_OR_EQ;
/.
    case $rule_number: {
        sym(1).ival = QSOperator::InplaceOr;
    } break;
./

Expression: AssignmentExpression;
Expression_In: AssignmentExpression_In;

Expression: Expression T_COMMA AssignmentExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Expression_In: Expression_In T_COMMA AssignmentExpression_In;
/.
    case $rule_number: {
          AST::Expression *node = new (pool) AST::Expression(sym(1).Expression, sym(3).Expression);
          node->commaToken = loc(2);
          sym(1).Node = node;
    } break;
./

ExpressionOpt: ;
/.  case $rule_number: Q_FALLTHROUGH(); ./
ExpressionOpt_In: ;
/.
    case $rule_number: {
      sym(1).Node = nullptr;
    } break;
./

ExpressionOpt: Expression;
ExpressionOpt_In: Expression_In;

-- Statements

Statement: ExpressionStatementLookahead T_FORCE_BLOCK BlockStatement;
/.
    case $rule_number: {
        sym(1).Node = sym(3).Node;
    } break;
./

Statement: ExpressionStatementLookahead VariableStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead EmptyStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead ExpressionStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead IfStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead BreakableStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead ContinueStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead BreakStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead ReturnStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead WithStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead LabelledStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead ThrowStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead TryStatement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
Statement: ExpressionStatementLookahead DebuggerStatement;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
    } break;
./

Declaration: HoistableDeclaration;
Declaration: ClassDeclaration;
Declaration: LexicalDeclaration_In;

HoistableDeclaration: FunctionDeclaration;
HoistableDeclaration: GeneratorDeclaration;

HoistableDeclaration_Default: FunctionDeclaration_Default;
HoistableDeclaration_Default: GeneratorDeclaration_Default;

BreakableStatement: IterationStatement;
BreakableStatement: SwitchStatement;

BlockStatement: Block;

Block: T_LBRACE StatementListOpt T_RBRACE;
/.
    case $rule_number: {
        AST::Block *node = new (pool) AST::Block(sym(2).StatementList);
        node->lbraceToken = loc(1);
        node->rbraceToken = loc(3);
        sym(1).Node = node;
    } break;
./

StatementList: StatementListItem;

StatementList: StatementList StatementListItem;
/.
    case $rule_number: {
        sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList);
    } break;
./

StatementListItem: Statement;
/.
    case $rule_number: {
        sym(1).StatementList = new (pool) AST::StatementList(sym(1).Statement);
    } break;
./

StatementListItem: ExpressionStatementLookahead T_FORCE_DECLARATION Declaration Semicolon;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::StatementList(sym(3).FunctionDeclaration);
    } break;
./

StatementListOpt: ExpressionStatementLookahead;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

StatementListOpt: StatementList;
/.
    case $rule_number: {
        sym(1).Node = sym(1).StatementList->finish();
    } break;
./

LetOrConst: T_LET;
/.
    case $rule_number: {
        sym(1).scope = AST::VariableScope::Let;
    } break;
./
LetOrConst: T_CONST;
/.
    case $rule_number: {
        sym(1).scope = AST::VariableScope::Const;
    } break;
./

Var: T_VAR;
/.
    case $rule_number: {
        sym(1).scope = AST::VariableScope::Var;
    } break;
./

LexicalDeclaration: LetOrConst BindingList;
/.  case $rule_number: Q_FALLTHROUGH(); ./
LexicalDeclaration_In: LetOrConst BindingList_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VarDeclaration: Var VariableDeclarationList;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VarDeclaration_In: Var VariableDeclarationList_In;
/.
    case $rule_number: {
        AST::VariableDeclarationList *declarations = sym(2).VariableDeclarationList->finish(sym(1).scope);
        for (auto it = declarations; it; it = it->next) {
            if (it->declaration && it->declaration->typeAnnotation) {
                syntaxError(it->declaration->typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations");
                return false;
            }
        }
        AST::VariableStatement *node = new (pool) AST::VariableStatement(declarations);
        node->declarationKindToken = loc(1);
        sym(1).Node = node;
    } break;
./

VariableStatement: VarDeclaration_In Semicolon;

BindingList: LexicalBinding_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
BindingList_In: LexicalBinding_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclarationList: VariableDeclaration;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclarationList_In: VariableDeclaration_In;
/.
    case $rule_number: {
  sym(1).Node = new (pool) AST::VariableDeclarationList(sym(1).PatternElement);
    } break;
./

BindingList: BindingList T_COMMA LexicalBinding;
/.  case $rule_number: Q_FALLTHROUGH(); ./
BindingList_In: BindingList_In T_COMMA LexicalBinding_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclarationList: VariableDeclarationList T_COMMA VariableDeclaration;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclarationList_In: VariableDeclarationList_In T_COMMA VariableDeclaration_In;
/.
    case $rule_number: {
        AST::VariableDeclarationList *node = new (pool) AST::VariableDeclarationList(sym(1).VariableDeclarationList, sym(3).PatternElement);
        node->commaToken = loc(2);
        sym(1).Node = node;
    } break;
./

LexicalBinding: BindingIdentifier TypeAnnotationOpt InitializerOpt;
/.  case $rule_number: Q_FALLTHROUGH(); ./
LexicalBinding_In: BindingIdentifier TypeAnnotationOpt InitializerOpt_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclaration: BindingIdentifier TypeAnnotationOpt InitializerOpt;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclaration_In: BindingIdentifier TypeAnnotationOpt InitializerOpt_In;
/.
    case $rule_number: {
        auto *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression);
        node->identifierToken = loc(1);
        sym(1).Node = node;
        // if initializer is an anonymous function expression, we need to assign identifierref as it's name
        if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression))
            f->name = stringRef(1);
        if (auto *c = asAnonymousClassDefinition(sym(3).Expression))
            c->name = stringRef(1);
    } break;
./

LexicalBinding: BindingPattern Initializer;
/.  case $rule_number: Q_FALLTHROUGH(); ./
LexicalBinding_In: BindingPattern Initializer_In;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclaration: BindingPattern Initializer;
/.  case $rule_number: Q_FALLTHROUGH(); ./
VariableDeclaration_In: BindingPattern Initializer_In;
/.
    case $rule_number: {
        auto *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression);
        node->identifierToken = loc(1);
        sym(1).Node = node;
    } break;
./

BindingPattern:  T_LBRACE ObjectBindingPattern T_RBRACE;
/.
    case $rule_number: {
        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;
./

BindingPattern: T_LBRACKET ArrayBindingPattern T_RBRACKET;
/.
    case $rule_number: {
        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;
./

ObjectBindingPattern: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

ObjectBindingPattern: BindingPropertyList;
/. case $rule_number: ./
ObjectBindingPattern: BindingPropertyList T_COMMA;
/.
    case $rule_number: {
        sym(1).Node = sym(1).PatternPropertyList->finish();
    } break;
./

ArrayBindingPattern: ElisionOpt BindingRestElementOpt;
/.
    case $rule_number: {
        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;
./

ArrayBindingPattern: BindingElementList;
/.
    case $rule_number: {
        sym(1).Node = sym(1).PatternElementList->finish();
    } break;
./

ArrayBindingPattern: BindingElementList T_COMMA ElisionOpt BindingRestElementOpt;
/.
    case $rule_number: {
        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;
./

BindingPropertyList: BindingProperty;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternProperty);
    } break;
./

BindingPropertyList: BindingPropertyList T_COMMA BindingProperty;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::PatternPropertyList(sym(1).PatternPropertyList, sym(3).PatternProperty);
    } break;
./

BindingElementList: BindingElisionElement;

BindingElementList: BindingElementList T_COMMA BindingElisionElement;
/.
    case $rule_number: {
        sym(1).PatternElementList = sym(1).PatternElementList->append(sym(3).PatternElementList);
    } break;
./

BindingElisionElement: ElisionOpt BindingElement;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::PatternElementList(sym(1).Elision, sym(2).PatternElement);
    } break;
./


BindingProperty: BindingIdentifier InitializerOpt_In;
/.
    case $rule_number: {
        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;
./

BindingProperty: PropertyName T_COLON BindingIdentifier InitializerOpt_In;
/.
    case $rule_number: {
        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, stringRef(3), sym(4).Expression);
        sym(1).Node = node;
    } break;
./

BindingProperty: PropertyName T_COLON BindingPattern InitializerOpt_In;
/.
    case $rule_number: {
        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, sym(3).Pattern, sym(4).Expression);
        sym(1).Node = node;
    } break;
./

BindingElement: BindingIdentifier TypeAnnotationOpt InitializerOpt_In;
/.
    case $rule_number: {
      AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1), sym(2).TypeAnnotation, sym(3).Expression);
      node->identifierToken = loc(1);
      // if initializer is an anonymous function expression, we need to assign identifierref as it's name
      if (auto *f = asAnonymousFunctionDefinition(sym(3).Expression))
          f->name = stringRef(1);
      if (auto *c = asAnonymousClassDefinition(sym(3).Expression))
          c->name = stringRef(1);
      sym(1).Node = node;
    } break;
./

BindingElement: BindingPattern InitializerOpt_In;
/.
    case $rule_number: {
        AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern, sym(2).Expression);
        sym(1).Node = node;
    } break;
./

BindingRestElement: T_ELLIPSIS BindingIdentifier;
/.
    case $rule_number: {
        AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(2), /*type annotation*/nullptr, nullptr, AST::PatternElement::RestElement);
        node->identifierToken = loc(2);
        sym(1).Node = node;
    } break;
./

BindingRestElement: T_ELLIPSIS BindingPattern;
/.
    case $rule_number: {
        AST::PatternElement *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr, AST::PatternElement::RestElement);
        sym(1).Node = node;
    } break;
./

BindingRestElementOpt: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

BindingRestElementOpt: BindingRestElement;


EmptyStatement: T_SEMICOLON;
/.
    case $rule_number: {
        AST::EmptyStatement *node = new (pool) AST::EmptyStatement();
        node->semicolonToken = loc(1);
        sym(1).Node = node;
    } break;
./

-- Spec says it should have a "[lookahead ∉ { {, function, class, let [ }]" before the Expression statement.
-- This is implemented with the rule below that is run before any statement and inserts a T_EXPRESSION_STATEMENT_OK
-- token if it's ok to parse as an expression statement.
ExpressionStatementLookahead: ;
/:
#define J_SCRIPT_EXPRESSIONSTATEMENTLOOKAHEAD_RULE $rule_number
:/
/.
    case $rule_number: {
        int token = lookaheadToken(lexer);
        if (token == T_LBRACE)
            pushToken(T_FORCE_BLOCK);
        else if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS || token == T_LET || token == T_CONST)
            pushToken(T_FORCE_DECLARATION);
    } break;
./

ExpressionStatement: Expression_In Semicolon;
/.
    case $rule_number: {
        AST::ExpressionStatement *node = new (pool) AST::ExpressionStatement(sym(1).Expression);
        node->semicolonToken = loc(2);
        sym(1).Node = node;
    } break;
./

IfStatement: T_IF T_LPAREN Expression_In T_RPAREN Statement T_ELSE Statement;
/.
    case $rule_number: {
        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;
./

IfStatement: T_IF T_LPAREN Expression_In T_RPAREN Statement;
/.
    case $rule_number: {
        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;
./


IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression_In T_RPAREN T_COMPATIBILITY_SEMICOLON;  -- for JSC/V8 compatibility
IterationStatement: T_DO Statement T_WHILE T_LPAREN Expression_In T_RPAREN Semicolon;
/.
    case $rule_number: {
        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;
./

IterationStatement: T_WHILE T_LPAREN Expression_In T_RPAREN Statement;
/.
    case $rule_number: {
        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;
./

IterationStatement: T_FOR T_LPAREN ExpressionOpt T_SEMICOLON ExpressionOpt_In T_SEMICOLON ExpressionOpt_In T_RPAREN Statement; -- [lookahead != { let [ }]
/.
    case $rule_number: {
        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;
./

IterationStatement: T_FOR T_LPAREN VarDeclaration T_SEMICOLON ExpressionOpt_In T_SEMICOLON ExpressionOpt_In T_RPAREN Statement;
/.  case $rule_number: Q_FALLTHROUGH(); ./
IterationStatement: T_FOR T_LPAREN LexicalDeclaration T_SEMICOLON ExpressionOpt_In T_SEMICOLON ExpressionOpt_In T_RPAREN Statement;
/.
    case $rule_number: {
        // ### 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;
./

InOrOf: T_IN;
/.
    case $rule_number: {
        sym(1).forEachType = AST::ForEachType::In;
    } break;
./

InOrOf: T_OF;
/.
    case $rule_number: {
        sym(1).forEachType = AST::ForEachType::Of;
    } break;
./

IterationStatement: T_FOR T_LPAREN LeftHandSideExpression InOrOf Expression_In T_RPAREN Statement;
/.
    case $rule_number: {
        // need to convert the LHS to an AssignmentPattern if it was an Array/ObjectLiteral
        if (AST::Pattern *p = sym(3).Expression->patternCast()) {
            SourceLocation errorLoc;
            QString errorMsg;
            if (!p->convertLiteralToAssignmentPattern(pool, &errorLoc, &errorMsg)) {
                syntaxError(errorLoc, errorMsg);
                return false;
            }
        }
        AST::ForEachStatement *node = new (pool) AST::ForEachStatement(sym(3).Expression, sym(5).Expression, sym(7).Statement);
        node->forToken = loc(1);
        node->lparenToken = loc(2);
        node->inOfToken = loc(4);
        node->rparenToken = loc(6);
        node->type = sym(4).forEachType;
        sym(1).Node = node;
    } break;
./

IterationStatement: T_FOR T_LPAREN ForDeclaration InOrOf Expression_In T_RPAREN Statement;
/.
    case $rule_number: {
        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;
./

ForDeclaration: LetOrConst BindingIdentifier TypeAnnotationOpt;
/.  case $rule_number: Q_FALLTHROUGH(); ./
ForDeclaration: Var BindingIdentifier TypeAnnotationOpt;
/.
    case $rule_number: {
        if (auto typeAnnotation = sym(3).TypeAnnotation) {
            syntaxError(typeAnnotation->firstSourceLocation(), "Type annotations are not permitted in variable declarations");
            return false;
        }
        auto *node = new (pool) AST::PatternElement(stringRef(2), sym(3).TypeAnnotation, nullptr);
        node->identifierToken = loc(2);
        node->scope = sym(1).scope;
        node->isForDeclaration = true;
        sym(1).Node = node;
    } break;
./

ForDeclaration: LetOrConst BindingPattern;
/.  case $rule_number: Q_FALLTHROUGH(); ./
ForDeclaration: Var BindingPattern;
/.
    case $rule_number: {
        auto *node = new (pool) AST::PatternElement(sym(2).Pattern, nullptr);
        node->scope = sym(1).scope;
        node->isForDeclaration = true;
        sym(1).Node = node;
    } break;
./

ContinueStatement: T_CONTINUE Semicolon;
/.
    case $rule_number: {
        AST::ContinueStatement *node = new (pool) AST::ContinueStatement();
        node->continueToken = loc(1);
        node->semicolonToken = loc(2);
        sym(1).Node = node;
    } break;
./

ContinueStatement: T_CONTINUE IdentifierReference Semicolon;
/.
    case $rule_number: {
        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;
./

BreakStatement: T_BREAK Semicolon;
/.
    case $rule_number: {
        AST::BreakStatement *node = new (pool) AST::BreakStatement(QStringRef());
        node->breakToken = loc(1);
        node->semicolonToken = loc(2);
        sym(1).Node = node;
    } break;
./

BreakStatement: T_BREAK IdentifierReference Semicolon;
/.
    case $rule_number: {
        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;
./

ReturnStatement: T_RETURN ExpressionOpt_In Semicolon;
/.
    case $rule_number: {
        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;
./

WithStatement: T_WITH T_LPAREN Expression_In T_RPAREN Statement;
/.
    case $rule_number: {
        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;
./

SwitchStatement: T_SWITCH T_LPAREN Expression_In T_RPAREN CaseBlock;
/.
    case $rule_number: {
        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;
./

CaseBlock: T_LBRACE CaseClausesOpt T_RBRACE;
/.
    case $rule_number: {
        AST::CaseBlock *node = new (pool) AST::CaseBlock(sym(2).CaseClauses);
        node->lbraceToken = loc(1);
        node->rbraceToken = loc(3);
        sym(1).Node = node;
    } break;
./

CaseBlock: T_LBRACE CaseClausesOpt DefaultClause CaseClausesOpt T_RBRACE;
/.
    case $rule_number: {
        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;
./

CaseClauses: CaseClause;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClause);
    } break;
./

CaseClauses: CaseClauses CaseClause;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::CaseClauses(sym(1).CaseClauses, sym(2).CaseClause);
    } break;
./

CaseClausesOpt: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

CaseClausesOpt: CaseClauses;
/.
    case $rule_number: {
        sym(1).Node = sym(1).CaseClauses->finish();
    } break;
./

CaseClause: T_CASE Expression_In T_COLON StatementListOpt;
/.
    case $rule_number: {
        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;
./

DefaultClause: T_DEFAULT T_COLON StatementListOpt;
/.
    case $rule_number: {
        AST::DefaultClause *node = new (pool) AST::DefaultClause(sym(3).StatementList);
        node->defaultToken = loc(1);
        node->colonToken = loc(2);
        sym(1).Node = node;
    } break;
./

LabelledStatement: IdentifierReference T_COLON LabelledItem;
/.
    case $rule_number: {
        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;
./

LabelledItem: Statement;

LabelledItem: ExpressionStatementLookahead T_FORCE_DECLARATION FunctionDeclaration;
/.
    case $rule_number: {
        syntaxError(loc(3), "FunctionDeclarations are not allowed after a label.");
        return false;
    } break;
./

ThrowStatement: T_THROW Expression_In Semicolon;
/.
    case $rule_number: {
        AST::ThrowStatement *node = new (pool) AST::ThrowStatement(sym(2).Expression);
        node->throwToken = loc(1);
        node->semicolonToken = loc(3);
        sym(1).Node = node;
    } break;
./

TryStatement: T_TRY Block Catch;
/.
    case $rule_number: {
        AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Catch);
        node->tryToken = loc(1);
        sym(1).Node = node;
    } break;
./

TryStatement: T_TRY Block Finally;
/.
    case $rule_number: {
        AST::TryStatement *node = new (pool) AST::TryStatement(sym(2).Statement, sym(3).Finally);
        node->tryToken = loc(1);
        sym(1).Node = node;
    } break;
./

TryStatement: T_TRY Block Catch Finally;
/.
    case $rule_number: {
        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;
./

Catch: T_CATCH T_LPAREN CatchParameter T_RPAREN Block;
/.
    case $rule_number: {
        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;
./

Finally: T_FINALLY Block;
/.
    case $rule_number: {
        AST::Finally *node = new (pool) AST::Finally(sym(2).Block);
        node->finallyToken = loc(1);
        sym(1).Node = node;
    } break;
./

CatchParameter: BindingIdentifier;
/.
    case $rule_number: {
        AST::PatternElement *node = new (pool) AST::PatternElement(stringRef(1));
        node->identifierToken = loc(1);
        node->scope = AST::VariableScope::Let;
        sym(1).Node = node;
    } break;
./

CatchParameter: BindingPattern;
/.
    case $rule_number: {
        AST::PatternElement *node = new (pool) AST::PatternElement(sym(1).Pattern);
        node->scope = AST::VariableScope::Let;
        sym(1).Node = node;
    } break;
./

DebuggerStatement: T_DEBUGGER Semicolon;
/.
    case $rule_number: {
        AST::DebuggerStatement *node = new (pool) AST::DebuggerStatement();
        node->debuggerToken = loc(1);
        node->semicolonToken = loc(2);
        sym(1).Node = node;
    } break;
./

-- tell the parser to prefer function declarations to function expressions.
-- That is, the `Function' symbol is used to mark the start of a function
-- declaration.
-- This is still required for parsing QML, where MemberExpression and FunctionDeclaration would
-- otherwise conflict.
Function: T_FUNCTION %prec REDUCE_HERE;

FunctionDeclaration: Function BindingIdentifier T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
            return false;
        AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList,
                                                                             /*type annotation*/nullptr);
        node->functionToken = loc(1);
        node->identifierToken = loc(2);
        node->lparenToken = loc(3);
        node->rparenToken = loc(5);
        node->lbraceToken = loc(7);
        node->rbraceToken = loc(9);
        sym(1).Node = node;
    } break;
./

FunctionDeclarationWithTypes: Function BindingIdentifier T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList,
                                                                             sym(6).TypeAnnotation);
        node->functionToken = loc(1);
        node->identifierToken = loc(2);
        node->lparenToken = loc(3);
        node->rparenToken = loc(5);
        node->lbraceToken = loc(7);
        node->rbraceToken = loc(9);
        sym(1).Node = node;
    } break;
./

FunctionDeclaration_Default: FunctionDeclaration;
FunctionDeclaration_Default: Function T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList))
            return false;
        AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList,
                                                                             /*type annotation*/nullptr);
        node->functionToken = loc(1);
        node->lparenToken = loc(2);
        node->rparenToken = loc(4);
        node->lbraceToken = loc(6);
        node->rbraceToken = loc(8);
        sym(1).Node = node;
    } break;
./

FunctionExpression: T_FUNCTION BindingIdentifier T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
            return false;
        AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList,
                                                                           /*type annotation*/nullptr);
        node->functionToken = loc(1);
        if (! stringRef(2).isNull())
          node->identifierToken = loc(2);
        node->lparenToken = loc(3);
        node->rparenToken = loc(5);
        node->lbraceToken = loc(7);
        node->rbraceToken = loc(9);
        sym(1).Node = node;
    } break;
./

FunctionExpression: T_FUNCTION T_LPAREN FormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList))
            return false;
        AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(7).StatementList,
                                                                           /*type annotation*/nullptr);
        node->functionToken = loc(1);
        node->lparenToken = loc(2);
        node->rparenToken = loc(4);
        node->lbraceToken = loc(6);
        node->rbraceToken = loc(8);
        sym(1).Node = node;
    } break;
./

StrictFormalParameters: FormalParameters;

FormalParameters: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

FormalParameters: BindingRestElement;
/.
    case $rule_number: {
        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);
        sym(1).Node = node;
    } break;
./

FormalParameters: FormalParameterList;
/. case $rule_number: ./
FormalParameters: FormalParameterList T_COMMA;
/.
    case $rule_number: {
        sym(1).Node = sym(1).FormalParameterList->finish(pool);
    } break;
./

FormalParameters: FormalParameterList T_COMMA BindingRestElement;
/.
    case $rule_number: {
        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement))->finish(pool);
        sym(1).Node = node;
    } break;
./

FormalParameterList: BindingElement;
/.
    case $rule_number: {
        AST::FormalParameterList *node = new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement);
        sym(1).Node = node;
    } break;
./


FormalParameterList: FormalParameterList T_COMMA BindingElement;
/.
    case $rule_number: {
        AST::FormalParameterList *node = new (pool) AST::FormalParameterList(sym(1).FormalParameterList, sym(3).PatternElement);
        sym(1).Node = node;
    } break;
./

FormalParameter: BindingElement;

FunctionLBrace: T_LBRACE;
/.
    case $rule_number: {
        ++functionNestingLevel;
    } break;
./

FunctionRBrace: T_RBRACE;
/.
    case $rule_number: {
        --functionNestingLevel;
    } break;
./


FunctionBody: StatementListOpt;

ArrowFunction: ArrowParameters T_ARROW ConciseBodyLookahead AssignmentExpression; -- [lookahead ≠ {]
/.  case $rule_number: Q_FALLTHROUGH(); ./
ArrowFunction_In: ArrowParameters T_ARROW ConciseBodyLookahead AssignmentExpression_In; -- [lookahead ≠ {]
/.
    case $rule_number: {
        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;
./

ArrowFunction: ArrowParameters T_ARROW ConciseBodyLookahead T_FORCE_BLOCK FunctionLBrace FunctionBody FunctionRBrace;
/.  case $rule_number: Q_FALLTHROUGH(); ./
ArrowFunction_In: ArrowParameters T_ARROW ConciseBodyLookahead T_FORCE_BLOCK FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        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;
./

ArrowParameters: BindingIdentifier;
/.
    case $rule_number: {
        AST::PatternElement *e = new (pool) AST::PatternElement(stringRef(1), /*type annotation*/nullptr, nullptr, AST::PatternElement::Binding);
        e->identifierToken = loc(1);
        sym(1).FormalParameterList = (new (pool) AST::FormalParameterList(nullptr, e))->finish(pool);
    } break;
./

-- CoverParenthesizedExpressionAndArrowParameterList for ArrowParameters i being refined to:
-- ArrowFormalParameters: T_LPAREN StrictFormalParameters T_RPAREN
ArrowParameters: CoverParenthesizedExpressionAndArrowParameterList;
/.
    case $rule_number: {
        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;
./

ConciseBodyLookahead: ;
/:
#define J_SCRIPT_CONCISEBODYLOOKAHEAD_RULE $rule_number
:/
/.
    case $rule_number: {
        if (lookaheadToken(lexer) == T_LBRACE)
            pushToken(T_FORCE_BLOCK);
    } break;
./

MethodDefinition: PropertyName T_LPAREN StrictFormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, sym(3).FormalParameterList))
            return false;
        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(1), sym(3).FormalParameterList, sym(7).StatementList);
        f->functionToken = sym(1).PropertyName->firstSourceLocation();
        f->lparenToken = loc(2);
        f->rparenToken = loc(4);
        f->lbraceToken = loc(6);
        f->rbraceToken = loc(8);
        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(1).PropertyName, f, AST::PatternProperty::Method);
        node->colonToken = loc(2);
        sym(1).Node = node;
    } break;
./

MethodDefinition: T_STAR PropertyName GeneratorLParen StrictFormalParameters T_RPAREN TypeAnnotationOpt FunctionLBrace GeneratorBody GeneratorRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
            return false;
        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList);
        f->functionToken = sym(2).PropertyName->firstSourceLocation();
        f->lparenToken = loc(3);
        f->rparenToken = loc(5);
        f->lbraceToken = loc(7);
        f->rbraceToken = loc(9);
        f->isGenerator = true;
        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Method);
        node->colonToken = loc(2);
        sym(1).Node = node;
    } break;
./


MethodDefinition: T_GET PropertyName T_LPAREN T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(5).TypeAnnotation, /*formals*/nullptr))
            return false;
        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), nullptr, sym(7).StatementList);
        f->functionToken = sym(2).PropertyName->firstSourceLocation();
        f->lparenToken = loc(3);
        f->rparenToken = loc(4);
        f->lbraceToken = loc(6);
        f->rbraceToken = loc(8);
        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Getter);
        node->colonToken = loc(2);
        sym(1).Node = node;
    } break;
./

MethodDefinition: T_SET PropertyName T_LPAREN PropertySetParameterList T_RPAREN TypeAnnotationOpt FunctionLBrace FunctionBody FunctionRBrace;
/.
    case $rule_number: {
        if (!ensureNoFunctionTypeAnnotations(sym(6).TypeAnnotation, sym(4).FormalParameterList))
            return false;
        AST::FunctionExpression *f = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(8).StatementList);
        f->functionToken = sym(2).PropertyName->firstSourceLocation();
        f->lparenToken = loc(3);
        f->rparenToken = loc(5);
        f->lbraceToken = loc(7);
        f->rbraceToken = loc(9);
        AST::PatternProperty *node = new (pool) AST::PatternProperty(sym(2).PropertyName, f, AST::PatternProperty::Setter);
        node->colonToken = loc(2);
        sym(1).Node = node;
    } break;
./


PropertySetParameterList: FormalParameter;
/.
    case $rule_number: {
        AST::FormalParameterList *node = (new (pool) AST::FormalParameterList(nullptr, sym(1).PatternElement))->finish(pool);
        sym(1).Node = node;
    } break;
./

GeneratorLParen: T_LPAREN;
/.
    case $rule_number: {
        lexer->enterGeneratorBody();
    } break;
./

GeneratorRBrace: T_RBRACE;
/.
    case $rule_number: {
        --functionNestingLevel;
        lexer->leaveGeneratorBody();
    } break;
./

FunctionStar: T_FUNCTION_STAR %prec REDUCE_HERE;

GeneratorDeclaration: FunctionStar BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;
/.
    case $rule_number: {
        AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);
        node->functionToken = loc(1);
        node->identifierToken = loc(2);
        node->lparenToken = loc(3);
        node->rparenToken = loc(5);
        node->lbraceToken = loc(6);
        node->rbraceToken = loc(8);
        node->isGenerator = true;
        sym(1).Node = node;
    } break;
./

GeneratorDeclaration_Default: GeneratorDeclaration;
GeneratorDeclaration_Default: FunctionStar GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;
/.
    case $rule_number: {
        AST::FunctionDeclaration *node = new (pool) AST::FunctionDeclaration(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList);
        node->functionToken = loc(1);
        node->lparenToken = loc(2);
        node->rparenToken = loc(4);
        node->lbraceToken = loc(5);
        node->rbraceToken = loc(7);
        node->isGenerator = true;
        sym(1).Node = node;
    } break;
./

GeneratorExpression: T_FUNCTION_STAR BindingIdentifier GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;
/.
    case $rule_number: {
        AST::FunctionExpression *node = new (pool) AST::FunctionExpression(stringRef(2), sym(4).FormalParameterList, sym(7).StatementList);
        node->functionToken = loc(1);
        if (!stringRef(2).isNull())
          node->identifierToken = loc(2);
        node->lparenToken = loc(3);
        node->rparenToken = loc(5);
        node->lbraceToken = loc(6);
        node->rbraceToken = loc(8);
        node->isGenerator = true;
        sym(1).Node = node;
    } break;
./

GeneratorExpression: T_FUNCTION_STAR GeneratorLParen FormalParameters T_RPAREN FunctionLBrace GeneratorBody GeneratorRBrace;
/.
    case $rule_number: {
        AST::FunctionExpression *node = new (pool) AST::FunctionExpression(QStringRef(), sym(3).FormalParameterList, sym(6).StatementList);
        node->functionToken = loc(1);
        node->lparenToken = loc(2);
        node->rparenToken = loc(4);
        node->lbraceToken = loc(5);
        node->rbraceToken = loc(7);
        node->isGenerator = true;
        sym(1).Node = node;
    } break;
./

GeneratorBody: FunctionBody;

YieldExpression: T_YIELD;
/.  case $rule_number: Q_FALLTHROUGH(); ./
YieldExpression_In: T_YIELD;
/.
    case $rule_number: {
        AST::YieldExpression *node = new (pool) AST::YieldExpression();
        node->yieldToken = loc(1);
        sym(1).Node = node;
    } break;
./

YieldExpression: T_YIELD T_STAR AssignmentExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
YieldExpression_In: T_YIELD T_STAR AssignmentExpression_In;
/.
    case $rule_number: {
        AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(3).Expression);
        node->yieldToken = loc(1);
        node->isYieldStar = true;
        sym(1).Node = node;
    } break;
./

YieldExpression: T_YIELD AssignmentExpression;
/.  case $rule_number: Q_FALLTHROUGH(); ./
YieldExpression_In: T_YIELD AssignmentExpression_In;
/.
    case $rule_number: {
        AST::YieldExpression *node = new (pool) AST::YieldExpression(sym(2).Expression);
        node->yieldToken = loc(1);
        sym(1).Node = node;
    } break;
./


ClassDeclaration: T_CLASS BindingIdentifier ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;
/.
    case $rule_number: {
        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;
./

ClassExpression: T_CLASS BindingIdentifier ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;
/.
    case $rule_number: {
        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;
./

ClassDeclaration_Default: T_CLASS ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;
/.
    case $rule_number: {
        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;
./

ClassExpression: T_CLASS ClassHeritageOpt ClassLBrace ClassBodyOpt ClassRBrace;
/.
    case $rule_number: {
        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;
./

ClassDeclaration_Default: ClassDeclaration;

ClassLBrace: T_LBRACE;
/.
    case $rule_number: {
        lexer->setStaticIsKeyword(true);
    } break;
./

ClassRBrace: T_RBRACE;
/. case $rule_number: ./
ClassStaticQualifier: T_STATIC;
/.
    case $rule_number: {
        lexer->setStaticIsKeyword(false);
    } break;
./

ClassHeritageOpt: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

ClassHeritageOpt: T_EXTENDS LeftHandSideExpression;
/.
    case $rule_number: {
        sym(1).Node = sym(2).Node;
    } break;
./

ClassBodyOpt: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

ClassBodyOpt: ClassElementList;
/.
    case $rule_number: {
        if (sym(1).Node)
            sym(1).Node = sym(1).ClassElementList->finish();
    } break;
./

ClassElementList: ClassElement;

ClassElementList: ClassElementList ClassElement;
/.
    case $rule_number: {
        if (sym(1).Node) {
            if (sym(2).Node)
                sym(1).ClassElementList = sym(1).ClassElementList->append(sym(2).ClassElementList);
        } else if (sym(2).Node) {
            sym(1).Node = sym(2).Node;
        }
    } break;
./

ClassElement: MethodDefinition;
/.
    case $rule_number: {
        AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(1).PatternProperty, false);
        sym(1).Node = node;
    } break;
./

ClassElement: ClassStaticQualifier MethodDefinition;
/.
    case $rule_number: {
        lexer->setStaticIsKeyword(true);
        AST::ClassElementList *node = new (pool) AST::ClassElementList(sym(2).PatternProperty, true);
        sym(1).Node = node;
    } break;
./

ClassElement: T_SEMICOLON;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

-- Scripts and Modules

Script: ;
/.
    case $rule_number: {
        sym(1).Node = nullptr;
    } break;
./

Script: ScriptBody;

ScriptBody: StatementList;
/.
    case $rule_number: {
        sym(1).Node = new (pool) AST::Program(sym(1).StatementList->finish());
    } break;
./

Module: ModuleBodyOpt;
/.  case $rule_number: {
        sym(1).Node = new (pool) AST::ESModule(sym(1).StatementList);
    } break;
./

ModuleBody: ModuleItemList;
/.
    case $rule_number: {
        sym(1).StatementList = sym(1).StatementList->finish();
    } break;
./

ModuleBodyOpt: ;
/.
    case $rule_number: {
        sym(1).StatementList = nullptr;
    } break;
./
ModuleBodyOpt: ModuleBody;

ModuleItemList: ModuleItem;

ModuleItemList: ModuleItemList ModuleItem;
/.
    case $rule_number: {
        sym(1).StatementList = sym(1).StatementList->append(sym(2).StatementList);
    } break;
./


ModuleItem: ImportDeclaration Semicolon;
/. case $rule_number:  Q_FALLTHROUGH(); ./
ModuleItem: ExportDeclaration Semicolon;
/.
    case $rule_number: {
        sym(1).StatementList = new (pool) AST::StatementList(sym(1).Node);
    } break;
./

ModuleItem: StatementListItem;

ImportDeclaration: T_IMPORT ImportClause FromClause;
/.
    case $rule_number: {
        auto decl = new (pool) AST::ImportDeclaration(sym(2).ImportClause, sym(3).FromClause);
        decl->importToken = loc(1);
        sym(1).Node = decl;
    } break;
./
ImportDeclaration: T_IMPORT ModuleSpecifier;
/.
    case $rule_number: {
        auto decl = new (pool) AST::ImportDeclaration(stringRef(2));
        decl->importToken = loc(1);
        decl->moduleSpecifierToken = loc(2);
        sym(1).Node = decl;
    } break;
./

ImportClause: ImportedDefaultBinding;
/.
    case $rule_number: {
        auto clause = new (pool) AST::ImportClause(stringRef(1));
        clause->importedDefaultBindingToken = loc(1);
        sym(1).ImportClause = clause;
    } break;
./
ImportClause: NameSpaceImport;
/.
    case $rule_number: {
        sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NameSpaceImport);
    } break;
./
ImportClause: NamedImports;
/.
    case $rule_number: {
        sym(1).ImportClause = new (pool) AST::ImportClause(sym(1).NamedImports);
    } break;
./
ImportClause: ImportedDefaultBinding T_COMMA NameSpaceImport;
/.
    case $rule_number: {
        auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NameSpaceImport);
        importClause->importedDefaultBindingToken = loc(1);
        sym(1).ImportClause = importClause;
    } break;
./
ImportClause: ImportedDefaultBinding T_COMMA NamedImports;
/.
    case $rule_number: {
        auto importClause = new (pool) AST::ImportClause(stringRef(1), sym(3).NamedImports);
        importClause->importedDefaultBindingToken = loc(1);
        sym(1).ImportClause = importClause;
    } break;
./

ImportedDefaultBinding: ImportedBinding;

NameSpaceImport: T_STAR T_AS ImportedBinding;
/.
    case $rule_number: {
        auto import = new (pool) AST::NameSpaceImport(stringRef(3));
        import->starToken = loc(1);
        import->importedBindingToken = loc(3);
        sym(1).NameSpaceImport = import;
    } break;
./

NamedImports: T_LBRACE T_RBRACE;
/.
    case $rule_number: {
        auto namedImports = new (pool) AST::NamedImports();
        namedImports->leftBraceToken = loc(1);
        namedImports->rightBraceToken = loc(2);
        sym(1).NamedImports = namedImports;
    } break;
./
NamedImports: T_LBRACE ImportsList T_RBRACE;
/.
    case $rule_number: {
        auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish());
        namedImports->leftBraceToken = loc(1);
        namedImports->rightBraceToken = loc(3);
        sym(1).NamedImports = namedImports;
    } break;
./
NamedImports: T_LBRACE ImportsList T_COMMA T_RBRACE;
/.
    case $rule_number: {
        auto namedImports = new (pool) AST::NamedImports(sym(2).ImportsList->finish());
        namedImports->leftBraceToken = loc(1);
        namedImports->rightBraceToken = loc(4);
        sym(1).NamedImports = namedImports;
    } break;
./

FromClause: T_FROM ModuleSpecifier;
/.
    case $rule_number: {
        auto clause = new (pool) AST::FromClause(stringRef(2));
        clause->fromToken = loc(1);
        clause->moduleSpecifierToken = loc(2);
        sym(1).FromClause = clause;
    } break;
./

ImportsList: ImportSpecifier;
/.
    case $rule_number: {
        auto importsList = new (pool) AST::ImportsList(sym(1).ImportSpecifier);
        importsList->importSpecifierToken = loc(1);
        sym(1).ImportsList = importsList;
    } break;
./
ImportsList: ImportsList T_COMMA ImportSpecifier;
/.
    case $rule_number: {
        auto importsList = new (pool) AST::ImportsList(sym(1).ImportsList, sym(3).ImportSpecifier);
        importsList->importSpecifierToken = loc(3);
        sym(1).ImportsList = importsList;
    } break;
./

-- When enconutering an IdentifierReference it can resolve to both ImportedBinding and IdentifierName
-- Using %right and %prec, we tell qlalr that it should not reduce immediately, but rather shift
-- so that we have a chance of actually parsing the correct rule if there is an "as" identifier
ImportSpecifier: ImportedBinding %prec T_WITHOUTAS;
/.
    case $rule_number: {
        auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1));
        importSpecifier->importedBindingToken = loc(1);
        sym(1).ImportSpecifier = importSpecifier;
    } break;
./
ImportSpecifier: IdentifierName T_AS ImportedBinding;
/.
    case $rule_number: {
    auto importSpecifier = new (pool) AST::ImportSpecifier(stringRef(1), stringRef(3));
    importSpecifier->identifierToken = loc(1);
    importSpecifier->importedBindingToken = loc(3);
    sym(1).ImportSpecifier = importSpecifier;
    } break;
./

ModuleSpecifier: T_STRING_LITERAL;

ImportedBinding: BindingIdentifier;

ExportDeclarationLookahead: ;
/:
#define J_SCRIPT_EXPORTDECLARATIONLOOKAHEAD_RULE $rule_number
:/
/.
    case $rule_number: {
        int token = lookaheadToken(lexer);
        if (token == T_FUNCTION || token == T_FUNCTION_STAR || token == T_CLASS)
            pushToken(T_FORCE_DECLARATION);
    } break;
./

ExportDeclaration: T_EXPORT T_STAR FromClause;
/.
    case $rule_number: {
        auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(3).FromClause);
        exportDeclaration->exportToken = loc(1);
        sym(1).ExportDeclaration = exportDeclaration;
    } break;
./
ExportDeclaration: T_EXPORT ExportClause FromClause;
/.
    case $rule_number: {
        auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause, sym(3).FromClause);
        exportDeclaration->exportToken = loc(1);
        sym(1).ExportDeclaration = exportDeclaration;
    } break;
./
ExportDeclaration: T_EXPORT ExportClause;
/.
    case $rule_number: {
        auto exportDeclaration = new (pool) AST::ExportDeclaration(sym(2).ExportClause);
        exportDeclaration->exportToken = loc(1);
        sym(1).ExportDeclaration = exportDeclaration;
    } break;
./
ExportDeclaration: T_EXPORT VariableStatement;
/. case $rule_number:  Q_FALLTHROUGH(); ./
ExportDeclaration: T_EXPORT Declaration;
/.
    case $rule_number: {
        auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/false, sym(2).Node);
        exportDeclaration->exportToken = loc(1);
        sym(1).ExportDeclaration = exportDeclaration;
    } break;
./
ExportDeclaration: T_EXPORT T_DEFAULT ExportDeclarationLookahead T_FORCE_DECLARATION HoistableDeclaration_Default;
/.
    case $rule_number: {
        if (auto *f = AST::cast<AST::FunctionDeclaration*>(sym(5).Node)) {
            if (f->name.isEmpty()) {
                f->name = stringRef(2);
                f->identifierToken = loc(2);
            }
        }
    } Q_FALLTHROUGH();
./
ExportDeclaration: T_EXPORT T_DEFAULT ExportDeclarationLookahead T_FORCE_DECLARATION ClassDeclaration_Default;
/.
    case $rule_number: {
        // Emulate 15.2.3.11
        if (auto *cls = AST::cast<AST::ClassDeclaration*>(sym(5).Node)) {
            if (cls->name.isEmpty()) {
                cls->name = stringRef(2);
                cls->identifierToken = loc(2);
            }
        }

        auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/true, sym(5).Node);
        exportDeclaration->exportToken = loc(1);
        sym(1).ExportDeclaration = exportDeclaration;
    } break;
./
ExportDeclaration: T_EXPORT T_DEFAULT ExportDeclarationLookahead AssignmentExpression_In; -- [lookahead ∉ { function, class }]
/.
    case $rule_number: {
        // if lhs is an identifier expression and rhs is an anonymous function expression, we need to assign the name of lhs to the function
        if (auto *f = asAnonymousFunctionDefinition(sym(4).Node)) {
            f->name = stringRef(2);
        }
        if (auto *c = asAnonymousClassDefinition(sym(4).Expression)) {
            c->name = stringRef(2);
        }

        auto exportDeclaration = new (pool) AST::ExportDeclaration(/*exportDefault=*/true, sym(4).Node);
        exportDeclaration->exportToken = loc(1);
        sym(1).ExportDeclaration = exportDeclaration;
    } break;
./

ExportClause: T_LBRACE T_RBRACE;
/.
    case $rule_number: {
        auto exportClause = new (pool) AST::ExportClause();
        exportClause->leftBraceToken = loc(1);
        exportClause->rightBraceToken = loc(2);
        sym(1).ExportClause = exportClause;
    } break;
./
ExportClause: T_LBRACE ExportsList T_RBRACE;
/.
    case $rule_number: {
        auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish());
        exportClause->leftBraceToken = loc(1);
        exportClause->rightBraceToken = loc(3);
        sym(1).ExportClause = exportClause;
    } break;
./
ExportClause: T_LBRACE ExportsList T_COMMA T_RBRACE;
/.
    case $rule_number: {
        auto exportClause = new (pool) AST::ExportClause(sym(2).ExportsList->finish());
        exportClause->leftBraceToken = loc(1);
        exportClause->rightBraceToken = loc(4);
        sym(1).ExportClause = exportClause;
    } break;
./

ExportsList: ExportSpecifier;
/.
    case $rule_number: {
        sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportSpecifier);
    } break;
./
ExportsList: ExportsList T_COMMA ExportSpecifier;
/.
    case $rule_number: {
        sym(1).ExportsList = new (pool) AST::ExportsList(sym(1).ExportsList, sym(3).ExportSpecifier);
    } break;
./

ExportSpecifier: IdentifierName;
/.
    case $rule_number: {
        auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1));
        exportSpecifier->identifierToken = loc(1);
        sym(1).ExportSpecifier = exportSpecifier;
    } break;
./
ExportSpecifier: IdentifierName T_AS IdentifierName;
/.
    case $rule_number: {
        auto exportSpecifier = new (pool) AST::ExportSpecifier(stringRef(1), stringRef(3));
        exportSpecifier->identifierToken = loc(1);
        exportSpecifier->exportedIdentifierToken = loc(3);
        sym(1).ExportSpecifier = exportSpecifier;
    } break;
./

-- Old top level code

/.
    // ------------ end of switch statement
            } // switch
            action = nt_action(state_stack[tos], lhs[r] - TERMINAL_COUNT);
        } // if
    } while (action != 0);

#ifdef PARSER_DEBUG
    qDebug() << "Done or error.";
#endif

    if (first_token == last_token) {
        const int errorState = state_stack[tos];

        // automatic insertion of `;'
        if (yytoken != -1 && ((t_action(errorState, T_AUTOMATIC_SEMICOLON) && lexer->canInsertAutomaticSemicolon(yytoken))
                              || t_action(errorState, T_COMPATIBILITY_SEMICOLON))) {
#ifdef PARSER_DEBUG
            qDebug() << "Inserting automatic semicolon.";
#endif
            SavedToken &tk = token_buffer[0];
            tk.token = yytoken;
            tk.dval = yylval;
            tk.spell = yytokenspell;
            tk.raw = yytokenraw;
            tk.loc = yylloc;

            yylloc = yyprevlloc;
            yylloc.offset += yylloc.length;
            yylloc.startColumn += yylloc.length;
            yylloc.length = 0;

            //const QString msg = QCoreApplication::translate("QQmlParser", "Missing `;'");
            //diagnostic_messages.append(compileError(yyloc, msg, QtWarningMsg));

            first_token = &token_buffer[0];
            last_token = &token_buffer[1];

            yytoken = T_SEMICOLON;
            yylval = 0;

            action = errorState;

            goto _Lcheck_token;
        }

        hadErrors = true;

        token_buffer[0].token = yytoken;
        token_buffer[0].dval = yylval;
        token_buffer[0].spell = yytokenspell;
        token_buffer[0].raw = yytokenraw;
        token_buffer[0].loc = yylloc;

        token_buffer[1].token = yytoken       = lexer->lex();
        token_buffer[1].dval  = yylval        = lexer->tokenValue();
        token_buffer[1].spell = yytokenspell  = lexer->tokenSpell();
        token_buffer[1].raw   = yytokenraw    = lexer->rawString();
        token_buffer[1].loc   = yylloc        = location(lexer);

        if (t_action(errorState, yytoken)) {
#ifdef PARSER_DEBUG
            qDebug() << "Parse error, trying to recover.";
#endif
            QString msg;
            int token = token_buffer[0].token;
            if (token < 0 || token >= TERMINAL_COUNT)
                msg = QCoreApplication::translate("QQmlParser", "Syntax error");
            else
                msg = QCoreApplication::translate("QQmlParser", "Unexpected token `%1'").arg(QLatin1String(spell[token]));
            diagnostic_messages.append(compileError(token_buffer[0].loc, msg));

            action = errorState;
            goto _Lcheck_token;
        }

        static int tokens[] = {
            T_PLUS,
            T_EQ,

            T_COMMA,
            T_COLON,
            T_SEMICOLON,

            T_RPAREN, T_RBRACKET, T_RBRACE,

            T_NUMERIC_LITERAL,
            T_IDENTIFIER,

            T_LPAREN, T_LBRACKET, T_LBRACE,

            EOF_SYMBOL
        };

        for (int *tk = tokens; *tk != EOF_SYMBOL; ++tk) {
            int a = t_action(errorState, *tk);
            if (a > 0 && t_action(a, yytoken)) {
#ifdef PARSER_DEBUG
                qDebug() << "Parse error, trying to recover (2).";
#endif
                const QString msg = QCoreApplication::translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[*tk]));
                diagnostic_messages.append(compileError(token_buffer[0].loc, msg));

                pushToken(*tk);
                goto _Lcheck_token;
            }
        }

        for (int tk = 1; tk < TERMINAL_COUNT; ++tk) {
            if (tk == T_AUTOMATIC_SEMICOLON || tk == T_FEED_UI_PROGRAM    ||
                tk == T_FEED_JS_STATEMENT   || tk == T_FEED_JS_EXPRESSION)
               continue;

            int a = t_action(errorState, tk);
            if (a > 0 && t_action(a, yytoken)) {
                const QString msg = QCoreApplication::translate("QQmlParser", "Expected token `%1'").arg(QLatin1String(spell[tk]));
                diagnostic_messages.append(compileError(token_buffer[0].loc, msg));

                pushToken(tk);
                goto _Lcheck_token;
            }
        }

        const QString msg = QCoreApplication::translate("QQmlParser", "Syntax error");
        diagnostic_messages.append(compileError(token_buffer[0].loc, msg));
    }

    return false;
}

QT_END_NAMESPACE


./
/:
QT_END_NAMESPACE


#endif // QQMLJSPARSER_P_H
:/