p4parser.ypp

/*
SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.

SPDX-License-Identifier: Apache-2.0
*/

// Use Bison's C++ mode.
%skeleton "lalr1.cc" /* -*-C++-*- */
%require "3.0.0"

// Set up names.
%defines
%define api.namespace {P4}
%define api.parser.class {P4Parser}

// Use the C++-native variant representation of tokens.
%define api.token.constructor
%define api.value.type variant

// Add asserts to ensure that we use the API correctly.
%define parse.assert true

// Enable verbose error reporting.
%define parse.error verbose

// Declare dependencies.
%code requires {
#include <cassert>   // NOLINT(build/include_order)
#include <iostream>  // NOLINT(build/include_order)

#include "frontends/common/constantParsing.h"
#include "frontends/common/options.h"
#include "ir/ir.h"
#include "lib/cstring.h"
#include "lib/source_file.h"

// Ignore a warning caused by autogenerated code.
// The #if pragma is a little awkward because some preprocessors do not like ||
#pragma GCC diagnostic push
#if defined(__has_warning)
#if __has_warning("-Wunused-but-set-variable")
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#endif
#if __has_warning("-Wswitch-enum")
#pragma GCC diagnostic ignored "-Wswitch-enum"
#endif
#else
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wswitch-enum"
#endif

namespace P4 {
class AbstractP4Lexer;
class P4ParserDriver;

// This is a workaround for an UndefinedBehaviorSanitizer issue triggered by
// Bison's variant implementation. When variant::move() is used to move a value
// from an initialized instance of variant to an uninitialized instance, it uses
// placement new to initialize the uninitialized instance, then calls
// variant::swap(), then destroys the moved-from instance. The problem is that
// placement new does not perform any initialization for primitive types, and
// for bool or enum types that can result in a value that isn't a valid element
// of those types, which UndefinedBehaviorSanitizer doesn't like.
struct OptionalConst {
    OptionalConst() = default;
    explicit OptionalConst(bool isConst) : isConst(isConst) { }
    bool isConst = false;
};

inline std::ostream& operator<<(std::ostream& out, const OptionalConst& oc) {
    out << "OptionalConst(" << oc.isConst << ')';
    return out;
}

// Bison uses the types you provide to %type to make constructors for the
// variant type it uses under the hood, but its code generation is a little
// naive and it always prepends 'const' to the type. This is problematic when
// the symbol type we want is itself const, since duplicate const qualifiers are
// forbidden in C++. We avoid the problem using a typedef.
typedef const IR::Type ConstType;

struct NameTypePair {
    IR::ID name;
    const IR::Type *type;
};

inline std::ostream &operator<<(std::ostream &out, const NameTypePair &nt) {
    return out << nt.name << ":" << nt.type;
}

}  // namespace P4

#ifndef YYDEBUG
#define YYDEBUG 1
#endif

#define YY_NULLPTR nullptr

namespace P4 {
using namespace literals;

class Token {
 public:
    int type;
    cstring text;
    UnparsedConstant* unparsedConstant;

    Token() : Token(0, cstring::empty, nullptr) { }
    Token(int type, cstring text) : Token(type, text, nullptr) { }
    Token(int type, const char* text) : Token(type, cstring(text), nullptr) { }    
    Token(int type, UnparsedConstant unparsedConstant)
            : Token(type, unparsedConstant.text,
                    new UnparsedConstant(unparsedConstant)) { }

 private:
    Token(int type, cstring text, UnparsedConstant* unparsedConstant)
            : type(type), text(text), unparsedConstant(unparsedConstant) { }
};

inline std::ostream& operator<<(std::ostream& out, const Token& t) {
    out << t.text;
    return out;
}

}  // namespace P4

}

%param { P4::P4ParserDriver& driver }
%parse-param { P4::AbstractP4Lexer& lexer }

// Use location tracking with our custom location type.
%locations
%define api.location.type {Util::SourceInfo}

%{ /* -*-C++-*- */
#include "frontends/parsers/parserDriver.h"
#include "frontends/parsers/p4/p4lexer.hpp"
#include "frontends/parsers/p4/p4parser.hpp"

using namespace P4;

#define YYLLOC_DEFAULT(Cur, Rhs, N)                                                        \
    ((Cur) = (N) ? YYRHSLOC(Rhs, 1) + YYRHSLOC(Rhs, N)                                     \
        : YYRHSLOC(Rhs, 0) ?  Util::SourceInfo(driver.sources, YYRHSLOC(Rhs, 0).getEnd())  \
                 : Util::SourceInfo(driver.sources, driver.sources->getCurrentPosition()))
#undef yylex
#define yylex lexer.yylex

%}

// Use iostreams to print all values.
%printer { yyoutput << $$; } <*>;

%define api.token.prefix {TOK_}
%token             START_PROGRAM

                   // Lists
                   START_EXPRESSION_LIST
                   START_KV_LIST
                   START_INTEGER_LIST
                   START_INTEGER_OR_STRING_LITERAL_LIST
                   START_STRING_LITERAL_LIST

                   // Singletons
                   START_EXPRESSION
                   START_INTEGER
                   START_INTEGER_OR_STRING_LITERAL
                   START_STRING_LITERAL

                   // Pairs
                   START_EXPRESSION_PAIR
                   START_INTEGER_PAIR
                   START_STRING_LITERAL_PAIR

                   // Triples
                   START_EXPRESSION_TRIPLE
                   START_INTEGER_TRIPLE
                   START_STRING_LITERAL_TRIPLE

                   // P4Runtime annotations
                   START_P4RT_TRANSLATION_ANNOTATION  // @p4runtime_translation

%token             END END_ANNOTATION


///////////////////////////////////////////////////////////////////////////////
//
// Language token definitions.
//
// NB: Tokens defined here should be added to the annotationToken production.
//
///////////////////////////////////////////////////////////////////////////////

%token<Token>      UNEXPECTED_TOKEN END_PRAGMA
%token<Token>      LE "<="
%token<Token>      GE ">="
%token<Token>      SHL "<<"
%token<Token>      AND "&&"
%token<Token>      OR "||"
%token<Token>      NE "!="
%token<Token>      EQ "=="
%token<Token>      PLUS "+"
%token<Token>      MINUS "-"
%token<Token>      PLUS_SAT "|+|"
%token<Token>      MINUS_SAT "|-|"
%token<Token>      MUL "*"
%token<Token>      INVALID "{#}"
%token<Token>      DIV "/"
%token<Token>      MOD "%"
%token<Token>      BIT_OR "|"
%token<Token>      BIT_AND "&"
%token<Token>      BIT_XOR "^"
%token<Token>      COMPLEMENT "~"
%token<Token>      L_BRACKET "["
%token<Token>      R_BRACKET "]"
%token<Token>      L_BRACE "{"
%token<Token>      R_BRACE "}"
%token<Token>      L_ANGLE "<"
%token<Token>      L_ANGLE_ARGS    // < where template args are expected
%token<Token>      R_ANGLE ">"
%token<Token>      R_ANGLE_SHIFT   // > immediately followed by another >
%token<Token>      L_PAREN "("
%token<Token>      R_PAREN ")"
%token<Token>      NOT "!"
%token<Token>      COLON ":"
%token<Token>      PLUS_COLON "+:"
%token<Token>      COMMA ","
%token<Token>      QUESTION "?"
%token<Token>      DOT "."
%token<Token>      ASSIGN "="
%token<Token>      ASSIGN_PLUS "+="
%token<Token>      ASSIGN_MINUS "-="
%token<Token>      ASSIGN_MUL "*="
%token<Token>      ASSIGN_DIV "/="
%token<Token>      ASSIGN_MOD "%="
%token<Token>      ASSIGN_BIT_AND "&="
%token<Token>      ASSIGN_BIT_OR "|="
%token<Token>      ASSIGN_XOR "^="
%token<Token>      ASSIGN_SHL "<<="
%token<Token>      ASSIGN_SHR ">>="
%token<Token>      ASSIGN_PLUS_SAT "|+|="
%token<Token>      ASSIGN_MINUS_SAT "|-|="
%token<Token>      SEMICOLON ";"
%token<Token>      AT "@"
%token<Token>      PP "++"
%token<Token>      DONTCARE "_"
%token<Token>      MASK "&&&"
%token<Token>      DOTS "..."
%token<Token>      RANGE ".."
%token<Token>      ABSTRACT ACTION ACTIONS APPLY BOOL BIT BREAK CONST CONTINUE CONTROL DEFAULT
                   ELSE ENTRIES ENUM ERROR EXIT EXTERN FALSE FOR HEADER HEADER_UNION IF IN INOUT
                   INT KEY LIST MATCH_KIND OUT PACKAGE PARSER PRAGMA PRIORITY RETURN SELECT
                   STATE STRING STRUCT SWITCH TABLE THIS TRANSITION TRUE TUPLE TYPE TYPEDEF
                   VARBIT VALUESET VOID

%token<cstring> IDENTIFIER TYPE_IDENTIFIER STRING_LITERAL
%token<UnparsedConstant>  INTEGER

// End of token definitions ///////////////////////////////////////////////////


%type<IR::ID>               name dot_name nonTypeName nonTableKwName annotationName
%type<NameTypePair>         declarator
%type<IR::Direction>        direction
%type<IR::Path*>            prefixedNonTypeName prefixedType
%type<IR::TypeParameters*>  optTypeParameters typeParameters typeParameterList
%type<IR::Expression*>      expression lvalue keysetExpression selectExpression
                            stateExpression optInitializer initializer
                            simpleKeysetExpression transitionStatement switchLabel
                            p4rtControllerType reducedSimpleKeysetExpression entryPriority
                            nonBraceExpression nonGrtExpression forCollectionExpr
%type<ConstType*>           baseType typeOrVoid specializedType arrayType
                            typeRef tupleType typeArg realTypeArg namedType p4listType
                            derivedTypeDeclarationAsType
%type<IR::Type_Name*>       typeName
%type<IR::Argument*>        argument
%type<IR::Vector<IR::Argument>> argumentList nonEmptyArgList
%type<IR::Parameter*>       parameter
%type<OptionalConst>        optCONST
%type<IR::Vector<IR::Annotation>> optAnnotations annotations
%type<IR::Annotation*>      annotation
%type<IR::Vector<IR::AnnotationToken>> annotationBody
%type<Token>                annotationToken
%type<IR::IndexedVector<IR::Parameter>>   parameterList nonEmptyParameterList
                                          optConstructorParameters
%type<IR::Vector<IR::Expression>>         expressionList
                                          simpleExpressionList tupleKeysetExpression
%type<IR::IndexedVector<IR::Declaration_ID>> identifierList
%type<IR::SelectCase*>      selectCase
%type<IR::Vector<IR::SelectCase>> selectCaseList
%type<IR::Statement*>       statement parserStatement emptyStatement returnStatement
                            switchStatement exitStatement
                            assignmentOrMethodCallStatement conditionalStatement parserConditionalStatement
                            assignmentOrMethodCallStatementWithoutSemicolon
                            forStatement breakStatement continueStatement
