Class: Parser::Ruby33

Inherits:
Base
  • Object
show all
Defined in:
lib/parser/ruby33.rb

Constant Summary collapse

Racc_arg =
[
racc_action_table,
racc_action_check,
racc_action_default,
racc_action_pointer,
racc_goto_table,
racc_goto_check,
racc_goto_default,
racc_goto_pointer,
racc_nt_base,
racc_reduce_table,
racc_token_table,
racc_shift_n,
racc_reduce_n,
racc_use_result_var ]
Racc_token_to_s_table =
[
"$end",
"error",
"kCLASS",
"kMODULE",
"kDEF",
"kUNDEF",
"kBEGIN",
"kRESCUE",
"kENSURE",
"kEND",
"kIF",
"kUNLESS",
"kTHEN",
"kELSIF",
"kELSE",
"kCASE",
"kWHEN",
"kWHILE",
"kUNTIL",
"kFOR",
"kBREAK",
"kNEXT",
"kREDO",
"kRETRY",
"kIN",
"kDO",
"kDO_COND",
"kDO_BLOCK",
"kDO_LAMBDA",
"kRETURN",
"kYIELD",
"kSUPER",
"kSELF",
"kNIL",
"kTRUE",
"kFALSE",
"kAND",
"kOR",
"kNOT",
"kIF_MOD",
"kUNLESS_MOD",
"kWHILE_MOD",
"kUNTIL_MOD",
"kRESCUE_MOD",
"kALIAS",
"kDEFINED",
"klBEGIN",
"klEND",
"k__LINE__",
"k__FILE__",
"k__ENCODING__",
"tIDENTIFIER",
"tFID",
"tGVAR",
"tIVAR",
"tCONSTANT",
"tLABEL",
"tCVAR",
"tNTH_REF",
"tBACK_REF",
"tSTRING_CONTENT",
"tINTEGER",
"tFLOAT",
"tUPLUS",
"tUMINUS",
"tUNARY_NUM",
"tPOW",
"tCMP",
"tEQ",
"tEQQ",
"tNEQ",
"tGEQ",
"tLEQ",
"tANDOP",
"tOROP",
"tMATCH",
"tNMATCH",
"tDOT",
"tDOT2",
"tDOT3",
"tAREF",
"tASET",
"tLSHFT",
"tRSHFT",
"tCOLON2",
"tCOLON3",
"tOP_ASGN",
"tASSOC",
"tLPAREN",
"tLPAREN2",
"tRPAREN",
"tLPAREN_ARG",
"tLBRACK",
"tLBRACK2",
"tRBRACK",
"tLBRACE",
"tLBRACE_ARG",
"tSTAR",
"tSTAR2",
"tAMPER",
"tAMPER2",
"tTILDE",
"tPERCENT",
"tDIVIDE",
"tDSTAR",
"tPLUS",
"tMINUS",
"tLT",
"tGT",
"tPIPE",
"tBANG",
"tCARET",
"tLCURLY",
"tRCURLY",
"tBACK_REF2",
"tSYMBEG",
"tSTRING_BEG",
"tXSTRING_BEG",
"tREGEXP_BEG",
"tREGEXP_OPT",
"tWORDS_BEG",
"tQWORDS_BEG",
"tSYMBOLS_BEG",
"tQSYMBOLS_BEG",
"tSTRING_DBEG",
"tSTRING_DVAR",
"tSTRING_END",
"tSTRING_DEND",
"tSTRING",
"tSYMBOL",
"tNL",
"tEH",
"tCOLON",
"tCOMMA",
"tSPACE",
"tSEMI",
"tLAMBDA",
"tLAMBEG",
"tCHARACTER",
"tRATIONAL",
"tIMAGINARY",
"tLABEL_END",
"tANDDOT",
"tBDOT2",
"tBDOT3",
"tEQL",
"tLOWEST",
"$start",
"program",
"top_compstmt",
"@1",
"top_stmts",
"opt_terms",
"top_stmt",
"terms",
"stmt",
"begin_block",
"bodystmt",
"compstmt",
"opt_rescue",
"opt_else",
"opt_ensure",
"stmts",
"stmt_or_begin",
"fitem",
"undef_list",
"expr_value",
"command_asgn",
"mlhs",
"command_call",
"lhs",
"mrhs",
"mrhs_arg",
"expr",
"@2",
"command_rhs",
"var_lhs",
"primary_value",
"opt_call_args",
"rbracket",
"call_op",
"defn_head",
"f_opt_paren_args",
"endless_command",
"defs_head",
"backref",
"command",
"arg",
"opt_nl",
"p_in_kwarg",
"p_pvtbl",
"p_pktbl",
"p_top_expr_body",
"expr_value_do",
"do",
"def_name",
"@3",
"fname",
"k_def",
"singleton",
"dot_or_colon",
"@4",
"block_command",
"block_call",
"operation2",
"command_args",
"cmd_brace_block",
"brace_body",
"fcall",
"@5",
"operation",
"k_return",
"call_args",
"mlhs_basic",
"mlhs_inner",
"rparen",
"mlhs_head",
"mlhs_item",
"mlhs_node",
"mlhs_post",
"user_variable",
"keyword_variable",
"cname",
"cpath",
"op",
"reswords",
"symbol",
"@6",
"arg_rhs",
"simple_numeric",
"rel_expr",
"begin_defined",
"endless_arg",
"primary",
"relop",
"none",
"arg_value",
"aref_args",
"args",
"trailer",
"assocs",
"paren_args",
"args_forward",
"opt_paren_args",
"opt_block_arg",
"block_arg",
"@7",
"arg_splat",
"literal",
"strings",
"xstring",
"regexp",
"words",
"qwords",
"symbols",
"qsymbols",
"var_ref",
"assoc_list",
"brace_block",
"method_call",
"lambda",
"then",
"if_tail",
"case_body",
"p_case_body",
"for_var",
"k_class",
"superclass",
"term",
"k_module",
"f_arglist",
"@8",
"@9",
"@10",
"@11",
"@12",
"f_marg",
"f_norm_arg",
"f_margs",
"f_marg_list",
"f_rest_marg",
"f_any_kwrest",
"f_kwrest",
"f_no_kwarg",
"f_eq",
"block_args_tail",
"@13",
"f_block_kwarg",
"opt_f_block_arg",
"f_block_arg",
"opt_block_args_tail",
"excessed_comma",
"block_param",
"f_arg",
"f_block_optarg",
"f_rest_arg",
"opt_block_param",
"block_param_def",
"opt_bv_decl",
"bv_decls",
"bvar",
"f_bad_arg",
"f_larglist",
"lambda_body",
"@14",
"@15",
"f_args",
"do_block",
"@16",
"@17",
"do_body",
"@18",
"operation3",
"@19",
"@20",
"@21",
"@22",
"@23",
"cases",
"p_top_expr",
"p_cases",
"@24",
"p_expr",
"p_args",
"p_find",
"p_args_tail",
"p_kwargs",
"p_as",
"p_variable",
"p_alt",
"p_expr_basic",
"p_lparen",
"p_lbracket",
"p_value",
"p_const",
"rbrace",
"@25",
"@26",
"p_args_head",
"p_arg",
"p_rest",
"p_args_post",
"p_kwarg",
"p_any_kwrest",
"p_kw",
"p_kw_label",
"string_contents",
"p_kwrest",
"kwrest_mark",
"p_kwnorest",
"p_primitive",
"p_var_ref",
"p_expr_ref",
"nonlocal_var",
"exc_list",
"exc_var",
"numeric",
"string",
"string1",
"xstring_contents",
"regexp_contents",
"words_sep",
"word_list",
"word",
"string_content",
"symbol_list",
"qword_list",
"qsym_list",
"string_dvar",
"string_dend",
"@27",
"ssym",
"dsym",
"@28",
"f_paren_args",
"args_tail",
"@29",
"f_kwarg",
"opt_args_tail",
"f_optarg",
"f_arg_asgn",
"f_arg_item",
"f_label",
"f_kw",
"f_block_kw",
"f_opt",
"f_block_opt",
"restarg_mark",
"blkarg_mark",
"assoc" ]
Racc_debug_parser =
false

Instance Attribute Summary

Attributes inherited from Base

#builder, #context, #current_arg_stack, #diagnostics, #lexer, #max_numparam_stack, #pattern_hash_keys, #pattern_variables, #source_buffer, #static_env

Instance Method Summary collapse

Methods inherited from Base

default_parser, #initialize, parse, #parse, parse_file, parse_file_with_comments, parse_with_comments, #parse_with_comments, #reset, #tokenize

Constructor Details

This class inherits a constructor from Parser::Base

Instance Method Details

#_reduce_1(val, _values, result) ⇒ Object

reduce 0 omitted



8371
8372
8373
8374
8375
8376
# File 'lib/parser/ruby33.rb', line 8371

def _reduce_1(val, _values, result)
                      @current_arg_stack.push(nil)
                      @max_numparam_stack.push(static: true)

    result
end

#_reduce_10(val, _values, result) ⇒ Object



8425
8426
8427
8428
8429
# File 'lib/parser/ruby33.rb', line 8425

def _reduce_10(val, _values, result)
                      result = val

    result
end

#_reduce_100(val, _values, result) ⇒ Object



9024
9025
9026
9027
9028
9029
# File 'lib/parser/ruby33.rb', line 9024

def _reduce_100(val, _values, result)
                      result = [ @builder.splat(val[0]),
                                 *val[2] ]

    result
end

#_reduce_102(val, _values, result) ⇒ Object

reduce 101 omitted



9033
9034
9035
9036
9037
# File 'lib/parser/ruby33.rb', line 9033

def _reduce_102(val, _values, result)
                      result = @builder.begin(val[0], val[1], val[2])

    result
end

#_reduce_103(val, _values, result) ⇒ Object



9039
9040
9041
9042
9043
# File 'lib/parser/ruby33.rb', line 9039

