diamantaire/third_party/parser/cc/grammars/typedruby.ypp

%require "3.0"
%skeleton "lalr1.cc"
%token-table

%code requires {
  #include <ruby_parser/builder.hh>
  #include <ruby_parser/node.hh>
  #include <ruby_parser/token.hh>
  #include <ruby_parser/lexer.hh>
  #include <ruby_parser/driver.hh>
  #include <ruby_parser/state_stack.hh>
  #include <iterator>
  #include <utility>
  #include <cstdlib>

using namespace ruby_parser;
using namespace std::string_literals;

#ifndef YY_NULLPTR
#define YY_NULLPTR nullptr
#endif
}

%param { ruby_parser::typedruby25& driver }
%parse-param { ruby_parser::SelfPtr self }
%define api.namespace {ruby_parser::bison::typedruby25}
%define api.prefix {typedruby25}
%define api.value.type { union parser_value }
%define api.token.constructor false
%define parse.assert
%define parse.error verbose

// mirrored in inc/ruby_parser/token.hh
// if any of these token values are changed here, the header must be updated
// as well.
%token <token>
  kCLASS              1001
  kMODULE             1002
  kDEF                1003
  kUNDEF              1004
  kBEGIN              1005
  kRESCUE             1006
  kENSURE             1007
  kEND                1008
  kIF                 1009
  kUNLESS             1010
  kTHEN               1011
  kELSIF              1012
  kELSE               1013
  kCASE               1014
  kWHEN               1015
  kWHILE              1016
  kUNTIL              1017
  kFOR                1018
  kBREAK              1019
  kNEXT               1020
  kREDO               1021
  kRETRY              1022
  kIN                 1023
  kDO                 1024
  kDO_COND            1025
  kDO_BLOCK           1026
  kDO_LAMBDA          1027
  kRETURN             1028
  kYIELD              1029
  kSUPER              1030
  kSELF               1031
  kNIL                1032
  kTRUE               1033
  kFALSE              1034
  kAND                1035
  kOR                 1036
  kNOT                1037
  kIF_MOD             1038
  kUNLESS_MOD         1039
  kWHILE_MOD          1040
  kUNTIL_MOD          1041
  kRESCUE_MOD         1042
  kALIAS              1043
  kDEFINED            1044
  klBEGIN             1045
  klEND               1046
  k__LINE__           1047
  k__FILE__           1048
  k__ENCODING__       1049
  tIDENTIFIER         1050
  tFID                1051
  tGVAR               1052
  tIVAR               1053
  tCONSTANT           1054
  tLABEL              1055
  tCVAR               1056
  tNTH_REF            1057
  tBACK_REF           1058
  tSTRING_CONTENT     1059
  tINTEGER            1060
  tFLOAT              1061
  tUPLUS              1062
  tUMINUS             1063
  tUNARY_NUM          1064
  tPOW                1065
  tCMP                1066
  tEQ                 1067
  tEQQ                1068
  tNEQ                1069
  tEQL                1070
  tGEQ                1071
  tLEQ                1072
  tANDOP              1073
  tOROP               1074
  tMATCH              1075
  tNMATCH             1076
  tDOT                1077
  tDOT2               1078
  tDOT3               1079
  tAREF               1080
  tASET               1081
  tLSHFT              1082
  tRSHFT              1083
  tCOLON2             1084
  tCOLON3             1085
  tOP_ASGN            1086
  tASSOC              1087
  tLPAREN             1088
  tLPAREN2            1089
  tRPAREN             1090
  tLPAREN_ARG         1091
  tLBRACK             1092
  tLBRACK2            1093
  tRBRACK             1094
  tLBRACE             1095
  tLBRACE_ARG         1096
  tSTAR               1097
  tSTAR2              1098
  tAMPER              1099
  tAMPER2             1100
  tTILDE              1101
  tPERCENT            1102
  tDIVIDE             1103
  tDSTAR              1104
  tPLUS               1105
  tMINUS              1106
  tLT                 1107
  tGT                 1108
  tPIPE               1109
  tBANG               1110
  tCARET              1111
  tLCURLY             1112
  tRCURLY             1113
  tBACK_REF2          1114
  tSYMBEG             1115
  tSTRING_BEG         1116
  tXSTRING_BEG        1117
  tREGEXP_BEG         1118
  tREGEXP_OPT         1119
  tWORDS_BEG          1120
  tQWORDS_BEG         1121
  tSYMBOLS_BEG        1122
  tQSYMBOLS_BEG       1123
  tSTRING_DBEG        1124
  tSTRING_DVAR        1125
  tSTRING_END         1126
  tSTRING_DEND        1127
  tSTRING             1128
  tSYMBOL             1129
  tNL                 1130
  tEH                 1131
  tCOLON              1132
  tCOMMA              1133
  tSPACE              1134
  tSEMI               1135
  tLAMBDA             1136
  tLAMBEG             1137
  tCHARACTER          1138
  tRATIONAL           1139
  tIMAGINARY          1140
  tLABEL_END          1141
  tANDDOT             1142
  tRATIONAL_IMAGINARY 1143
  tFLOAT_IMAGINARY    1144

%type <node>
  arg
  arg_rhs
  arg_value
  assoc
  backref
  block_arg
  block_call
  block_command
  block_param_def
  bodystmt
  bvar
  command
  command_asgn
  command_call
  command_rhs
  compstmt
  cpath
  dsym
  expr
  expr_value
  f_arg_item
  f_arglist
  f_block_kw
  f_block_opt
  f_kw
  f_larglist
  f_marg
  f_opt
  fitem
  for_var
  fsym
  keyword_variable
  lhs
  literal
  method_call
  mlhs
  mlhs_inner
  mlhs_item
  mlhs_node
  mrhs_arg
  none
  numeric
  opt_block_param
  primary
  primary_value
  qsymbols
  qwords
  regexp
  simple_numeric
  singleton
  stmt
  stmt_or_begin
  string1
  string_content
  string_dvar
  strings
  symbol
  symbols
  top_compstmt
  top_stmt
  user_variable
  var_lhs
  var_ref
  words
  xstring
  rel_expr

%type <list>
  aref_args
  args
  args_tail
  assoc_list
  assocs
  block_args_tail
  block_param
  bv_decls
  call_args
  command_args
  exc_list
  f_arg
  f_args
  f_block_arg
  f_block_kwarg
  f_block_optarg
  f_kwarg
  f_kwrest
  f_marg_list
  f_margs
  f_optarg
  f_rest_arg
  list_none
  mlhs_basic
  mlhs_head
  mlhs_post
  mrhs
  opt_args_tail
  opt_block_arg
  opt_block_args_tail
  opt_bv_decl
  opt_call_args
  opt_f_block_arg
  opt_rescue
  qsym_list
  qword_list
  regexp_contents
  stmts
  string
  string_contents
  symbol_list
  top_stmts
  undef_list
  word
  word_list
  xstring_contents

%type <token>
  blkarg_mark
  call_op
  cname
  do
  dot_or_colon
  f_arg_asgn
  f_bad_arg
  f_label
  f_norm_arg
  fcall
  fname
  kwrest_mark
  op
  operation
  operation2
  operation3
  rbracket
  restarg_mark
  reswords
  rparen
  term
  then
  relop
  k_return

%type <delimited_list>
  opt_paren_args
  paren_args

%type <delimited_block>
  brace_block
  brace_body
  cmd_brace_block
  do_block
  do_body
  lambda
  lambda_body
  begin_block

%type <with_token>
  exc_var
  if_tail
  opt_else
  opt_ensure
  superclass
  expr_value_do

%type <case_body>
  case_body
  cases

%nonassoc tLOWEST
%nonassoc tLBRACE_ARG
%nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD
%left     kOR kAND
%right    kNOT
%nonassoc kDEFINED
%right    tEQL tOP_ASGN
%left     kRESCUE_MOD
%right    tEH tCOLON
%nonassoc tDOT2 tDOT3
%left     tOROP
%left     tANDOP
%nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
%left     tGT tGEQ tLT tLEQ
%left     tPIPE tCARET
%left     tAMPER2
%left     tLSHFT tRSHFT
%left     tPLUS tMINUS
%left     tSTAR2 tDIVIDE tPERCENT
%right    tUNARY_NUM tUMINUS
%right    tPOW
%right    tBANG tTILDE tUPLUS

%code requires {

union parser_value {
  ruby_parser::token *token;
  ruby_parser::delimited_node_list *delimited_list;
  ruby_parser::delimited_block *delimited_block;
  ruby_parser::node_with_token *with_token;
  ruby_parser::case_body *case_body;
  ruby_parser::ForeignPtr node;
  ruby_parser::node_list *list;
  ruby_parser::state_stack *stack;
  size_t size;
  bool boolean;
};

}