%type<IR::BlockStatement*>  blockStatement parserBlockStatement controlBody
                            optObjInitializer
%type<IR::StatOrDecl*>      statementOrDeclaration parserStatementOrDeclaration
                            declOrAssignmentOrMethodCallStatement
%type<IR::IndexedVector<IR::StatOrDecl>>  objDeclarations statOrDeclList parserStatOrDeclList
                            forInitStatements forInitStatementsNonEmpty
                            forUpdateStatements forUpdateStatementsNonEmpty
%type<IR::SwitchCase*>      switchCase
%type<IR::Vector<IR::SwitchCase>> switchCases
%type<IR::Vector<IR::Type>> typeArgumentList realTypeArgumentList
%type<IR::ParserState*>     parserState
%type<IR::IndexedVector<IR::ParserState>> parserStates
%type<IR::Declaration*>     constantDeclaration actionDeclaration
                            variableDeclaration variableDeclarationWithoutSemicolon instantiation functionDeclaration
                            objDeclaration tableDeclaration controlLocalDeclaration
                            parserLocalElement valueSetDeclaration
%type<IR::Type_Declaration*>  headerTypeDeclaration structTypeDeclaration
                              headerUnionDeclaration derivedTypeDeclaration
                              parserDeclaration controlDeclaration enumDeclaration
                              typedefDeclaration packageTypeDeclaration typeDeclaration
%type<IR::Type_Error*>      errorDeclaration
%type<IR::Node*>            fragment
%type<IR::Node*>            declaration externDeclaration matchKindDeclaration
%type<IR::Type_Parser*>     parserTypeDeclaration
%type<IR::Type_Control*>    controlTypeDeclaration
%type<IR::IndexedVector<IR::Declaration>>  parserLocalElements controlLocalDeclarations
%type<IR::StructField*>     structField
%type<IR::IndexedVector<IR::StructField>>  structFieldList
%type<IR::IndexedVector<IR::SerEnumMember>> specifiedIdentifierList
%type<IR::SerEnumMember*>   specifiedIdentifier
%type<IR::Method*>          methodPrototype functionPrototype
%type<IR::Vector<IR::Method>> methodPrototypes
%type<IR::Property*>        tableProperty
%type<IR::TableProperties*> tablePropertyList
%type<IR::KeyElement*>      keyElement
%type<IR::Vector<IR::KeyElement>> keyElementList
%type<IR::Expression*>  actionRef
%type<IR::IndexedVector<IR::ActionListElement>> actionList
%type<IR::Entry*>           entry
%type<IR::Vector<IR::Entry>> entriesList
%type<IR::IndexedVector<IR::NamedExpression>> kvList
%type<IR::NamedExpression*> kvPair
%type<IR::Vector<IR::Expression>> intList
%type<IR::Vector<IR::Expression>> intOrStrList
%type<IR::Vector<IR::Expression>> strList
%type<IR::Expression*>      intOrStr
%type<IR::P4Program*>       input

// %precedence COMMA
%precedence QUESTION
%precedence COLON PLUS_COLON
%left OR
%left AND
%left EQ NE
%left L_ANGLE R_ANGLE LE GE
%left BIT_OR
%left BIT_XOR
%left BIT_AND
%left SHL R_ANGLE_SHIFT
%left PP PLUS MINUS PLUS_SAT MINUS_SAT
%left MUL DIV MOD
%precedence PREFIX
%precedence R_BRACKET L_PAREN L_BRACKET L_ANGLE_ARGS
%precedence DOT

%right THEN ELSE /* THEN is a fake token */

/*
FIXME -- we need this %destructor for correct error recovery, but because of the
broken bison C++ skeleton, it gets declarations in the wrong order and it won't
compile.  Not having it (just) means that the symbol table may get confused after
a syntax error causing a spurious error cascade, which isn't too bad.

%destructor { driver.structure->pop(); } functionPrototype parserTypeDeclaration
                                         controlTypeDeclaration
*/

%%

/*
   This grammar may look weird in some places, but a lot of effort was put into
   eliminating conflicts.  This sometimes required having the grammar be more
   lenient than necessary.  Moreover, the grammar is context-sensitive, and it
   needs some rudiments of type information to properly perform parsing.  This
   is done with the help of P4ParserDriver's "structure" object, which keeps
   track of which identifiers represent types, and which represent namespaces.
*/

// Simulate multiple start symbols to allow the parser to be reused for
// annotation bodies.
start
    : fragment END_ANNOTATION { driver.result = $1->getNode(); YYACCEPT; }
    | START_PROGRAM program
    ;

fragment
      // Lists
    : START_EXPRESSION_LIST expressionList {
                $$ = new IR::Vector<IR::Expression>(std::move($2)); }
    | START_KV_LIST kvList {
                $$ = new IR::IndexedVector<IR::NamedExpression>(std::move($2)); }
    | START_INTEGER_LIST intList {
                $$ = new IR::Vector<IR::Expression>(std::move($2)); }
    | START_INTEGER_OR_STRING_LITERAL_LIST intOrStrList {
                $$ = new IR::Vector<IR::Expression>(std::move($2)); }
    | START_STRING_LITERAL_LIST strList {
                $$ = new IR::Vector<IR::Expression>(std::move($2)); }

      // Singletons
    | START_EXPRESSION expression                       { $$ = $2; }
    | START_INTEGER INTEGER                             { $$ = parseConstant(@2, $2, 0); }
    | START_INTEGER_OR_STRING_LITERAL intOrStr          { $$ = $2; }
    | START_STRING_LITERAL STRING_LITERAL               { $$ = new IR::StringLiteral(@2, $2); }

      // Pairs
    | START_EXPRESSION_PAIR expression "," expression
        { auto* result = new IR::Vector<IR::Expression>();
          result->push_back($2);
          result->push_back($4);
          result->srcInfo = @2 + @4;
          $$ = result; }
    | START_INTEGER_PAIR INTEGER "," INTEGER
        { auto* result = new IR::Vector<IR::Expression>();
          result->push_back(parseConstant(@2, $2, 0));
          result->push_back(parseConstant(@4, $4, 0));
          result->srcInfo = @2 + @4;
          $$ = result; }
    | START_STRING_LITERAL_PAIR STRING_LITERAL "," STRING_LITERAL
        { auto* result = new IR::Vector<IR::Expression>();
          result->push_back(new IR::StringLiteral(@2, $2));
          result->push_back(new IR::StringLiteral(@4, $4));
          result->srcInfo = @2 + @4;
          $$ = result; }

      // Triples
    | START_EXPRESSION_TRIPLE expression "," expression "," expression
        { auto* result = new IR::Vector<IR::Expression>();
          result->push_back($2);
          result->push_back($4);
          result->push_back($6);
          result->srcInfo = @2 + @6;
          $$ = result; }
    | START_INTEGER_TRIPLE INTEGER "," INTEGER "," INTEGER
        { auto* result = new IR::Vector<IR::Expression>();
          result->push_back(parseConstant(@2, $2, 0));
          result->push_back(parseConstant(@4, $4, 0));
          result->push_back(parseConstant(@6, $6, 0));
          result->srcInfo = @2 + @6;
          $$ = result; }
    | START_STRING_LITERAL_TRIPLE STRING_LITERAL "," STRING_LITERAL ","
      STRING_LITERAL
        { auto* result = new IR::Vector<IR::Expression>();
          result->push_back(new IR::StringLiteral(@2, $2));
          result->push_back(new IR::StringLiteral(@4, $4));
          result->push_back(new IR::StringLiteral(@6, $6));
          result->srcInfo = @2 + @6;
          $$ = result; }

      // P4Runtime annotations
    | START_P4RT_TRANSLATION_ANNOTATION STRING_LITERAL "," p4rtControllerType
        { auto* result = new IR::Vector<IR::Expression>();
          result->push_back(new IR::StringLiteral(@2, $2));
          result->push_back($4);
          result->srcInfo = @2 + @4;
          $$ = result; }
    ;

// We want this to return an `IR::Type`, but we need it to return an
// `IR::Expression` for things to type-check. We thus use `IR::StringLiteral` to
// encode the type "string", and `IR::Constant(W)` to encode the type "bit<W>".
// TODO: Could this be redesigned to avoid this hack?
p4rtControllerType
    : STRING
        { $$ = new IR::StringLiteral(@1, ""_cs); }
    | BIT l_angle INTEGER r_angle
        { $$ = new IR::Constant(parseConstantChecked(@3, $3)); }
    // Legacy syntax; to be removed in P4RT 2.0
    | INTEGER
        { $$ = new IR::Constant(parseConstantChecked(@1, $1)); }
    ;

program : input END { YYACCEPT; };

input
    : %empty             { driver.result = $$ = new IR::P4Program; }
    | input declaration  { if ($2) $1->objects.push_back($2->getNode());
                           $$ = $1; }
    | input ";"          { $$ = $1; }   // empty declaration
    ;

declaration
    : constantDeclaration     { $$ = $1; }
    | externDeclaration       { $$ = $1; }
    | actionDeclaration       { $$ = $1; }
    | parserDeclaration       { $$ = $1; }
    | typeDeclaration         { $$ = $1; }
    | controlDeclaration      { $$ = $1; }
    | instantiation           { $$ = $1; }
    | errorDeclaration        { $$ = driver.onReadErrorDeclaration($1) ? $1 : nullptr; }
    | matchKindDeclaration    { $$ = $1; }
    | functionDeclaration     { $$ = $1; }
    ;

nonTypeName
    : IDENTIFIER  { $$ = IR::ID(@1, $1); }
    | ACTIONS     { $$ = IR::ID(@1, "actions"_cs); }
    | APPLY       { $$ = IR::ID(@1, "apply"_cs); }
    | ENTRIES     { $$ = IR::ID(@1, "entries"_cs); }
    | KEY         { $$ = IR::ID(@1, "key"_cs); }
    | PRIORITY    { $$ = IR::ID(@1, "priority"_cs); }
    | STATE       { $$ = IR::ID(@1, "state"_cs); }
    | TYPE        { $$ = IR::ID(@1, "type"_cs); }
    ;

name
    : nonTypeName { $$ = $1; }
    | LIST { $$ = IR::ID(@1, "list"_cs); }
    | TYPE_IDENTIFIER  { $$ = IR::ID(@1, $1); }
    ;

nonTableKwName
    : IDENTIFIER       { $$ = IR::ID(@1, $1); }
    | TYPE_IDENTIFIER  { $$ = IR::ID(@1, $1); }
    | APPLY            { $$ = IR::ID(@1, "apply"_cs); }
    | PRIORITY         { $$ = IR::ID(@1, "priority"_cs); }
    | STATE            { $$ = IR::ID(@1, "state"_cs); }
    | TYPE             { $$ = IR::ID(@1, "type"_cs); }
    ;