def _reduce_103(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_104(val, _values, result) ⇒ Object



9045
9046
9047
9048
9049
# File 'lib/parser/ruby33.rb', line 9045

def _reduce_104(val, _values, result)
                      result = val[0] << val[1]

    result
end

#_reduce_105(val, _values, result) ⇒ Object



9051
9052
9053
9054
9055
# File 'lib/parser/ruby33.rb', line 9051

def _reduce_105(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_106(val, _values, result) ⇒ Object



9057
9058
9059
9060
9061
# File 'lib/parser/ruby33.rb', line 9057

def _reduce_106(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_107(val, _values, result) ⇒ Object



9063
9064
9065
9066
9067
# File 'lib/parser/ruby33.rb', line 9063

def _reduce_107(val, _values, result)
                      result = @builder.assignable(val[0])

    result
end

#_reduce_108(val, _values, result) ⇒ Object



9069
9070
9071
9072
9073
# File 'lib/parser/ruby33.rb', line 9069

def _reduce_108(val, _values, result)
                      result = @builder.assignable(val[0])

    result
end

#_reduce_109(val, _values, result) ⇒ Object



9075
9076
9077
9078
9079
# File 'lib/parser/ruby33.rb', line 9075

def _reduce_109(val, _values, result)
                      result = @builder.index_asgn(val[0], val[1], val[2], val[3])

    result
end

#_reduce_11(val, _values, result) ⇒ Object



8431
8432
8433
8434
8435
8436
8437
8438
8439
8440
8441
8442
8443
8444
8445
8446
# File 'lib/parser/ruby33.rb', line 8431

def _reduce_11(val, _values, result)
                      rescue_bodies     = val[1]
                      else_t,   else_   = val[2]
                      ensure_t, ensure_ = val[3]

                      if rescue_bodies.empty? && !else_t.nil?
                        diagnostic :error, :useless_else, nil, else_t
                      end

                      result = @builder.begin_body(val[0],
                                  rescue_bodies,
                                  else_t,   else_,
                                  ensure_t, ensure_)

    result
end

#_reduce_110(val, _values, result) ⇒ Object



9081
9082
9083
9084
9085
9086
9087
9088
9089
# File 'lib/parser/ruby33.rb', line 9081

def _reduce_110(val, _values, result)
                      if (val[1][0] == :anddot)
                        diagnostic :error, :csend_in_lhs_of_masgn, nil, val[1]
                      end

                      result = @builder.attr_asgn(val[0], val[1], val[2])

    result
end

#_reduce_111(val, _values, result) ⇒ Object



9091
9092
9093
9094
9095
# File 'lib/parser/ruby33.rb', line 9091

def _reduce_111(val, _values, result)
                      result = @builder.attr_asgn(val[0], val[1], val[2])

    result
end

#_reduce_112(val, _values, result) ⇒ Object



9097
9098
9099
9100
9101
9102
9103
9104
9105
# File 'lib/parser/ruby33.rb', line 9097

def _reduce_112(val, _values, result)
                      if (val[1][0] == :anddot)
                        diagnostic :error, :csend_in_lhs_of_masgn, nil, val[1]
                      end

                      result = @builder.attr_asgn(val[0], val[1], val[2])

    result
end

#_reduce_113(val, _values, result) ⇒ Object



9107
9108
9109
9110
9111
9112
# File 'lib/parser/ruby33.rb', line 9107

def _reduce_113(val, _values, result)
                      result = @builder.assignable(
                                  @builder.const_fetch(val[0], val[1], val[2]))

    result
end

#_reduce_114(val, _values, result) ⇒ Object



9114
9115
9116
9117
9118
9119
# File 'lib/parser/ruby33.rb', line 9114

def _reduce_114(val, _values, result)
                      result = @builder.assignable(
                                  @builder.const_global(val[0], val[1]))

    result
end

#_reduce_115(val, _values, result) ⇒ Object



9121
9122
9123
9124
9125
# File 'lib/parser/ruby33.rb', line 9121

def _reduce_115(val, _values, result)
                      result = @builder.assignable(val[0])

    result
end

#_reduce_116(val, _values, result) ⇒ Object



9127
9128
9129
9130
9131
# File 'lib/parser/ruby33.rb', line 9127

def _reduce_116(val, _values, result)
                      result = @builder.assignable(val[0])

    result
end

#_reduce_117(val, _values, result) ⇒ Object



9133
9134
9135
9136
9137
# File 'lib/parser/ruby33.rb', line 9133

def _reduce_117(val, _values, result)
                      result = @builder.assignable(val[0])

    result
end

#_reduce_118(val, _values, result) ⇒ Object



9139
9140
9141
9142
9143
# File 'lib/parser/ruby33.rb', line 9139

def _reduce_118(val, _values, result)
                      result = @builder.index_asgn(val[0], val[1], val[2], val[3])

    result
end

#_reduce_119(val, _values, result) ⇒ Object



9145
9146
9147
9148
9149
# File 'lib/parser/ruby33.rb', line 9145

def _reduce_119(val, _values, result)
                      result = @builder.attr_asgn(val[0], val[1], val[2])

    result
end

#_reduce_12(val, _values, result) ⇒ Object



8448
8449
8450
8451
8452
# File 'lib/parser/ruby33.rb', line 8448

def _reduce_12(val, _values, result)
                      result = @builder.compstmt(val[0])

    result
end

#_reduce_120(val, _values, result) ⇒ Object



9151
9152
9153
9154
9155
# File 'lib/parser/ruby33.rb', line 9151

def _reduce_120(val, _values, result)
                      result = @builder.attr_asgn(val[0], val[1], val[2])

    result
end

#_reduce_121(val, _values, result) ⇒ Object



9157
9158
9159
9160
9161
# File 'lib/parser/ruby33.rb', line 9157

def _reduce_121(val, _values, result)
                      result = @builder.attr_asgn(val[0], val[1], val[2])

    result
end

#_reduce_122(val, _values, result) ⇒ Object



9163
9164
9165
9166
9167
9168
# File 'lib/parser/ruby33.rb', line 9163

def _reduce_122(val, _values, result)
                      result = @builder.assignable(
                                  @builder.const_fetch(val[0], val[1], val[2]))

    result
end

#_reduce_123(val, _values, result) ⇒ Object



9170
9171
9172
9173
9174
9175
# File 'lib/parser/ruby33.rb', line 9170

def _reduce_123(val, _values, result)
                      result = @builder.assignable(
                                  @builder.const_global(val[0], val[1]))

    result
end

#_reduce_124(val, _values, result) ⇒ Object



9177
9178
9179
9180
9181
# File 'lib/parser/ruby33.rb', line 9177

def _reduce_124(val, _values, result)
                      result = @builder.assignable(val[0])

    result
end

#_reduce_125(val, _values, result) ⇒ Object



9183
9184
9185
9186
9187
# File 'lib/parser/ruby33.rb', line 9183

def _reduce_125(val, _values, result)
                      diagnostic :error, :module_name_const, nil, val[0]

    result
end

#_reduce_127(val, _values, result) ⇒ Object

reduce 126 omitted



9191
9192
9193
9194
9195
# File 'lib/parser/ruby33.rb', line 9191

def _reduce_127(val, _values, result)
                      result = @builder.const_global(val[0], val[1])

    result
end

#_reduce_128(val, _values, result) ⇒ Object



9197
9198
9199
9200
9201
# File 'lib/parser/ruby33.rb', line 9197

def _reduce_128(val, _values, result)
                      result = @builder.const(val[0])

    result
end

#_reduce_129(val, _values, result) ⇒ Object



9203
9204
9205
9206
9207
# File 'lib/parser/ruby33.rb', line 9203

def _reduce_129(val, _values, result)
                      result = @builder.const_fetch(val[0], val[1], val[2])

    result
end

#_reduce_13(val, _values, result) ⇒ Object



8454
8455
8456
8457
8458
# File 'lib/parser/ruby33.rb', line 8454

def _reduce_13(val, _values, result)
                      result = []

    result
end

#_reduce_135(val, _values, result) ⇒ Object

reduce 134 omitted



9219
9220
9221
9222
9223
# File 'lib/parser/ruby33.rb', line 9219

def _reduce_135(val, _values, result)
                      result = @builder.symbol_internal(val[0])

    result
end

#_reduce_137(val, _values, result) ⇒ Object

reduce 136 omitted



9227
9228
9229
9230
9231
# File 'lib/parser/ruby33.rb', line 9227

def _reduce_137(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_138(val, _values, result) ⇒ Object



9233
9234
9235
9236
9237
# File 'lib/parser/ruby33.rb', line 9233

def _reduce_138(val, _values, result)
                      @lexer.state = :expr_fname

    result
end

#_reduce_139(val, _values, result) ⇒ Object



9239
9240
9241
9242
9243
# File 'lib/parser/ruby33.rb', line 9239

def _reduce_139(val, _values, result)
                      result = val[0] << val[3]

    result
end

#_reduce_14(val, _values, result) ⇒ Object



8460
8461
8462
8463
8464
# File 'lib/parser/ruby33.rb', line 8460

def _reduce_14(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_15(val, _values, result) ⇒ Object



8466
8467
8468
8469
8470
# File 'lib/parser/ruby33.rb', line 8466

def _reduce_15(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_16(val, _values, result) ⇒ Object



8472
8473
8474
8475
8476
# File 'lib/parser/ruby33.rb', line 8472

def _reduce_16(val, _values, result)
                      result = [ val[1] ]

    result
end

#_reduce_18(val, _values, result) ⇒ Object

reduce 17 omitted



8480
8481
8482
8483
8484
# File 'lib/parser/ruby33.rb', line 8480

def _reduce_18(val, _values, result)
                      diagnostic :error, :begin_in_method, nil, val[0]

    result
end

#_reduce_19(val, _values, result) ⇒ Object



8486
8487
8488
8489
8490
# File 'lib/parser/ruby33.rb', line 8486

def _reduce_19(val, _values, result)
                      @lexer.state = :expr_fname

    result
end

#_reduce_2(val, _values, result) ⇒ Object



8378
8379
8380
8381
8382
8383
8384
8385
# File 'lib/parser/ruby33.rb', line 8378

def _reduce_2(val, _values, result)
                      result = val[1]

                      @current_arg_stack.pop
                      @max_numparam_stack.pop

    result
end

#_reduce_20(val, _values, result) ⇒ Object



8492
8493
8494
8495
8496
# File 'lib/parser/ruby33.rb', line 8492

def _reduce_20(val, _values, result)
                      result = @builder.alias(val[0], val[1], val[3])

    result
end

#_reduce_21(val, _values, result) ⇒ Object



8498
8499
8500
8501
8502
8503
8504
# File 'lib/parser/ruby33.rb', line 8498

def _reduce_21(val, _values, result)
                      result = @builder.alias(val[0],
                                  @builder.gvar(val[1]),
                                  @builder.gvar(val[2]))

    result
end

#_reduce_211(val, _values, result) ⇒ Object

reduce 210 omitted



9387
9388
9389
9390
9391
# File 'lib/parser/ruby33.rb', line 9387

def _reduce_211(val, _values, result)
                      result = @builder.assign(val[0], val[1], val[2])

    result
end

#_reduce_212(val, _values, result) ⇒ Object



9393
9394
9395
9396
9397
# File 'lib/parser/ruby33.rb', line 9393

def _reduce_212(val, _values, result)
                      result = @builder.op_assign(val[0], val[1], val[2])

    result
end

#_reduce_213(val, _values, result) ⇒ Object



9399
9400
9401
9402
9403
9404
9405
9406
# File 'lib/parser/ruby33.rb', line 9399

def _reduce_213(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.index(
                                    val[0], val[1], val[2], val[3]),
                                  val[4], val[5])

    result
end

#_reduce_214(val, _values, result) ⇒ Object



9408
9409
9410
9411
9412
9413
9414
9415
# File 'lib/parser/ruby33.rb', line 9408

def _reduce_214(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.call_method(
                                    val[0], val[1], val[2]),
                                  val[3], val[4])

    result
end

#_reduce_215(val, _values, result) ⇒ Object



9417
9418
9419
9420
9421
9422
9423
9424
# File 'lib/parser/ruby33.rb', line 9417

def _reduce_215(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.call_method(
                                    val[0], val[1], val[2]),
                                  val[3], val[4])

    result
end

#_reduce_216(val, _values, result) ⇒ Object



9426
9427
9428
9429
9430
9431
9432
9433
# File 'lib/parser/ruby33.rb', line 9426

def _reduce_216(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.call_method(
                                    val[0], val[1], val[2]),
                                  val[3], val[4])

    result
end

#_reduce_217(val, _values, result) ⇒ Object



9435
9436
9437
9438
9439
9440
9441
# File 'lib/parser/ruby33.rb', line 9435

def _reduce_217(val, _values, result)
                      const  = @builder.const_op_assignable(
                                  @builder.const_fetch(val[0], val[1], val[2]))
                      result = @builder.op_assign(const, val[3], val[4])

    result
end

#_reduce_218(val, _values, result) ⇒ Object



9443
9444
9445
9446
9447
9448
9449
# File 'lib/parser/ruby33.rb', line 9443

def _reduce_218(val, _values, result)
                      const  = @builder.const_op_assignable(
                                  @builder.const_global(val[0], val[1]))
                      result = @builder.op_assign(const, val[2], val[3])

    result
end

#_reduce_219(val, _values, result) ⇒ Object



9451
9452
9453
9454
9455
# File 'lib/parser/ruby33.rb', line 9451

def _reduce_219(val, _values, result)
                      result = @builder.op_assign(val[0], val[1], val[2])

    result
end

#_reduce_22(val, _values, result) ⇒ Object



8506
8507
8508
8509
8510
8511
8512
# File 'lib/parser/ruby33.rb', line 8506

def _reduce_22(val, _values, result)
                      result = @builder.alias(val[0],
                                  @builder.gvar(val[1]),
                                  @builder.back_ref(val[2]))

    result
end

#_reduce_220(val, _values, result) ⇒ Object



9457
9458
9459
9460
9461
# File 'lib/parser/ruby33.rb', line 9457

def _reduce_220(val, _values, result)
                      result = @builder.range_inclusive(val[0], val[1], val[2])

    result
end

#_reduce_221(val, _values, result) ⇒ Object



9463
9464
9465
9466
9467
# File 'lib/parser/ruby33.rb', line 9463

def _reduce_221(val, _values, result)
                      result = @builder.range_exclusive(val[0], val[1], val[2])

    result
end

#_reduce_222(val, _values, result) ⇒ Object



9469
9470
9471
9472
9473
# File 'lib/parser/ruby33.rb', line 9469

def _reduce_222(val, _values, result)
                      result = @builder.range_inclusive(val[0], val[1], nil)

    result
end

#_reduce_223(val, _values, result) ⇒ Object



9475
9476
9477
9478
9479
# File 'lib/parser/ruby33.rb', line 9475

def _reduce_223(val, _values, result)
                      result = @builder.range_exclusive(val[0], val[1], nil)

    result
end

#_reduce_224(val, _values, result) ⇒ Object



9481
9482
9483
9484
9485
# File 'lib/parser/ruby33.rb', line 9481

def _reduce_224(val, _values, result)
                      result = @builder.range_inclusive(nil, val[0], val[1])

    result
end

#_reduce_225(val, _values, result) ⇒ Object



9487
9488
9489
9490
9491
# File 'lib/parser/ruby33.rb', line 9487

def _reduce_225(val, _values, result)
                      result = @builder.range_exclusive(nil, val[0], val[1])

    result
end

#_reduce_226(val, _values, result) ⇒ Object



9493
9494
9495
9496
9497
# File 'lib/parser/ruby33.rb', line 9493

def _reduce_226(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_227(val, _values, result) ⇒ Object



9499
9500
9501
9502
9503
# File 'lib/parser/ruby33.rb', line 9499

def _reduce_227(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_228(val, _values, result) ⇒ Object



9505
9506
9507
9508
9509
# File 'lib/parser/ruby33.rb', line 9505

def _reduce_228(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_229(val, _values, result) ⇒ Object



9511
9512
9513
9514
9515
# File 'lib/parser/ruby33.rb', line 9511

def _reduce_229(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_23(val, _values, result) ⇒ Object



8514
8515
8516
8517
8518
# File 'lib/parser/ruby33.rb', line 8514

def _reduce_23(val, _values, result)
                      diagnostic :error, :nth_ref_alias, nil, val[2]

    result
end

#_reduce_230(val, _values, result) ⇒ Object



9517
9518
9519
9520
9521
# File 'lib/parser/ruby33.rb', line 9517

def _reduce_230(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_231(val, _values, result) ⇒ Object



9523
9524
9525
9526
9527
# File 'lib/parser/ruby33.rb', line 9523

def _reduce_231(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_232(val, _values, result) ⇒ Object



9529
9530
9531
9532
9533
9534
9535
# File 'lib/parser/ruby33.rb', line 9529

def _reduce_232(val, _values, result)
                      result = @builder.unary_op(val[0],
                                  @builder.binary_op(
                                    val[1], val[2], val[3]))

    result
end

#_reduce_233(val, _values, result) ⇒ Object



9537
9538
9539
9540
9541
# File 'lib/parser/ruby33.rb', line 9537

def _reduce_233(val, _values, result)
                      result = @builder.unary_op(val[0], val[1])

    result
end

#_reduce_234(val, _values, result) ⇒ Object



9543
9544
9545
9546
9547
# File 'lib/parser/ruby33.rb', line 9543

def _reduce_234(val, _values, result)
                      result = @builder.unary_op(val[0], val[1])

    result
end

#_reduce_235(val, _values, result) ⇒ Object



9549
9550
9551
9552
9553
# File 'lib/parser/ruby33.rb', line 9549

def _reduce_235(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_236(val, _values, result) ⇒ Object



9555
9556
9557
9558
9559
# File 'lib/parser/ruby33.rb', line 9555

def _reduce_236(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_237(val, _values, result) ⇒ Object



9561
9562
9563
9564
9565
# File 'lib/parser/ruby33.rb', line 9561

def _reduce_237(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_238(val, _values, result) ⇒ Object



9567
9568
9569
9570
9571
# File 'lib/parser/ruby33.rb', line 9567

def _reduce_238(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_24(val, _values, result) ⇒ Object



8520
8521
8522
8523
8524
# File 'lib/parser/ruby33.rb', line 8520

def _reduce_24(val, _values, result)
                      result = @builder.undef_method(val[0], val[1])

    result
end

#_reduce_240(val, _values, result) ⇒ Object

reduce 239 omitted



9575
9576
9577
9578
9579
# File 'lib/parser/ruby33.rb', line 9575

def _reduce_240(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_241(val, _values, result) ⇒ Object



9581
9582
9583
9584
9585
# File 'lib/parser/ruby33.rb', line 9581

def _reduce_241(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_242(val, _values, result) ⇒ Object



9587
9588
9589
9590
9591
# File 'lib/parser/ruby33.rb', line 9587

def _reduce_242(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_243(val, _values, result) ⇒ Object



9593
9594
9595
9596
9597
# File 'lib/parser/ruby33.rb', line 9593

def _reduce_243(val, _values, result)
                      result = @builder.match_op(val[0], val[1], val[2])

    result
end

#_reduce_244(val, _values, result) ⇒ Object



9599
9600
9601
9602
9603
# File 'lib/parser/ruby33.rb', line 9599

def _reduce_244(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_245(val, _values, result) ⇒ Object



9605
9606
9607
9608
9609
# File 'lib/parser/ruby33.rb', line 9605

def _reduce_245(val, _values, result)
                      result = @builder.not_op(val[0], nil, val[1], nil)

    result
end

#_reduce_246(val, _values, result) ⇒ Object



9611
9612
9613
9614
9615
# File 'lib/parser/ruby33.rb', line 9611

def _reduce_246(val, _values, result)
                      result = @builder.unary_op(val[0], val[1])

    result
end

#_reduce_247(val, _values, result) ⇒ Object



9617
9618
9619
9620
9621
# File 'lib/parser/ruby33.rb', line 9617

def _reduce_247(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_248(val, _values, result) ⇒ Object



9623
9624
9625
9626
9627
# File 'lib/parser/ruby33.rb', line 9623

def _reduce_248(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_249(val, _values, result) ⇒ Object



9629
9630
9631
9632
9633
# File 'lib/parser/ruby33.rb', line 9629

def _reduce_249(val, _values, result)
                      result = @builder.logical_op(:and, val[0], val[1], val[2])

    result
end

#_reduce_25(val, _values, result) ⇒ Object



8526
8527
8528
8529
8530
8531
# File 'lib/parser/ruby33.rb', line 8526

def _reduce_25(val, _values, result)
                      result = @builder.condition_mod(val[0], nil,
                                                      val[1], val[2])

    result
end

#_reduce_250(val, _values, result) ⇒ Object



9635
9636
9637
9638
9639
# File 'lib/parser/ruby33.rb', line 9635

def _reduce_250(val, _values, result)
                      result = @builder.logical_op(:or, val[0], val[1], val[2])

    result
end

#_reduce_251(val, _values, result) ⇒ Object



9641
9642
9643
9644
9645
9646
# File 'lib/parser/ruby33.rb', line 9641

def _reduce_251(val, _values, result)
                      @context.in_defined = val[2].in_defined
                      result = @builder.keyword_cmd(:defined?, val[0], nil, [ val[3] ], nil)

    result
end

#_reduce_252(val, _values, result) ⇒ Object



9648
9649
9650
9651
9652
9653
# File 'lib/parser/ruby33.rb', line 9648

def _reduce_252(val, _values, result)
                      result = @builder.ternary(val[0], val[1],
                                                val[2], val[4], val[5])

    result
end

#_reduce_253(val, _values, result) ⇒ Object



9655
9656
9657
9658
9659
9660
9661
9662
9663
9664
9665
9666
9667
# File 'lib/parser/ruby33.rb', line 9655

def _reduce_253(val, _values, result)
                      def_t, (name_t, ctx) = val[0]
                      endless_method_name(name_t)

                      result = @builder.def_endless_method(def_t, name_t,
                                 val[1], val[2], val[3])

                      local_pop
                      @current_arg_stack.pop
                      @context.in_def = ctx.in_def

    result
end

#_reduce_254(val, _values, result) ⇒ Object



9669
9670
9671
9672
9673
9674
9675
9676
9677
9678
9679
9680
9681
# File 'lib/parser/ruby33.rb', line 9669

def _reduce_254(val, _values, result)
                      def_t, recv, dot_t, (name_t, ctx) = val[0]
                      endless_method_name(name_t)

                      result = @builder.def_endless_singleton(def_t, recv, dot_t, name_t,
                                 val[1], val[2], val[3])

                      local_pop
                      @current_arg_stack.pop
                      @context.in_def = ctx.in_def

    result
end

#_reduce_257(val, _values, result) ⇒ Object

reduce 256 omitted



9687
9688
9689
9690
9691
9692
9693
9694
9695
# File 'lib/parser/ruby33.rb', line 9687

def _reduce_257(val, _values, result)
                      rescue_body = @builder.rescue_body(val[1],
                                        nil, nil, nil,
                                        nil, val[2])

                      result = @builder.begin_body(val[0], [ rescue_body ])

    result
end

#_reduce_258(val, _values, result) ⇒ Object



9697
9698
9699
9700
9701
# File 'lib/parser/ruby33.rb', line 9697

def _reduce_258(val, _values, result)
                      result = @builder.not_op(val[0], nil, val[2], nil)

    result
end

#_reduce_26(val, _values, result) ⇒ Object



8533
8534
8535
8536
8537
8538
# File 'lib/parser/ruby33.rb', line 8533

def _reduce_26(val, _values, result)
                      result = @builder.condition_mod(nil, val[0],
                                                      val[1], val[2])

    result
end

#_reduce_263(val, _values, result) ⇒ Object

reduce 262 omitted



9711
9712
9713
9714
9715
# File 'lib/parser/ruby33.rb', line 9711

def _reduce_263(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_264(val, _values, result) ⇒ Object



9717
9718
9719
9720
9721
# File 'lib/parser/ruby33.rb', line 9717

def _reduce_264(val, _values, result)
                      result = @builder.binary_op(val[0], val[1], val[2])

    result
end

#_reduce_265(val, _values, result) ⇒ Object



9723
9724
9725
9726
9727
# File 'lib/parser/ruby33.rb', line 9723

def _reduce_265(val, _values, result)
                      result = @context.dup

    result
end

#_reduce_269(val, _values, result) ⇒ Object

reduce 268 omitted



9735
9736
9737
9738
9739
# File 'lib/parser/ruby33.rb', line 9735

def _reduce_269(val, _values, result)
                      result = val[0] << @builder.associate(nil, val[2], nil)

    result
end

#_reduce_27(val, _values, result) ⇒ Object



8540
8541
8542
8543
8544
# File 'lib/parser/ruby33.rb', line 8540

def _reduce_27(val, _values, result)
                      result = @builder.loop_mod(:while, val[0], val[1], val[2])

    result
end

#_reduce_270(val, _values, result) ⇒ Object



9741
9742
9743
9744
9745
# File 'lib/parser/ruby33.rb', line 9741

def _reduce_270(val, _values, result)
                      result = [ @builder.associate(nil, val[0], nil) ]

    result
end

#_reduce_272(val, _values, result) ⇒ Object

reduce 271 omitted



9749
9750
9751
9752
9753
9754
9755
9756
9757
# File 'lib/parser/ruby33.rb', line 9749

def _reduce_272(val, _values, result)
                      rescue_body = @builder.rescue_body(val[1],
                                        nil, nil, nil,
                                        nil, val[2])

                      result = @builder.begin_body(val[0], [ rescue_body ])

    result
end

#_reduce_273(val, _values, result) ⇒ Object



9759
9760
9761
9762
9763
# File 'lib/parser/ruby33.rb', line 9759

def _reduce_273(val, _values, result)
                      result = val

    result
end

#_reduce_274(val, _values, result) ⇒ Object



9765
9766
9767
9768
9769
9770
9771
9772
9773
# File 'lib/parser/ruby33.rb', line 9765

def _reduce_274(val, _values, result)
                      unless @static_env.declared_forward_args?
                        diagnostic :error, :unexpected_token, { :token => 'tBDOT3' } , val[3]
                      end

                      result = [val[0], [*val[1], @builder.forwarded_args(val[3])], val[4]]

    result
end

#_reduce_275(val, _values, result) ⇒ Object



9775
9776
9777
9778
9779
9780
9781
9782
9783
# File 'lib/parser/ruby33.rb', line 9775

def _reduce_275(val, _values, result)
                      unless @static_env.declared_forward_args?
                        diagnostic :error, :unexpected_token, { :token => 'tBDOT3' } , val[1]
                      end

                      result = [val[0], [@builder.forwarded_args(val[1])], val[2]]

    result
end

#_reduce_276(val, _values, result) ⇒ Object



9785
9786
9787
9788
9789
# File 'lib/parser/ruby33.rb', line 9785

def _reduce_276(val, _values, result)
                      result = [ nil, [], nil ]

    result
end

#_reduce_278(val, _values, result) ⇒ Object

reduce 277 omitted



9793
9794
9795
9796
9797
# File 'lib/parser/ruby33.rb', line 9793

def _reduce_278(val, _values, result)
                      result = []

    result
end

#_reduce_28(val, _values, result) ⇒ Object



8546
8547
8548
8549
8550
# File 'lib/parser/ruby33.rb', line 8546

def _reduce_28(val, _values, result)
                      result = @builder.loop_mod(:until, val[0], val[1], val[2])

    result
end

#_reduce_281(val, _values, result) ⇒ Object

reduce 280 omitted



9803
9804
9805
9806
9807
# File 'lib/parser/ruby33.rb', line 9803

def _reduce_281(val, _values, result)
                      result = val[0] << @builder.associate(nil, val[2], nil)

    result
end

#_reduce_282(val, _values, result) ⇒ Object



9809
9810
9811
9812
9813
# File 'lib/parser/ruby33.rb', line 9809

def _reduce_282(val, _values, result)
                      result = [ @builder.associate(nil, val[0], nil) ]

    result
end

#_reduce_283(val, _values, result) ⇒ Object



9815
9816
9817
9818
9819
# File 'lib/parser/ruby33.rb', line 9815

def _reduce_283(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_284(val, _values, result) ⇒ Object



9821
9822
9823
9824
9825
# File 'lib/parser/ruby33.rb', line 9821

def _reduce_284(val, _values, result)
                      result = val[0].concat(val[1])

    result
end

#_reduce_285(val, _values, result) ⇒ Object



9827
9828
9829
9830
9831
9832
# File 'lib/parser/ruby33.rb', line 9827

def _reduce_285(val, _values, result)
                      result = [ @builder.associate(nil, val[0], nil) ]
                      result.concat(val[1])

    result
end

#_reduce_286(val, _values, result) ⇒ Object



9834
9835
9836
9837
9838
9839
9840
# File 'lib/parser/ruby33.rb', line 9834

def _reduce_286(val, _values, result)
                      assocs = @builder.associate(nil, val[2], nil)
                      result = val[0] << assocs
                      result.concat(val[3])

    result
end

#_reduce_287(val, _values, result) ⇒ Object



9842
9843
9844
9845
9846
# File 'lib/parser/ruby33.rb', line 9842

def _reduce_287(val, _values, result)
                      result =  [ val[0] ]

    result
end

#_reduce_288(val, _values, result) ⇒ Object



9848
9849
9850
9851
9852
9853
9854
9855
9856
9857
9858
9859
9860
9861
9862
9863
9864
9865
9866
9867
9868
9869
9870
9871
9872
9873
# File 'lib/parser/ruby33.rb', line 9848

def _reduce_288(val, _values, result)
                      # When branch gets invoked by RACC's lookahead
                      # and command args start with '[' or '('
                      # we need to put `true` to the cmdarg stack
                      # **before** `false` pushed by lexer
                      #   m [], n
                      #     ^
                      # Right here we have cmdarg [...0] because
                      # lexer pushed it on '['
                      # We need to modify cmdarg stack to [...10]
                      #
                      # For all other cases (like `m n` or `m n, []`) we simply put 1 to the stack
                      # and later lexer pushes corresponding bits on top of it.
                      last_token = @last_token[0]
                      lookahead = last_token == :tLBRACK || last_token == :tLPAREN_ARG

                      if lookahead
                        top = @lexer.cmdarg.pop
                        @lexer.cmdarg.push(true)
                        @lexer.cmdarg.push(top)
                      else
                        @lexer.cmdarg.push(true)
                      end

    result
end

#_reduce_289(val, _values, result) ⇒ Object



9875
9876
9877
9878
9879
9880
9881
9882
9883
9884
9885
9886
9887
9888
9889
9890
9891
9892
9893
9894
# File 'lib/parser/ruby33.rb', line 9875

def _reduce_289(val, _values, result)
                      # call_args can be followed by tLBRACE_ARG (that does cmdarg.push(0) in the lexer)
                      # but the push must be done after cmdarg.pop() in the parser.
                      # So this code does cmdarg.pop() to pop 0 pushed by tLBRACE_ARG,
                      # cmdarg.pop() to pop 1 pushed by command_args,
                      # and cmdarg.push(0) to restore back the flag set by tLBRACE_ARG.
                      last_token = @last_token[0]
                      lookahead = last_token == :tLBRACE_ARG
                      if lookahead
                        top = @lexer.cmdarg.pop
                        @lexer.cmdarg.pop
                        @lexer.cmdarg.push(top)
                      else
                        @lexer.cmdarg.pop
                      end

                      result = val[1]

    result
end

#_reduce_29(val, _values, result) ⇒ Object



8552
8553
8554
8555
8556
8557
8558
8559
8560
# File 'lib/parser/ruby33.rb', line 8552

def _reduce_29(val, _values, result)
                      rescue_body = @builder.rescue_body(val[1],
                                        nil, nil, nil,
                                        nil, val[2])

                      result = @builder.begin_body(val[0], [ rescue_body ])

    result
end

#_reduce_290(val, _values, result) ⇒ Object



9896
9897
9898
9899
9900
# File 'lib/parser/ruby33.rb', line 9896

def _reduce_290(val, _values, result)
                      result = @builder.block_pass(val[0], val[1])

    result
end

#_reduce_291(val, _values, result) ⇒ Object



9902
9903
9904
9905
9906
9907
9908
9909
9910
9911
9912
9913
9914
9915
# File 'lib/parser/ruby33.rb', line 9902

def _reduce_291(val, _values, result)
                      if !@static_env.declared_anonymous_blockarg?
                        diagnostic :error, :no_anonymous_blockarg, nil, val[0]
                      end

                      if @context.in_dynamic_block? && context.in_def &&
                        @static_env.declared_anonymous_blockarg_in_current_scpe? && @static_env.parent_has_anonymous_blockarg?
                        diagnostic :error, :ambiguous_anonymous_blockarg, nil, val[0]
                      end

                      result = @builder.block_pass(val[0], nil)

    result
end

#_reduce_292(val, _values, result) ⇒ Object



9917
9918
9919
9920
9921
# File 'lib/parser/ruby33.rb', line 9917

def _reduce_292(val, _values, result)
                      result = [ val[1] ]

    result
end

#_reduce_293(val, _values, result) ⇒ Object



9923
9924
9925
9926
9927
# File 'lib/parser/ruby33.rb', line 9923

def _reduce_293(val, _values, result)
                      result = []

    result
end

#_reduce_294(val, _values, result) ⇒ Object



9929
9930
9931
9932
9933
# File 'lib/parser/ruby33.rb', line 9929

def _reduce_294(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_296(val, _values, result) ⇒ Object

reduce 295 omitted



9937
9938
9939
9940
9941
# File 'lib/parser/ruby33.rb', line 9937

def _reduce_296(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_297(val, _values, result) ⇒ Object



9943
9944
9945
9946
9947
# File 'lib/parser/ruby33.rb', line 9943

def _reduce_297(val, _values, result)
                      result = val[0].concat(val[2])

    result
end

#_reduce_298(val, _values, result) ⇒ Object



9949
9950
9951
9952
9953
# File 'lib/parser/ruby33.rb', line 9949

def _reduce_298(val, _values, result)
                      result = [ @builder.splat(val[0], val[1]) ]

    result
end

#_reduce_299(val, _values, result) ⇒ Object



9955
9956
9957
9958
9959
9960
9961
9962
9963
9964
9965
9966
9967
9968
# File 'lib/parser/ruby33.rb', line 9955

def _reduce_299(val, _values, result)
                      if !@static_env.declared_anonymous_restarg?
                        diagnostic :error, :no_anonymous_restarg, nil, val[0]
                      end

                      if @context.in_dynamic_block? && context.in_def &&
                        @static_env.declared_anonymous_restarg_in_current_scope? && @static_env.parent_has_anonymous_restarg?
                        diagnostic :error, :ambiguous_anonymous_restarg, nil, val[0]
                      end

                      result = [ @builder.forwarded_restarg(val[0]) ]

    result
end

#_reduce_3(val, _values, result) ⇒ Object



8387
8388
8389
8390
8391
# File 'lib/parser/ruby33.rb', line 8387

def _reduce_3(val, _values, result)
                      result = @builder.compstmt(val[0])

    result
end

#_reduce_30(val, _values, result) ⇒ Object



8562
8563
8564
8565
8566
# File 'lib/parser/ruby33.rb', line 8562

def _reduce_30(val, _values, result)
                      result = @builder.postexe(val[0], val[1], val[2], val[3])

    result
end

#_reduce_300(val, _values, result) ⇒ Object



9970
9971
9972
9973
9974
# File 'lib/parser/ruby33.rb', line 9970

def _reduce_300(val, _values, result)
                      result = @builder.array(nil, val[0], nil)

    result
end

#_reduce_302(val, _values, result) ⇒ Object

reduce 301 omitted



9978
9979
9980
9981
9982
# File 'lib/parser/ruby33.rb', line 9978

def _reduce_302(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_303(val, _values, result) ⇒ Object



9984
9985
9986
9987
9988
# File 'lib/parser/ruby33.rb', line 9984

def _reduce_303(val, _values, result)
                      result = val[0] << @builder.splat(val[2], val[3])

    result
end

#_reduce_304(val, _values, result) ⇒ Object



9990
9991
9992
9993
9994
# File 'lib/parser/ruby33.rb', line 9990

def _reduce_304(val, _values, result)
                      result = [ @builder.splat(val[0], val[1]) ]

    result
end

#_reduce_315(val, _values, result) ⇒ Object

reduce 314 omitted



10016
10017
10018
10019
10020
# File 'lib/parser/ruby33.rb', line 10016

def _reduce_315(val, _values, result)
                      result = @builder.call_method(nil, nil, val[0])

    result
end

#_reduce_316(val, _values, result) ⇒ Object



10022
10023
10024
10025
10026
# File 'lib/parser/ruby33.rb', line 10022

def _reduce_316(val, _values, result)
                      @lexer.cmdarg.push(false)

    result
end

#_reduce_317(val, _values, result) ⇒ Object



10028
10029
10030
10031
10032
10033
10034
# File 'lib/parser/ruby33.rb', line 10028

def _reduce_317(val, _values, result)
                      @lexer.cmdarg.pop

                      result = @builder.begin_keyword(val[0], val[2], val[3])

    result
end

#_reduce_318(val, _values, result) ⇒ Object



10036
10037
10038
10039
10040
# File 'lib/parser/ruby33.rb', line 10036

def _reduce_318(val, _values, result)
                      @lexer.state = :expr_endarg

    result
end

#_reduce_319(val, _values, result) ⇒ Object



10042
10043
10044
10045
10046
# File 'lib/parser/ruby33.rb', line 10042

def _reduce_319(val, _values, result)
                      result = @builder.begin(val[0], val[1], val[3])

    result
end

#_reduce_32(val, _values, result) ⇒ Object

reduce 31 omitted



8570
8571
8572
8573
8574
# File 'lib/parser/ruby33.rb', line 8570

def _reduce_32(val, _values, result)
                      result = @builder.multi_assign(val[0], val[1], val[2])

    result
end

#_reduce_320(val, _values, result) ⇒ Object



10048
10049
10050
10051
10052
# File 'lib/parser/ruby33.rb', line 10048

def _reduce_320(val, _values, result)
                      result = @builder.begin(val[0], val[1], val[2])

    result
end

#_reduce_321(val, _values, result) ⇒ Object



10054
10055
10056
10057
10058
# File 'lib/parser/ruby33.rb', line 10054

def _reduce_321(val, _values, result)
                      result = @builder.const_fetch(val[0], val[1], val[2])

    result
end

#_reduce_322(val, _values, result) ⇒ Object



10060
10061
10062
10063
10064
# File 'lib/parser/ruby33.rb', line 10060

def _reduce_322(val, _values, result)
                      result = @builder.const_global(val[0], val[1])

    result
end

#_reduce_323(val, _values, result) ⇒ Object



10066
10067
10068
10069
10070
# File 'lib/parser/ruby33.rb', line 10066

def _reduce_323(val, _values, result)
                      result = @builder.array(val[0], val[1], val[2])

    result
end

#_reduce_324(val, _values, result) ⇒ Object



10072
10073
10074
10075
10076
# File 'lib/parser/ruby33.rb', line 10072

def _reduce_324(val, _values, result)
                      result = @builder.associate(val[0], val[1], val[2])

    result
end

#_reduce_325(val, _values, result) ⇒ Object



10078
10079
10080
10081
10082
# File 'lib/parser/ruby33.rb', line 10078

def _reduce_325(val, _values, result)
                      result = @builder.keyword_cmd(:return, val[0])

    result
end

#_reduce_326(val, _values, result) ⇒ Object



10084
10085
10086
10087
10088
# File 'lib/parser/ruby33.rb', line 10084

def _reduce_326(val, _values, result)
                      result = @builder.keyword_cmd(:yield, val[0], val[1], val[2], val[3])

    result
end

#_reduce_327(val, _values, result) ⇒ Object



10090
10091
10092
10093
10094
# File 'lib/parser/ruby33.rb', line 10090

def _reduce_327(val, _values, result)
                      result = @builder.keyword_cmd(:yield, val[0], val[1], [], val[2])

    result
end

#_reduce_328(val, _values, result) ⇒ Object



10096
10097
10098
10099
10100
# File 'lib/parser/ruby33.rb', line 10096

def _reduce_328(val, _values, result)
                      result = @builder.keyword_cmd(:yield, val[0])

    result
end

#_reduce_329(val, _values, result) ⇒ Object



10102
10103
10104
10105
10106
10107
10108
# File 'lib/parser/ruby33.rb', line 10102

def _reduce_329(val, _values, result)
                      @context.in_defined = val[3].in_defined
                      result = @builder.keyword_cmd(:defined?, val[0],
                                                    val[2], [ val[4] ], val[5])

    result
end

#_reduce_33(val, _values, result) ⇒ Object



8576
8577
8578
8579
8580
8581
# File 'lib/parser/ruby33.rb', line 8576

def _reduce_33(val, _values, result)
                      result = @builder.assign(val[0], val[1],
                                  @builder.array(nil, val[2], nil))

    result
end

#_reduce_330(val, _values, result) ⇒ Object



10110
10111
10112
10113
10114
# File 'lib/parser/ruby33.rb', line 10110

def _reduce_330(val, _values, result)
                      result = @builder.not_op(val[0], val[1], val[2], val[3])

    result
end

#_reduce_331(val, _values, result) ⇒ Object



10116
10117
10118
10119
10120
# File 'lib/parser/ruby33.rb', line 10116

def _reduce_331(val, _values, result)
                      result = @builder.not_op(val[0], val[1], nil, val[2])

    result
end

#_reduce_332(val, _values, result) ⇒ Object



10122
10123
10124
10125
10126
10127
10128
10129
10130
# File 'lib/parser/ruby33.rb', line 10122

def _reduce_332(val, _values, result)
                      method_call = @builder.call_method(nil, nil, val[0])

                      begin_t, args, body, end_t = val[1]
                      result      = @builder.block(method_call,
                                      begin_t, args, body, end_t)

    result
end

#_reduce_334(val, _values, result) ⇒ Object

reduce 333 omitted



10134
10135
10136
10137
10138
10139
10140
# File 'lib/parser/ruby33.rb', line 10134

def _reduce_334(val, _values, result)
                      begin_t, args, body, end_t = val[1]
                      result      = @builder.block(val[0],
                                      begin_t, args, body, end_t)

    result
end

#_reduce_336(val, _values, result) ⇒ Object

reduce 335 omitted



10144
10145
10146
10147
10148
10149
10150
10151
# File 'lib/parser/ruby33.rb', line 10144

def _reduce_336(val, _values, result)
                      else_t, else_ = val[4]
                      result = @builder.condition(val[0], val[1], val[2],
                                                  val[3], else_t,
                                                  else_,  val[5])

    result
end

#_reduce_337(val, _values, result) ⇒ Object



10153
10154
10155
10156
10157
10158
10159
10160
# File 'lib/parser/ruby33.rb', line 10153

def _reduce_337(val, _values, result)
                      else_t, else_ = val[4]
                      result = @builder.condition(val[0], val[1], val[2],
                                                  else_,  else_t,
                                                  val[3], val[5])

    result
end

#_reduce_338(val, _values, result) ⇒ Object



10162
10163
10164
10165
10166
# File 'lib/parser/ruby33.rb', line 10162

def _reduce_338(val, _values, result)
                      result = @builder.loop(:while, val[0], *val[1], val[2], val[3])

    result
end

#_reduce_339(val, _values, result) ⇒ Object



10168
10169
10170
10171
10172
# File 'lib/parser/ruby33.rb', line 10168

def _reduce_339(val, _values, result)
                      result = @builder.loop(:until, val[0], *val[1], val[2], val[3])

    result
end

#_reduce_34(val, _values, result) ⇒ Object



8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
# File 'lib/parser/ruby33.rb', line 8583

def _reduce_34(val, _values, result)
                      rescue_body = @builder.rescue_body(val[3],
                                                         nil, nil, nil,
                                                         nil, val[4])
                      begin_body = @builder.begin_body(val[2], [ rescue_body ])

                      result = @builder.multi_assign(val[0], val[1], begin_body)

    result
end

#_reduce_340(val, _values, result) ⇒ Object



10174
10175
10176
10177
10178
10179
10180
10181
10182
# File 'lib/parser/ruby33.rb', line 10174

def _reduce_340(val, _values, result)
                      *when_bodies, (else_t, else_body) = *val[3]

                      result = @builder.case(val[0], val[1],
                                             when_bodies, else_t, else_body,
                                             val[4])

    result
end

#_reduce_341(val, _values, result) ⇒ Object



10184
10185
10186
10187
10188
10189
10190
10191
10192
# File 'lib/parser/ruby33.rb', line 10184

def _reduce_341(val, _values, result)
                      *when_bodies, (else_t, else_body) = *val[2]

                      result = @builder.case(val[0], nil,
                                             when_bodies, else_t, else_body,
                                             val[3])

    result
end

#_reduce_342(val, _values, result) ⇒ Object



10194
10195
10196
10197
10198
10199
10200
10201
10202
# File 'lib/parser/ruby33.rb', line 10194

def _reduce_342(val, _values, result)
                      *in_bodies, (else_t, else_body) = *val[3]

                      result = @builder.case_match(val[0], val[1],
                                             in_bodies, else_t, else_body,
                                             val[4])

    result
end

#_reduce_343(val, _values, result) ⇒ Object



10204
10205
10206
10207
10208
# File 'lib/parser/ruby33.rb', line 10204

def _reduce_343(val, _values, result)
                      result = @builder.for(val[0], val[1], val[2], *val[3], val[4], val[5])

    result
end

#_reduce_344(val, _values, result) ⇒ Object



10210
10211
10212
10213
10214
10215
# File 'lib/parser/ruby33.rb', line 10210

def _reduce_344(val, _values, result)
                      @context.in_class = true
                      local_push

    result
end

#_reduce_345(val, _values, result) ⇒ Object



10217
10218
10219
10220
10221
10222
10223
10224
10225
10226
10227
10228
10229
10230
10231
# File 'lib/parser/ruby33.rb', line 10217

def _reduce_345(val, _values, result)
                      k_class, ctx = val[0]
                      if @context.in_def
                        diagnostic :error, :class_in_def, nil, k_class
                      end
                      lt_t, superclass = val[2]
                      result = @builder.def_class(k_class, val[1],
                                                  lt_t, superclass,
                                                  val[4], val[5])

                      local_pop
                      @context.in_class = ctx.in_class

    result
end

#_reduce_346(val, _values, result) ⇒ Object



10233
10234
10235
10236
10237
10238
10239
# File 'lib/parser/ruby33.rb', line 10233

def _reduce_346(val, _values, result)
                      @context.in_def = false
                      @context.in_class = false
                      local_push

    result
end

#_reduce_347(val, _values, result) ⇒ Object



10241
10242
10243
10244
10245
10246
10247
10248
10249
10250
10251
# File 'lib/parser/ruby33.rb', line 10241

def _reduce_347(val, _values, result)
                      k_class, ctx = val[0]
                      result = @builder.def_sclass(k_class, val[1], val[2],
                                                   val[5], val[6])

                      local_pop
                      @context.in_def = ctx.in_def
                      @context.in_class = ctx.in_class

    result
end

#_reduce_348(val, _values, result) ⇒ Object



10253
10254
10255
10256
10257
10258
# File 'lib/parser/ruby33.rb', line 10253

def _reduce_348(val, _values, result)
                      @context.in_class = true
                      local_push

    result
end

#_reduce_349(val, _values, result) ⇒ Object



10260
10261
10262
10263
10264
10265
10266
10267
10268
10269
10270
10271
10272
# File 'lib/parser/ruby33.rb', line 10260

def _reduce_349(val, _values, result)
                      k_mod, ctx = val[0]
                      if @context.in_def
                        diagnostic :error, :module_in_def, nil, k_mod
                      end
                      result = @builder.def_module(k_mod, val[1],
                                                   val[3], val[4])

                      local_pop
                      @context.in_class = ctx.in_class

    result
end

#_reduce_35(val, _values, result) ⇒ Object



8594
8595
8596
8597
8598
# File 'lib/parser/ruby33.rb', line 8594

def _reduce_35(val, _values, result)
                      result = @builder.multi_assign(val[0], val[1], val[2])

    result
end

#_reduce_350(val, _values, result) ⇒ Object



10274
10275
10276
10277
10278
10279
10280
10281
10282
10283
10284
# File 'lib/parser/ruby33.rb', line 10274

def _reduce_350(val, _values, result)
                      def_t, (name_t, ctx) = val[0]
                      result = @builder.def_method(def_t, name_t, val[1],
                                  val[2], val[3])

                      local_pop
                      @current_arg_stack.pop
                      @context.in_def = ctx.in_def

    result
end

#_reduce_351(val, _values, result) ⇒ Object



10286
10287
10288
10289
10290
10291
10292
10293
10294
10295
10296
# File 'lib/parser/ruby33.rb', line 10286

def _reduce_351(val, _values, result)
                      def_t, recv, dot_t, (name_t, ctx) = val[0]
                      result = @builder.def_singleton(def_t, recv, dot_t, name_t, val[1],
                                  val[2], val[3])

                      local_pop
                      @current_arg_stack.pop
                      @context.in_def = ctx.in_def

    result
end

#_reduce_352(val, _values, result) ⇒ Object



10298
10299
10300
10301
10302
# File 'lib/parser/ruby33.rb', line 10298

def _reduce_352(val, _values, result)
                      result = @builder.keyword_cmd(:break, val[0])

    result
end

#_reduce_353(val, _values, result) ⇒ Object



10304
10305
10306
10307
10308
# File 'lib/parser/ruby33.rb', line 10304

def _reduce_353(val, _values, result)
                      result = @builder.keyword_cmd(:next, val[0])

    result
end

#_reduce_354(val, _values, result) ⇒ Object



10310
10311
10312
10313
10314
# File 'lib/parser/ruby33.rb', line 10310

def _reduce_354(val, _values, result)
                      result = @builder.keyword_cmd(:redo, val[0])

    result
end

#_reduce_355(val, _values, result) ⇒ Object



10316
10317
10318
10319
10320
# File 'lib/parser/ruby33.rb', line 10316

def _reduce_355(val, _values, result)
                      result = @builder.keyword_cmd(:retry, val[0])

    result
end

#_reduce_357(val, _values, result) ⇒ Object

reduce 356 omitted



10324
10325
10326
10327
10328
# File 'lib/parser/ruby33.rb', line 10324

def _reduce_357(val, _values, result)
                      result = [ val[0], @context.dup ]

    result
end

#_reduce_358(val, _values, result) ⇒ Object



10330
10331
10332
10333
10334
# File 'lib/parser/ruby33.rb', line 10330

def _reduce_358(val, _values, result)
                      result = [ val[0], @context.dup ]

    result
end

#_reduce_359(val, _values, result) ⇒ Object



10336
10337
10338
10339
10340
10341
# File 'lib/parser/ruby33.rb', line 10336

def _reduce_359(val, _values, result)
                      result = val[0]
                      @context.in_argdef = true

    result
end

#_reduce_360(val, _values, result) ⇒ Object



10343
10344
10345
10346
10347
10348
10349
# File 'lib/parser/ruby33.rb', line 10343

def _reduce_360(val, _values, result)
                      if @context.in_class && !@context.in_def && !(context.in_block || context.in_lambda)
                        diagnostic :error, :invalid_return, nil, val[0]
                      end

    result
end

#_reduce_363(val, _values, result) ⇒ Object

reduce 362 omitted



10355
10356
10357
10358
10359
# File 'lib/parser/ruby33.rb', line 10355

def _reduce_363(val, _values, result)
                      result = val[1]

    result
end

#_reduce_367(val, _values, result) ⇒ Object

reduce 366 omitted



10367
10368
10369
10370
10371
10372
10373
10374
10375
10376
# File 'lib/parser/ruby33.rb', line 10367

def _reduce_367(val, _values, result)
                      else_t, else_ = val[4]
                      result = [ val[0],
                                 @builder.condition(val[0], val[1], val[2],
                                                    val[3], else_t,
                                                    else_,  nil),
                               ]

    result
end

#_reduce_369(val, _values, result) ⇒ Object

reduce 368 omitted



10380
10381
10382
10383
10384
# File 'lib/parser/ruby33.rb', line 10380

def _reduce_369(val, _values, result)
                      result = val

    result
end

#_reduce_37(val, _values, result) ⇒ Object

reduce 36 omitted



8602
8603
8604
8605
8606
# File 'lib/parser/ruby33.rb', line 8602

def _reduce_37(val, _values, result)
                      result = @builder.assign(val[0], val[1], val[2])

    result
end

#_reduce_372(val, _values, result) ⇒ Object

reduce 371 omitted



10390
10391
10392
10393
10394
# File 'lib/parser/ruby33.rb', line 10390

def _reduce_372(val, _values, result)
                      result = @builder.arg(val[0])

    result
end

#_reduce_373(val, _values, result) ⇒ Object



10396
10397
10398
10399
10400
# File 'lib/parser/ruby33.rb', line 10396

def _reduce_373(val, _values, result)
                      result = @builder.multi_lhs(val[0], val[1], val[2])

    result
end

#_reduce_374(val, _values, result) ⇒ Object



10402
10403
10404
10405
10406
# File 'lib/parser/ruby33.rb', line 10402

def _reduce_374(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_375(val, _values, result) ⇒ Object



10408
10409
10410
10411
10412
# File 'lib/parser/ruby33.rb', line 10408

def _reduce_375(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_377(val, _values, result) ⇒ Object

reduce 376 omitted



10416
10417
10418
10419
10420
10421
# File 'lib/parser/ruby33.rb', line 10416

def _reduce_377(val, _values, result)
                      result = val[0].
                                  push(val[2])

    result
end

#_reduce_378(val, _values, result) ⇒ Object



10423
10424
10425
10426
10427
10428
10429
# File 'lib/parser/ruby33.rb', line 10423

def _reduce_378(val, _values, result)
                      result = val[0].
                                  push(val[2]).
                                  concat(val[4])

    result
end

#_reduce_379(val, _values, result) ⇒ Object



10431
10432
10433
10434
10435
# File 'lib/parser/ruby33.rb', line 10431

def _reduce_379(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_38(val, _values, result) ⇒ Object



8608
8609
8610
8611
8612
# File 'lib/parser/ruby33.rb', line 8608

def _reduce_38(val, _values, result)
                      result = @builder.op_assign(val[0], val[1], val[2])

    result
end

#_reduce_380(val, _values, result) ⇒ Object



10437
10438
10439
10440
10441
# File 'lib/parser/ruby33.rb', line 10437

def _reduce_380(val, _values, result)
                      result = [ val[0], *val[2] ]

    result
end

#_reduce_381(val, _values, result) ⇒ Object



10443
10444
10445
10446
10447
# File 'lib/parser/ruby33.rb', line 10443

def _reduce_381(val, _values, result)
                      result = @builder.restarg(val[0], val[1])

    result
end

#_reduce_382(val, _values, result) ⇒ Object



10449
10450
10451
10452
10453
# File 'lib/parser/ruby33.rb', line 10449

def _reduce_382(val, _values, result)
                      result = @builder.restarg(val[0])

    result
end

#_reduce_385(val, _values, result) ⇒ Object

reduce 384 omitted



10459
10460
10461
10462
10463
# File 'lib/parser/ruby33.rb', line 10459

def _reduce_385(val, _values, result)
                      @context.in_argdef = false

    result
end

#_reduce_386(val, _values, result) ⇒ Object



10465
10466
10467
10468
10469
# File 'lib/parser/ruby33.rb', line 10465

def _reduce_386(val, _values, result)
                      result = val[1]

    result
end

#_reduce_387(val, _values, result) ⇒ Object



10471
10472
10473
10474
10475
# File 'lib/parser/ruby33.rb', line 10471

def _reduce_387(val, _values, result)
                      result = val[0].concat(val[2]).concat(val[3])

    result
end

#_reduce_388(val, _values, result) ⇒ Object



10477
10478
10479
10480
10481
# File 'lib/parser/ruby33.rb', line 10477

def _reduce_388(val, _values, result)
                      result = val[0].concat(val[1])

    result
end

#_reduce_389(val, _values, result) ⇒ Object



10483
10484
10485
10486
10487
# File 'lib/parser/ruby33.rb', line 10483

def _reduce_389(val, _values, result)
                      result = val[0].concat(val[1])

    result
end

#_reduce_39(val, _values, result) ⇒ Object



8614
8615
8616
8617
8618
8619
8620
8621
# File 'lib/parser/ruby33.rb', line 8614

def _reduce_39(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.index(
                                    val[0], val[1], val[2], val[3]),
                                  val[4], val[5])

    result
end

#_reduce_390(val, _values, result) ⇒ Object



10489
10490
10491
10492
10493
# File 'lib/parser/ruby33.rb', line 10489

def _reduce_390(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_391(val, _values, result) ⇒ Object



10495
10496
10497
10498
10499
# File 'lib/parser/ruby33.rb', line 10495

def _reduce_391(val, _values, result)
                      result = val[1]

    result
end

#_reduce_392(val, _values, result) ⇒ Object



10501
10502
10503
10504
10505
# File 'lib/parser/ruby33.rb', line 10501

def _reduce_392(val, _values, result)
                      result = []

    result
end

#_reduce_394(val, _values, result) ⇒ Object

reduce 393 omitted



10509
10510
10511
10512
10513
10514
10515
10516
# File 'lib/parser/ruby33.rb', line 10509

def _reduce_394(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[4]).
                                  concat(val[5])

    result
end

#_reduce_395(val, _values, result) ⇒ Object



10518
10519
10520
10521
10522
10523
10524
10525
10526
# File 'lib/parser/ruby33.rb', line 10518

def _reduce_395(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[4]).
                                  concat(val[6]).
                                  concat(val[7])

    result
end

#_reduce_396(val, _values, result) ⇒ Object



10528
10529
10530
10531
10532
10533
10534
# File 'lib/parser/ruby33.rb', line 10528

def _reduce_396(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[3])

    result
end

#_reduce_397(val, _values, result) ⇒ Object



10536
10537
10538
10539
10540
10541
10542
10543
# File 'lib/parser/ruby33.rb', line 10536

def _reduce_397(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[4]).
                                  concat(val[5])

    result
end

#_reduce_398(val, _values, result) ⇒ Object



10545
10546
10547
10548
10549
10550
10551
# File 'lib/parser/ruby33.rb', line 10545

def _reduce_398(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[3])

    result
end

#_reduce_4(val, _values, result) ⇒ Object



8393
8394
8395
8396
8397
# File 'lib/parser/ruby33.rb', line 8393

def _reduce_4(val, _values, result)
                      result = []

    result
end

#_reduce_40(val, _values, result) ⇒ Object



8623
8624
8625
8626
8627
8628
8629
8630
# File 'lib/parser/ruby33.rb', line 8623

def _reduce_40(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.call_method(
                                    val[0], val[1], val[2]),
                                  val[3], val[4])

    result
end

#_reduce_400(val, _values, result) ⇒ Object

reduce 399 omitted



10555
10556
10557
10558
10559
10560
10561
10562
# File 'lib/parser/ruby33.rb', line 10555

def _reduce_400(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[4]).
                                  concat(val[5])

    result
end

#_reduce_401(val, _values, result) ⇒ Object



10564
10565
10566
10567
10568
10569
10570
10571
10572
# File 'lib/parser/ruby33.rb', line 10564

def _reduce_401(val, _values, result)
                      if val[1].empty? && val[0].size == 1
                        result = [@builder.procarg0(val[0][0])]
                      else
                        result = val[0].concat(val[1])
                      end

    result
end

#_reduce_402(val, _values, result) ⇒ Object



10574
10575
10576
10577
10578
10579
10580
# File 'lib/parser/ruby33.rb', line 10574

def _reduce_402(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[3])

    result
end

#_reduce_403(val, _values, result) ⇒ Object



10582
10583
10584
10585
10586
10587
10588
10589
# File 'lib/parser/ruby33.rb', line 10582

def _reduce_403(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[4]).
                                  concat(val[5])

    result
end

#_reduce_404(val, _values, result) ⇒ Object



10591
10592
10593
10594
10595
10596
# File 'lib/parser/ruby33.rb', line 10591

def _reduce_404(val, _values, result)
                      result = val[0].
                                  concat(val[1])

    result
end

#_reduce_405(val, _values, result) ⇒ Object



10598
10599
10600
10601
10602
10603
10604
# File 'lib/parser/ruby33.rb', line 10598

def _reduce_405(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[3])

    result
end

#_reduce_406(val, _values, result) ⇒ Object



10606
10607
10608
10609
10610
10611
# File 'lib/parser/ruby33.rb', line 10606

def _reduce_406(val, _values, result)
                      result = val[0].
                                  concat(val[1])

    result
end

#_reduce_407(val, _values, result) ⇒ Object



10613
10614
10615
10616
10617
10618
10619
# File 'lib/parser/ruby33.rb', line 10613

def _reduce_407(val, _values, result)
                      result = val[0].
                                  concat(val[2]).
                                  concat(val[3])

    result
end

#_reduce_409(val, _values, result) ⇒ Object

reduce 408 omitted



10623
10624
10625
10626
10627
# File 'lib/parser/ruby33.rb', line 10623

def _reduce_409(val, _values, result)
                      result = @builder.args(nil, [], nil)

    result
end

#_reduce_41(val, _values, result) ⇒ Object



8632
8633
8634
8635
8636
8637
8638
8639
# File 'lib/parser/ruby33.rb', line 8632

def _reduce_41(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.call_method(
                                    val[0], val[1], val[2]),
                                  val[3], val[4])

    result
end

#_reduce_410(val, _values, result) ⇒ Object



10629
10630
10631
10632
10633
# File 'lib/parser/ruby33.rb', line 10629

def _reduce_410(val, _values, result)
                      @lexer.state = :expr_value

    result
end

#_reduce_411(val, _values, result) ⇒ Object



10635
10636
10637
10638
10639
10640
10641
10642
# File 'lib/parser/ruby33.rb', line 10635

def _reduce_411(val, _values, result)
                      @max_numparam_stack.has_ordinary_params!
                      @current_arg_stack.set(nil)
                      @context.in_argdef = false
                      result = @builder.args(val[0], val[1], val[2])

    result
end

#_reduce_412(val, _values, result) ⇒ Object



10644
10645
10646
10647
10648
10649
10650
10651
# File 'lib/parser/ruby33.rb', line 10644

def _reduce_412(val, _values, result)
                      @max_numparam_stack.has_ordinary_params!
                      @current_arg_stack.set(nil)
                      @context.in_argdef = false
                      result = @builder.args(val[0], val[1].concat(val[2]), val[3])

    result
end

#_reduce_413(val, _values, result) ⇒ Object



10653
10654
10655
10656
10657
# File 'lib/parser/ruby33.rb', line 10653

def _reduce_413(val, _values, result)
                      result = []

    result
end

#_reduce_414(val, _values, result) ⇒ Object



10659
10660
10661
10662
10663
# File 'lib/parser/ruby33.rb', line 10659

def _reduce_414(val, _values, result)
                      result = val[2]

    result
end

#_reduce_415(val, _values, result) ⇒ Object



10665
10666
10667
10668
10669
# File 'lib/parser/ruby33.rb', line 10665

def _reduce_415(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_416(val, _values, result) ⇒ Object



10671
10672
10673
10674
10675
# File 'lib/parser/ruby33.rb', line 10671

def _reduce_416(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_417(val, _values, result) ⇒ Object



10677
10678
10679
10680
10681
10682
# File 'lib/parser/ruby33.rb', line 10677

def _reduce_417(val, _values, result)
                      @static_env.declare val[0][0]
                      result = @builder.shadowarg(val[0])

    result
end

#_reduce_419(val, _values, result) ⇒ Object

reduce 418 omitted



10686
10687
10688
10689
10690
10691
10692
10693
# File 'lib/parser/ruby33.rb', line 10686

def _reduce_419(val, _values, result)
                      @static_env.extend_dynamic
                      @max_numparam_stack.push(static: false)
                      result = @context.dup
                      @context.in_lambda = true

    result
end

#_reduce_42(val, _values, result) ⇒ Object



8641
8642
8643
8644
8645
8646
8647
# File 'lib/parser/ruby33.rb', line 8641

def _reduce_42(val, _values, result)
                      const  = @builder.const_op_assignable(
                                  @builder.const_fetch(val[0], val[1], val[2]))
                      result = @builder.op_assign(const, val[3], val[4])

    result
end

#_reduce_420(val, _values, result) ⇒ Object



10695
10696
10697
10698
10699
# File 'lib/parser/ruby33.rb', line 10695

def _reduce_420(val, _values, result)
                      @lexer.cmdarg.push(false)

    result
end

#_reduce_421(val, _values, result) ⇒ Object



10701
10702
10703
10704
10705
10706
10707
10708
10709
10710
10711
10712
10713
10714
10715
# File 'lib/parser/ruby33.rb', line 10701

def _reduce_421(val, _values, result)
                      lambda_call = @builder.call_lambda(val[0])
                      args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[2]
                      begin_t, body, end_t = val[4]

                      @max_numparam_stack.pop
                      @static_env.unextend
                      @lexer.cmdarg.pop
                      @context.in_lambda = val[1].in_lambda

                      result      = @builder.block(lambda_call,
                                      begin_t, args, body, end_t)

    result
end

#_reduce_422(val, _values, result) ⇒ Object



10717
10718
10719
10720
10721
10722
10723
# File 'lib/parser/ruby33.rb', line 10717

def _reduce_422(val, _values, result)
                      @context.in_argdef = false
                      @max_numparam_stack.has_ordinary_params!
                      result = @builder.args(val[0], val[1].concat(val[2]), val[3])

    result
end

#_reduce_423(val, _values, result) ⇒ Object



10725
10726
10727
10728
10729
10730
10731
10732
10733
# File 'lib/parser/ruby33.rb', line 10725

def _reduce_423(val, _values, result)
                      @context.in_argdef = false
                      if val[0].any?
                        @max_numparam_stack.has_ordinary_params!
                      end
                      result = @builder.args(nil, val[0], nil)

    result
end

#_reduce_424(val, _values, result) ⇒ Object



10735
10736
10737
10738
10739
10740
# File 'lib/parser/ruby33.rb', line 10735

def _reduce_424(val, _values, result)
                      result = @context.dup
                      @context.in_lambda = true

    result
end

#_reduce_425(val, _values, result) ⇒ Object



10742
10743
10744
10745
10746
10747
# File 'lib/parser/ruby33.rb', line 10742

def _reduce_425(val, _values, result)
                      @context.in_lambda = val[1].in_lambda
                      result = [ val[0], val[2], val[3] ]

    result
end

#_reduce_426(val, _values, result) ⇒ Object



10749
10750
10751
10752
10753
10754
# File 'lib/parser/ruby33.rb', line 10749

def _reduce_426(val, _values, result)
                      result = @context.dup
                      @context.in_lambda = true

    result
end

#_reduce_427(val, _values, result) ⇒ Object



10756
10757
10758
10759
10760
10761
# File 'lib/parser/ruby33.rb', line 10756

def _reduce_427(val, _values, result)
                      @context.in_lambda = val[1].in_lambda
                      result = [ val[0], val[2], val[3] ]

    result
end

#_reduce_428(val, _values, result) ⇒ Object



10763
10764
10765
10766
10767
10768
# File 'lib/parser/ruby33.rb', line 10763

def _reduce_428(val, _values, result)
                      result = @context.dup
                      @context.in_block = true

    result
end

#_reduce_429(val, _values, result) ⇒ Object



10770
10771
10772
10773
10774
10775
# File 'lib/parser/ruby33.rb', line 10770

def _reduce_429(val, _values, result)
                      @context.in_block = val[1].in_block
                      result = [ val[0], *val[2], val[3] ]

    result
end

#_reduce_43(val, _values, result) ⇒ Object



8649
8650
8651
8652
8653
8654
8655
8656
# File 'lib/parser/ruby33.rb', line 8649

def _reduce_43(val, _values, result)
                      result = @builder.op_assign(
                                  @builder.call_method(
                                    val[0], val[1], val[2]),
                                  val[3], val[4])

    result
end

#_reduce_430(val, _values, result) ⇒ Object



10777
10778
10779
10780
10781
10782
10783
# File 'lib/parser/ruby33.rb', line 10777

def _reduce_430(val, _values, result)
                      begin_t, block_args, body, end_t = val[1]
                      result      = @builder.block(val[0],
                                      begin_t, block_args, body, end_t)

    result
end

#_reduce_431(val, _values, result) ⇒ Object



10785
10786
10787
10788
10789
10790
10791
# File 'lib/parser/ruby33.rb', line 10785

def _reduce_431(val, _values, result)
                      lparen_t, args, rparen_t = val[3]
                      result = @builder.call_method(val[0], val[1], val[2],
                                  lparen_t, args, rparen_t)

    result
end

#_reduce_432(val, _values, result) ⇒ Object



10793
10794
10795
10796
10797
10798
10799
10800
10801
10802
10803
# File 'lib/parser/ruby33.rb', line 10793

def _reduce_432(val, _values, result)
                      lparen_t, args, rparen_t = val[3]
                      method_call = @builder.call_method(val[0], val[1], val[2],
                                      lparen_t, args, rparen_t)

                      begin_t, args, body, end_t = val[4]
                      result      = @builder.block(method_call,
                                      begin_t, args, body, end_t)

    result
end

#_reduce_433(val, _values, result) ⇒ Object



10805
10806
10807
10808
10809
10810
10811
10812
10813
10814
# File 'lib/parser/ruby33.rb', line 10805

def _reduce_433(val, _values, result)
                      method_call = @builder.call_method(val[0], val[1], val[2],
                                      nil, val[3], nil)

                      begin_t, args, body, end_t = val[4]
                      result      = @builder.block(method_call,
                                      begin_t, args, body, end_t)

    result
end

#_reduce_434(val, _values, result) ⇒ Object



10816
10817
10818
10819
10820
10821
10822
# File 'lib/parser/ruby33.rb', line 10816

def _reduce_434(val, _values, result)
                      lparen_t, args, rparen_t = val[1]
                      result = @builder.call_method(nil, nil, val[0],
                                  lparen_t, args, rparen_t)

    result
end

#_reduce_435(val, _values, result) ⇒ Object



10824
10825
10826
10827
10828
10829
10830
# File 'lib/parser/ruby33.rb', line 10824

def _reduce_435(val, _values, result)
                      lparen_t, args, rparen_t = val[3]
                      result = @builder.call_method(val[0], val[1], val[2],
                                  lparen_t, args, rparen_t)

    result
end

#_reduce_436(val, _values, result) ⇒ Object



10832
10833
10834
10835
10836
10837
10838
# File 'lib/parser/ruby33.rb', line 10832

def _reduce_436(val, _values, result)
                      lparen_t, args, rparen_t = val[3]
                      result = @builder.call_method(val[0], val[1], val[2],
                                  lparen_t, args, rparen_t)

    result
end

#_reduce_437(val, _values, result) ⇒ Object



10840
10841
10842
10843
10844
# File 'lib/parser/ruby33.rb', line 10840

def _reduce_437(val, _values, result)
                      result = @builder.call_method(val[0], val[1], val[2])

    result
end

#_reduce_438(val, _values, result) ⇒ Object



10846
10847
10848
10849
10850
10851
10852
# File 'lib/parser/ruby33.rb', line 10846

def _reduce_438(val, _values, result)
                      lparen_t, args, rparen_t = val[2]
                      result = @builder.call_method(val[0], val[1], nil,
                                  lparen_t, args, rparen_t)

    result
end

#_reduce_439(val, _values, result) ⇒ Object



10854
10855
10856
10857
10858
10859
10860
# File 'lib/parser/ruby33.rb', line 10854

def _reduce_439(val, _values, result)
                      lparen_t, args, rparen_t = val[2]
                      result = @builder.call_method(val[0], val[1], nil,
                                  lparen_t, args, rparen_t)

    result
end

#_reduce_44(val, _values, result) ⇒ Object



8658
8659
8660
8661
8662
8663
8664
8665
8666
8667
8668
8669
8670
# File 'lib/parser/ruby33.rb', line 8658

def _reduce_44(val, _values, result)
                      def_t, (name_t, ctx) = val[0]
                      endless_method_name(name_t)

                      result = @builder.def_endless_method(def_t, name_t,
                                 val[1], val[2], val[3])

                      local_pop
                      @current_arg_stack.pop
                      @context.in_def = ctx.in_def

    result
end

#_reduce_440(val, _values, result) ⇒ Object



10862
10863
10864
10865
10866
10867
10868
# File 'lib/parser/ruby33.rb', line 10862

def _reduce_440(val, _values, result)
                      lparen_t, args, rparen_t = val[1]
                      result = @builder.keyword_cmd(:super, val[0],
                                  lparen_t, args, rparen_t)

    result
end

#_reduce_441(val, _values, result) ⇒ Object



10870
10871
10872
10873
10874
# File 'lib/parser/ruby33.rb', line 10870

def _reduce_441(val, _values, result)
                      result = @builder.keyword_cmd(:zsuper, val[0])

    result
end

#_reduce_442(val, _values, result) ⇒ Object



10876
10877
10878
10879
10880
# File 'lib/parser/ruby33.rb', line 10876

def _reduce_442(val, _values, result)
                      result = @builder.index(val[0], val[1], val[2], val[3])

    result
end

#_reduce_443(val, _values, result) ⇒ Object



10882
10883
10884
10885
10886
10887
# File 'lib/parser/ruby33.rb', line 10882

def _reduce_443(val, _values, result)
                      result = @context.dup
                      @context.in_block = true

    result
end

#_reduce_444(val, _values, result) ⇒ Object



10889
10890
10891
10892
10893
10894
# File 'lib/parser/ruby33.rb', line 10889

def _reduce_444(val, _values, result)
                      @context.in_block = val[1].in_block
                      result = [ val[0], *val[2], val[3] ]

    result
end

#_reduce_445(val, _values, result) ⇒ Object



10896
10897
10898
10899
10900
10901
# File 'lib/parser/ruby33.rb', line 10896

def _reduce_445(val, _values, result)
                      result = @context.dup
                      @context.in_block = true

    result
end

#_reduce_446(val, _values, result) ⇒ Object



10903
10904
10905
10906
10907
10908
# File 'lib/parser/ruby33.rb', line 10903

def _reduce_446(val, _values, result)
                      @context.in_block = val[1].in_block
                      result = [ val[0], *val[2], val[3] ]

    result
end

#_reduce_447(val, _values, result) ⇒ Object



10910
10911
10912
10913
10914
10915
# File 'lib/parser/ruby33.rb', line 10910

def _reduce_447(val, _values, result)
                      @static_env.extend_dynamic
                      @max_numparam_stack.push(static: false)

    result
end

#_reduce_448(val, _values, result) ⇒ Object



10917
10918
10919
10920
10921
10922
10923
10924
10925
# File 'lib/parser/ruby33.rb', line 10917

def _reduce_448(val, _values, result)
                      args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[1]
                      result = [ args, val[2] ]

                      @max_numparam_stack.pop
                      @static_env.unextend

    result
end

#_reduce_449(val, _values, result) ⇒ Object



10927
10928
10929
10930
10931
10932
# File 'lib/parser/ruby33.rb', line 10927

def _reduce_449(val, _values, result)
                      @static_env.extend_dynamic
                      @max_numparam_stack.push(static: false)

    result
end

#_reduce_45(val, _values, result) ⇒ Object



8672
8673
8674
8675
8676
8677
8678
8679
8680
8681
8682
8683
8684
# File 'lib/parser/ruby33.rb', line 8672

def _reduce_45(val, _values, result)
                      def_t, recv, dot_t, (name_t, ctx) = val[0]
                      endless_method_name(name_t)

                      result = @builder.def_endless_singleton(def_t, recv, dot_t, name_t,
                                 val[1], val[2], val[3])

                      local_pop
                      @current_arg_stack.pop
                      @context.in_def = ctx.in_def

    result
end

#_reduce_450(val, _values, result) ⇒ Object



10934
10935
10936
10937
10938
# File 'lib/parser/ruby33.rb', line 10934

def _reduce_450(val, _values, result)
                      @lexer.cmdarg.push(false)

    result
end

#_reduce_451(val, _values, result) ⇒ Object



10940
10941
10942
10943
10944
10945
10946
10947
10948
10949
# File 'lib/parser/ruby33.rb', line 10940

def _reduce_451(val, _values, result)
                      args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[2]
                      result = [ args, val[3] ]

                      @max_numparam_stack.pop
                      @static_env.unextend
                      @lexer.cmdarg.pop

    result
end

#_reduce_452(val, _values, result) ⇒ Object



10951
10952
10953
10954
10955
10956
# File 'lib/parser/ruby33.rb', line 10951

def _reduce_452(val, _values, result)
                      result = [ @builder.when(val[0], val[1], val[2], val[3]),
                                 *val[4] ]

    result
end

#_reduce_453(val, _values, result) ⇒ Object



10958
10959
10960
10961
10962
# File 'lib/parser/ruby33.rb', line 10958

def _reduce_453(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_455(val, _values, result) ⇒ Object

reduce 454 omitted



10966
10967
10968
10969
10970
# File 'lib/parser/ruby33.rb', line 10966

def _reduce_455(val, _values, result)
                      @pattern_variables.push

    result
end

#_reduce_456(val, _values, result) ⇒ Object



10972
10973
10974
10975
10976
# File 'lib/parser/ruby33.rb', line 10972

def _reduce_456(val, _values, result)
                      @pattern_hash_keys.push

    result
end

#_reduce_457(val, _values, result) ⇒ Object



10978
10979
10980
10981
10982
10983
10984
10985
10986
# File 'lib/parser/ruby33.rb', line 10978

def _reduce_457(val, _values, result)
                      result = @context.in_kwarg

                      @lexer.state = :expr_beg
                      @lexer.command_start = false
                      @context.in_kwarg = true

    result
end

#_reduce_458(val, _values, result) ⇒ Object



10988
10989
10990
10991
10992
10993
10994
# File 'lib/parser/ruby33.rb', line 10988

def _reduce_458(val, _values, result)
                      @pattern_variables.pop
                      @pattern_hash_keys.pop
                      @context.in_kwarg = val[1]

    result
end

#_reduce_459(val, _values, result) ⇒ Object



10996
10997
10998
10999
11000
11001
# File 'lib/parser/ruby33.rb', line 10996

def _reduce_459(val, _values, result)
                      result = [ @builder.in_pattern(val[0], *val[4], val[5], val[7]),
                                 *val[8] ]

    result
end

#_reduce_46(val, _values, result) ⇒ Object



8686
8687
8688
8689
8690
# File 'lib/parser/ruby33.rb', line 8686

def _reduce_46(val, _values, result)
                      @builder.op_assign(val[0], val[1], val[2])

    result
end

#_reduce_460(val, _values, result) ⇒ Object



11003
11004
11005
11006
11007
# File 'lib/parser/ruby33.rb', line 11003

def _reduce_460(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_462(val, _values, result) ⇒ Object

reduce 461 omitted



11011
11012
11013
11014
11015
# File 'lib/parser/ruby33.rb', line 11011

def _reduce_462(val, _values, result)
                      result = [ val[0], nil ]

    result
end

#_reduce_463(val, _values, result) ⇒ Object



11017
11018
11019
11020
11021
# File 'lib/parser/ruby33.rb', line 11017

def _reduce_463(val, _values, result)
                      result = [ val[0], @builder.if_guard(val[1], val[2]) ]

    result
end

#_reduce_464(val, _values, result) ⇒ Object



11023
11024
11025
11026
11027
# File 'lib/parser/ruby33.rb', line 11023

def _reduce_464(val, _values, result)
                      result = [ val[0], @builder.unless_guard(val[1], val[2]) ]

    result
end

#_reduce_466(val, _values, result) ⇒ Object

reduce 465 omitted



11031
11032
11033
11034
11035
11036
11037
11038
11039
# File 'lib/parser/ruby33.rb', line 11031

def _reduce_466(val, _values, result)
                      # array patterns that end with comma
                      # like 1, 2,
                      # must be emitted as `array_pattern_with_tail`
                      item = @builder.match_with_trailing_comma(val[0], val[1])
                      result = @builder.array_pattern(nil, [ item ], nil)

    result
end

#_reduce_467(val, _values, result) ⇒ Object



11041
11042
11043
11044
11045
# File 'lib/parser/ruby33.rb', line 11041

def _reduce_467(val, _values, result)
                      result = @builder.array_pattern(nil, [val[0]].concat(val[2]), nil)

    result
end

#_reduce_468(val, _values, result) ⇒ Object



11047
11048
11049
11050
11051
# File 'lib/parser/ruby33.rb', line 11047

def _reduce_468(val, _values, result)
                      result = @builder.find_pattern(nil, val[0], nil)

    result
end

#_reduce_469(val, _values, result) ⇒ Object



11053
11054
11055
11056
11057
# File 'lib/parser/ruby33.rb', line 11053

def _reduce_469(val, _values, result)
                      result = @builder.array_pattern(nil, val[0], nil)

    result
end

#_reduce_470(val, _values, result) ⇒ Object



11059
11060
11061
11062
11063
# File 'lib/parser/ruby33.rb', line 11059

def _reduce_470(val, _values, result)
                      result = @builder.hash_pattern(nil, val[0], nil)

    result
end

#_reduce_472(val, _values, result) ⇒ Object

reduce 471 omitted



11067
11068
11069
11070
11071
# File 'lib/parser/ruby33.rb', line 11067

def _reduce_472(val, _values, result)
                      result = @builder.match_as(val[0], val[1], val[2])

    result
end

#_reduce_474(val, _values, result) ⇒ Object

reduce 473 omitted



11075
11076
11077
11078
11079
# File 'lib/parser/ruby33.rb', line 11075

def _reduce_474(val, _values, result)
                      result = @builder.match_alt(val[0], val[1], val[2])

    result
end

#_reduce_476(val, _values, result) ⇒ Object

reduce 475 omitted



11083
11084
11085
11086
11087
11088
# File 'lib/parser/ruby33.rb', line 11083

def _reduce_476(val, _values, result)
                      result = val[0]
                      @pattern_hash_keys.push

    result
end

#_reduce_477(val, _values, result) ⇒ Object



11090
11091
11092
11093
11094
11095
# File 'lib/parser/ruby33.rb', line 11090

def _reduce_477(val, _values, result)
                      result = val[0]
                      @pattern_hash_keys.push

    result
end

#_reduce_48(val, _values, result) ⇒ Object

reduce 47 omitted



8694
8695
8696
8697
8698
8699
8700
8701
8702
# File 'lib/parser/ruby33.rb', line 8694

def _reduce_48(val, _values, result)
                      rescue_body = @builder.rescue_body(val[1],
                                        nil, nil, nil,
                                        nil, val[2])

                      result = @builder.begin_body(val[0], [ rescue_body ])

    result
end

#_reduce_480(val, _values, result) ⇒ Object

reduce 479 omitted



11101
11102
11103
11104
11105
11106
11107
# File 'lib/parser/ruby33.rb', line 11101

def _reduce_480(val, _values, result)
                      @pattern_hash_keys.pop
                      pattern = @builder.array_pattern(nil, val[2], nil)
                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])

    result
end

#_reduce_481(val, _values, result) ⇒ Object



11109
11110
11111
11112
11113
11114
11115
# File 'lib/parser/ruby33.rb', line 11109

def _reduce_481(val, _values, result)
                      @pattern_hash_keys.pop
                      pattern = @builder.find_pattern(nil, val[2], nil)
                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])

    result
end

#_reduce_482(val, _values, result) ⇒ Object



11117
11118
11119
11120
11121
11122
11123
# File 'lib/parser/ruby33.rb', line 11117

def _reduce_482(val, _values, result)
                      @pattern_hash_keys.pop
                      pattern = @builder.hash_pattern(nil, val[2], nil)
                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])

    result
end

#_reduce_483(val, _values, result) ⇒ Object



11125
11126
11127
11128
11129
11130
# File 'lib/parser/ruby33.rb', line 11125

def _reduce_483(val, _values, result)
                      pattern = @builder.array_pattern(val[1], nil, val[2])
                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])

    result
end

#_reduce_484(val, _values, result) ⇒ Object



11132
11133
11134
11135
11136
11137
11138
# File 'lib/parser/ruby33.rb', line 11132

def _reduce_484(val, _values, result)
                      @pattern_hash_keys.pop
                      pattern = @builder.array_pattern(nil, val[2], nil)
                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])

    result
end

#_reduce_485(val, _values, result) ⇒ Object



11140
11141
11142
11143
11144
11145
11146
# File 'lib/parser/ruby33.rb', line 11140

def _reduce_485(val, _values, result)
                      @pattern_hash_keys.pop
                      pattern = @builder.find_pattern(nil, val[2], nil)
                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])

    result
end

#_reduce_486(val, _values, result) ⇒ Object



11148
11149
11150
11151
11152
11153
11154
# File 'lib/parser/ruby33.rb', line 11148

def _reduce_486(val, _values, result)
                      @pattern_hash_keys.pop
                      pattern = @builder.hash_pattern(nil, val[2], nil)
                      result = @builder.const_pattern(val[0], val[1], pattern, val[3])

    result
end

#_reduce_487(val, _values, result) ⇒ Object



11156
11157
11158
11159
11160
11161
# File 'lib/parser/ruby33.rb', line 11156

def _reduce_487(val, _values, result)
                      pattern = @builder.array_pattern(val[1], nil, val[2])
                      result = @builder.const_pattern(val[0], val[1], pattern, val[2])

    result
end

#_reduce_488(val, _values, result) ⇒ Object



11163
11164
11165
11166
11167
# File 'lib/parser/ruby33.rb', line 11163

def _reduce_488(val, _values, result)
                      result = @builder.array_pattern(val[0], val[1], val[2])

    result
end

#_reduce_489(val, _values, result) ⇒ Object



11169
11170
11171
11172
11173
# File 'lib/parser/ruby33.rb', line 11169

def _reduce_489(val, _values, result)
                      result = @builder.find_pattern(val[0], val[1], val[2])

    result
end

#_reduce_49(val, _values, result) ⇒ Object



8704
8705
8706
8707
8708
# File 'lib/parser/ruby33.rb', line 8704

def _reduce_49(val, _values, result)
                      result = @builder.not_op(val[0], nil, val[2], nil)

    result
end

#_reduce_490(val, _values, result) ⇒ Object



11175
11176
11177
11178
11179
# File 'lib/parser/ruby33.rb', line 11175

def _reduce_490(val, _values, result)
                      result = @builder.array_pattern(val[0], [], val[1])

    result
end

#_reduce_491(val, _values, result) ⇒ Object



11181
11182
11183
11184
11185
11186
11187
# File 'lib/parser/ruby33.rb', line 11181

def _reduce_491(val, _values, result)
                      @pattern_hash_keys.push
                      result = @context.in_kwarg
                      @context.in_kwarg = false

    result
end

#_reduce_492(val, _values, result) ⇒ Object



11189
11190
11191
11192
11193
11194
11195
# File 'lib/parser/ruby33.rb', line 11189

def _reduce_492(val, _values, result)
                      @pattern_hash_keys.pop
                      @context.in_kwarg = val[1]
                      result = @builder.hash_pattern(val[0], val[2], val[3])

    result
end

#_reduce_493(val, _values, result) ⇒ Object



11197
11198
11199
11200
11201
# File 'lib/parser/ruby33.rb', line 11197

def _reduce_493(val, _values, result)
                      result = @builder.hash_pattern(val[0], [], val[1])

    result
end

#_reduce_494(val, _values, result) ⇒ Object



11203
11204
11205
11206
11207
# File 'lib/parser/ruby33.rb', line 11203

def _reduce_494(val, _values, result)
                      @pattern_hash_keys.push

    result
end

#_reduce_495(val, _values, result) ⇒ Object



11209
11210
11211
11212
11213
11214
# File 'lib/parser/ruby33.rb', line 11209

def _reduce_495(val, _values, result)
                      @pattern_hash_keys.pop
                      result = @builder.begin(val[0], val[2], val[3])

    result
end

#_reduce_496(val, _values, result) ⇒ Object



11216
11217
11218
11219
11220
# File 'lib/parser/ruby33.rb', line 11216

def _reduce_496(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_497(val, _values, result) ⇒ Object



11222
11223
11224
11225
11226
# File 'lib/parser/ruby33.rb', line 11222

def _reduce_497(val, _values, result)
                      result = val[0]

    result
end

#_reduce_498(val, _values, result) ⇒ Object



11228
11229
11230
11231
11232
# File 'lib/parser/ruby33.rb', line 11228

def _reduce_498(val, _values, result)
                      result = [ *val[0], val[1] ]

    result
end

#_reduce_499(val, _values, result) ⇒ Object



11234
11235
11236
11237
11238
# File 'lib/parser/ruby33.rb', line 11234

def _reduce_499(val, _values, result)
                      result = [ *val[0], val[1] ]

    result
end

#_reduce_5(val, _values, result) ⇒ Object



8399
8400
8401
8402
8403
# File 'lib/parser/ruby33.rb', line 8399

def _reduce_5(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_500(val, _values, result) ⇒ Object



11240
11241
11242
11243
11244
# File 'lib/parser/ruby33.rb', line 11240

def _reduce_500(val, _values, result)
                      result = [ *val[0], val[1], *val[3] ]

    result
end

#_reduce_502(val, _values, result) ⇒ Object

reduce 501 omitted



11248
11249
11250
11251
11252
11253
11254
11255
11256
# File 'lib/parser/ruby33.rb', line 11248

def _reduce_502(val, _values, result)
                      # array patterns that end with comma
                      # like [1, 2,]
                      # must be emitted as `array_pattern_with_tail`
                      item = @builder.match_with_trailing_comma(val[0], val[1])
                      result = [ item ]

    result
end

#_reduce_503(val, _values, result) ⇒ Object



11258
11259
11260
11261
11262
11263
11264
11265
11266
# File 'lib/parser/ruby33.rb', line 11258

def _reduce_503(val, _values, result)
                      # array patterns that end with comma
                      # like [1, 2,]
                      # must be emitted as `array_pattern_with_tail`
                      last_item = @builder.match_with_trailing_comma(val[1], val[2])
                      result = [ *val[0], last_item ]

    result
end

#_reduce_504(val, _values, result) ⇒ Object



11268
11269
11270
11271
11272
# File 'lib/parser/ruby33.rb', line 11268

def _reduce_504(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_505(val, _values, result) ⇒ Object



11274
11275
11276
11277
11278
# File 'lib/parser/ruby33.rb', line 11274

def _reduce_505(val, _values, result)
                      result = [ val[0], *val[2] ]

    result
end

#_reduce_506(val, _values, result) ⇒ Object



11280
11281
11282
11283
11284
# File 'lib/parser/ruby33.rb', line 11280

def _reduce_506(val, _values, result)
                      result = [ val[0], *val[2], val[4] ]

    result
end

#_reduce_507(val, _values, result) ⇒ Object



11286
11287
11288
11289
11290
# File 'lib/parser/ruby33.rb', line 11286

def _reduce_507(val, _values, result)
                      result = @builder.match_rest(val[0], val[1])

    result
end

#_reduce_508(val, _values, result) ⇒ Object



11292
11293
11294
11295
11296
# File 'lib/parser/ruby33.rb', line 11292

def _reduce_508(val, _values, result)
                      result = @builder.match_rest(val[0])

    result
end

#_reduce_509(val, _values, result) ⇒ Object



11298
11299
11300
11301
11302
# File 'lib/parser/ruby33.rb', line 11298

def _reduce_509(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_51(val, _values, result) ⇒ Object

reduce 50 omitted



8712
8713
8714
8715
8716
8717
8718
8719
8720
# File 'lib/parser/ruby33.rb', line 8712

def _reduce_51(val, _values, result)
                      rescue_body = @builder.rescue_body(val[1],
                                        nil, nil, nil,
                                        nil, val[2])

                      result = @builder.begin_body(val[0], [ rescue_body ])

    result
end

#_reduce_510(val, _values, result) ⇒ Object



11304
11305
11306
11307
11308
# File 'lib/parser/ruby33.rb', line 11304

def _reduce_510(val, _values, result)
                      result = [ *val[0], val[2] ]

    result
end

#_reduce_512(val, _values, result) ⇒ Object

reduce 511 omitted



11312
11313
11314
11315
11316
# File 'lib/parser/ruby33.rb', line 11312

def _reduce_512(val, _values, result)
                      result = [ *val[0], *val[2] ]

    result
end

#_reduce_513(val, _values, result) ⇒ Object



11318
11319
11320
11321
11322
# File 'lib/parser/ruby33.rb', line 11318

def _reduce_513(val, _values, result)
                      result = val[0]

    result
end

#_reduce_514(val, _values, result) ⇒ Object



11324
11325
11326
11327
11328
# File 'lib/parser/ruby33.rb', line 11324

def _reduce_514(val, _values, result)
                      result = val[0]

    result
end

#_reduce_515(val, _values, result) ⇒ Object



11330
11331
11332
11333
11334
# File 'lib/parser/ruby33.rb', line 11330

def _reduce_515(val, _values, result)
                      result = val[0]

    result
end

#_reduce_516(val, _values, result) ⇒ Object



11336
11337
11338
11339
11340
# File 'lib/parser/ruby33.rb', line 11336

def _reduce_516(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_517(val, _values, result) ⇒ Object



11342
11343
11344
11345
11346
# File 'lib/parser/ruby33.rb', line 11342

def _reduce_517(val, _values, result)
                      result = [ *val[0], val[2] ]

    result
end

#_reduce_518(val, _values, result) ⇒ Object



11348
11349
11350
11351
11352
# File 'lib/parser/ruby33.rb', line 11348

def _reduce_518(val, _values, result)
                      result = @builder.match_pair(*val[0], val[1])

    result
end

#_reduce_519(val, _values, result) ⇒ Object



11354
11355
11356
11357
11358
# File 'lib/parser/ruby33.rb', line 11354

def _reduce_519(val, _values, result)
                      result = @builder.match_label(*val[0])

    result
end

#_reduce_520(val, _values, result) ⇒ Object



11360
11361
11362
11363
11364
# File 'lib/parser/ruby33.rb', line 11360

def _reduce_520(val, _values, result)
                    result = [:label, val[0]]

    result
end

#_reduce_521(val, _values, result) ⇒ Object



11366
11367
11368
11369
11370
# File 'lib/parser/ruby33.rb', line 11366

def _reduce_521(val, _values, result)
                    result = [:quoted, [val[0], val[1], val[2]]]

    result
end

#_reduce_522(val, _values, result) ⇒ Object



11372
11373
11374
11375
11376
# File 'lib/parser/ruby33.rb', line 11372

def _reduce_522(val, _values, result)
                      result = [ @builder.match_rest(val[0], val[1]) ]

    result
end

#_reduce_523(val, _values, result) ⇒ Object



11378
11379
11380
11381
11382
# File 'lib/parser/ruby33.rb', line 11378

def _reduce_523(val, _values, result)
                      result = [ @builder.match_rest(val[0], nil) ]

    result
end

#_reduce_524(val, _values, result) ⇒ Object



11384
11385
11386
11387
11388
# File 'lib/parser/ruby33.rb', line 11384

def _reduce_524(val, _values, result)
                      result = val

    result
end

#_reduce_526(val, _values, result) ⇒ Object

reduce 525 omitted



11392
11393
11394
11395
11396
# File 'lib/parser/ruby33.rb', line 11392

def _reduce_526(val, _values, result)
                      result = [ @builder.match_nil_pattern(val[0][0], val[0][1]) ]

    result
end

#_reduce_528(val, _values, result) ⇒ Object

reduce 527 omitted



11400
11401
11402
11403
11404
# File 'lib/parser/ruby33.rb', line 11400

def _reduce_528(val, _values, result)
                      result = @builder.range_inclusive(val[0], val[1], val[2])

    result
end

#_reduce_529(val, _values, result) ⇒ Object



11406
11407
11408
11409
11410
# File 'lib/parser/ruby33.rb', line 11406

def _reduce_529(val, _values, result)
                      result = @builder.range_exclusive(val[0], val[1], val[2])

    result
end

#_reduce_530(val, _values, result) ⇒ Object



11412
11413
11414
11415
11416
# File 'lib/parser/ruby33.rb', line 11412

def _reduce_530(val, _values, result)
                      result = @builder.range_inclusive(val[0], val[1], nil)

    result
end

#_reduce_531(val, _values, result) ⇒ Object



11418
11419
11420
11421
11422
# File 'lib/parser/ruby33.rb', line 11418

def _reduce_531(val, _values, result)
                      result = @builder.range_exclusive(val[0], val[1], nil)

    result
end

#_reduce_535(val, _values, result) ⇒ Object

reduce 534 omitted



11430
11431
11432
11433
11434
# File 'lib/parser/ruby33.rb', line 11430

def _reduce_535(val, _values, result)
                      result = @builder.range_inclusive(nil, val[0], val[1])

    result
end

#_reduce_536(val, _values, result) ⇒ Object



11436
11437
11438
11439
11440
# File 'lib/parser/ruby33.rb', line 11436

def _reduce_536(val, _values, result)
                      result = @builder.range_exclusive(nil, val[0], val[1])

    result
end

#_reduce_54(val, _values, result) ⇒ Object

reduce 53 omitted



8726
8727
8728
8729
8730
# File 'lib/parser/ruby33.rb', line 8726

def _reduce_54(val, _values, result)
                      result = @builder.logical_op(:and, val[0], val[1], val[2])

    result
end

#_reduce_545(val, _values, result) ⇒ Object

reduce 544 omitted



11458
11459
11460
11461
11462
# File 'lib/parser/ruby33.rb', line 11458

def _reduce_545(val, _values, result)
                      result = @builder.accessible(val[0])

    result
end

#_reduce_547(val, _values, result) ⇒ Object

reduce 546 omitted



11466
11467
11468
11469
11470
# File 'lib/parser/ruby33.rb', line 11466

def _reduce_547(val, _values, result)
                      result = @builder.assignable(@builder.match_var(val[0]))

    result
end

#_reduce_548(val, _values, result) ⇒ Object



11472
11473
11474
11475
11476
11477
11478
11479
11480
11481
11482
# File 'lib/parser/ruby33.rb', line 11472

def _reduce_548(val, _values, result)
                      name = val[1][0]
                      unless static_env.declared?(name)
                        diagnostic :error, :undefined_lvar, { :name => name }, val[1]
                      end

                      lvar = @builder.accessible(@builder.ident(val[1]))
                      result = @builder.pin(val[0], lvar)

    result
end

#_reduce_549(val, _values, result) ⇒ Object



11484
11485
11486
11487
11488
11489
# File 'lib/parser/ruby33.rb', line 11484

def _reduce_549(val, _values, result)
                      non_lvar = @builder.accessible(val[1])
                      result = @builder.pin(val[0], non_lvar)

    result
end

#_reduce_55(val, _values, result) ⇒ Object



8732
8733
8734
8735
8736
# File 'lib/parser/ruby33.rb', line 8732

def _reduce_55(val, _values, result)
                      result = @builder.logical_op(:or, val[0], val[1], val[2])

    result
end

#_reduce_550(val, _values, result) ⇒ Object



11491
11492
11493
11494
11495
11496
# File 'lib/parser/ruby33.rb', line 11491

def _reduce_550(val, _values, result)
                      expr = @builder.begin(val[1], val[2], val[3])
                      result = @builder.pin(val[0], expr)

    result
end

#_reduce_551(val, _values, result) ⇒ Object



11498
11499
11500
11501
11502
# File 'lib/parser/ruby33.rb', line 11498

def _reduce_551(val, _values, result)
                      result = @builder.const_global(val[0], val[1])

    result
end

#_reduce_552(val, _values, result) ⇒ Object



11504
11505
11506
11507
11508
# File 'lib/parser/ruby33.rb', line 11504

def _reduce_552(val, _values, result)
                      result = @builder.const_fetch(val[0], val[1], val[2])

    result
end

#_reduce_553(val, _values, result) ⇒ Object



11510
11511
11512
11513
11514
# File 'lib/parser/ruby33.rb', line 11510

def _reduce_553(val, _values, result)
                      result = @builder.const(val[0])

    result
end

#_reduce_554(val, _values, result) ⇒ Object



11516
11517
11518
11519
11520
11521
11522
11523
11524
11525
11526
11527
11528
11529
# File 'lib/parser/ruby33.rb', line 11516

def _reduce_554(val, _values, result)
                      assoc_t, exc_var = val[2]

                      if val[1]
                        exc_list = @builder.array(nil, val[1], nil)
                      end

                      result = [ @builder.rescue_body(val[0],
                                      exc_list, assoc_t, exc_var,
                                      val[3], val[4]),
                                 *val[5] ]

    result
end

#_reduce_555(val, _values, result) ⇒ Object



11531
11532
11533
11534
11535
# File 'lib/parser/ruby33.rb', line 11531

def _reduce_555(val, _values, result)
                      result = []

    result
end

#_reduce_556(val, _values, result) ⇒ Object



11537
11538
11539
11540
11541
# File 'lib/parser/ruby33.rb', line 11537

def _reduce_556(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_559(val, _values, result) ⇒ Object

reduce 558 omitted



11547
11548
11549
11550
11551
# File 'lib/parser/ruby33.rb', line 11547

def _reduce_559(val, _values, result)
                      result = [ val[0], val[1] ]

    result
end

#_reduce_56(val, _values, result) ⇒ Object



8738
8739
8740
8741
8742
# File 'lib/parser/ruby33.rb', line 8738

def _reduce_56(val, _values, result)
                      result = @builder.not_op(val[0], nil, val[2], nil)

    result
end

#_reduce_561(val, _values, result) ⇒ Object

reduce 560 omitted



11555
11556
11557
11558
11559
# File 'lib/parser/ruby33.rb', line 11555

def _reduce_561(val, _values, result)
                      result = [ val[0], val[1] ]

    result
end

#_reduce_565(val, _values, result) ⇒ Object

reduce 564 omitted



11567
11568
11569
11570
11571
# File 'lib/parser/ruby33.rb', line 11567

def _reduce_565(val, _values, result)
                      result = @builder.string_compose(nil, val[0], nil)

    result
end

#_reduce_566(val, _values, result) ⇒ Object



11573
11574
11575
11576
11577
# File 'lib/parser/ruby33.rb', line 11573

def _reduce_566(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_567(val, _values, result) ⇒ Object



11579
11580
11581
11582
11583
# File 'lib/parser/ruby33.rb', line 11579

def _reduce_567(val, _values, result)
                      result = val[0] << val[1]

    result
end

#_reduce_568(val, _values, result) ⇒ Object



11585
11586
11587
11588
11589
11590
# File 'lib/parser/ruby33.rb', line 11585

def _reduce_568(val, _values, result)
                      string = @builder.string_compose(val[0], val[1], val[2])
                      result = @builder.dedent_string(string, @lexer.dedent_level)

    result
end

#_reduce_569(val, _values, result) ⇒ Object



11592
11593
11594
11595
11596
11597
# File 'lib/parser/ruby33.rb', line 11592

def _reduce_569(val, _values, result)
                      string = @builder.string(val[0])
                      result = @builder.dedent_string(string, @lexer.dedent_level)

    result
end

#_reduce_57(val, _values, result) ⇒ Object



8744
8745
8746
8747
8748
# File 'lib/parser/ruby33.rb', line 8744

def _reduce_57(val, _values, result)
                      result = @builder.not_op(val[0], nil, val[1], nil)

    result
end

#_reduce_570(val, _values, result) ⇒ Object



11599
11600
11601
11602
11603
# File 'lib/parser/ruby33.rb', line 11599

def _reduce_570(val, _values, result)
                      result = @builder.character(val[0])

    result
end

#_reduce_571(val, _values, result) ⇒ Object



11605
11606
11607
11608
11609
11610
# File 'lib/parser/ruby33.rb', line 11605

def _reduce_571(val, _values, result)
                      string = @builder.xstring_compose(val[0], val[1], val[2])
                      result = @builder.dedent_string(string, @lexer.dedent_level)

    result
end

#_reduce_572(val, _values, result) ⇒ Object



11612
11613
11614
11615
11616
11617
# File 'lib/parser/ruby33.rb', line 11612

def _reduce_572(val, _values, result)
                      opts   = @builder.regexp_options(val[3])
                      result = @builder.regexp_compose(val[0], val[1], val[2], opts)

    result
end

#_reduce_575(val, _values, result) ⇒ Object

reduce 574 omitted



11623
11624
11625
11626
11627
# File 'lib/parser/ruby33.rb', line 11623

def _reduce_575(val, _values, result)
                      result = @builder.words_compose(val[0], val[1], val[2])

    result
end

#_reduce_576(val, _values, result) ⇒ Object



11629
11630
11631
11632
11633
# File 'lib/parser/ruby33.rb', line 11629

def _reduce_576(val, _values, result)
                      result = []

    result
end

#_reduce_577(val, _values, result) ⇒ Object



11635
11636
11637
11638
11639
# File 'lib/parser/ruby33.rb', line 11635

def _reduce_577(val, _values, result)
                      result = val[0] << @builder.word(val[1])

    result
end

#_reduce_578(val, _values, result) ⇒ Object



11641
11642
11643
11644
11645
# File 'lib/parser/ruby33.rb', line 11641

def _reduce_578(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_579(val, _values, result) ⇒ Object



11647
11648
11649
11650
11651
# File 'lib/parser/ruby33.rb', line 11647

def _reduce_579(val, _values, result)
                      result = val[0] << val[1]

    result
end

#_reduce_58(val, _values, result) ⇒ Object



8750
8751
8752
8753
8754
8755
8756
8757
# File 'lib/parser/ruby33.rb', line 8750

def _reduce_58(val, _values, result)
                      @pattern_variables.pop
                      @pattern_hash_keys.pop
                      @context.in_kwarg = val[2]
                      result = @builder.match_pattern(val[0], val[1], val[5])

    result
end

#_reduce_580(val, _values, result) ⇒ Object



11653
11654
11655
11656
11657
# File 'lib/parser/ruby33.rb', line 11653

def _reduce_580(val, _values, result)
                      result = @builder.symbols_compose(val[0], val[1], val[2])

    result
end

#_reduce_581(val, _values, result) ⇒ Object



11659
11660
11661
11662
11663
# File 'lib/parser/ruby33.rb', line 11659

def _reduce_581(val, _values, result)
                      result = []

    result
end

#_reduce_582(val, _values, result) ⇒ Object



11665
11666
11667
11668
11669
# File 'lib/parser/ruby33.rb', line 11665

def _reduce_582(val, _values, result)
                      result = val[0] << @builder.word(val[1])

    result
end

#_reduce_583(val, _values, result) ⇒ Object



11671
11672
11673
11674
11675
# File 'lib/parser/ruby33.rb', line 11671

def _reduce_583(val, _values, result)
                      result = @builder.words_compose(val[0], val[1], val[2])

    result
end

#_reduce_584(val, _values, result) ⇒ Object



11677
11678
11679
11680
11681
# File 'lib/parser/ruby33.rb', line 11677

def _reduce_584(val, _values, result)
                      result = @builder.symbols_compose(val[0], val[1], val[2])

    result
end

#_reduce_585(val, _values, result) ⇒ Object



11683
11684
11685
11686
11687
# File 'lib/parser/ruby33.rb', line 11683

def _reduce_585(val, _values, result)
                      result = []

    result
end

#_reduce_586(val, _values, result) ⇒ Object



11689
11690
11691
11692
11693
# File 'lib/parser/ruby33.rb', line 11689

def _reduce_586(val, _values, result)
                      result = val[0] << @builder.string_internal(val[1])

    result
end

#_reduce_587(val, _values, result) ⇒ Object



11695
11696
11697
11698
11699
# File 'lib/parser/ruby33.rb', line 11695

def _reduce_587(val, _values, result)
                      result = []

    result
end

#_reduce_588(val, _values, result) ⇒ Object



11701
11702
11703
11704
11705
# File 'lib/parser/ruby33.rb', line 11701

def _reduce_588(val, _values, result)
                      result = val[0] << @builder.symbol_internal(val[1])

    result
end

#_reduce_589(val, _values, result) ⇒ Object



11707
11708
11709
11710
11711
# File 'lib/parser/ruby33.rb', line 11707

def _reduce_589(val, _values, result)
                      result = []

    result
end

#_reduce_59(val, _values, result) ⇒ Object



8759
8760
8761
8762
8763
8764
8765
8766
# File 'lib/parser/ruby33.rb', line 8759

def _reduce_59(val, _values, result)
                      @pattern_variables.pop
                      @pattern_hash_keys.pop
                      @context.in_kwarg = val[2]
                      result = @builder.match_pattern_p(val[0], val[1], val[5])

    result
end

#_reduce_590(val, _values, result) ⇒ Object



11713
11714
11715
11716
11717
# File 'lib/parser/ruby33.rb', line 11713

def _reduce_590(val, _values, result)
                      result = val[0] << val[1]

    result
end

#_reduce_591(val, _values, result) ⇒ Object



11719
11720
11721
11722
11723
# File 'lib/parser/ruby33.rb', line 11719

def _reduce_591(val, _values, result)
                      result = []

    result
end

#_reduce_592(val, _values, result) ⇒ Object



11725
11726
11727
11728
11729
# File 'lib/parser/ruby33.rb', line 11725

def _reduce_592(val, _values, result)
                      result = val[0] << val[1]

    result
end

#_reduce_593(val, _values, result) ⇒ Object



11731
11732
11733
11734
11735
# File 'lib/parser/ruby33.rb', line 11731

def _reduce_593(val, _values, result)
                      result = []

    result
end

#_reduce_594(val, _values, result) ⇒ Object



11737
11738
11739
11740
11741
# File 'lib/parser/ruby33.rb', line 11737

def _reduce_594(val, _values, result)
                      result = val[0] << val[1]

    result
end

#_reduce_595(val, _values, result) ⇒ Object



11743
11744
11745
11746
11747
# File 'lib/parser/ruby33.rb', line 11743

def _reduce_595(val, _values, result)
                      result = @builder.string_internal(val[0])

    result
end

#_reduce_596(val, _values, result) ⇒ Object



11749
11750
11751
11752
11753
# File 'lib/parser/ruby33.rb', line 11749

def _reduce_596(val, _values, result)
                      result = val[1]

    result
end

#_reduce_597(val, _values, result) ⇒ Object



11755
11756
11757
11758
11759
11760
# File 'lib/parser/ruby33.rb', line 11755

def _reduce_597(val, _values, result)
                      @lexer.cmdarg.push(false)
                      @lexer.cond.push(false)

    result
end

#_reduce_598(val, _values, result) ⇒ Object



11762
11763
11764
11765
11766
11767
11768
11769
# File 'lib/parser/ruby33.rb', line 11762

def _reduce_598(val, _values, result)
                      @lexer.cmdarg.pop
                      @lexer.cond.pop

                      result = @builder.begin(val[0], val[2], val[3])

    result
end

#_reduce_6(val, _values, result) ⇒ Object



8405
8406
8407
8408
8409
# File 'lib/parser/ruby33.rb', line 8405

def _reduce_6(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_600(val, _values, result) ⇒ Object

reduce 599 omitted



11773
11774
11775
11776
11777
# File 'lib/parser/ruby33.rb', line 11773

def _reduce_600(val, _values, result)
                      result = @builder.accessible(val[0])

    result
end

#_reduce_604(val, _values, result) ⇒ Object

reduce 603 omitted



11785
11786
11787
11788
11789
11790
# File 'lib/parser/ruby33.rb', line 11785

def _reduce_604(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.symbol(val[0])

    result
end

#_reduce_605(val, _values, result) ⇒ Object



11792
11793
11794
11795
11796
11797
# File 'lib/parser/ruby33.rb', line 11792

def _reduce_605(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.symbol_compose(val[0], val[1], val[2])

    result
end

#_reduce_606(val, _values, result) ⇒ Object



11799
11800
11801
11802
11803
# File 'lib/parser/ruby33.rb', line 11799

def _reduce_606(val, _values, result)
                      result = val[0]

    result
end

#_reduce_607(val, _values, result) ⇒ Object



11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
# File 'lib/parser/ruby33.rb', line 11805

def _reduce_607(val, _values, result)
                      if @builder.respond_to? :negate
                        # AST builder interface compatibility
                        result = @builder.negate(val[0], val[1])
                      else
                        result = @builder.unary_num(val[0], val[1])
                      end

    result
end

#_reduce_608(val, _values, result) ⇒ Object



11816
11817
11818
11819
11820
11821
# File 'lib/parser/ruby33.rb', line 11816

def _reduce_608(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.integer(val[0])

    result
end

#_reduce_609(val, _values, result) ⇒ Object



11823
11824
11825
11826
11827
11828
# File 'lib/parser/ruby33.rb', line 11823

def _reduce_609(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.float(val[0])

    result
end

#_reduce_610(val, _values, result) ⇒ Object



11830
11831
11832
11833
11834
11835
# File 'lib/parser/ruby33.rb', line 11830

def _reduce_610(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.rational(val[0])

    result
end

#_reduce_611(val, _values, result) ⇒ Object



11837
11838
11839
11840
11841
11842
# File 'lib/parser/ruby33.rb', line 11837

def _reduce_611(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.complex(val[0])

    result
end

#_reduce_612(val, _values, result) ⇒ Object



11844
11845
11846
11847
11848
# File 'lib/parser/ruby33.rb', line 11844

def _reduce_612(val, _values, result)
                      result = @builder.ivar(val[0])

    result
end

#_reduce_613(val, _values, result) ⇒ Object



11850
11851
11852
11853
11854
# File 'lib/parser/ruby33.rb', line 11850

def _reduce_613(val, _values, result)
                      result = @builder.gvar(val[0])

    result
end

#_reduce_614(val, _values, result) ⇒ Object



11856
11857
11858
11859
11860
# File 'lib/parser/ruby33.rb', line 11856

def _reduce_614(val, _values, result)
                      result = @builder.cvar(val[0])

    result
end

#_reduce_615(val, _values, result) ⇒ Object



11862
11863
11864
11865
11866
# File 'lib/parser/ruby33.rb', line 11862

def _reduce_615(val, _values, result)
                      result = @builder.ident(val[0])

    result
end

#_reduce_616(val, _values, result) ⇒ Object



11868
11869
11870
11871
11872
# File 'lib/parser/ruby33.rb', line 11868

def _reduce_616(val, _values, result)
                      result = @builder.const(val[0])

    result
end

#_reduce_618(val, _values, result) ⇒ Object

reduce 617 omitted



11876
11877
11878
11879
11880
# File 'lib/parser/ruby33.rb', line 11876

def _reduce_618(val, _values, result)
                      result = @builder.nil(val[0])

    result
end

#_reduce_619(val, _values, result) ⇒ Object



11882
11883
11884
11885
11886
# File 'lib/parser/ruby33.rb', line 11882

def _reduce_619(val, _values, result)
                      result = @builder.self(val[0])

    result
end

#_reduce_62(val, _values, result) ⇒ Object

reduce 61 omitted



8772
8773
8774
8775
8776
# File 'lib/parser/ruby33.rb', line 8772

def _reduce_62(val, _values, result)
                      @lexer.cond.push(true)

    result
end

#_reduce_620(val, _values, result) ⇒ Object