%code {
namespace ruby_parser {
namespace bison {
namespace typedruby25 {

#define DIAGCHECK() do { \
	if (driver.pending_error) { \
		driver.pending_error = false; \
		YYERROR; \
	} \
} while(false);

void parser::error(const std::string &msg) {
  std::string error_message = msg;

  int token_type = static_cast<int>(driver.last_token->type());
  const char* token_str_name = yytname_[yytranslate_(token_type)];

  if (token_str_name != nullptr) {
    error_message = token_str_name;
  }

	driver.diagnostics.emplace_back(
		dlevel::ERROR, dclass::UnexpectedToken,
		diagnostic::range(driver.lex.last_token_s, driver.lex.last_token_e),
		error_message);
}

int yylex(parser::semantic_type *lval, ruby_parser::typedruby25 &driver) {
	auto token = driver.lex.advance();
	driver.last_token = token;
	int token_type = static_cast<int>(token->type());
	assert(token_type >= 0);
	lval->token = token;
	return token_type;
}

}}} // namespace
} // %code

%%
         program: top_compstmt
                    {
                      driver.ast = $1;
                    }

    top_compstmt: top_stmts opt_terms
                    {
                      $$ = driver.build.compstmt(self, $1);
                    }

       top_stmts: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | top_stmt
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | top_stmts terms top_stmt
                    {
                      $1->emplace_back($3);
                      $$ = $1;
                    }
                | error top_stmt
                    {
                      $$ = driver.alloc.node_list($2);
                    }

        top_stmt: stmt
                | klBEGIN begin_block
                    {
                      auto &delimited_block = $2;
                      $$ = driver.build.preexe(self, $1, delimited_block->body, delimited_block->end);
                    }

     begin_block: tLCURLY top_compstmt tRCURLY
                    {
                      $$ = driver.alloc.delimited_block($1, nullptr, $2, $3);
                    }

        bodystmt: compstmt opt_rescue opt_else opt_ensure
                    {
                      auto &rescueBodies = $2;
                      auto &else_ = $3;
                      auto &ensure = $4;

                      if (rescueBodies->size() == 0 && else_ != nullptr) {
                        driver.diagnostics.emplace_back(
			                    dlevel::ERROR,
                          dclass::UselessElse,
                          else_->tok
                        );
                      }

                      $$ = driver.build.beginBody(
                        self,
                        $1,
                        rescueBodies,
                        else_ ? else_->tok : nullptr,
                        else_ ? else_->nod : nullptr,
                        ensure ? ensure->tok : nullptr,
                        ensure ? ensure->nod : nullptr
                      );
                    }

        compstmt: stmts opt_terms
                    {
                      $$ = driver.build.compstmt(self, $1);
                    }

           stmts: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | stmt_or_begin
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | stmts terms stmt_or_begin
                    {
                      $1->emplace_back($3);
                      $$ = $1;
                    }
                | error
                    {
                      $$ = driver.alloc.node_list();
                    }

   stmt_or_begin: stmt
                | klBEGIN begin_block
                    {
                      driver.diagnostics.emplace_back(
                        dlevel::ERROR,
			                  dclass::BeginInMethod,
                        $1
                      );
                      YYERROR;
                    }

            stmt: kALIAS fitem
                    {
                      driver.lex.set_state_expr_fname();
                    }
                    fitem
                    {
                      $$ = driver.build.alias(self, $1, $2, $4);
                    }
                | kALIAS tGVAR tGVAR
                    {
                      $$ = driver.build.alias(self, $1, driver.build.gvar(self, $2), driver.build.gvar(self, $3));
                    }
                | kALIAS tGVAR tBACK_REF
                    {
                      $$ = driver.build.alias(self, $1, driver.build.gvar(self, $2), driver.build.backRef(self, $3));
                    }
                | kALIAS tGVAR tNTH_REF
                    {
                      driver.diagnostics.emplace_back(dlevel::ERROR, dclass::NthRefAlias, $3);
                      YYERROR;
                    }
                | kUNDEF undef_list
                    {
                      $$ = driver.build.undefMethod(self, $1, $2);
                    }
                | stmt kIF_MOD expr_value
                    {
                      $$ = driver.build.conditionMod(self, $1, nullptr, $3);
                    }
                | stmt kUNLESS_MOD expr_value
                    {
                      $$ = driver.build.conditionMod(self, nullptr, $1, $3);
                    }
                | stmt kWHILE_MOD expr_value
                    {
                      $$ = driver.build.loop_while_mod(self, $1, $3);
                    }
                | stmt kUNTIL_MOD expr_value
                    {
                      $$ = driver.build.loopUntil_mod(self, $1, $3);
                    }
                | stmt kRESCUE_MOD stmt
                    {
                      ruby_parser::node_list rescue_body(
						driver.build.rescue_body(self, $2, nullptr, nullptr, nullptr, nullptr, $3));
                      $$ = driver.build.beginBody(self, $1, &rescue_body, nullptr, nullptr, nullptr, nullptr);
                    }
                | klEND tLCURLY compstmt tRCURLY
                    {
                      $$ = driver.build.postexe(self, $1, $3, $4);
                    }
                | command_asgn
                | mlhs tEQL command_call
                    {
                      $$ = driver.build.multi_assign(self, $1, $3);
                    }
                | lhs tEQL mrhs
                    {
                      $$ = driver.build.assign(self, $1, $2, driver.build.array(self, nullptr, $3, nullptr));
                    }
                | mlhs tEQL mrhs_arg
                    {
                      $$ = driver.build.multi_assign(self, $1, $3);
                    }
                | expr

    command_asgn: lhs tEQL command_rhs
                    {
                      $$ = driver.build.assign(self, $1, $2, $3);
                    }
                | var_lhs tOP_ASGN command_rhs
                    {
                      $$ = driver.build.op_assign(self, $1, $2, $3);
                      DIAGCHECK();
                    }
                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.index(self, $1, $2, $3, $4), $5, $6);
                      DIAGCHECK();
                    }
                | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.call_method(self, $1, $2, $3, nullptr, nullptr, nullptr), $4, $5);
                      DIAGCHECK();
                    }
                | primary_value call_op tCONSTANT tOP_ASGN command_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.call_method(self, $1, $2, $3, nullptr, nullptr, nullptr), $4, $5);
                      DIAGCHECK();
                    }
                | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
                    {
                      auto const_node = driver.build.constOpAssignable(self, driver.build.constFetch(self, $1, $2, $3));
                      $$ = driver.build.op_assign(self, const_node, $4, $5);
                      DIAGCHECK();
                    }
                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.call_method(self, $1, $2, $3, nullptr, nullptr, nullptr), $4, $5);
                      DIAGCHECK();
                    }
                | backref tOP_ASGN command_rhs
                    {
                      $$ = driver.build.op_assign(self, $1, $2, $3);
                      DIAGCHECK();
                    }

     command_rhs: command_call %prec tOP_ASGN
                | command_call kRESCUE_MOD stmt
                    {
                      node_list rescue_body(
			                  driver.build.rescue_body(self, $2, nullptr, nullptr, nullptr, nullptr, $3)
                      );
                      $$ = driver.build.beginBody(self, $1, &rescue_body, nullptr, nullptr, nullptr, nullptr);
                    }
                | command_asgn

            expr: command_call
                | expr kAND expr
                    {
                      $$ = driver.build.logicalAnd(self, $1, $2, $3);
                    }
                | expr kOR expr
                    {
                      $$ = driver.build.logicalOr(self, $1, $2, $3);
                    }
                | kNOT opt_nl expr
                    {
                      $$ = driver.build.not_op(self, $1, nullptr, $3, nullptr);
                    }
                | tBANG command_call
                    {
                      $$ = driver.build.not_op(self, $1, nullptr, $2, nullptr);
                    }
                | arg

      expr_value: expr

   expr_value_do:   {
                      driver.lex.cond.push(true);
                    }
                  expr_value do
                    {
                      driver.lex.cond.pop();

                      $$ = driver.alloc.node_with_token($3, $2);
                    }

    command_call: command
                | block_command

   block_command: block_call
                | block_call dot_or_colon operation2 command_args
                    {
                      $$ = driver.build.call_method(self, $1, $2, $3, nullptr, $4, nullptr);
                    }

 cmd_brace_block: tLBRACE_ARG
                    {
                      driver.lex.context.push(Context::State::BLOCK);
                    }
                  brace_body tRCURLY
                    {
                      auto &block = $3;
                      block->begin = $1;
                      block->end = $4;
                      $$ = block;
                      driver.lex.context.pop();
                    }

           fcall: operation

         command: fcall command_args %prec tLOWEST
                    {
                      $$ = driver.build.call_method(self, nullptr, nullptr, $1, nullptr, $2, nullptr);
                    }
                | fcall command_args cmd_brace_block
                    {
                      auto method_call = driver.build.call_method(self, nullptr, nullptr, $1, nullptr, $2, nullptr);
                      auto &delimited_block = $3;
                      $$ = driver.build.block(self, method_call,
                                      delimited_block->begin,
                                      delimited_block->args,
                                      delimited_block->body,
                                      delimited_block->end);
                      DIAGCHECK();
                    }
                | primary_value call_op operation2 command_args %prec tLOWEST
                    {
                      $$ = driver.build.call_method(self, $1, $2, $3, nullptr, $4, nullptr);
                    }
                | primary_value call_op operation2 command_args cmd_brace_block
                    {
                      auto method_call = driver.build.call_method(self, $1, $2, $3, nullptr, $4, nullptr);
                      auto &delimited_block = $5;
                      $$ = driver.build.block(self, method_call,
                                      delimited_block->begin,
                                      delimited_block->args,
                                      delimited_block->body,
                                      delimited_block->end);
                      DIAGCHECK();
                    }
                | primary_value tCOLON2 operation2 command_args %prec tLOWEST
                    {
                      $$ = driver.build.call_method(self, $1, $2, $3, nullptr, $4, nullptr);
                    }
                | primary_value tCOLON2 operation2 command_args cmd_brace_block
                    {
                      auto method_call = driver.build.call_method(self, $1, $2, $3, nullptr, $4, nullptr);
                      auto &delimited_block = $5;
                      $$ = driver.build.block(self, method_call,
                                      delimited_block->begin,
                                      delimited_block->args,
                                      delimited_block->body,
                                      delimited_block->end);
                      DIAGCHECK();
                    }
                | kSUPER command_args
                    {
                      $$ = driver.build.keywordSuper(self, $1, nullptr, $2, nullptr);
                    }
                | kYIELD command_args
                    {
                      $$ = driver.build.keywordYield(self, $1, nullptr, $2, nullptr);
                      DIAGCHECK();
                    }
                | k_return call_args
                    {
                      $$ = driver.build.keywordReturn(self, $1, nullptr, $2, nullptr);
                    }
                | kBREAK call_args
                    {
                      $$ = driver.build.keywordBreak(self, $1, nullptr, $2, nullptr);
                    }
                | kNEXT call_args
                    {
                      $$ = driver.build.keywordNext(self, $1, nullptr, $2, nullptr);
                    }

            mlhs: mlhs_basic
                    {
                      $$ = driver.build.multi_lhs(self, nullptr, $1, nullptr);
                    }
                | tLPAREN mlhs_inner rparen
                    {
                      $$ = driver.build.begin(self, $1, $2, $3);
                    }

      mlhs_inner: mlhs_basic
                    {
                      $$ = driver.build.multi_lhs(self, nullptr, $1, nullptr);
                    }
                | tLPAREN mlhs_inner rparen
                    {
                      $$ = driver.build.multi_lhs1(self, $1, $2, $3);
                    }

      mlhs_basic: mlhs_head
                | mlhs_head mlhs_item
                    {
                      auto &list = $1;
                      list->emplace_back($2);
                      $$ = list;
                    }
                | mlhs_head tSTAR mlhs_node
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.splat_mlhs(self, $2, $3));
                      $$ = list;
                    }
                | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
                    {
                      auto &head = $1;
                      head->emplace_back(driver.build.splat_mlhs(self, $2, $3));
                      head->concat($5);
                      $$ = head;
                    }
                | mlhs_head tSTAR
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.splat_mlhs(self, $2, nullptr));
                      $$ = list;
                    }
                | mlhs_head tSTAR tCOMMA mlhs_post
                    {
                      auto &head = $1;
                      head->emplace_back(driver.build.splat_mlhs(self, $2, nullptr));
                      head->concat($4);
                      $$ = head;
                    }
                | tSTAR mlhs_node
                    {
                      $$ = driver.alloc.node_list(driver.build.splat_mlhs(self, $1, $2));
                    }
                | tSTAR mlhs_node tCOMMA mlhs_post
                    {
                      node_list *items = driver.alloc.node_list(driver.build.splat_mlhs(self, $1, $2));
                      items->concat($4);
                      $$ = items;
                    }
                | tSTAR
                    {
                      $$ = driver.alloc.node_list(driver.build.splat_mlhs(self, $1, nullptr));
                    }
                | tSTAR tCOMMA mlhs_post
                    {
                      node_list *items = driver.alloc.node_list(driver.build.splat_mlhs(self, $1, nullptr));
                      items->concat($3);
                      $$ = items;
                    }

       mlhs_item: mlhs_node
                | tLPAREN mlhs_inner rparen
                    {
                      $$ = driver.build.begin(self, $1, $2, $3);
                    }

       mlhs_head: mlhs_item tCOMMA
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | mlhs_head mlhs_item tCOMMA
                    {
                      auto &list = $1;
                      list->emplace_back($2);
                      $$ = list;
                    }

       mlhs_post: mlhs_item
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | mlhs_post tCOMMA mlhs_item
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

       mlhs_node: user_variable
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }
                | keyword_variable
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }
                | primary_value tLBRACK2 opt_call_args rbracket
                    {
                      $$ = driver.build.indexAsgn(self, $1, $2, $3, $4);
                    }
                | primary_value call_op tIDENTIFIER
                    {
                      $$ = driver.build.attrAsgn(self, $1, $2, $3);
                    }
                | primary_value tCOLON2 tIDENTIFIER
                    {
                      $$ = driver.build.attrAsgn(self, $1, $2, $3);
                    }
                | primary_value call_op tCONSTANT
                    {
                      $$ = driver.build.attrAsgn(self, $1, $2, $3);
                    }
                | primary_value tCOLON2 tCONSTANT
                    {
                      $$ = driver.build.assignable(self, driver.build.constFetch(self, $1, $2, $3));
                      DIAGCHECK();
                    }
                | tCOLON3 tCONSTANT
                    {
                      $$ = driver.build.assignable(self, driver.build.constGlobal(self, $1, $2));
                      DIAGCHECK();
                    }
                | backref
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }

             lhs: user_variable
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }
                | keyword_variable
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }
                | primary_value tLBRACK2 opt_call_args rbracket
                    {
                      $$ = driver.build.indexAsgn(self, $1, $2, $3, $4);
                    }
                | primary_value call_op tIDENTIFIER
                    {
                      $$ = driver.build.attrAsgn(self, $1, $2, $3);
                    }
                | primary_value tCOLON2 tIDENTIFIER
                    {
                      $$ = driver.build.attrAsgn(self, $1, $2, $3);
                    }
                | primary_value call_op tCONSTANT
                    {
                      $$ = driver.build.attrAsgn(self, $1, $2, $3);
                    }
                | primary_value tCOLON2 tCONSTANT
                    {
                      $$ = driver.build.assignable(self, driver.build.constFetch(self, $1, $2, $3));
                      DIAGCHECK();
                    }
                | tCOLON3 tCONSTANT
                    {
                      $$ = driver.build.assignable(self, driver.build.constGlobal(self, $1, $2));
                      DIAGCHECK();
                    }
                | backref
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }

           cname: tIDENTIFIER
                    {
                      driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ModuleNameConst, $1);
                      YYERROR;
                    }
                | tCONSTANT

           cpath: tCOLON3 cname
                    {
                      $$ = driver.build.constGlobal(self, $1, $2);
                    }
                | cname
                    {
                      $$ = driver.build.const_(self, $1);
                    }
                | primary_value tCOLON2 cname
                    {
                      $$ = driver.build.constFetch(self, $1, $2, $3);
                    }

           fname: tIDENTIFIER | tCONSTANT | tFID
                | op
                | reswords

            fsym: fname
                    {
                      $$ = driver.build.symbol(self, $1);
                    }
                | symbol

           fitem: fsym
                | dsym

      undef_list: fitem
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | undef_list tCOMMA
                    {
                      driver.lex.set_state_expr_fname();
                    }
                    fitem
                    {
                      auto &list = $1;
                      list->emplace_back($4);
                      $$ = list;
                    }

              op:   tPIPE    | tCARET  | tAMPER2  | tCMP  | tEQ     | tEQQ
                |   tMATCH   | tNMATCH | tGT      | tGEQ  | tLT     | tLEQ
                |   tNEQ     | tLSHFT  | tRSHFT   | tPLUS | tMINUS  | tSTAR2
                |   tSTAR    | tDIVIDE | tPERCENT | tPOW  | tBANG   | tTILDE
                |   tUPLUS   | tUMINUS | tAREF    | tASET | tDSTAR  | tBACK_REF2

        reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
                | kALIAS    | kAND      | kBEGIN        | kBREAK  | kCASE
                | kCLASS    | kDEF      | kDEFINED      | kDO     | kELSE
                | kELSIF    | kEND      | kENSURE       | kFALSE  | kFOR
                | kIN       | kMODULE   | kNEXT         | kNIL    | kNOT
                | kOR       | kREDO     | kRESCUE       | kRETRY  | kRETURN
                | kSELF     | kSUPER    | kTHEN         | kTRUE   | kUNDEF
                | kWHEN     | kYIELD    | kIF           | kUNLESS | kWHILE
                | kUNTIL

             arg: lhs tEQL arg_rhs
                    {
                      $$ = driver.build.assign(self, $1, $2, $3);
                    }
                | var_lhs tOP_ASGN arg_rhs
                    {
                      $$ = driver.build.op_assign(self, $1, $2, $3);
                      DIAGCHECK();
                    }
                | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.index(self, $1, $2, $3, $4), $5, $6);
                      DIAGCHECK();
                    }
                | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.call_method(self, $1, $2, $3, nullptr, nullptr, nullptr), $4, $5);
                      DIAGCHECK();
                    }
                | primary_value call_op tCONSTANT tOP_ASGN arg_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.call_method(self, $1, $2, $3, nullptr, nullptr, nullptr), $4, $5);
                      DIAGCHECK();
                    }
                | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
                    {
                      $$ = driver.build.op_assign(self, driver.build.call_method(self, $1, $2, $3, nullptr, nullptr, nullptr), $4, $5);
                      DIAGCHECK();
                    }
                | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
                    {
                      auto const_ = driver.build.constOpAssignable(self, driver.build.constFetch(self, $1, $2, $3));
                      $$ = driver.build.op_assign(self, const_, $4, $5);
                      DIAGCHECK();
                    }
                | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
                    {
                      auto const_ = driver.build.constOpAssignable(self, driver.build.constGlobal(self, $1, $2));
                      $$ = driver.build.op_assign(self, const_, $3, $4);
                      DIAGCHECK();
                    }
                | backref tOP_ASGN arg_rhs
                    {
                      $$ = driver.build.op_assign(self, $1, $2, $3);
                      DIAGCHECK();
                    }
                | arg tDOT2 arg
                    {
                      $$ = driver.build.range_inclusive(self, $1, $2, $3);
                    }
                | arg tDOT3 arg
                    {
                      $$ = driver.build.range_exclusive(self, $1, $2, $3);
                    }
                | arg tDOT2
                    {
                      $$ = driver.build.range_inclusive(self, $1, $2, nullptr);
                    }
                | arg tDOT3
                    {
                      $$ = driver.build.range_exclusive(self, $1, $2, nullptr);
                    }
                | arg tPLUS arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tMINUS arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tSTAR2 arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tDIVIDE arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tPERCENT arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tPOW arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | tUNARY_NUM simple_numeric tPOW arg
                    {
                      $$ = driver.build.unary_op(self, $1, driver.build.binaryOp(self, $2, $3, $4));
                    }
                | tUPLUS arg
                    {
                      $$ = driver.build.unary_op(self, $1, $2);
                    }
                | tUMINUS arg
                    {
                      $$ = driver.build.unary_op(self, $1, $2);
                    }
                | arg tPIPE arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tCARET arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tAMPER2 arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tCMP arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | rel_expr %prec tCMP
                | arg tEQ arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tEQQ arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tNEQ arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tMATCH arg
                    {
                      $$ = driver.build.match_op(self, $1, $2, $3);
                      DIAGCHECK();
                    }
                | arg tNMATCH arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | tBANG arg
                    {
                      $$ = driver.build.not_op(self, $1, nullptr, $2, nullptr);
                    }
                | tTILDE arg
                    {
                      $$ = driver.build.unary_op(self, $1, $2);
                    }
                | arg tLSHFT arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tRSHFT arg
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | arg tANDOP arg
                    {
                      $$ = driver.build.logicalAnd(self, $1, $2, $3);
                    }
                | arg tOROP arg
                    {
                      $$ = driver.build.logicalOr(self, $1, $2, $3);
                    }
                | kDEFINED opt_nl arg
                    {
                      $$ = driver.build.keywordDefined(self, $1, $3);
                    }
                | arg tEH arg opt_nl tCOLON arg
                    {
                      $$ = driver.build.ternary(self, $1, $2, $3, $5, $6);
                    }
                | primary

           relop: tGT | tLT | tGEQ | tLEQ

        rel_expr: arg relop arg %prec tGT
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }
                | rel_expr relop arg %prec tGT
                    {
                      $$ = driver.build.binaryOp(self, $1, $2, $3);
                    }

       arg_value: arg

       aref_args: list_none
                | args trailer
                | args tCOMMA assocs trailer
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.associate(self, nullptr, $3, nullptr));
                      $$ = list;
                    }
                | assocs trailer
                    {
                      $$ = driver.alloc.node_list(driver.build.associate(self, nullptr, $1, nullptr));
                    }

         arg_rhs: arg %prec tOP_ASGN
                | arg kRESCUE_MOD arg
                    {
                      node_list rescue_body(driver.build.rescue_body(self, $2, nullptr, nullptr, nullptr, nullptr, $3));
                      $$ = driver.build.beginBody(self, $1, &rescue_body, nullptr, nullptr, nullptr, nullptr);
                    }

      paren_args: tLPAREN2 opt_call_args rparen
                    {
                      $$ = driver.alloc.delimited_node_list($1, $2, $3);
                    }

  opt_paren_args: // nothing
                    {
                      $$ = driver.alloc.delimited_node_list(nullptr, driver.alloc.node_list(), nullptr);
                    }
                | paren_args

   opt_call_args: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | call_args
                | args tCOMMA
                | args tCOMMA assocs tCOMMA
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.associate(self, nullptr, $3, nullptr));
                      $$ = list;
                    }
                | assocs tCOMMA
                    {
                      $$ = driver.alloc.node_list(driver.build.associate(self, nullptr, $1, nullptr));
                    }

       call_args: command
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | args opt_block_arg
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                | assocs opt_block_arg
                    {
                      node_list *args = driver.alloc.node_list(driver.build.associate(self, nullptr, $1, nullptr));
                      args->concat($2);
                      $$ = args;
                    }
                | args tCOMMA assocs opt_block_arg
                    {
                      auto &args = $1;
                      args->emplace_back(driver.build.associate(self, nullptr, $3, nullptr));
                      args->concat($4);
                      $$ = args;
                    }
                | block_arg
                    {
                      $$ = driver.alloc.node_list($1);
                    }

    command_args:   {
                      ruby_parser::token_type last_token = driver.last_token->type();
                      bool lookahead = (last_token == ruby_parser::token_type::tLBRACK) || (last_token == ruby_parser::token_type::tLPAREN_ARG);

                      if (lookahead) {
                        auto top = driver.lex.cmdarg.pop();
                        driver.lex.cmdarg.push(true);
                        driver.lex.cmdarg.push(top);
                      } else {
                        driver.lex.cmdarg.push(true);
                      }
                    }
                  call_args
                    {
                      ruby_parser::token_type last_token = driver.last_token->type();
                      bool lookahead = (last_token == ruby_parser::token_type::tLBRACE_ARG);

                      if (lookahead) {
                        auto top = driver.lex.cmdarg.pop();
                        driver.lex.cmdarg.pop();
                        driver.lex.cmdarg.push(top);
                      } else {
                        driver.lex.cmdarg.pop();
                      }

                      $$ = $2;
                    }

       block_arg: tAMPER arg_value
                    {
                      $$ = driver.build.blockPass(self, $1, $2);
                    }

   opt_block_arg: tCOMMA block_arg
                    {
                      $$ = driver.alloc.node_list($2);
                    }
                | // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }

            args: arg_value
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | tSTAR arg_value
                    {
                      $$ = driver.alloc.node_list(driver.build.splat(self, $1, $2));
                    }
                | args tCOMMA arg_value
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }
                | args tCOMMA tSTAR arg_value
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.splat(self, $3, $4));
                      $$ = list;
                    }

        mrhs_arg: mrhs
                    {
                      $$ = driver.build.array(self, nullptr, $1, nullptr);
                    }
                | arg_value

            mrhs: args tCOMMA arg_value
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }
                | args tCOMMA tSTAR arg_value
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.splat(self, $3, $4));
                      $$ = list;
                    }
                | tSTAR arg_value
                    {
                      $$ = driver.alloc.node_list(driver.build.splat(self, $1, $2));
                    }

         primary: literal
                | strings
                | xstring
                | regexp
                | words
                | qwords
                | symbols
                | qsymbols
                | var_ref
                | backref
                | tFID
                    {
                      $$ = driver.build.call_method(self, nullptr, nullptr, $1, nullptr, nullptr, nullptr);
                    }
                | kBEGIN
                    {
                      $<stack>$ = driver.copy_stack();
                      driver.lex.cmdarg.clear();
                    }
                    bodystmt kEND
                    {
                      driver.replace_stack($<stack>2);
                      $$ = driver.build.beginKeyword(self, $1, $3, $4);
                    }
                | tLPAREN_ARG stmt
                    {
                      driver.lex.set_state_expr_endarg();
                    }
                    rparen
                    {
                      $$ = driver.build.begin(self, $1, $2, $4);
                    }
                | tLPAREN_ARG
                    {
                      driver.lex.set_state_expr_endarg();
                    }
                    opt_nl tRPAREN
                    {
                      $$ = driver.build.begin(self, $1, nullptr, $4);
                    }
                | tLPAREN compstmt tRPAREN
                    {
                      $$ = driver.build.begin(self, $1, $2, $3);
                    }
                | primary_value tCOLON2 tCONSTANT
                    {
                      $$ = driver.build.constFetch(self, $1, $2, $3);
                    }
                | tCOLON3 tCONSTANT
                    {
                      $$ = driver.build.constGlobal(self, $1, $2);
                    }
                | tLBRACK aref_args tRBRACK
                    {
                      $$ = driver.build.array(self, $1, $2, $3);
                    }
                | tLBRACE assoc_list tRCURLY
                    {
                      $$ = driver.build.associate(self, $1, $2, $3);
                    }
                | k_return
                    {
                      $$ = driver.build.keywordReturn(self, $1, nullptr, nullptr, nullptr);
                    }
                | kYIELD tLPAREN2 call_args rparen
                    {
                      $$ = driver.build.keywordYield(self, $1, $2, $3, $4);
                      DIAGCHECK();
                    }
                | kYIELD tLPAREN2 rparen
                    {
                      node_list tmp;
                      $$ = driver.build.keywordYield(self, $1, $2, &tmp, $3);
                      DIAGCHECK();
                    }
                | kYIELD
                    {
                      $$ = driver.build.keywordYield(self, $1, nullptr, nullptr, nullptr);
                      DIAGCHECK();
                    }
                | kDEFINED opt_nl tLPAREN2 expr rparen
                    {
                      $$ = driver.build.keywordDefined(self, $1, $4);
                    }
                | kNOT tLPAREN2 expr rparen
                    {
                      $$ = driver.build.not_op(self, $1, $2, $3, $4);
                    }
                | kNOT tLPAREN2 rparen
                    {
                      $$ = driver.build.not_op(self, $1, $2, nullptr, $3);
                    }
                | fcall brace_block
                    {
                      auto method_call = driver.build.call_method(self, nullptr, nullptr, $1, nullptr, nullptr, nullptr);
                      auto &delimited_block = $2;

                      $$ = driver.build.block(self, method_call,
                        delimited_block->begin,
                        delimited_block->args,
                        delimited_block->body,
                        delimited_block->end);
                      DIAGCHECK();
                    }
                | method_call
                | method_call brace_block
                    {
                      auto &delimited_block = $2;
                      $$ = driver.build.block(self, $1,
                        delimited_block->begin,
                        delimited_block->args,
                        delimited_block->body,
                        delimited_block->end);
                      DIAGCHECK();
                    }
                | tLAMBDA lambda
                    {
                      auto lambda_call = driver.build.callLambda(self, $1);
                      auto &lambda = $2;
                      $$ = driver.build.block(self, lambda_call,
                        lambda->begin,
                        lambda->args,
                        lambda->body,
                        lambda->end);
                      DIAGCHECK();
                    }
                | kIF expr_value then compstmt if_tail kEND
                    {
                      auto &else_ = $5;
                      $$ = driver.build.condition(self, $1, $2, $3, $4,
                        else_ ? else_->tok : nullptr,
                        else_ ? else_->nod : nullptr, $6);
                    }
                | kUNLESS expr_value then compstmt opt_else kEND
                    {
                      auto &else_ = $5;
                      $$ = driver.build.condition(self, $1, $2, $3,
                        else_ ? else_->nod : nullptr,
			                  else_ ? else_->tok : nullptr, $4, $6);
                    }
                | kWHILE expr_value_do compstmt kEND
                    {
                      $$ = driver.build.loop_while(self, $1, $2->nod, $2->tok, $3, $4);
                    }
                | kUNTIL expr_value_do compstmt kEND
                    {
                      $$ = driver.build.loopUntil(self, $1, $2->nod, $2->tok, $3, $4);
                    }
                | kCASE expr_value opt_terms case_body kEND
                    {
                      auto &case_body = $4;
                      auto &else_ = case_body->els;
                      $$ = driver.build.case_(self, $1, $2,
                        &case_body->whens,
                        else_ ? else_->tok : nullptr,
			                  else_ ? else_->nod : nullptr, $5);
                    }
                | kCASE            opt_terms case_body kEND
                    {
                      auto &case_body = $3;
                      auto &else_ = case_body->els;
                      $$ = driver.build.case_(self, $1, nullptr,
                        &case_body->whens,
                        else_ ? else_->tok : nullptr,
			                  else_ ? else_->nod : nullptr, $4);
                    }
                | kFOR for_var kIN expr_value_do compstmt kEND
                    {
                      $$ = driver.build.for_(self, $1, $2, $3, $4->nod, $4->tok, $5, $6);
                    }
                | kCLASS cpath superclass
                    {
                      driver.lex.extend_static();
                      driver.lex.cmdarg.push(false);
                      driver.lex.cond.push(false);
                      driver.lex.context.push(Context::State::CLASS);
                    }
                    bodystmt kEND
                    {
                      if (!driver.lex.context.classDefintinionAllowed()) {
                        driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ClassInDef, $1);
                        YYERROR;
                      }

                      auto class_tok = $1;
                      auto end_tok = $6;

                      auto &superclass_ = $3;
                      auto lt_t       = superclass_ ? superclass_->tok : nullptr;
                      auto superclass = superclass_ ? superclass_->nod : nullptr;

                      $$ = driver.build.def_class(self, class_tok, $2, lt_t, superclass, $5, end_tok);

                      driver.lex.cmdarg.pop();
                      driver.lex.cond.pop();
                      driver.lex.unextend();
                      driver.lex.context.pop();
                    }
                | kCLASS tLSHFT expr term
                    {
                      driver.lex.extend_static();
                      driver.lex.cmdarg.push(false);
                      driver.lex.cond.push(false);
                      driver.lex.context.push(Context::State::SCLASS);
                    }
                    bodystmt kEND
                    {
                      $$ = driver.build.def_sclass(self, $1, $2, $3, $6, $7);

                      driver.lex.cmdarg.pop();
                      driver.lex.cond.pop();
                      driver.lex.unextend();
                      driver.lex.context.pop();
                    }
                | kMODULE cpath
                    {
                      driver.lex.extend_static();
                      driver.lex.cmdarg.push(false);
                    }
                    bodystmt kEND
                    {
                      if (!driver.lex.context.moduleDefintinionAllowed()) {
                        driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ModuleInDef, $1);
                        YYERROR;
                      }

                      auto module_tok = $1;
                      auto end_tok = $5;

                      $$ = driver.build.defModule(self, module_tok, $2, $4, end_tok);

                      driver.lex.cmdarg.pop();
                      driver.lex.unextend();
                    }
                | kDEF fname
                    {
                      driver.lex.extend_static();
                      driver.lex.cmdarg.push(false);
                      driver.lex.cond.push(false);
                      driver.lex.context.push(Context::State::DEF);
                    }
                    f_arglist bodystmt kEND
                    {
                      $$ = driver.build.defMethod(self, $1, $2, $4, $5, $6);

                      driver.lex.cmdarg.pop();
                      driver.lex.cond.pop();
                      driver.lex.unextend();
                      driver.lex.context.pop();
                    }
                | kDEF singleton dot_or_colon
                    {
                      driver.lex.set_state_expr_fname();
                    }
                    fname
                    {
                      driver.lex.extend_static();
                      driver.lex.cmdarg.push(false);
                      driver.lex.cond.push(false);
                      driver.lex.context.push(Context::State::DEFS);
                    }
                    f_arglist bodystmt kEND
                    {
                      $$ = driver.build.defSingleton(self, $1, $2, $3, $5, $7, $8, $9);
                      DIAGCHECK();

                      driver.lex.cmdarg.pop();
                      driver.lex.cond.pop();
                      driver.lex.unextend();
                      driver.lex.context.pop();
                    }
                | kBREAK
                    {
                      $$ = driver.build.keywordBreak(self, $1, nullptr, nullptr, nullptr);
                    }
                | kNEXT
                    {
                      $$ = driver.build.keywordNext(self, $1, nullptr, nullptr, nullptr);
                    }
                | kREDO
                    {
                      $$ = driver.build.keywordRedo(self, $1);
                    }
                | kRETRY
                    {
                      $$ = driver.build.keywordRetry(self, $1);
                    }

   primary_value: primary

        k_return: kRETURN
                    {
                      if (driver.lex.context.inClass()) {
                        driver.diagnostics.emplace_back(dlevel::ERROR, dclass::InvalidReturn, $1);
                        YYERROR;
                      }
                    }

            then: term
                | kTHEN
                | term kTHEN
                    {
                      $$ = $2;
                    }

              do: term
                | kDO_COND

         if_tail: opt_else
                | kELSIF expr_value then compstmt if_tail
                    {
                      auto elsif_t = $1;
                      auto &else_ = $5;
                      $$ = driver.alloc.node_with_token(elsif_t,
                        driver.build.condition(self,
                          elsif_t, $2, $3, $4,
                          else_ ? else_->tok : nullptr,
                          else_ ? else_->nod : nullptr, nullptr)
                      );
                    }

        opt_else: none
                    {
                      $$ = nullptr;
                    }
                | kELSE compstmt
                    {
                      $$ = driver.alloc.node_with_token($1, $2);
                    }

         for_var: lhs
                | mlhs

          f_marg: f_norm_arg
                    {
                      $$ = driver.build.arg(self, $1);
                    }
                | tLPAREN f_margs rparen
                    {
                      $$ = driver.build.multi_lhs(self, $1, $2, $3);
                    }

     f_marg_list: f_marg
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | f_marg_list tCOMMA f_marg
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

         f_margs: f_marg_list
                | f_marg_list tCOMMA tSTAR f_norm_arg
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.restarg(self, $3, $4));
                      $$ = list;
                    }
                | f_marg_list tCOMMA tSTAR f_norm_arg tCOMMA f_marg_list
                    {
                      auto &args = $1;
                      args->emplace_back(driver.build.restarg(self, $3, $4));
                      args->concat($6);
                      $$ = args;
                    }
                | f_marg_list tCOMMA tSTAR
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.restarg(self, $3, nullptr));
                      $$ = list;
                    }
                | f_marg_list tCOMMA tSTAR            tCOMMA f_marg_list
                    {
                      auto &args = $1;
                      args->emplace_back(driver.build.restarg(self, $3, nullptr));
                      args->concat($5);
                      $$ = args;
                    }
                |                    tSTAR f_norm_arg
                    {
                      $$ = driver.alloc.node_list(driver.build.restarg(self, $1, $2));
                    }
                |                    tSTAR f_norm_arg tCOMMA f_marg_list
                    {
                      auto &args = $4;
                      args->push_front(driver.build.restarg(self, $1, $2));
                      $$ = args;
                    }
                |                    tSTAR
                    {
                      $$ = driver.alloc.node_list(driver.build.restarg(self, $1, nullptr));
                    }
                |                    tSTAR tCOMMA f_marg_list
                    {
                      auto &args = $3;
                      args->push_front(driver.build.restarg(self, $1, nullptr));
                      $$ = args;
                    }

 block_args_tail: f_block_kwarg tCOMMA f_kwrest opt_f_block_arg
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                | f_block_kwarg opt_f_block_arg
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                | f_kwrest opt_f_block_arg
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                | f_block_arg
                    {
                      $$ = $1;
                    }