optCONST
    : %empty      { $$ = OptionalConst{false}; }
    | CONST       { $$ = OptionalConst{true}; }
    ;

optAnnotations
    : %empty      { $$ = {}; }
    | annotations { $$ = $1; }
    ;

annotations
    : annotation  {
       $$ = {};
       if (!P4CContext::get().options().isAnnotationDisabled($1)) {
         $$.push_back($1);
         $$.srcInfo = @1;
       }}
    | annotations annotation {
       $$ = std::move($1);
       if (!P4CContext::get().options().isAnnotationDisabled($2)) {
          $$.push_back($2);
          $$.srcInfo = @1 + @2;
       }}
    ;

annotation
    : "@" annotationName
        { // Initialize with an empty sequence of annotation tokens so that the
          // annotation node is marked as unparsed.
          $$ = new IR::Annotation(@1, $2, IR::Vector<IR::AnnotationToken>()); }
    | "@" annotationName "(" annotationBody ")"
        { $$ = new IR::Annotation(@1, $2, std::move($4)); }
    | "@" annotationName "[" expressionList optTrailingComma "]"
        { $$ = new IR::Annotation(@1, $2, std::move($4), true); }
    | "@" annotationName "[" kvList optTrailingComma "]"
        { $$ = new IR::Annotation(@1, $2, std::move($4), true); }
    // Experimental: backwards compatibility with P4-14 pragmas (which
    // themselves are experimental!)
    | PRAGMA annotationName annotationBody END_PRAGMA
        { $$ = new IR::Annotation(@1, $2, std::move($3), false); }
    ;

annotationBody
    : %empty  { $$ = {}; }
    | annotationBody "(" annotationBody ")"
        { ($$ = std::move($1)).push_back(new IR::AnnotationToken(@2, $2.type, $2.text));
          $$.append($3);
          $$.push_back(new IR::AnnotationToken(@4, $4.type, $4.text));
          $$.srcInfo = @1 + @4;
        }
    | annotationBody annotationToken
        { $$ = std::move($1);
          $$.push_back(new IR::AnnotationToken(@2, $2.type, $2.text, $2.unparsedConstant));
          $$.srcInfo = @1 + @2;
        }
    ;

annotationName
    : ABSTRACT         { $$ = IR::ID(@1, "abstract"_cs); }
    | ACTION           { $$ = IR::ID(@1, "action"_cs); }
    | ACTIONS          { $$ = IR::ID(@1, "actions"_cs); }
    | APPLY            { $$ = IR::ID(@1, "apply"_cs); }
    | BOOL             { $$ = IR::ID(@1, "bool"_cs); }
    | BIT              { $$ = IR::ID(@1, "bit"_cs); }
    | BREAK            { $$ = IR::ID(@1, "break"_cs); }
    | CONST            { $$ = IR::ID(@1, "const"_cs); }
    | CONTINUE         { $$ = IR::ID(@1, "continue"_cs); }
    | CONTROL          { $$ = IR::ID(@1, "control"_cs); }
    | DEFAULT          { $$ = IR::ID(@1, "default"_cs); }
    | ELSE             { $$ = IR::ID(@1, "else"_cs); }
    | ENTRIES          { $$ = IR::ID(@1, "entries"_cs); }
    | ENUM             { $$ = IR::ID(@1, "enum"_cs); }
    | ERROR            { $$ = IR::ID(@1, "error"_cs); }
    | EXIT             { $$ = IR::ID(@1, "exit"_cs); }
    | EXTERN           { $$ = IR::ID(@1, "extern"_cs); }
    | FALSE            { $$ = IR::ID(@1, "false"_cs); }
    | FOR              { $$ = IR::ID(@1, "for"_cs); }
    | HEADER           { $$ = IR::ID(@1, "header"_cs); }
    | HEADER_UNION     { $$ = IR::ID(@1, "header_union"_cs); }
    | IF               { $$ = IR::ID(@1, "if"_cs); }
    | IN               { $$ = IR::ID(@1, "in"_cs); }
    | INOUT            { $$ = IR::ID(@1, "inout"_cs); }
    | INT              { $$ = IR::ID(@1, "int"_cs); }
    | KEY              { $$ = IR::ID(@1, "key"_cs); }
    | LIST             { $$ = IR::ID(@1, "list"_cs); }
    | MATCH_KIND       { $$ = IR::ID(@1, "match_kind"_cs); }
    | OUT              { $$ = IR::ID(@1, "out"_cs); }
    | PARSER           { $$ = IR::ID(@1, "parser"_cs); }
    | PACKAGE          { $$ = IR::ID(@1, "package"_cs); }
    | PRIORITY         { $$ = IR::ID(@1, "priority"_cs); }
    | RETURN           { $$ = IR::ID(@1, "return"_cs); }
    | SELECT           { $$ = IR::ID(@1, "select"_cs); }
    | STATE            { $$ = IR::ID(@1, "state"_cs); }
    | STRING           { $$ = IR::ID(@1, "string"_cs); }
    | STRUCT           { $$ = IR::ID(@1, "struct"_cs); }
    | SWITCH           { $$ = IR::ID(@1, "switch"_cs); }
    | TABLE            { $$ = IR::ID(@1, "table"_cs); }
    | THIS             { $$ = IR::ID(@1, "this"_cs); }
    | TRANSITION       { $$ = IR::ID(@1, "transition"_cs); }
    | TRUE             { $$ = IR::ID(@1, "true"_cs); }
    | TUPLE            { $$ = IR::ID(@1, "tuple"_cs); }
    | TYPE             { $$ = IR::ID(@1, "type"_cs); }
    | TYPEDEF          { $$ = IR::ID(@1, "typedef"_cs); }
    | VARBIT           { $$ = IR::ID(@1, "varbit"_cs); }
    | VALUESET         { $$ = IR::ID(@1, "valueset"_cs); }
    | VOID             { $$ = IR::ID(@1, "void"_cs); }
    | "_"              { $$ = IR::ID(@1, "_"_cs); }
    | IDENTIFIER       { $$ = IR::ID(@1, $1); }
    | TYPE_IDENTIFIER  { $$ = IR::ID(@1, $1); }
    ;

annotationToken
    : UNEXPECTED_TOKEN { $$ = $1; }
    | ABSTRACT         { $$ = $1; }
    | ACTION           { $$ = $1; }
    | ACTIONS          { $$ = $1; }
    | APPLY            { $$ = $1; }
    | BOOL             { $$ = $1; }
    | BIT              { $$ = $1; }
    | BREAK            { $$ = $1; }
    | CONST            { $$ = $1; }
    | CONTINUE         { $$ = $1; }
    | CONTROL          { $$ = $1; }
    | DEFAULT          { $$ = $1; }
    | ELSE             { $$ = $1; }
    | ENTRIES          { $$ = $1; }
    | ENUM             { $$ = $1; }
    | ERROR            { $$ = $1; }
    | EXIT             { $$ = $1; }
    | EXTERN           { $$ = $1; }
    | FALSE            { $$ = $1; }
    | FOR              { $$ = $1; }
    | HEADER           { $$ = $1; }
    | HEADER_UNION     { $$ = $1; }
    | IF               { $$ = $1; }
    | IN               { $$ = $1; }
    | INOUT            { $$ = $1; }
    | INT              { $$ = $1; }
    | KEY              { $$ = $1; }
    | LIST             { $$ = $1; }
    | MATCH_KIND       { $$ = $1; }
    | OUT              { $$ = $1; }
    | PARSER           { $$ = $1; }
    | PACKAGE          { $$ = $1; }
    | PRAGMA           { $$ = $1; }
    | RETURN           { $$ = $1; }
    | SELECT           { $$ = $1; }
    | STATE            { $$ = $1; }
    | STRING           { $$ = $1; }
    | STRUCT           { $$ = $1; }
    | SWITCH           { $$ = $1; }
    | TABLE            { $$ = $1; }
    | THIS             { $$ = $1; }
    | TRANSITION       { $$ = $1; }
    | TRUE             { $$ = $1; }
    | TUPLE            { $$ = $1; }
    | TYPE             { $$ = $1; }
    | TYPEDEF          { $$ = $1; }
    | VARBIT           { $$ = $1; }
    | VALUESET         { $$ = $1; }
    | VOID             { $$ = $1; }
    | "_"              { $$ = $1; }

    | IDENTIFIER       { $$ = Token(token::TOK_IDENTIFIER, $1); }
    | TYPE_IDENTIFIER  { $$ = Token(token::TOK_TYPE_IDENTIFIER, $1); }
    | STRING_LITERAL   { $$ = Token(token::TOK_STRING_LITERAL, $1); }
    | INTEGER          { $$ = Token(token::TOK_INTEGER, $1); }

    | "&&&"            { $$ = $1; }
    | ".."             { $$ = $1; }
    | "<<"             { $$ = $1; }
    | "&&"             { $$ = $1; }
    | "||"             { $$ = $1; }
    | "=="             { $$ = $1; }
    | "!="             { $$ = $1; }
    | ">="             { $$ = $1; }
    | "<="             { $$ = $1; }
    | "++"             { $$ = $1; }

    | "+"              { $$ = $1; }
    | "|+|"            { $$ = $1; }
    | "-"              { $$ = $1; }
    | "|-|"            { $$ = $1; }
    | "*"              { $$ = $1; }
    | "/"              { $$ = $1; }
    | "%"              { $$ = $1; }

    | "|"              { $$ = $1; }
    | "&"              { $$ = $1; }
    | "^"              { $$ = $1; }
    | "~"              { $$ = $1; }

    // Omit parens. These are handled in annotationBody, since they must be
    // balanced.
    // | "("              { $$ = $1; }
    // | ")"              { $$ = $1; }

    | "["              { $$ = $1; }
    | "]"              { $$ = $1; }
    | "{"              { $$ = $1; }
    | "}"              { $$ = $1; }
    | "<"              { $$ = $1; }
    | L_ANGLE_ARGS     { $$ = $1; }
    | ">"              { $$ = $1; }
    | R_ANGLE_SHIFT    { $$ = $1; }

    | "!"              { $$ = $1; }
    | ":"              { $$ = $1; }
    | ","              { $$ = $1; }
    | "?"              { $$ = $1; }
    | "."              { $$ = $1; }
    | "="              { $$ = $1; }
    | ";"              { $$ = $1; }
    | "@"              { $$ = $1; }
    ;