opt_block_args_tail:
                  tCOMMA block_args_tail
                    {
                      $$ = $2;
                    }
                | // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }

     block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg              opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($7);
                      args->concat($8);
                      $$ = args;
                    }
                | f_arg tCOMMA f_block_optarg                                opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                | f_arg tCOMMA f_block_optarg tCOMMA                   f_arg opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                | f_arg tCOMMA                       f_rest_arg              opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                | f_arg tCOMMA
                | f_arg tCOMMA                       f_rest_arg tCOMMA f_arg opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                | f_arg                                                      opt_block_args_tail
                    {
                      auto &args = $1;
                      auto &block_args_tail = $2;

                      if (block_args_tail->size() == 0 && args->size() == 1) {
                        $$ = driver.alloc.node_list(driver.build.procarg0(self, args->at(0)));
                      } else {
                        args->concat(block_args_tail);
                        $$ = args;
                      }
                    }
                | f_block_optarg tCOMMA              f_rest_arg              opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                | f_block_optarg tCOMMA              f_rest_arg tCOMMA f_arg opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                | f_block_optarg                                             opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                | f_block_optarg tCOMMA                                f_arg opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                |                                    f_rest_arg              opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                |                                    f_rest_arg tCOMMA f_arg opt_block_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                |                                                                block_args_tail

 opt_block_param: // nothing
                    {
                      $$ = driver.build.args(self, nullptr, nullptr, nullptr, true);
                      DIAGCHECK();
                    }
                | block_param_def
                    {
                      driver.lex.set_state_expr_value();
                    }

 block_param_def: tPIPE opt_bv_decl tPIPE
                    {
                      $$ = driver.build.args(self, $1, $2, $3, true);
                      DIAGCHECK();
                    }
                | tOROP
                    {
                      $$ = driver.build.args(self, $1, nullptr, $1, true);
                      DIAGCHECK();
                    }
                | tPIPE block_param opt_bv_decl tPIPE
                    {
                      auto &params = $2;
                      params->concat($3);
                      $$ = driver.build.args(self, $1, params, $4, true);
                      DIAGCHECK();
                    }

     opt_bv_decl: opt_nl
                    {
                      $$ = driver.alloc.node_list();
                    }
                | opt_nl tSEMI bv_decls opt_nl
                    {
                      $$ = $3;
                    }

        bv_decls: bvar
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | bv_decls tCOMMA bvar
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

            bvar: tIDENTIFIER
                    {
                      auto ident = $1;
                      driver.lex.declare(ident->string());
                      $$ = driver.build.shadowarg(self, ident);
                    }
                | f_bad_arg
                    {
                      $$ = nullptr;
                    }

          lambda:   {
                      driver.lex.extend_dynamic();
                    }
                  f_larglist
                    {
                      driver.lex.cmdarg.push(false);
                    }
                  lambda_body
                    {
                      driver.lex.cmdarg.pop();

                      auto &delimited_block = $4;
                      delimited_block->args = $2;
                      $$ = delimited_block;

                      driver.lex.unextend();
                    }

     f_larglist: tLPAREN2 f_args opt_bv_decl tRPAREN
                    {
                      auto &args = $2;
                      args->concat($3);
                      $$ = driver.build.args(self, $1, args, $4, true);
                      DIAGCHECK();
                    }
                | f_args
                    {
                      $$ = driver.build.args(self, nullptr, $1, nullptr, true);
                      DIAGCHECK();
                    }

     lambda_body: tLAMBEG
                    {
                      driver.lex.context.push(Context::State::LAMBDA);
                    }
                  compstmt tRCURLY
                    {
                      $$ = driver.alloc.delimited_block($1, nullptr, $3, $4);
                      driver.lex.context.pop();
                    }
                | kDO_LAMBDA
                    {
                      driver.lex.context.push(Context::State::LAMBDA);
                    }
                  bodystmt kEND
                    {
                      $$ = driver.alloc.delimited_block($1, nullptr, $3, $4);
                      driver.lex.context.pop();
                    }

        do_block: kDO_BLOCK
                    {
                      driver.lex.context.push(Context::State::BLOCK);
                    }
                  do_body kEND
                    {
                      auto &delimited_block = $3;
                      delimited_block->begin = $1;
                      delimited_block->end = $4;
                      $$ = delimited_block;
                      driver.lex.context.pop();
                    }

      block_call: command do_block
                    {
                      auto &delimited_block = $2;
                      $$ = driver.build.block(self, $1,
                          delimited_block->begin,
                          delimited_block->args,
                          delimited_block->body,
                          delimited_block->end
                        );
                      DIAGCHECK();
                    }
                | block_call dot_or_colon operation2 opt_paren_args
                    {
                      auto &delimited = $4;
                      $$ = driver.build.call_method(self, $1, $2, $3,
                                  delimited->begin,
                                  delimited->inner,
                                  delimited->end);
                    }
                | block_call dot_or_colon operation2 opt_paren_args brace_block
                    {
                      auto &delimited = $4;
                      auto method_call = driver.build.call_method(self, $1, $2, $3,
                          delimited->begin,
                          delimited->inner,
                          delimited->end);
                      auto &block = $5;
                      $$ = driver.build.block(self, method_call,
                          block->begin,
                          block->args,
                          block->body,
                          block->end);
                      DIAGCHECK();
                    }
                | block_call dot_or_colon operation2 command_args do_block
                    {
                      auto method_call = driver.build.call_method(self, $1, $2, $3, nullptr, $4, nullptr);
                      auto &block = $5;
                      $$ = driver.build.block(self, method_call, block->begin, block->args, block->body, block->end);
                      DIAGCHECK();
                    }

     method_call: fcall paren_args
                    {
                      auto &delimited = $2;
                      $$ = driver.build.call_method(self, nullptr, nullptr, $1,
                        delimited->begin,
                        delimited->inner,
                        delimited->end);
                    }
                | primary_value call_op operation2 opt_paren_args
                    {
                      auto &delimited = $4;
                      $$ = driver.build.call_method(self, $1, $2, $3,
                          delimited->begin,
                          delimited->inner,
                          delimited->end);
                    }
                | primary_value tCOLON2 operation2 paren_args
                    {
                      auto &delimited = $4;
                      $$ = driver.build.call_method(self, $1, $2, $3,
                          delimited->begin,
                          delimited->inner,
                          delimited->end);
                    }
                | primary_value tCOLON2 operation3
                    {
                      $$ = driver.build.call_method(self, $1, $2, $3, nullptr, nullptr, nullptr);
                    }
                | primary_value call_op paren_args
                    {
                      auto &delimited = $3;
                      $$ = driver.build.call_method(self, $1, $2, nullptr,
                          delimited->begin,
                          delimited->inner,
                          delimited->end);
                    }
                | primary_value tCOLON2 paren_args
                    {
                      auto &delimited = $3;
                      $$ = driver.build.call_method(self, $1, $2, nullptr,
                          delimited->begin,
                          delimited->inner,
                          delimited->end);
                    }
                | kSUPER paren_args
                    {
                      auto &delimited = $2;
                      $$ = driver.build.keywordSuper(self, $1,
                          delimited->begin,
                          delimited->inner,
                          delimited->end);
                    }
                | kSUPER
                    {
                      $$ = driver.build.keywordZsuper(self, $1);
                    }
                | primary_value tLBRACK2 opt_call_args rbracket
                    {
                      $$ = driver.build.index(self, $1, $2, $3, $4);
                    }

     brace_block: tLCURLY
                    {
                      driver.lex.context.push(Context::State::BLOCK);
                    }
                  brace_body tRCURLY
                    {
                      auto &block = $3;
                      block->begin = $1;
                      block->end = $4;
                      $$ = block;
                      driver.lex.context.pop();
                    }
                | kDO
                    {
                      driver.lex.context.push(Context::State::BLOCK);
                    }
                  do_body kEND
                    {
                      auto &block = $3;
                      block->begin = $1;
                      block->end = $4;
                      $$ = block;
                      driver.lex.context.pop();
                    }

      brace_body:   {
                      driver.lex.extend_dynamic();
                    }
                    opt_block_param bodystmt
                    {
                      $$ = driver.alloc.delimited_block(nullptr, $2, $3, nullptr);

                      driver.lex.unextend();
                    }

         do_body:   {
                      driver.lex.extend_dynamic();
                    }
                    {
                      driver.lex.cmdarg.push(false);
                    }
                    opt_block_param bodystmt
                    {
                      $$ = driver.alloc.delimited_block(nullptr, $3, $4, nullptr);
                      driver.lex.unextend();

                      driver.lex.cmdarg.pop();
                    }

       case_body: kWHEN args then compstmt cases
                    {
                      auto &cases = $5;
                      cases->whens.push_front(driver.build.when(self, $1, $2, $3, $4));
                      $$ = cases;
                    }

           cases: opt_else
                    {
                      $$ = driver.alloc.case_body($1);
                    }
                | case_body

      opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
                    {
                      auto &exc_var = $3;
                      auto &exc_list_ = $2;
                      auto exc_list = exc_list_
                        ? driver.build.array(self, nullptr, exc_list_, nullptr)
                        : nullptr;
                      auto &rescues = $6;

                      rescues->push_front(driver.build.rescue_body(self, $1,
                          exc_list,
                          exc_var ? exc_var->tok : nullptr,
                          exc_var ? exc_var->nod : nullptr,
                          $4, $5));

                      $$ = rescues;
                    }
                |
                    {
                      $$ = driver.alloc.node_list();
                    }

        exc_list: arg_value
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | mrhs
                | list_none

         exc_var: tASSOC lhs
                    {
                      $$ = driver.alloc.node_with_token($1, $2);
                    }
                | // nothing
                    {
                      $$ = nullptr;
                    }

      opt_ensure: kENSURE compstmt
                    {
                      $$ = driver.alloc.node_with_token($1, $2);
                    }
                | // nothing
                    {
                      $$ = nullptr;
                    }

         literal: numeric
                | symbol
                | dsym

         strings: string
                    {
                      $$ = driver.build.string_compose(self, nullptr, $1, nullptr);
                    }

          string: string1
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | string string1
                    {
                      auto &list = $1;
                      list->emplace_back($2);
                      $$ = list;
                    }

         string1: tSTRING_BEG string_contents tSTRING_END
                    {
                      auto str = driver.build.string_compose(self, $1, $2, $3);
                      $$ = driver.build.dedentString(self, str, driver.lex.dedentLevel().value_or(0));
                    }
                | tSTRING
                    {
                      auto str = driver.build.string(self, $1);
                      $$ = driver.build.dedentString(self, str, driver.lex.dedentLevel().value_or(0));
                    }
                | tCHARACTER
                    {
                      $$ = driver.build.character(self, $1);
                    }

         xstring: tXSTRING_BEG xstring_contents tSTRING_END
                    {
                      auto xstr = driver.build.xstring_compose(self, $1, $2, $3);
                      $$ = driver.build.dedentString(self, xstr, driver.lex.dedentLevel().value_or(0));
                    }

          regexp: tREGEXP_BEG regexp_contents tSTRING_END tREGEXP_OPT
                    {
                      auto opts = driver.build.regexp_options(self, $4);
                      $$ = driver.build.regexp_compose(self, $1, $2, $3, opts);
                      DIAGCHECK();
                    }

           words: tWORDS_BEG word_list tSTRING_END
                    {
                      $$ = driver.build.words_compose(self, $1, $2, $3);
                    }

       word_list: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | word_list word tSPACE
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.word(self, $2));
                      $$ = list;
                    }

            word: string_content
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | word string_content
                    {
                      auto &list = $1;
                      list->emplace_back($2);
                      $$ = list;
                    }

         symbols: tSYMBOLS_BEG symbol_list tSTRING_END
                    {
                      $$ = driver.build.symbols_compose(self, $1, $2, $3);
                    }

     symbol_list: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | symbol_list word tSPACE
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.word(self, $2));
                      $$ = list;
                    }

          qwords: tQWORDS_BEG qword_list tSTRING_END
                    {
                      $$ = driver.build.words_compose(self, $1, $2, $3);
                    }

        qsymbols: tQSYMBOLS_BEG qsym_list tSTRING_END
                    {
                      $$ = driver.build.symbols_compose(self, $1, $2, $3);
                    }

      qword_list: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | qword_list tSTRING_CONTENT tSPACE
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.string_internal(self, $2));
                      $$ = list;
                    }

       qsym_list: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | qsym_list tSTRING_CONTENT tSPACE
                    {
                      auto &list = $1;
                      list->emplace_back(driver.build.symbol_internal(self, $2));
                      $$ = list;
                    }

 string_contents: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | string_contents string_content
                    {
                      auto &list = $1;
                      list->emplace_back($2);
                      $$ = list;
                    }