kvList
    : kvPair            { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | kvList "," kvPair { ($$ = std::move($1)).push_back($3); $$.srcInfo = @1 + @3;}
    ;

kvPair
    : name "=" expression             { $$ = new IR::NamedExpression(@1, $1, $3); }
    ;

parameterList
    : %empty                          { $$ = {}; }
    | nonEmptyParameterList           { $$ = $1; }
    ;

nonEmptyParameterList
    : parameter                           { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | nonEmptyParameterList "," parameter { ($$ = std::move($1)).push_back($3); $$.srcInfo = @1 + @3; }
    ;

parameter
    : optAnnotations direction typeRef declarator {
            $$ = new IR::Parameter(@4, $4.name, $1, $2, $4.type, nullptr); }
    | optAnnotations direction typeRef declarator "=" expression {
            $$ = new IR::Parameter(@4, $4.name, $1, $2, $4.type, $6); }
    ;

direction
    : IN           { $$ = IR::Direction::In; }
    | INOUT        { $$ = IR::Direction::InOut; }
    | OUT          { $$ = IR::Direction::Out; }
    | %empty       { $$ = IR::Direction::None; }
    ;

packageTypeDeclaration
    : optAnnotations PACKAGE name { driver.structure->pushContainerType($3, false); }
      optTypeParameters {
          if (!$5->empty()) driver.structure->markAsTemplate($3);
          driver.structure->declareTypes($5->parameters); }
      "(" parameterList ")"        {
          driver.structure->declareParameters($8);
          auto pl = new IR::ParameterList(@8, $8);
          $$ = new IR::Type_Package(@3, $3, std::move($1), $5, pl); }
    ;

instantiation
      : annotations typeRef "(" argumentList ")" <ConstType*>{ $$ = $2; } declarator optObjInitializer ";"
                     { $$ = new IR::Declaration_Instance(@7, $7.name, std::move($1), $7.type, std::move($4), $8);
                       driver.structure->declareObject($7.name, $2->toString()); }
      | typeRef "(" argumentList ")" <ConstType*>{ $$ = $1; } declarator optObjInitializer ";"
                     { $$ = new IR::Declaration_Instance(@6, $6.name, $6.type, std::move($3), $7);
                       driver.structure->declareObject($6.name, $1->toString()); }
    ;

optObjInitializer
    : %empty                   { $$ = nullptr; }
    | "=" "{" { driver.structure->pushNamespace(@1, false); } objDeclarations "}"
                               { driver.structure->pop();
                                 $$ = new IR::BlockStatement(@2+@5, std::move($4)); }
    ;

objDeclarations
    : %empty                         { $$ = {}; }
    | objDeclarations objDeclaration { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2;}
    ;

objDeclaration
    : functionDeclaration      { $$ = $1; }
    | instantiation            { $$ = $1; }
    ;

optConstructorParameters
    : %empty                 { $$ = {}; }
    | "(" parameterList ")"  { $$ = $2; }
    ;

dotPrefix
    : "."                      { driver.structure->startAbsolutePath(); }
    ;

/**************************** PARSER ******************************/

parserDeclaration
    : parserTypeDeclaration optConstructorParameters
      "{" parserLocalElements parserStates "}"
                             { driver.structure->pop();
                               auto pl = new IR::ParameterList(@2, std::move($2));
                               $$ = new IR::P4Parser($1->name.srcInfo, $1->name,
                                                     $1, pl, std::move($4), std::move($5));}
    ;

parserLocalElements
    : %empty                                 { $$ = {}; }
    | parserLocalElements parserLocalElement { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

parserLocalElement
    : constantDeclaration             { $$ = $1; }
    | instantiation                   { $$ = $1; }
    | variableDeclaration             { $$ = $1; }
    | valueSetDeclaration             { $$ = $1; }
    ;

parserTypeDeclaration
    : optAnnotations
        PARSER name       { driver.structure->pushContainerType($3, true); }
        optTypeParameters { if (!$5->empty()) driver.structure->markAsTemplate($3);
                            driver.structure->declareTypes($5->parameters); }
        "(" parameterList ")" {
                            driver.structure->declareParameters($8);
                            auto pl = new IR::ParameterList(@8, std::move($8));
                            $$ = new IR::Type_Parser(@3, std::move($3), std::move($1), $5, pl); }
    ;

parserStates
    : parserState                     { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | parserStates parserState        { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

parserState
    : optAnnotations STATE name { driver.structure->pushContainerType($3, false); }
      "{" parserStatOrDeclList transitionStatement "}" {
                  driver.structure->pop();
                  $$ = new IR::ParserState(@3, std::move($3), std::move($1), std::move($6), $7); }
    ;

parserStatement
    : assignmentOrMethodCallStatement { $$ = $1; }
    | emptyStatement                  { $$ = $1; }
    | parserBlockStatement            { $$ = $1; }
    | parserConditionalStatement      { $$ = $1; }
    ;

parserStatementOrDeclaration
    : variableDeclaration             { $$ = $1; }
    | constantDeclaration             { $$ = $1; }
    | parserStatement                 { $$ = $1; }
    ;

parserStatOrDeclList
    : %empty                                            { $$ = {}; }
    | parserStatOrDeclList parserStatementOrDeclaration { ($$ = std::move($1)).push_back($2);
                                                          $$.srcInfo = @1 + @2; }
    ;

parserBlockStatement
    : optAnnotations "{"        { driver.structure->pushNamespace(@2, false); }
      parserStatOrDeclList "}"  { driver.structure->pop();
                                  $$ = new IR::BlockStatement(@1+@5, std::move($1), std::move($4)); }
    ;

parserConditionalStatement
    : IF "(" expression ")" parserStatement                       %prec THEN
        { $$ = new IR::IfStatement(@1, $3, $5, nullptr); }
    | IF "(" expression ")" parserStatement ELSE parserStatement  %prec THEN
        { $$ = new IR::IfStatement(@1, $3, $5, $7); }
    ;

transitionStatement
    : %empty                      { $$ = nullptr; }
    | TRANSITION stateExpression  { $$ = $2; }
    ;

stateExpression
    : name ";"         { $$ = new IR::PathExpression($1); }
    | selectExpression { $$ = $1; }
    ;

selectExpression
    : SELECT "(" expressionList ")" "{" selectCaseList "}" {
                $$ = new IR::SelectExpression(@1 + @7,
                        new IR::ListExpression(@3, std::move($3)), std::move($6)); }
    ;

selectCaseList
    : %empty                     { $$ = {}; }
    | selectCaseList selectCase  { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2;}
    ;

selectCase
    : keysetExpression ":" name ";" { auto expr = new IR::PathExpression($3);
                                      $$ = new IR::SelectCase(@1 + @3, $1, expr); }
    ;

keysetExpression
    : tupleKeysetExpression     { $$ = new IR::ListExpression(@1, std::move($1)); }
    | simpleKeysetExpression    { $$ = $1; }
    ;

tupleKeysetExpression
    : "(" simpleKeysetExpression "," simpleExpressionList ")" {
                $$ = std::move($4);
                $$.insert($$.begin(), $2);
                $$.srcInfo = @2 + @4; }
    | "(" reducedSimpleKeysetExpression ")" { $$ = {}; $$.push_back($2); $$.srcInfo = @2; }
    ;

optTrailingComma
    : %empty
    | ","
    ;

simpleExpressionList
    : simpleKeysetExpression { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | simpleExpressionList "," simpleKeysetExpression { ($$ = std::move($1)).push_back($3);
                                                        $$.srcInfo = @1 + @3; }
    ;

reducedSimpleKeysetExpression
    // like simpleKeysetExpression, but without 'expression', to avoid a conflict
    : expression "&&&" expression { $$ = new IR::Mask(@1 + @3, $1, $3); }
    | expression ".." expression  { $$ = new IR::Range(@1 + @3, $1, $3); }
    | DEFAULT                     { $$ = new IR::DefaultExpression(@1); }
    | "_"                         { $$ = new IR::DefaultExpression(@1); }
    ;

simpleKeysetExpression
    : expression                  { $$ = $1; }
    | expression "&&&" expression { $$ = new IR::Mask(@1 + @3, $1, $3); }
    | expression ".." expression  { $$ = new IR::Range(@1 + @3, $1, $3); }
    | DEFAULT                     { $$ = new IR::DefaultExpression(@1); }
    | "_"                         { $$ = new IR::DefaultExpression(@1); }
    ;

valueSetDeclaration
    : optAnnotations VALUESET l_angle baseType r_angle "(" expression ")" name ";" {
                $$ = new IR::P4ValueSet(@9, std::move($9), std::move($1), $4, $7); }
    | optAnnotations VALUESET l_angle tupleType r_angle "(" expression ")" name ";" {
                $$ = new IR::P4ValueSet(@9, std::move($9), std::move($1), $4, $7); }
    | optAnnotations VALUESET l_angle typeName r_angle "(" expression ")" name ";" {
                $$ = new IR::P4ValueSet(@9, std::move($9), std::move($1), $4, $7); }
    ;

/*************************** CONTROL ************************/

controlDeclaration
    : controlTypeDeclaration optConstructorParameters
      "{" controlLocalDeclarations APPLY controlBody "}"
        { driver.structure->pop();
          auto pl = new IR::ParameterList(@2, std::move($2));
          $$ = new IR::P4Control($1->name.srcInfo, $1->name, $1, pl, std::move($4), $6); }
    ;

controlTypeDeclaration
    : optAnnotations
        CONTROL name { driver.structure->pushContainerType($3, true); }
        optTypeParameters { if (!$5->empty()) driver.structure->markAsTemplate($3);
                            driver.structure->declareTypes($5->parameters); }
        "(" parameterList ")" { driver.structure->declareParameters($8);
                                auto pl = new IR::ParameterList(@8, std::move($8));
                                $$ = new IR::Type_Control(@3, std::move($3), std::move($1), $5, pl); }
    ;

controlLocalDeclarations
    : %empty { $$ = {}; }
    | controlLocalDeclarations controlLocalDeclaration { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

controlLocalDeclaration
    : constantDeclaration      { $$ = $1; }
    | actionDeclaration        { $$ = $1; }
    | tableDeclaration         { $$ = $1; }
    | instantiation            { $$ = $1; }
    | variableDeclaration      { $$ = $1; }
    ;

controlBody
    : blockStatement { $$ = $1; }
    ;

/*************************** EXTERN *************************/

externDeclaration
    : optAnnotations
        EXTERN nonTypeName { driver.structure->pushContainerType($3, true); }
        optTypeParameters { if (!$5->empty()) driver.structure->markAsTemplate($3);
                            driver.structure->declareTypes($5->parameters); }
        "{" methodPrototypes "}" {
            driver.structure->pop();
            $$ = new IR::Type_Extern(@3, std::move($3), $5, std::move($8), std::move($1)); }
    | optAnnotations EXTERN functionPrototype ";" {
            driver.structure->pop();
            $3->annotations = std::move($1);
            $$ = $3; }
    | optAnnotations EXTERN name ";" {
            // forward declaration;
            driver.structure->pushContainerType($3, true);
            driver.structure->pop();
            $$ = nullptr; }
    ;

methodPrototypes
    : %empty                           { $$ = {}; }
    | methodPrototypes methodPrototype { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

functionPrototype
    : typeOrVoid
        name optTypeParameters {
            driver.structure->declareObject($2, $1->toString());
            if (!$3->empty()) driver.structure->markAsTemplate($2);
            driver.structure->pushNamespace(@2, false);
            driver.structure->declareTypes($3->parameters); }
        "(" parameterList ")" { driver.structure->declareParameters($6);
                                auto params = new IR::ParameterList(@6, std::move($6));
                                auto mt = new IR::Type_Method(@2, $3, $1, params, $2);
                                $$ = new IR::Method(@2, $2, mt); }
    ;

methodPrototype
    : optAnnotations functionPrototype ";" {
            driver.structure->pop();
            $$ = $2; $2->annotations = std::move($1); }
    | optAnnotations ABSTRACT functionPrototype ";" {
            driver.structure->pop();
            $$ = $3; $$->setAbstract();
            $3->annotations = std::move($1); }
    | optAnnotations TYPE_IDENTIFIER "(" parameterList ")" ";" {  // constructor
            auto par = new IR::ParameterList(@4, std::move($4));
            auto mt = new IR::Type_Method(@2, par, $2);
            $$ = new IR::Method(@2, IR::ID(@2, $2), mt, std::move($1)); }
    ;

/************************** TYPES ****************************/

typeRef
    : baseType                         { $$ = $1; }
    | typeName                         { $$ = $1; }
    | specializedType                  { $$ = $1; }
    | arrayType                        { $$ = $1; }
    | p4listType                       { $$ = $1; }
    | tupleType                        { $$ = $1; }
    ;

namedType
    : typeName                         { $$ = $1; }
    | specializedType                  { $$ = $1; }
    ;

prefixedType
    : TYPE_IDENTIFIER                  { $$ = new IR::Path(IR::ID(@1, $1)); }
    | dotPrefix TYPE_IDENTIFIER        { $$ = new IR::Path(IR::ID(@2, $2), true);
                                         driver.structure->clearPath(); }
    ;

typeName
    : prefixedType                     { $$ = new IR::Type_Name(@1, $1); }
    ;

p4listType
    : LIST l_angle typeArg r_angle   { $$ = new IR::Type_P4List(@1+@4, $3); }
    ;

tupleType
    : TUPLE l_angle typeArgumentList r_angle    { $$ = new IR::Type_Tuple(@1+@4, std::move($3)); }
    ;

arrayType
    : typeRef "[" expression "]"         { $$ = new IR::Type_Array(@1+@4, $1, $3); }
    ;

specializedType
    : typeName l_angle typeArgumentList r_angle {
                $$ = new IR::Type_Specialized(@1 + @4, $1, std::move($3)); }
    ;

baseType
    : BIT    { $$ = IR::Type::Bits::get(@1, 1); }
    | BIT l_angle nonGrtExpression r_angle { $$ = IR::Type_Bits::get(@1+@4, $3, false); }
    | BOOL   { $$ = IR::Type_Boolean::get(@1); }
    | ERROR  { $$ = new IR::Type_Name(@1, new IR::Path(IR::ID(@1, "error"_cs))); }
    | INT    { $$ = IR::Type_InfInt::get(@1); }
    | INT l_angle nonGrtExpression r_angle { $$ = IR::Type_Bits::get(@1+@4, $3, true); }
    | MATCH_KIND { $$ = IR::Type_MatchKind::get(@1); }
    | STRING { $$ = IR::Type::String::get(@1); }
    | VARBIT l_angle nonGrtExpression r_angle { $$ = IR::Type_Varbits::get(@1+@4, $3); }
    ;

typeOrVoid
    : typeRef     { $$ = $1; }
    | VOID        { $$ = IR::Type_Void::get(@1); }
    | IDENTIFIER  { $$ = new IR::Type_Name(@1, new IR::Path(IR::ID(@1, $1))); }
        // This is necessary because template arguments may introduce the return type
    ;

optTypeParameters
    : %empty                    { $$ = new IR::TypeParameters(); }
    | typeParameters            { $$ = $1; }
    ;

typeParameters
    : l_angle typeParameterList r_angle { $$ = $2; }
    ;

typeParameterList
    : name                        { $$ = new IR::TypeParameters;
                                    $$->parameters.push_back(new IR::Type_Var(@1, $1));
                                    $$->srcInfo += @1; }
    | typeParameterList "," name  { ($$ = $1)->parameters.push_back(new IR::Type_Var(@3, $3));
                                    $$->srcInfo += @3; }
    ;

typeArg
    : typeRef                     { $$ = $1; }
    | nonTypeName                 { $$ = new IR::Type_Name(@1, new IR::Path($1)); }
        // This is necessary because template arguments may introduce the return type
    | VOID                        { $$ = IR::Type_Void::get(@1); }
    | "_"                         { $$ = IR::Type_Dontcare::get(@1); }
    ;

typeArgumentList
    : %empty                         { $$ = {}; }
    | typeArg                        { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | typeArgumentList "," typeArg   { ($$ = std::move($1)).push_back($3); $$.srcInfo = @1 + @3; }
    ;

realTypeArg
    : typeRef                     { $$ = $1; }
    | VOID                        { $$ = IR::Type_Void::get(@1); }
    | "_"                         { $$ = IR::Type_Dontcare::get(@1); }
    ;

// For use in contexts where the `<` might be a less-than rather than introducing a type
// argument list -- we only allow the token after `<` to be a TYPE_IDENTIFIER, not an ID
realTypeArgumentList
    : realTypeArg                        { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | realTypeArgumentList "," typeArg   { ($$ = std::move($1)).push_back($3); $$.srcInfo = @1 + @3; }
    ;

typeDeclaration
    : derivedTypeDeclaration     { $$ = $1; }
    | typedefDeclaration ";"     { $$ = $1; }
    | parserTypeDeclaration ";"  { driver.structure->pop(); $$ = $1; }
    | controlTypeDeclaration ";" { driver.structure->pop(); $$ = $1; }
    | packageTypeDeclaration ";" { driver.structure->pop(); $$ = $1; }
    ;

derivedTypeDeclaration
    : headerTypeDeclaration            { $$ = $1; }
    | headerUnionDeclaration           { $$ = $1; }
    | structTypeDeclaration            { $$ = $1; }
    | enumDeclaration                  { $$ = $1; }
    ;

// workaround for bison's broken type variant handling that needs an explicit conversion
// to the base class
derivedTypeDeclarationAsType
    : derivedTypeDeclaration           { $$ = static_cast<const IR::Type *>($1); }
    ;

headerTypeDeclaration
    : optAnnotations HEADER name { driver.structure->pushContainerType($3, true); } optTypeParameters {
        driver.structure->markAsTemplate($3);
        driver.structure->declareTypes($5->parameters); }
      "{" structFieldList "}" { $$ = new IR::Type_Header(@3, std::move($3), std::move($1), $5, std::move($8));
                                driver.structure->pop(); }
    ;

structTypeDeclaration
    : optAnnotations STRUCT name  { driver.structure->pushContainerType($3, true); } optTypeParameters {
        driver.structure->markAsTemplate($3);
        driver.structure->declareTypes($5->parameters); }
      "{" structFieldList "}" { $$ = new IR::Type_Struct(@3, std::move($3), std::move($1), $5, std::move($8));
                                driver.structure->pop(); }
    ;

headerUnionDeclaration
    : optAnnotations HEADER_UNION name { driver.structure->pushContainerType($3, true); } optTypeParameters {
        driver.structure->markAsTemplate($3);
        driver.structure->declareTypes($5->parameters); }
      "{" structFieldList "}" { $$ = new IR::Type_HeaderUnion(@3, std::move($3), std::move($1), $5, std::move($8));
                                driver.structure->pop(); }
    ;

structFieldList
    : %empty                           { $$ = {}; }
    | structFieldList structField      { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

structField
    : optAnnotations typeRef declarator ";"  {
                $$ = new IR::StructField(@3, $3.name, std::move($1), $3.type); }
    ;

enumDeclaration
    : optAnnotations
        ENUM name { driver.structure->declareType($3); }
        "{" identifierList optTrailingComma "}" { $$ = new IR::Type_Enum(@3, $3, std::move($1), std::move($6)); }
    | optAnnotations ENUM typeRef name { driver.structure->declareType($4); }
      "{" specifiedIdentifierList optTrailingComma "}" {
              $$ = new IR::Type_SerEnum(@4, $4, std::move($1), $3, std::move($7)); }
    ;

specifiedIdentifierList
    : specifiedIdentifier                  { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | specifiedIdentifierList "," specifiedIdentifier { ($$ = std::move($1)).push_back($3);
                                                        $$.srcInfo = @1 + @3; }
    ;

specifiedIdentifier
    : name "=" initializer    { $$ = new IR::SerEnumMember(@1+@3, $1, $3); }
    ;

errorDeclaration
    : ERROR "{" identifierList "}"
        { $$ = new IR::Type_Error(@1 + @4, IR::ID(@1, "error"_cs), std::move($3)); }
    ;

matchKindDeclaration
    : MATCH_KIND "{" identifierList optTrailingComma "}"
        { $$ = new IR::Declaration_MatchKind(@1 + @4, std::move($3)); }
    ;

identifierList
    : name                    { $$ = {};
                                $$.push_back(new IR::Declaration_ID(@1, $1)); $$.srcInfo = @1; }
    | identifierList "," name { ($$ = std::move($1)).push_back(new IR::Declaration_ID(@3, $3));
                                $$.srcInfo = @1 + @3; }
    ;

typedefDeclaration
    : optAnnotations TYPEDEF typeRef declarator {
            driver.structure->declareType($4.name);
            $$ = new IR::Type_Typedef(@4, $4.name, std::move($1), $4.type); }
    | optAnnotations TYPEDEF derivedTypeDeclarationAsType declarator {
            driver.structure->declareType($4.name);
            $$ = new IR::Type_Typedef(@4, $4.name, std::move($1), $4.type); }
    | optAnnotations TYPE typeRef declarator {
            driver.structure->declareType($4.name);
            $$ = new IR::Type_Newtype(@4, $4.name, std::move($1), $4.type); }
    ;

/*************************** STATEMENTS *************************/

assignmentOrMethodCallStatement
    : assignmentOrMethodCallStatementWithoutSemicolon ";"  { $$ = $1; }
    ;

assignmentOrMethodCallStatementWithoutSemicolon
    // These rules are overly permissive, but they avoid some conflicts
    : lvalue "(" argumentList ")"
        { auto mc = new IR::MethodCallExpression(@1 + @4, $1, std::move($3));
          $$ = new IR::MethodCallStatement(@1 + @4, mc); }
    | lvalue l_angle typeArgumentList r_angle "(" argumentList ")"
        { auto mc = new IR::MethodCallExpression(@1 + @7, $1, std::move($3), std::move($6));
          $$ = new IR::MethodCallStatement(@1 + @7, mc); }
    | lvalue "=" expression
        { $$ = new IR::AssignmentStatement(@2, $1, $3); }
    | lvalue "*=" expression
        { $$ = new IR::MulAssign(@2, $1, $3); }
    | lvalue "/=" expression
        { $$ = new IR::DivAssign(@2, $1, $3); }
    | lvalue "%=" expression
        { $$ = new IR::ModAssign(@2, $1, $3); }
    | lvalue "+=" expression
        { $$ = new IR::AddAssign(@2, $1, $3); }
    | lvalue "-=" expression
        { $$ = new IR::SubAssign(@2, $1, $3); }
    | lvalue "|+|=" expression
        { $$ = new IR::AddSatAssign(@2, $1, $3); }
    | lvalue "|-|=" expression
        { $$ = new IR::SubSatAssign(@2, $1, $3); }
    | lvalue "<<=" expression
        { $$ = new IR::ShlAssign(@2, $1, $3); }
    | lvalue ">>=" expression
        { $$ = new IR::ShrAssign(@2, $1, $3); }
    | lvalue R_ANGLE_SHIFT ">=" expression
        { $$ = new IR::ShrAssign(@2+@3, $1, $4); }
    | lvalue "&=" expression
        { $$ = new IR::BAndAssign(@2, $1, $3); }
    | lvalue "|=" expression
        { $$ = new IR::BOrAssign(@2, $1, $3); }
    | lvalue "^=" expression
        { $$ = new IR::BXorAssign(@2, $1, $3); }
    ;

emptyStatement
    : ";"      { $$ = new IR::EmptyStatement(@1); }
    ;

exitStatement
    : EXIT ";" { $$ = new IR::ExitStatement(@1); }
    ;

returnStatement
    : RETURN ";"            { $$ = new IR::ReturnStatement(@1, nullptr); }
    | RETURN expression ";" { $$ = new IR::ReturnStatement(@1, $2); }
    ;

conditionalStatement
    : IF "(" expression ")" statement                 %prec THEN
        { $$ = new IR::IfStatement(@1, $3, $5, nullptr); }
    | IF "(" expression ")" statement ELSE statement  %prec THEN
        { $$ = new IR::IfStatement(@1, $3, $5, $7); }
    ;

breakStatement
    : BREAK ";" { $$ = new IR::BreakStatement(@1); }
    ;

continueStatement
    : CONTINUE ";" { $$ = new IR::ContinueStatement(@1); }
    ;

statement
    : assignmentOrMethodCallStatement  { $$ = $1; }
    | conditionalStatement             { $$ = $1; }
    | emptyStatement                   { $$ = $1; }
    | blockStatement                   { $$ = $1; }
    | returnStatement                  { $$ = $1; }
    | breakStatement                   { $$ = $1; }
    | continueStatement                { $$ = $1; }
    | exitStatement                    { $$ = $1; }
    | switchStatement                  { $$ = $1; }
    | forStatement                     { $$ = $1; }
    ;

blockStatement
    : optAnnotations "{" { driver.structure->pushNamespace(@2, false); }
      statOrDeclList "}" { driver.structure->pop();
                           $$ = new IR::BlockStatement(@1 + @5, std::move($1), std::move($4)); }
    ;

statOrDeclList
    : %empty                                { $$ = {}; }
    | statOrDeclList statementOrDeclaration { ($$ = std::move($1)).push_back($2);
                                              $$.srcInfo = @1 + @2; }
    ;

switchStatement
    : SWITCH "(" expression ")" "{" switchCases "}" {
            $$ = new IR::SwitchStatement(@1, $3, std::move($6)); }
    ;

switchCases
    : %empty                   { $$ = {}; }
    | switchCases switchCase   { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

switchCase
    : switchLabel ":" blockStatement { $$ = new IR::SwitchCase(@1 + @3, $1, $3); }
    | switchLabel ":"                { $$ = new IR::SwitchCase(@1, $1, nullptr); }
    ;

switchLabel
    : DEFAULT                  { $$ = new IR::DefaultExpression(@1); }
    | nonBraceExpression       { $$ = $1; }
    ;

statementOrDeclaration
    : variableDeclaration      { $$ = $1; }
    | constantDeclaration      { $$ = $1; }
    | statement                { $$ = $1; }
      // The transition to instantiation below is not required by the
      // languge spec, but it does help p4c give a more clear error
      // message if one erroneously attempts to perform an
      // instantiation inside of a block.
    | instantiation            { $$ = $1; }
    ;

forStatement
    : optAnnotations FOR "(" forInitStatements ";"
              expression ";"
	      forUpdateStatements ")"
      statement
    { $$ = new IR::ForStatement(@2+@9, std::move($1), std::move($4), $6, std::move($8), $10); }
    | optAnnotations FOR "(" typeRef name IN forCollectionExpr ")" statement
    { auto decl = new IR::Declaration_Variable(@4+@5, $5, $4);
      $$ = new IR::ForInStatement(@2+@7, std::move($1), decl, $7, $9); }
    | optAnnotations FOR "(" annotations typeRef name IN forCollectionExpr ")" statement
    { auto decl = new IR::Declaration_Variable(@5+@6, $6, $4, $5);
      $$ = new IR::ForInStatement(@2+@8, std::move($1), decl, $8, $10); }
    ;

forInitStatements
    : %empty                    { $$ = {}; }
    | forInitStatementsNonEmpty { $$ = $1; }
    ;

forInitStatementsNonEmpty
    : declOrAssignmentOrMethodCallStatement     { $$.push_back($1); }
    | forInitStatementsNonEmpty "," declOrAssignmentOrMethodCallStatement {
            ($$ = std::move($1)).push_back($3); }
    ;

declOrAssignmentOrMethodCallStatement
    : variableDeclarationWithoutSemicolon               { $$ = $1; }
    | assignmentOrMethodCallStatementWithoutSemicolon   { $$ = $1; }
    ;

forUpdateStatements
    : %empty                            { $$ = {}; }
    | forUpdateStatementsNonEmpty       { $$ = $1; }
    ;

forUpdateStatementsNonEmpty
    : assignmentOrMethodCallStatementWithoutSemicolon   { $$.push_back($1); }
    | forUpdateStatementsNonEmpty "," assignmentOrMethodCallStatementWithoutSemicolon {
            ($$ = std::move($1)).push_back($3); }
    ;

forCollectionExpr
    : expression                        { $$ = $1; }
    | expression ".." expression        { $$ = new IR::Range(@1 + @3, $1, $3); }
    ;

/************************* TABLE *********************************/

tableDeclaration
    : optAnnotations TABLE name "{" tablePropertyList "}"
          { $$ = new IR::P4Table(@3, $3, std::move($1), $5); }
    ;

tablePropertyList
    : tableProperty                      { $$ = new IR::TableProperties(@1, { $1 }); }
    | tablePropertyList tableProperty    { ($$ = $1)->properties.push_back($2);
                                           $$->srcInfo += @2; }
    ;

tableProperty
    : KEY "=" "{" keyElementList "}"
        { auto v = new IR::Key(@4, std::move($4));
          auto id = IR::ID(@1, "key"_cs);
          $$ = new IR::Property( @1 + @5, id, v, false); }
    | ACTIONS "=" "{" actionList "}"
        { auto v = new IR::ActionList(@4, std::move($4));
          auto id = IR::ID(@1, "actions"_cs);
          $$ = new IR::Property(@1 + @5, id, v, false); }
    | optAnnotations optCONST ENTRIES "=" "{" entriesList "}"
        { auto l = new IR::EntriesList(@3, std::move($6));
          auto id = IR::ID(@3+@7, "entries"_cs);
          $$ = new IR::Property(@3, id, std::move($1), l, $2.isConst); }
    | optAnnotations optCONST nonTableKwName "=" initializer ";"
        { auto v = new IR::ExpressionValue(@5, $5);
          $$ = new IR::Property(@3, $3, std::move($1), v, $2.isConst); }
    ;

keyElementList
    : %empty                             { $$ = {}; }
    | keyElementList keyElement          { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

keyElement
    : expression ":" name optAnnotations ";"
                                         { auto expr = new IR::PathExpression($3);
                                           $$ = new IR::KeyElement(@1, $1, expr, std::move($4)); }
    ;

actionList
    : %empty { $$ = {}; }
    | actionList optAnnotations actionRef ";" {
                ($$ = std::move($1)).push_back(new IR::ActionListElement(@3, std::move($2), $3));
                $$.srcInfo = @1 + @3; }
    ;

actionRef
    : prefixedNonTypeName
        { $$ = new IR::PathExpression($1); }
    | prefixedNonTypeName "(" argumentList ")"
        { $$ = new IR::MethodCallExpression(@1+@3, new IR::PathExpression($1), $3); }
    ;

entry
    : optCONST entryPriority keysetExpression ":" actionRef optAnnotations ";" {
                // below we set the position starting at @3 because optional
                // fields generate weird position information.
                if (auto l = $3->to<IR::ListExpression>())
                    $$ = new IR::Entry(@3+@6, std::move($6), $1.isConst, $2, l, $5, false);
                else   // if not a tuple, make it a list of 1
                    $$ = new IR::Entry(@3+@6, std::move($6), $1.isConst, $2,
                                       new IR::ListExpression(@3, {$3}), $5, true); }
    | optCONST keysetExpression ":" actionRef optAnnotations ";" {
                // below we set the position starting at @2 because optional
                // fields generate weird position information.
                if (auto l = $2->to<IR::ListExpression>())
                    $$ = new IR::Entry(@2+@5, std::move($5), $1.isConst, nullptr, l, $4, false);
                else   // if not a tuple, make it a list of 1
                    $$ = new IR::Entry(@2+@5, std::move($5), $1.isConst, nullptr,
                                       new IR::ListExpression(@2, {$2}), $4, true); }
    ;

entryPriority
    : PRIORITY "=" INTEGER ":"       { $$ = new IR::Constant(parseConstantChecked(@3, $3)); }
    | PRIORITY "=" "(" expression ")" ":" { $$ = $4; }
    ;

entriesList
    : %empty                         { $$ = {}; }
    | entriesList entry              { ($$ = std::move($1)).push_back($2); $$.srcInfo = @1 + @2; }
    ;

/************************* ACTION ********************************/

actionDeclaration
    : optAnnotations ACTION name "(" parameterList ")" blockStatement
        { auto pl = new IR::ParameterList(@5, std::move($5));
          $$ = new IR::P4Action(@3, $3, std::move($1), pl, $7); }
    ;

/************************* VARIABLES *****************************/

variableDeclaration
    : variableDeclarationWithoutSemicolon ";"    { $$ = $1; }
    ;

variableDeclarationWithoutSemicolon
    : annotations typeRef declarator optInitializer {
                $$ = new IR::Declaration_Variable(@3, $3.name, std::move($1), $3.type, $4);
                driver.structure->declareObject($3.name, $3.type->toString()); }
    | typeRef declarator optInitializer {
                $$ = new IR::Declaration_Variable(@2, $2.name, $2.type, $3);
                driver.structure->declareObject($2.name, $2.type->toString()); }
    ;

constantDeclaration
    : optAnnotations CONST typeRef declarator "=" initializer ";" {
                $$ = new IR::Declaration_Constant(@4, $4.name, std::move($1), $4.type, $6);
                driver.structure->declareObject($4.name, $4.type->toString()); }
    ;

declarator
    : name                { $$.name = $1; $$.type = $<ConstType *>0; }
    | declarator "[" expression "]"
                          { $$ = $1; $$.type = new IR::Type_Array(@2+@4, $1.type, $3); }
    ;

optInitializer
    : %empty                           { $$ = nullptr; }
    | "=" initializer                  { $$ = $2; }
    ;

initializer
    : expression                          { $$ = $1; }
    ;

/**************** Expressions ****************/

functionDeclaration
    : annotations functionPrototype blockStatement   {
            driver.structure->pop();
            $$ = new IR::Function($2->srcInfo, $2->name, std::move($1), $2->type, $3); }
    | functionPrototype blockStatement   {
            driver.structure->pop();
            $$ = new IR::Function($1->srcInfo, $1->name, $1->type, $2); }
    ;

argumentList
    : %empty                             { $$ = {}; }
    | nonEmptyArgList                    { $$ = $1; }
    ;

nonEmptyArgList
    : argument                           { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | nonEmptyArgList "," argument       { ($$ = std::move($1)).push_back($3); $$.srcInfo = @1 + @3; }
    ;

argument
    : expression                         { $$ = new IR::Argument(@1, $1); }
    | name "=" expression                { $$ = new IR::Argument(@1, $1, $3); }
    | "_"                                { $$ = new IR::Argument(@1, new IR::DefaultExpression(@1)); }
    | name "=" "_"                       { $$ = new IR::Argument(@1, $1, new IR::DefaultExpression(@3)); }
    ;

expressionList
    : %empty                             { $$ = {}; }
    | expression                         { $$ = {}; $$.push_back($1); $$.srcInfo = @1; }
    | expressionList "," expression      { ($$ = std::move($1)).push_back($3); $$.srcInfo = @1 + @3; }
    ;

prefixedNonTypeName
    : nonTypeName                        { $$ = new IR::Path($1); }
    | dotPrefix nonTypeName              { $$ = new IR::Path($2, true);
                                           driver.structure->clearPath(); }
    ;

dot_name:
    "." { driver.structure->relativePathFromLastSymbol(); } name {
          driver.structure->clearPath(); $$ = $3; }
    ;

lvalue
    : prefixedNonTypeName                { $$ = new IR::PathExpression($1); }
    | THIS                               { $$ = new IR::This(@1); }
    | lvalue dot_name %prec DOT          { $$ = new IR::Member(@1 + @2, $1, $2); }
    | typeName dot_name %prec DOT        {
                    $$ = new IR::Member(@1 + @2, new IR::TypeNameExpression($1), $2); }
    | specializedType dot_name %prec DOT {
                    $$ = new IR::Member(@1 + @2, new IR::TypeNameExpression($1), $2); }
    | lvalue "[" expression "]"          { $$ = new IR::ArrayIndex(@1 + @4, $1, $3); }
    | lvalue "[" expression ":" expression "]" { $$ = new IR::Slice(@1 + @6, $1, $3, $5); }
    | lvalue "[" expression "+:" expression "]" { $$ = new IR::PlusSlice(@1 + @6, $1, $3, $5); }
    | "(" lvalue ")"                     { $$ = $2; }
    ;

expression
    : INTEGER                            { $$ = parseConstant(@1, $1, 0); }
    | DOTS                               { $$ = new IR::Dots(@1); }
    | STRING_LITERAL                     { $$ = new IR::StringLiteral(@1, $1); }
    | TRUE                               { $$ = new IR::BoolLiteral(@1, true); }
    | FALSE                              { $$ = new IR::BoolLiteral(@1, false); }
    | THIS                               { $$ = new IR::This(@1); }
    | prefixedNonTypeName                { $$ = new IR::PathExpression($1); }
    | expression "[" expression "]"      { $$ = new IR::ArrayIndex(@1 + @4, $1, $3); }
    | expression "[" expression ":" expression "]"
        { $$ = new IR::Slice(@1 + @6, $1, $3, $5); }
    | expression "[" expression "+:" expression "]"
        { $$ = new IR::PlusSlice(@1 + @6, $1, $3, $5); }
    | "{" expressionList optTrailingComma "}" { $$ = new IR::ListExpression(@1 + @4, std::move($2)); }
    | INVALID                            { $$ = new IR::Invalid(@1, IR::Type::Unknown::get()); }
    | "{" kvList optTrailingComma "}"    { $$ = new IR::StructExpression(
                                                  @1 + @4, IR::Type::Unknown::get(), (IR::Type_Name*)nullptr, std::move($2)); }
    | "{" kvList "," DOTS optTrailingComma "}" {
                                           $2.push_back(new IR::NamedDots(@4));
                                           $2.srcInfo += @4;
                                           $$ = new IR::StructExpression(
                                                  @1 + @6, IR::Type::Unknown::get(),
                                                  (IR::Type_Name*)nullptr, $2); }
    | "(" expression ")"                 { ($$ = $2)->srcInfo = @1 + @3; }
    | "!" expression %prec PREFIX        { $$ = new IR::LNot(@1 + @2, $2); }
    | "~" expression %prec PREFIX        { $$ = new IR::Cmpl(@1 + @2, $2); }
    | "-" expression %prec PREFIX        { $$ = new IR::Neg(@1 + @2, $2); }
    | "+" expression %prec PREFIX        { $$ = new IR::UPlus(@1 + @2, $2); }
    | typeName dot_name %prec DOT
        { $$ = new IR::Member(@1 + @2, new IR::TypeNameExpression(@1, $1), $2); }
    | ERROR "." name
        { auto typeName = new IR::Type_Name(@1, new IR::Path(IR::ID(@1, "error"_cs)));
          $$ = new IR::Member(@1+@3, new IR::TypeNameExpression(@1+@3, typeName), $3); }
    | expression dot_name %prec DOT      { $$ = new IR::Member(@1 + @2, $1, $2); }
    | expression "*" expression          { $$ = new IR::Mul(@1 + @3, $1, $3); }
    | expression "/" expression          { $$ = new IR::Div(@1 + @3, $1, $3); }
    | expression "%" expression          { $$ = new IR::Mod(@1 + @3, $1, $3); }
    | expression "+" expression          { $$ = new IR::Add(@1 + @3, $1, $3); }
    | expression "-" expression          { $$ = new IR::Sub(@1 + @3, $1, $3); }
    | expression "|+|" expression        { $$ = new IR::AddSat(@1 + @3, $1, $3); }
    | expression "|-|" expression        { $$ = new IR::SubSat(@1 + @3, $1, $3); }
    | expression "<<" expression         { $$ = new IR::Shl(@1 + @3, $1, $3); }
    | expression R_ANGLE_SHIFT ">" expression %prec R_ANGLE_SHIFT
        { $$ = new IR::Shr(@1 + @4, $1, $4); }
    | expression "<=" expression         { $$ = new IR::Leq(@1 + @3, $1, $3); }
    | expression ">=" expression         { $$ = new IR::Geq(@1 + @3, $1, $3); }
    | expression l_angle expression %prec "<"
                                         { $$ = new IR::Lss(@1 + @3, $1, $3); }
    | expression ">" expression          { $$ = new IR::Grt(@1 + @3, $1, $3); }
    | expression "!=" expression         { $$ = new IR::Neq(@1 + @3, $1, $3); }
    | expression "==" expression         { $$ = new IR::Equ(@1 + @3, $1, $3); }
    | expression "&" expression          { $$ = new IR::BAnd(@1 + @3, $1, $3); }
    | expression "^" expression          { $$ = new IR::BXor(@1 + @3, $1, $3); }
    | expression "|" expression          { $$ = new IR::BOr(@1 + @3, $1, $3); }
    | expression "++" expression         { $$ = new IR::Concat(@1 + @3, $1, $3); }
    | expression "&&" expression         { $$ = new IR::LAnd(@1 + @2 + @3, $1, $3); }
    | expression "||" expression         { $$ = new IR::LOr(@1 + @2 + @3, $1, $3); }
    | expression "?" expression ":" expression { $$ = new IR::Mux(@1 + @5, $1, $3, $5); }
    | expression l_angle realTypeArgumentList r_angle "(" argumentList ")"
        { $$ = new IR::MethodCallExpression(@1 + @7, $1, std::move($3), std::move($6)); }
    | expression "(" argumentList ")"
        { $$ = new IR::MethodCallExpression(@1 + @4, $1, std::move($3)); }
    | namedType "(" argumentList ")"
        { $$ = new IR::ConstructorCallExpression(@1 + @4, $1, std::move($3)); }
    | "(" typeRef ")" expression %prec PREFIX { $$ = new IR::Cast(@1 + @4, $2, $4); }
    ;

nonBraceExpression
    : INTEGER                            { $$ = parseConstant(@1, $1, 0); }
    | STRING_LITERAL                     { $$ = new IR::StringLiteral(@1, $1); }
    | TRUE                               { $$ = new IR::BoolLiteral(@1, true); }
    | FALSE                              { $$ = new IR::BoolLiteral(@1, false); }
    | THIS                               { $$ = new IR::This(@1); }
    | prefixedNonTypeName                { $$ = new IR::PathExpression($1); }
    | nonBraceExpression "[" expression "]"      { $$ = new IR::ArrayIndex(@1 + @4, $1, $3); }
    | nonBraceExpression "[" expression ":" expression "]"
        { $$ = new IR::Slice(@1 + @6, $1, $3, $5); }
    | nonBraceExpression "[" expression "+:" expression "]"
        { $$ = new IR::PlusSlice(@1 + @6, $1, $3, $5); }
    | "(" expression ")"                 { ($$ = $2)->srcInfo = @1 + @3; }
    | "!" expression %prec PREFIX        { $$ = new IR::LNot(@1 + @2, $2); }
    | "~" expression %prec PREFIX        { $$ = new IR::Cmpl(@1 + @2, $2); }
    | "-" expression %prec PREFIX        { $$ = new IR::Neg(@1 + @2, $2); }
    | "+" expression %prec PREFIX        { $$ = new IR::UPlus(@1 + @2, $2); }
    | typeName dot_name %prec DOT
        { $$ = new IR::Member(@1 + @2, new IR::TypeNameExpression(@1, $1), $2); }
    | ERROR "." name
        { auto typeName = new IR::Type_Name(@1, new IR::Path(IR::ID(@1, "error"_cs)));
          $$ = new IR::Member(@1+@3, new IR::TypeNameExpression(@1+@3, typeName), $3); }
    | nonBraceExpression dot_name %prec DOT      { $$ = new IR::Member(@1 + @2, $1, $2); }
    | nonBraceExpression "*" expression          { $$ = new IR::Mul(@1 + @3, $1, $3); }
    | nonBraceExpression "/" expression          { $$ = new IR::Div(@1 + @3, $1, $3); }
    | nonBraceExpression "%" expression          { $$ = new IR::Mod(@1 + @3, $1, $3); }
    | nonBraceExpression "+" expression          { $$ = new IR::Add(@1 + @3, $1, $3); }
    | nonBraceExpression "-" expression          { $$ = new IR::Sub(@1 + @3, $1, $3); }
    | nonBraceExpression "|+|" expression        { $$ = new IR::AddSat(@1 + @3, $1, $3); }
    | nonBraceExpression "|-|" expression        { $$ = new IR::SubSat(@1 + @3, $1, $3); }
    | nonBraceExpression "<<" expression         { $$ = new IR::Shl(@1 + @3, $1, $3); }
    | nonBraceExpression R_ANGLE_SHIFT ">" expression %prec R_ANGLE_SHIFT
        { $$ = new IR::Shr(@1 + @4, $1, $4); }
    | nonBraceExpression "<=" expression         { $$ = new IR::Leq(@1 + @3, $1, $3); }
    | nonBraceExpression ">=" expression         { $$ = new IR::Geq(@1 + @3, $1, $3); }
    | nonBraceExpression l_angle expression %prec "<"
                                         { $$ = new IR::Lss(@1 + @3, $1, $3); }
    | nonBraceExpression ">" expression          { $$ = new IR::Grt(@1 + @3, $1, $3); }
    | nonBraceExpression "!=" expression         { $$ = new IR::Neq(@1 + @3, $1, $3); }
    | nonBraceExpression "==" expression         { $$ = new IR::Equ(@1 + @3, $1, $3); }
    | nonBraceExpression "&" expression          { $$ = new IR::BAnd(@1 + @3, $1, $3); }
    | nonBraceExpression "^" expression          { $$ = new IR::BXor(@1 + @3, $1, $3); }
    | nonBraceExpression "|" expression          { $$ = new IR::BOr(@1 + @3, $1, $3); }
    | nonBraceExpression "++" expression         { $$ = new IR::Concat(@1 + @3, $1, $3); }
    | nonBraceExpression "&&" expression         { $$ = new IR::LAnd(@1 + @2 + @3, $1, $3); }
    | nonBraceExpression "||" expression         { $$ = new IR::LOr(@1 + @2 + @3, $1, $3); }
    | nonBraceExpression "?" expression ":" expression { $$ = new IR::Mux(@1 + @5, $1, $3, $5); }
    | nonBraceExpression l_angle realTypeArgumentList r_angle "(" argumentList ")"
        { $$ = new IR::MethodCallExpression(@1 + @7, $1, std::move($3), std::move($6)); }
    | nonBraceExpression "(" argumentList ")"
        { $$ = new IR::MethodCallExpression(@1 + @4, $1, std::move($3)); }
    | namedType "(" argumentList ")"
        { $$ = new IR::ConstructorCallExpression(@1 + @4, $1, std::move($3)); }
    | "(" typeRef ")" expression %prec PREFIX { $$ = new IR::Cast(@1 + @4, $2, $4); }
    ;

nonGrtExpression
    : INTEGER                                 { $$ = parseConstant(@1, $1, 0); }
    | STRING_LITERAL                          { $$ = new IR::StringLiteral(@1, $1); }
    | TRUE                                    { $$ = new IR::BoolLiteral(@1, true); }
    | FALSE                                   { $$ = new IR::BoolLiteral(@1, false); }
    | THIS                                    { $$ = new IR::This(@1); }
    | prefixedNonTypeName                     { $$ = new IR::PathExpression($1); }
    | nonGrtExpression "[" expression "]"     { $$ = new IR::ArrayIndex(@1 + @4, $1, $3); }
    | nonGrtExpression "[" expression ":" expression "]" {
                                                $$ = new IR::Slice(@1 + @6, $1, $3, $5); }
    | nonGrtExpression "[" expression "+:" expression "]" {
                                                $$ = new IR::PlusSlice(@1 + @6, $1, $3, $5); }
    | "{" expressionList optTrailingComma "}" { $$ = new IR::ListExpression(@1 + @4, std::move($2)); }
    | INVALID                                 { $$ = new IR::Invalid(
                                                        @1, IR::Type::Unknown::get()); }
    | "{" kvList optTrailingComma "}"         { $$ = new IR::StructExpression(
                                                          @1 + @4, IR::Type::Unknown::get(),
                                                          (IR::Type_Name*)nullptr, std::move($2)); }
    | "{" kvList "," DOTS optTrailingComma "}" {
                                                $2.push_back(new IR::NamedDots(@4));
                                                $2.srcInfo = $2.srcInfo + @4;
                                                $$ = new IR::StructExpression(
                                                        @1 + @6, IR::Type::Unknown::get(),
                                                        (IR::Type_Name*)nullptr, $2); }
    | "(" expression ")"                      { ($$ = $2)->srcInfo = @1 + @3; }
    | "!" expression %prec PREFIX             { $$ = new IR::LNot(@1 + @2, $2); }
    | "~" expression %prec PREFIX             { $$ = new IR::Cmpl(@1 + @2, $2); }
    | "-" expression %prec PREFIX             { $$ = new IR::Neg(@1 + @2, $2); }
    | "+" expression %prec PREFIX             { $$ = new IR::UPlus(@1 + @2, $2); }
    | typeName dot_name %prec DOT
        { $$ = new IR::Member(@1 + @2, new IR::TypeNameExpression(@1, $1), $2); }
    | ERROR "." name
        { auto typeName = new IR::Type_Name(@1, new IR::Path(IR::ID(@1, "error"_cs)));
          $$ = new IR::Member(@1+@3, new IR::TypeNameExpression(@1+@3, typeName), $3); }
    | nonGrtExpression dot_name %prec DOT     { $$ = new IR::Member(@1 + @2, $1, $2); }
    | nonGrtExpression "*" expression         { $$ = new IR::Mul(@1 + @3, $1, $3); }
    | nonGrtExpression "/" expression         { $$ = new IR::Div(@1 + @3, $1, $3); }
    | nonGrtExpression "%" expression         { $$ = new IR::Mod(@1 + @3, $1, $3); }
    | nonGrtExpression "+" expression         { $$ = new IR::Add(@1 + @3, $1, $3); }
    | nonGrtExpression "-" expression         { $$ = new IR::Sub(@1 + @3, $1, $3); }
    | nonGrtExpression "|+|" expression       { $$ = new IR::AddSat(@1 + @3, $1, $3); }
    | nonGrtExpression "|-|" expression       { $$ = new IR::SubSat(@1 + @3, $1, $3); }
    | nonGrtExpression "<<" expression        { $$ = new IR::Shl(@1 + @3, $1, $3); }
    | nonGrtExpression "<=" nonGrtExpression  { $$ = new IR::Leq(@1 + @3, $1, $3); }
    | nonGrtExpression ">=" nonGrtExpression  { $$ = new IR::Geq(@1 + @3, $1, $3); }
    | nonGrtExpression l_angle nonGrtExpression %prec "<" {
                                                $$ = new IR::Lss(@1 + @3, $1, $3); }
    | nonGrtExpression "!=" nonGrtExpression  { $$ = new IR::Neq(@1 + @3, $1, $3); }
    | nonGrtExpression "==" nonGrtExpression  { $$ = new IR::Equ(@1 + @3, $1, $3); }
    | nonGrtExpression "&" nonGrtExpression   { $$ = new IR::BAnd(@1 + @3, $1, $3); }
    | nonGrtExpression "^" nonGrtExpression   { $$ = new IR::BXor(@1 + @3, $1, $3); }
    | nonGrtExpression "|" nonGrtExpression   { $$ = new IR::BOr(@1 + @3, $1, $3); }
    | nonGrtExpression "++" expression        { $$ = new IR::Concat(@1 + @3, $1, $3); }
    | nonGrtExpression "&&" nonGrtExpression  { $$ = new IR::LAnd(@1 + @2 + @3, $1, $3); }
    | nonGrtExpression "||" nonGrtExpression  { $$ = new IR::LOr(@1 + @2 + @3, $1, $3); }
    | nonGrtExpression "?" expression ":" nonGrtExpression {
                                                $$ = new IR::Mux(@1 + @5, $1, $3, $5); }
    | nonGrtExpression l_angle realTypeArgumentList r_angle "(" argumentList ")"
        { $$ = new IR::MethodCallExpression(@1 + @7, $1, std::move($3), std::move($6)); }
    | nonGrtExpression "(" argumentList ")"
        { $$ = new IR::MethodCallExpression(@1 + @4, $1, std::move($3)); }
    | namedType "(" argumentList ")"
        { $$ = new IR::ConstructorCallExpression(@1 + @4, $1, std::move($3)); }
    | "(" typeRef ")" expression %prec PREFIX { $$ = new IR::Cast(@1 + @4, $2, $4); }
    ;

intOrStr
    : INTEGER                    { $$ = parseConstant(@1, $1, 0); }
    | STRING_LITERAL             { $$ = new IR::StringLiteral(@1, $1); }
    ;

intList
    : INTEGER                    { $$ = {};
                                   $$.push_back(parseConstant(@1, $1, 0));
                                   $$.srcInfo = @1; }
    | intList "," INTEGER        { ($$ = std::move($1)).push_back(parseConstant(@3, $3, 0));
                                   $$.srcInfo = @1 + @3; }
    ;

intOrStrList
    : intOrStr                  { $$ = {};
                                  $$.push_back($1);
                                  $$.srcInfo = @1; }
    | intOrStrList "," intOrStr { ($$ = std::move($1)).push_back($3);
                                  $$.srcInfo = @1 + @3; }
    ;

strList
    : STRING_LITERAL             { $$ = {};
                                   $$.push_back(new IR::StringLiteral(@1, $1));
                                   $$.srcInfo = @1; }
    | strList "," STRING_LITERAL { ($$ = std::move($1)).push_back(new IR::StringLiteral(@3, $3));
                                   $$.srcInfo = @1 + @3; }
    ;

l_angle : "<" | L_ANGLE_ARGS ;
r_angle : ">" | R_ANGLE_SHIFT ;

/*****************************************************************************/

%%

namespace P4 {

void P4Parser::error(const Util::SourceInfo& location,
                     const std::string& message) {
    driver.onParseError(location, message);
}

}  // namespace P4

#pragma GCC diagnostic pop