xstring_contents: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | xstring_contents string_content
                    {
                      auto &list = $1;
                      list->emplace_back($2);
                      $$ = list;
                    }

regexp_contents: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | regexp_contents string_content
                    {
                      auto &list = $1;
                      list->emplace_back($2);
                      $$ = list;
                    }

  string_content: tSTRING_CONTENT
                    {
                      $$ = driver.build.string_internal(self, $1);
                    }
                | tSTRING_DVAR string_dvar
                    {
                      $$ = $2;
                    }
                | tSTRING_DBEG
                    {
                      driver.lex.cond.push(false);
                      driver.lex.cmdarg.push(false);
                    }
                    compstmt tSTRING_DEND
                    {
                      driver.lex.cond.pop();
                      driver.lex.cmdarg.pop();
                      $$ = driver.build.begin(self, $1, $3, $4);
                    }

     string_dvar: tGVAR
                    {
                      $$ = driver.build.gvar(self, $1);
                    }
                | tIVAR
                    {
                      $$ = driver.build.ivar(self, $1);
                    }
                | tCVAR
                    {
                      $$ = driver.build.cvar(self, $1);
                    }
                | backref


          symbol: tSYMBOL
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.symbol(self, $1);
                    }

            dsym: tSYMBEG xstring_contents tSTRING_END
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.symbol_compose(self, $1, $2, $3);
                    }

         numeric: simple_numeric
                    {
                      $$ = $1;
                    }
                | tUNARY_NUM simple_numeric %prec tLOWEST
                    {
                      $$ = driver.build.unary_op(self, $1, $2);
                    }

  simple_numeric: tINTEGER
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.integer(self, $1);
                    }
                | tFLOAT
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.float_(self, $1);
                    }
                | tRATIONAL
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.rational(self, $1);
                    }
                | tIMAGINARY
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.complex(self, $1);
                    }
                | tRATIONAL_IMAGINARY
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.rational_complex(self, $1);
                    }
                | tFLOAT_IMAGINARY
                    {
                      driver.lex.set_state_expr_end();
                      $$ = driver.build.floatComplex(self, $1);
                    }

   user_variable: tIDENTIFIER
                    {
                      $$ = driver.build.ident(self, $1);
                    }
                | tIVAR
                    {
                      $$ = driver.build.ivar(self, $1);
                    }
                | tGVAR
                    {
                      $$ = driver.build.gvar(self, $1);
                    }
                | tCONSTANT
                    {
                      $$ = driver.build.const_(self, $1);
                    }
                | tCVAR
                    {
                      $$ = driver.build.cvar(self, $1);
                    }

keyword_variable: kNIL
                    {
                      $$ = driver.build.nil(self, $1);
                    }
                | kSELF
                    {
                      $$ = driver.build.self_(self, $1);
                    }
                | kTRUE
                    {
                      $$ = driver.build.true_(self, $1);
                    }
                | kFALSE
                    {
                      $$ = driver.build.false_(self, $1);
                    }
                | k__FILE__
                    {
                      $$ = driver.build.fileLiteral(self, $1);
                    }
                | k__LINE__
                    {
                      $$ = driver.build.line_literal(self, $1);
                    }
                | k__ENCODING__
                    {
                      $$ = driver.build.encodingLiteral(self, $1);
                    }

         var_ref: user_variable
                    {
                      $$ = driver.build.accessible(self, $1);
                    }
                | keyword_variable
                    {
                      $$ = driver.build.accessible(self, $1);
                    }

         var_lhs: user_variable
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }
                | keyword_variable
                    {
                      $$ = driver.build.assignable(self, $1);
                      DIAGCHECK();
                    }

         backref: tNTH_REF
                    {
                      $$ = driver.build.nth_ref(self, $1);
                    }
                | tBACK_REF
                    {
                      $$ = driver.build.backRef(self, $1);
                    }

      superclass: tLT
                    {
                      driver.lex.set_state_expr_value();
                    }
                    expr_value term
                    {
                      $$ = driver.alloc.node_with_token($1, $3);
                    }
                | // nothing
                    {
                      $$ = nullptr;
                    }

       f_arglist: tLPAREN2 f_args rparen
                    {
                      driver.lex.set_state_expr_value();
                      $$ = driver.build.args(self, $1, $2, $3, true);
                    }
                |   {
                      $<boolean>$ = driver.lex.in_kwarg;
                      driver.lex.in_kwarg = true;
                    }
                  f_args term
                    {
                      driver.lex.in_kwarg = $<boolean>1;
                      $$ = driver.build.args(self, nullptr, $2, nullptr, true);
                      DIAGCHECK();
                    }

       args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                | f_kwarg opt_f_block_arg
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                | f_kwrest opt_f_block_arg
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                | f_block_arg
                    {
                      $$ = $1;
                    }

   opt_args_tail: tCOMMA args_tail
                    {
                      $$ = $2;
                    }
                | // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }

          f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg              opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                | f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($7);
                      args->concat($8);
                      $$ = args;
                    }
                | f_arg tCOMMA f_optarg                                opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                | f_arg tCOMMA f_optarg tCOMMA                   f_arg opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                | f_arg tCOMMA                 f_rest_arg              opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                | f_arg tCOMMA                 f_rest_arg tCOMMA f_arg opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                | f_arg                                                opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                |              f_optarg tCOMMA f_rest_arg              opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                |              f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($5);
                      args->concat($6);
                      $$ = args;
                    }
                |              f_optarg                                opt_args_tail
                    {

                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                |              f_optarg tCOMMA                   f_arg opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                |                              f_rest_arg              opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($2);
                      $$ = args;
                    }
                |                              f_rest_arg tCOMMA f_arg opt_args_tail
                    {
                      auto &args = $1;
                      args->concat($3);
                      args->concat($4);
                      $$ = args;
                    }
                |                                                          args_tail
                    {
                      $$ = $1;
                    }
                | // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }

       f_bad_arg: tCONSTANT
                    {
                      driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ArgumentConst, $1);
                      YYERROR;
                    }
                | tIVAR
                    {
                      driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ArgumentIvar, $1);
                      YYERROR;
                    }
                | tGVAR
                    {
                      driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ArgumentGvar, $1);
                      YYERROR;
                    }
                | tCVAR
                    {
                      driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ArgumentCvar, $1);
                      YYERROR;
                    }

      f_norm_arg: f_bad_arg
                | tIDENTIFIER
                    {
                      auto ident = $1;
                      driver.lex.declare(ident->string());
                      $$ = ident;
                    }

      f_arg_asgn: f_norm_arg
                    {
                      $$ = $1;
                    }

      f_arg_item: f_arg_asgn
                    {
                      $$ = driver.build.arg(self, $1);
                    }
                | tLPAREN f_margs rparen
                    {
                      $$ = driver.build.multi_lhs(self, $1, $2, $3);
                    }

           f_arg: f_arg_item
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | f_arg tCOMMA f_arg_item
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

         f_label: tLABEL
                    {
                      auto label = $1;
                      if (!driver.valid_kwarg_name(label)) {
                        driver.diagnostics.emplace_back(dlevel::ERROR, dclass::ArgumentConst, label);
                        YYERROR;
                      }
                      driver.lex.declare(label->string());
                      $$ = label;
                    }

            f_kw: f_label arg_value
                    {
                      $$ = driver.build.kwoptarg(self, $1, $2);
                    }
                | f_label
                    {
                      $$ = driver.build.kwarg(self, $1);
                    }

      f_block_kw: f_label primary_value
                    {
                      $$ = driver.build.kwoptarg(self, $1, $2);
                    }
                | f_label
                    {
                      $$ = driver.build.kwarg(self, $1);
                    }

   f_block_kwarg: f_block_kw
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | f_block_kwarg tCOMMA f_block_kw
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

         f_kwarg: f_kw
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | f_kwarg tCOMMA f_kw
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

     kwrest_mark: tPOW | tDSTAR

        f_kwrest: kwrest_mark tIDENTIFIER
                    {
                      auto ident = $2;

                      driver.lex.declare(ident->string());

                      auto kwrestarg = driver.build.kwrestarg(self, $1, ident);

                      $$ = driver.alloc.node_list(kwrestarg);
                    }
                | kwrest_mark
                    {
                      auto kwrestarg = driver.build.kwrestarg(self, $1, nullptr);

                      $$ = driver.alloc.node_list(kwrestarg);
                    }

           f_opt: f_arg_asgn tEQL arg_value
                    {
                      $$ = driver.build.optarg(self, $1, $2, $3);
                    }

     f_block_opt: f_arg_asgn tEQL primary_value
                    {
                      $$ = driver.build.optarg(self, $1, $2, $3);
                    }

  f_block_optarg: f_block_opt
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | f_block_optarg tCOMMA f_block_opt
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

        f_optarg: f_opt
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | f_optarg tCOMMA f_opt
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

    restarg_mark: tSTAR2 | tSTAR

      f_rest_arg: restarg_mark tIDENTIFIER
                    {
                      auto ident = $2;

                      driver.lex.declare(ident->string());

                      auto restarg = driver.build.restarg(self, $1, ident);

                      $$ = driver.alloc.node_list(restarg);
                    }
                | restarg_mark
                    {
                      auto restarg = driver.build.restarg(self, $1, nullptr);

                      $$ = driver.alloc.node_list(restarg);
                    }

     blkarg_mark: tAMPER2 | tAMPER

     f_block_arg: blkarg_mark tIDENTIFIER
                    {
                      auto ident = $2;

                      driver.lex.declare(ident->string());

                      auto blockarg = driver.build.blockarg(self, $1, ident);

                      $$ = driver.alloc.node_list(blockarg);
                    }

 opt_f_block_arg: tCOMMA f_block_arg
                    {
                      $$ = $2;
                    }
                |
                    {
                      $$ = driver.alloc.node_list();
                    }

       singleton: var_ref
                | tLPAREN2 expr rparen
                    {
                      $$ = $2;
                    }

      assoc_list: // nothing
                    {
                      $$ = driver.alloc.node_list();
                    }
                | assocs trailer

          assocs: assoc
                    {
                      $$ = driver.alloc.node_list($1);
                    }
                | assocs tCOMMA assoc
                    {
                      auto &list = $1;
                      list->emplace_back($3);
                      $$ = list;
                    }

           assoc: arg_value tASSOC arg_value
                    {
                      $$ = driver.build.pair(self, $1, $2, $3);
                    }
                | tLABEL arg_value
                    {
                      $$ = driver.build.pair_keyword(self, $1, $2);
                    }
                | tSTRING_BEG string_contents tLABEL_END arg_value
                    {
                      $$ = driver.build.pair_quoted(self, $1, $2, $3, $4);
                    }
                | tDSTAR arg_value
                    {
                      $$ = driver.build.kwsplat(self, $1, $2);
                    }

       operation: tIDENTIFIER | tCONSTANT | tFID
      operation2: tIDENTIFIER | tCONSTANT | tFID | op
      operation3: tIDENTIFIER | tFID | op
    dot_or_colon: call_op | tCOLON2
         call_op: tDOT
                    {
                      // XXX what is this???
                      // $$ = put(p, [:dot, $1[1]]
                      // whitequark/parser doesn't check
                      // raw source of the token,
                      // so :dot/:anddot works as a flag.
                      $$ = $1;
                    }
                | tANDDOT
                    {
                      // XXX what is this???
                      // $$ = [:anddot, $1[1]]
                      $$ = $1;
                    }
       opt_terms:  | terms
          opt_nl:  | tNL
          rparen: opt_nl tRPAREN
                    {
                      $$ = $2;
                    }
        rbracket: opt_nl tRBRACK
                    {
                      $$ = $2;
                    }
         trailer:  | tNL | tCOMMA

            term: tSEMI
                  {
                    yyerrok;
                  }
                | tNL

           terms: term
                | terms tSEMI

            none: // nothing
                  {
                    $$ = nullptr;
                  }

       list_none: // nothing
                  {
                    $$ = nullptr;
                  }

%%