Class: Parser::Ruby34

Inherits:
Base
  • Object
show all
Defined in:
lib/parser/ruby34.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/ruby34.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/ruby34.rb', line 8425

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

    result
end

#_reduce_100(val, _values, result) ⇒ Object 



9025
9026
9027
9028
9029
9030
 
# File 'lib/parser/ruby34.rb', line 9025

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

    result
end

#_reduce_102(val, _values, result) ⇒ Object

reduce 101 omitted



9034
9035
9036
9037
9038
 
# File 'lib/parser/ruby34.rb', line 9034

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

    result
end

#_reduce_103(val, _values, result) ⇒ Object 



9040
9041
9042
9043
9044
 
# File 'lib/parser/ruby34.rb', line 9040

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

    result
end

#_reduce_104(val, _values, result) ⇒ Object 



9046
9047
9048
9049
9050
 
# File 'lib/parser/ruby34.rb', line 9046

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

    result
end

#_reduce_105(val, _values, result) ⇒ Object 



9052
9053
9054
9055
9056
 
# File 'lib/parser/ruby34.rb', line 9052

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

    result
end

#_reduce_106(val, _values, result) ⇒ Object 



9058
9059
9060
9061
9062
 
# File 'lib/parser/ruby34.rb', line 9058

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

    result
end

#_reduce_107(val, _values, result) ⇒ Object 



9064
9065
9066
9067
9068
 
# File 'lib/parser/ruby34.rb', line 9064

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

    result
end

#_reduce_108(val, _values, result) ⇒ Object 



9070
9071
9072
9073
9074
 
# File 'lib/parser/ruby34.rb', line 9070

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

    result
end

#_reduce_109(val, _values, result) ⇒ Object 



9076
9077
9078
9079
9080
 
# File 'lib/parser/ruby34.rb', line 9076

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/ruby34.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 



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

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 



9092
9093
9094
9095
9096
 
# File 'lib/parser/ruby34.rb', line 9092

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

    result
end

#_reduce_112(val, _values, result) ⇒ Object 



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

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 



9108
9109
9110
9111
9112
9113
 
# File 'lib/parser/ruby34.rb', line 9108

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 



9115
9116
9117
9118
9119
9120
 
# File 'lib/parser/ruby34.rb', line 9115

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

    result
end

#_reduce_115(val, _values, result) ⇒ Object 



9122
9123
9124
9125
9126
 
# File 'lib/parser/ruby34.rb', line 9122

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

    result
end

#_reduce_116(val, _values, result) ⇒ Object 



9128
9129
9130
9131
9132
 
# File 'lib/parser/ruby34.rb', line 9128

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

    result
end

#_reduce_117(val, _values, result) ⇒ Object 



9134
9135
9136
9137
9138
 
# File 'lib/parser/ruby34.rb', line 9134

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

    result
end

#_reduce_118(val, _values, result) ⇒ Object 



9140
9141
9142
9143
9144
 
# File 'lib/parser/ruby34.rb', line 9140

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 



9146
9147
9148
9149
9150
 
# File 'lib/parser/ruby34.rb', line 9146

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/ruby34.rb', line 8448

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

    result
end

#_reduce_120(val, _values, result) ⇒ Object 



9152
9153
9154
9155
9156
 
# File 'lib/parser/ruby34.rb', line 9152

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

    result
end

#_reduce_121(val, _values, result) ⇒ Object 



9158
9159
9160
9161
9162
 
# File 'lib/parser/ruby34.rb', line 9158

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

    result
end

#_reduce_122(val, _values, result) ⇒ Object 



9164
9165
9166
9167
9168
9169
 
# File 'lib/parser/ruby34.rb', line 9164

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 



9171
9172
9173
9174
9175
9176
 
# File 'lib/parser/ruby34.rb', line 9171

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

    result
end

#_reduce_124(val, _values, result) ⇒ Object 



9178
9179
9180
9181
9182
 
# File 'lib/parser/ruby34.rb', line 9178

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

    result
end

#_reduce_125(val, _values, result) ⇒ Object 



9184
9185
9186
9187
9188
 
# File 'lib/parser/ruby34.rb', line 9184

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



9192
9193
9194
9195
9196
 
# File 'lib/parser/ruby34.rb', line 9192

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

    result
end

#_reduce_128(val, _values, result) ⇒ Object 



9198
9199
9200
9201
9202
 
# File 'lib/parser/ruby34.rb', line 9198

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

    result
end

#_reduce_129(val, _values, result) ⇒ Object 



9204
9205
9206
9207
9208
 
# File 'lib/parser/ruby34.rb', line 9204

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/ruby34.rb', line 8454

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

    result
end

#_reduce_135(val, _values, result) ⇒ Object

reduce 134 omitted



9220
9221
9222
9223
9224
 
# File 'lib/parser/ruby34.rb', line 9220

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

    result
end

#_reduce_137(val, _values, result) ⇒ Object

reduce 136 omitted



9228
9229
9230
9231
9232
 
# File 'lib/parser/ruby34.rb', line 9228

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

    result
end

#_reduce_138(val, _values, result) ⇒ Object 



9234
9235
9236
9237
9238
 
# File 'lib/parser/ruby34.rb', line 9234

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

    result
end

#_reduce_139(val, _values, result) ⇒ Object 



9240
9241
9242
9243
9244
 
# File 'lib/parser/ruby34.rb', line 9240

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/ruby34.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/ruby34.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/ruby34.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/ruby34.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/ruby34.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/ruby34.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/ruby34.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/ruby34.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



9388
9389
9390
9391
9392
 
# File 'lib/parser/ruby34.rb', line 9388

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

    result
end

#_reduce_212(val, _values, result) ⇒ Object 



9394
9395
9396
9397
9398
 
# File 'lib/parser/ruby34.rb', line 9394

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

    result
end

#_reduce_213(val, _values, result) ⇒ Object 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



9452
9453
9454
9455
9456
 
# File 'lib/parser/ruby34.rb', line 9452

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/ruby34.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 



9458
9459
9460
9461
9462
 
# File 'lib/parser/ruby34.rb', line 9458

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

    result
end

#_reduce_221(val, _values, result) ⇒ Object 



9464
9465
9466
9467
9468
 
# File 'lib/parser/ruby34.rb', line 9464

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

    result
end

#_reduce_222(val, _values, result) ⇒ Object 



9470
9471
9472
9473
9474
 
# File 'lib/parser/ruby34.rb', line 9470

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

    result
end

#_reduce_223(val, _values, result) ⇒ Object 



9476
9477
9478
9479
9480
 
# File 'lib/parser/ruby34.rb', line 9476

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

    result
end

#_reduce_224(val, _values, result) ⇒ Object 



9482
9483
9484
9485
9486
 
# File 'lib/parser/ruby34.rb', line 9482

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

    result
end

#_reduce_225(val, _values, result) ⇒ Object 



9488
9489
9490
9491
9492
 
# File 'lib/parser/ruby34.rb', line 9488

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

    result
end

#_reduce_226(val, _values, result) ⇒ Object 



9494
9495
9496
9497
9498
 
# File 'lib/parser/ruby34.rb', line 9494

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

    result
end

#_reduce_227(val, _values, result) ⇒ Object 



9500
9501
9502
9503
9504
 
# File 'lib/parser/ruby34.rb', line 9500

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

    result
end

#_reduce_228(val, _values, result) ⇒ Object 



9506
9507
9508
9509
9510
 
# File 'lib/parser/ruby34.rb', line 9506

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

    result
end

#_reduce_229(val, _values, result) ⇒ Object 



9512
9513
9514
9515
9516
 
# File 'lib/parser/ruby34.rb', line 9512

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/ruby34.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 



9518
9519
9520
9521
9522
 
# File 'lib/parser/ruby34.rb', line 9518

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

    result
end

#_reduce_231(val, _values, result) ⇒ Object 



9524
9525
9526
9527
9528
 
# File 'lib/parser/ruby34.rb', line 9524

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

    result
end

#_reduce_232(val, _values, result) ⇒ Object 



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

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 



9538
9539
9540
9541
9542
 
# File 'lib/parser/ruby34.rb', line 9538

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

    result
end

#_reduce_234(val, _values, result) ⇒ Object 



9544
9545
9546
9547
9548
 
# File 'lib/parser/ruby34.rb', line 9544

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

    result
end

#_reduce_235(val, _values, result) ⇒ Object 



9550
9551
9552
9553
9554
 
# File 'lib/parser/ruby34.rb', line 9550

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

    result
end

#_reduce_236(val, _values, result) ⇒ Object 



9556
9557
9558
9559
9560
 
# File 'lib/parser/ruby34.rb', line 9556

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

    result
end

#_reduce_237(val, _values, result) ⇒ Object 



9562
9563
9564
9565
9566
 
# File 'lib/parser/ruby34.rb', line 9562

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

    result
end

#_reduce_238(val, _values, result) ⇒ Object 



9568
9569
9570
9571
9572
 
# File 'lib/parser/ruby34.rb', line 9568

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/ruby34.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



9576
9577
9578
9579
9580
 
# File 'lib/parser/ruby34.rb', line 9576

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

    result
end

#_reduce_241(val, _values, result) ⇒ Object 



9582
9583
9584
9585
9586
 
# File 'lib/parser/ruby34.rb', line 9582

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

    result
end

#_reduce_242(val, _values, result) ⇒ Object 



9588
9589
9590
9591
9592
 
# File 'lib/parser/ruby34.rb', line 9588

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

    result
end

#_reduce_243(val, _values, result) ⇒ Object 



9594
9595
9596
9597
9598
 
# File 'lib/parser/ruby34.rb', line 9594

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

    result
end

#_reduce_244(val, _values, result) ⇒ Object 



9600
9601
9602
9603
9604
 
# File 'lib/parser/ruby34.rb', line 9600

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

    result
end

#_reduce_245(val, _values, result) ⇒ Object 



9606
9607
9608
9609
9610
 
# File 'lib/parser/ruby34.rb', line 9606

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

    result
end

#_reduce_246(val, _values, result) ⇒ Object 



9612
9613
9614
9615
9616
 
# File 'lib/parser/ruby34.rb', line 9612

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

    result
end

#_reduce_247(val, _values, result) ⇒ Object 



9618
9619
9620
9621
9622
 
# File 'lib/parser/ruby34.rb', line 9618

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

    result
end

#_reduce_248(val, _values, result) ⇒ Object 



9624
9625
9626
9627
9628
 
# File 'lib/parser/ruby34.rb', line 9624

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

    result
end

#_reduce_249(val, _values, result) ⇒ Object 



9630
9631
9632
9633
9634
 
# File 'lib/parser/ruby34.rb', line 9630

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/ruby34.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 



9636
9637
9638
9639
9640
 
# File 'lib/parser/ruby34.rb', line 9636

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 



9642
9643
9644
9645
9646
9647
 
# File 'lib/parser/ruby34.rb', line 9642

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 



9649
9650
9651
9652
9653
9654
 
# File 'lib/parser/ruby34.rb', line 9649

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 



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

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 



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

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



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

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 



9698
9699
9700
9701
9702
 
# File 'lib/parser/ruby34.rb', line 9698

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/ruby34.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



9712
9713
9714
9715
9716
 
# File 'lib/parser/ruby34.rb', line 9712

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

    result
end

#_reduce_264(val, _values, result) ⇒ Object 



9718
9719
9720
9721
9722
 
# File 'lib/parser/ruby34.rb', line 9718

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

    result
end

#_reduce_265(val, _values, result) ⇒ Object 



9724
9725
9726
9727
9728
 
# File 'lib/parser/ruby34.rb', line 9724

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

    result
end

#_reduce_269(val, _values, result) ⇒ Object

reduce 268 omitted



9736
9737
9738
9739
9740
 
# File 'lib/parser/ruby34.rb', line 9736

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/ruby34.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 



9742
9743
9744
9745
9746
 
# File 'lib/parser/ruby34.rb', line 9742

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

    result
end

#_reduce_272(val, _values, result) ⇒ Object

reduce 271 omitted



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

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 



9760
9761
9762
9763
9764
 
# File 'lib/parser/ruby34.rb', line 9760

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

    result
end

#_reduce_274(val, _values, result) ⇒ Object 



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

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 



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

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 



9786
9787
9788
9789
9790
 
# File 'lib/parser/ruby34.rb', line 9786

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

    result
end

#_reduce_278(val, _values, result) ⇒ Object

reduce 277 omitted



9794
9795
9796
9797
9798
 
# File 'lib/parser/ruby34.rb', line 9794

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

    result
end

#_reduce_28(val, _values, result) ⇒ Object 



8546
8547
8548
8549
8550
 
# File 'lib/parser/ruby34.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



9804
9805
9806
9807
9808
 
# File 'lib/parser/ruby34.rb', line 9804

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

    result
end

#_reduce_282(val, _values, result) ⇒ Object 



9810
9811
9812
9813
9814
 
# File 'lib/parser/ruby34.rb', line 9810

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

    result
end

#_reduce_283(val, _values, result) ⇒ Object 



9816
9817
9818
9819
9820
 
# File 'lib/parser/ruby34.rb', line 9816

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

    result
end

#_reduce_284(val, _values, result) ⇒ Object 



9822
9823
9824
9825
9826
 
# File 'lib/parser/ruby34.rb', line 9822

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

    result
end

#_reduce_285(val, _values, result) ⇒ Object 



9828
9829
9830
9831
9832
9833
 
# File 'lib/parser/ruby34.rb', line 9828

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 



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

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 



9843
9844
9845
9846
9847
 
# File 'lib/parser/ruby34.rb', line 9843

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

    result
end

#_reduce_288(val, _values, result) ⇒ Object 



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
9874
 
# File 'lib/parser/ruby34.rb', line 9849

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 



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

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/ruby34.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 



9897
9898
9899
9900
9901
 
# File 'lib/parser/ruby34.rb', line 9897

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

    result
end

#_reduce_291(val, _values, result) ⇒ Object 



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

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 



9918
9919
9920
9921
9922
 
# File 'lib/parser/ruby34.rb', line 9918

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

    result
end

#_reduce_293(val, _values, result) ⇒ Object 



9924
9925
9926
9927
9928
 
# File 'lib/parser/ruby34.rb', line 9924

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

    result
end

#_reduce_294(val, _values, result) ⇒ Object 



9930
9931
9932
9933
9934
 
# File 'lib/parser/ruby34.rb', line 9930

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

    result
end

#_reduce_296(val, _values, result) ⇒ Object

reduce 295 omitted



9938
9939
9940
9941
9942
 
# File 'lib/parser/ruby34.rb', line 9938

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

    result
end

#_reduce_297(val, _values, result) ⇒ Object 



9944
9945
9946
9947
9948
 
# File 'lib/parser/ruby34.rb', line 9944

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

    result
end

#_reduce_298(val, _values, result) ⇒ Object 



9950
9951
9952
9953
9954
 
# File 'lib/parser/ruby34.rb', line 9950

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

    result
end

#_reduce_299(val, _values, result) ⇒ Object 



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

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/ruby34.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/ruby34.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 



9971
9972
9973
9974
9975
 
# File 'lib/parser/ruby34.rb', line 9971

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

    result
end

#_reduce_302(val, _values, result) ⇒ Object

reduce 301 omitted



9979
9980
9981
9982
9983
 
# File 'lib/parser/ruby34.rb', line 9979

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

    result
end

#_reduce_303(val, _values, result) ⇒ Object 



9985
9986
9987
9988
9989
 
# File 'lib/parser/ruby34.rb', line 9985

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

    result
end

#_reduce_304(val, _values, result) ⇒ Object 



9991
9992
9993
9994
9995
 
# File 'lib/parser/ruby34.rb', line 9991

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

    result
end

#_reduce_315(val, _values, result) ⇒ Object

reduce 314 omitted



10017
10018
10019
10020
10021
 
# File 'lib/parser/ruby34.rb', line 10017

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

    result
end

#_reduce_316(val, _values, result) ⇒ Object 



10023
10024
10025
10026
10027
 
# File 'lib/parser/ruby34.rb', line 10023

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

    result
end

#_reduce_317(val, _values, result) ⇒ Object 



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

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 



10037
10038
10039
10040
10041
 
# File 'lib/parser/ruby34.rb', line 10037

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

    result
end

#_reduce_319(val, _values, result) ⇒ Object 



10043
10044
10045
10046
10047
 
# File 'lib/parser/ruby34.rb', line 10043

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/ruby34.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 



10049
10050
10051
10052
10053
 
# File 'lib/parser/ruby34.rb', line 10049

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

    result
end

#_reduce_321(val, _values, result) ⇒ Object 



10055
10056
10057
10058
10059
 
# File 'lib/parser/ruby34.rb', line 10055

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

    result
end

#_reduce_322(val, _values, result) ⇒ Object 



10061
10062
10063
10064
10065
 
# File 'lib/parser/ruby34.rb', line 10061

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

    result
end

#_reduce_323(val, _values, result) ⇒ Object 



10067
10068
10069
10070
10071
 
# File 'lib/parser/ruby34.rb', line 10067

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

    result
end

#_reduce_324(val, _values, result) ⇒ Object 



10073
10074
10075
10076
10077
 
# File 'lib/parser/ruby34.rb', line 10073

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

    result
end

#_reduce_325(val, _values, result) ⇒ Object 



10079
10080
10081
10082
10083
 
# File 'lib/parser/ruby34.rb', line 10079

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

    result
end

#_reduce_326(val, _values, result) ⇒ Object 



10085
10086
10087
10088
10089
 
# File 'lib/parser/ruby34.rb', line 10085

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 



10091
10092
10093
10094
10095
 
# File 'lib/parser/ruby34.rb', line 10091

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 



10097
10098
10099
10100
10101
 
# File 'lib/parser/ruby34.rb', line 10097

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

    result
end

#_reduce_329(val, _values, result) ⇒ Object 



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

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/ruby34.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 



10111
10112
10113
10114
10115
 
# File 'lib/parser/ruby34.rb', line 10111

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 



10117
10118
10119
10120
10121
 
# File 'lib/parser/ruby34.rb', line 10117

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 



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

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



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

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



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

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 



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

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 



10163
10164
10165
10166
10167
 
# File 'lib/parser/ruby34.rb', line 10163

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 



10169
10170
10171
10172
10173
 
# File 'lib/parser/ruby34.rb', line 10169

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/ruby34.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 



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

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 



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

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 



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

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 



10205
10206
10207
10208
10209
 
# File 'lib/parser/ruby34.rb', line 10205

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 



10211
10212
10213
10214
10215
10216
10217
 
# File 'lib/parser/ruby34.rb', line 10211

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

    result
end

#_reduce_345(val, _values, result) ⇒ Object 



10219
10220
10221
10222
10223
10224
10225
10226
10227
10228
10229
10230
10231
10232
10233
10234
 
# File 'lib/parser/ruby34.rb', line 10219

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
                      @context.cant_return = ctx.cant_return

    result
end

#_reduce_346(val, _values, result) ⇒ Object 



10236
10237
10238
10239
10240
10241
10242
10243
 
# File 'lib/parser/ruby34.rb', line 10236

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

    result
end

#_reduce_347(val, _values, result) ⇒ Object 



10245
10246
10247
10248
10249
10250
10251
10252
10253
10254
10255
10256
 
# File 'lib/parser/ruby34.rb', line 10245

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
                      @context.cant_return = ctx.cant_return

    result
end

#_reduce_348(val, _values, result) ⇒ Object 



10258
10259
10260
10261
10262
10263
10264
 
# File 'lib/parser/ruby34.rb', line 10258

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

    result
end

#_reduce_349(val, _values, result) ⇒ Object 



10266
10267
10268
10269
10270
10271
10272
10273
10274
10275
10276
10277
10278
10279
 
# File 'lib/parser/ruby34.rb', line 10266

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
                      @context.cant_return = ctx.cant_return

    result
end

#_reduce_35(val, _values, result) ⇒ Object 



8594
8595
8596
8597
8598
 
# File 'lib/parser/ruby34.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 



10281
10282
10283
10284
10285
10286
10287
10288
10289
10290
10291
 
# File 'lib/parser/ruby34.rb', line 10281

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 



10293
10294
10295
10296
10297
10298
10299
10300
10301
10302
10303
 
# File 'lib/parser/ruby34.rb', line 10293

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 



10305
10306
10307
10308
10309
 
# File 'lib/parser/ruby34.rb', line 10305

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

    result
end

#_reduce_353(val, _values, result) ⇒ Object 



10311
10312
10313
10314
10315
 
# File 'lib/parser/ruby34.rb', line 10311

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

    result
end

#_reduce_354(val, _values, result) ⇒ Object 



10317
10318
10319
10320
10321
 
# File 'lib/parser/ruby34.rb', line 10317

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

    result
end

#_reduce_355(val, _values, result) ⇒ Object 



10323
10324
10325
10326
10327
 
# File 'lib/parser/ruby34.rb', line 10323

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

    result
end

#_reduce_357(val, _values, result) ⇒ Object

reduce 356 omitted



10331
10332
10333
10334
10335
 
# File 'lib/parser/ruby34.rb', line 10331

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

    result
end

#_reduce_358(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_359(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_360(val, _values, result) ⇒ Object 



10350
10351
10352
10353
10354
10355
10356
 
# File 'lib/parser/ruby34.rb', line 10350

def _reduce_360(val, _values, result)
                      if @context.cant_return && !(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



10362
10363
10364
10365
10366
 
# File 'lib/parser/ruby34.rb', line 10362

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

    result
end

#_reduce_367(val, _values, result) ⇒ Object

reduce 366 omitted



10374
10375
10376
10377
10378
10379
10380
10381
10382
10383
 
# File 'lib/parser/ruby34.rb', line 10374

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



10387
10388
10389
10390
10391
 
# File 'lib/parser/ruby34.rb', line 10387

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/ruby34.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



10397
10398
10399
10400
10401
 
# File 'lib/parser/ruby34.rb', line 10397

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

    result
end

#_reduce_373(val, _values, result) ⇒ Object 



10403
10404
10405
10406
10407
 
# File 'lib/parser/ruby34.rb', line 10403

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

    result
end

#_reduce_374(val, _values, result) ⇒ Object 



10409
10410
10411
10412
10413
 
# File 'lib/parser/ruby34.rb', line 10409

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

    result
end

#_reduce_375(val, _values, result) ⇒ Object 



10415
10416
10417
10418
10419
 
# File 'lib/parser/ruby34.rb', line 10415

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

    result
end

#_reduce_377(val, _values, result) ⇒ Object

reduce 376 omitted



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

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

    result
end

#_reduce_378(val, _values, result) ⇒ Object 



10430
10431
10432
10433
10434
10435
10436
 
# File 'lib/parser/ruby34.rb', line 10430

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

    result
end

#_reduce_379(val, _values, result) ⇒ Object 



10438
10439
10440
10441
10442
 
# File 'lib/parser/ruby34.rb', line 10438

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/ruby34.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 



10444
10445
10446
10447
10448
 
# File 'lib/parser/ruby34.rb', line 10444

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

    result
end

#_reduce_381(val, _values, result) ⇒ Object 



10450
10451
10452
10453
10454
 
# File 'lib/parser/ruby34.rb', line 10450

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

    result
end

#_reduce_382(val, _values, result) ⇒ Object 



10456
10457
10458
10459
10460
 
# File 'lib/parser/ruby34.rb', line 10456

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

    result
end

#_reduce_385(val, _values, result) ⇒ Object

reduce 384 omitted



10466
10467
10468
10469
10470
 
# File 'lib/parser/ruby34.rb', line 10466

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

    result
end

#_reduce_386(val, _values, result) ⇒ Object 



10472
10473
10474
10475
10476
 
# File 'lib/parser/ruby34.rb', line 10472

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

    result
end

#_reduce_387(val, _values, result) ⇒ Object 



10478
10479
10480
10481
10482
 
# File 'lib/parser/ruby34.rb', line 10478

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

    result
end

#_reduce_388(val, _values, result) ⇒ Object 



10484
10485
10486
10487
10488
 
# File 'lib/parser/ruby34.rb', line 10484

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

    result
end

#_reduce_389(val, _values, result) ⇒ Object 



10490
10491
10492
10493
10494
 
# File 'lib/parser/ruby34.rb', line 10490

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/ruby34.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 



10496
10497
10498
10499
10500
 
# File 'lib/parser/ruby34.rb', line 10496

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

    result
end

#_reduce_391(val, _values, result) ⇒ Object 



10502
10503
10504
10505
10506
 
# File 'lib/parser/ruby34.rb', line 10502

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

    result
end

#_reduce_392(val, _values, result) ⇒ Object 



10508
10509
10510
10511
10512
 
# File 'lib/parser/ruby34.rb', line 10508

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

    result
end

#_reduce_394(val, _values, result) ⇒ Object

reduce 393 omitted



10516
10517
10518
10519
10520
10521
10522
10523
 
# File 'lib/parser/ruby34.rb', line 10516

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 



10525
10526
10527
10528
10529
10530
10531
10532
10533
 
# File 'lib/parser/ruby34.rb', line 10525

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 



10535
10536
10537
10538
10539
10540
10541
 
# File 'lib/parser/ruby34.rb', line 10535

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

    result
end

#_reduce_397(val, _values, result) ⇒ Object 



10543
10544
10545
10546
10547
10548
10549
10550
 
# File 'lib/parser/ruby34.rb', line 10543

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 



10552
10553
10554
10555
10556
10557
10558
 
# File 'lib/parser/ruby34.rb', line 10552

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/ruby34.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/ruby34.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



10562
10563
10564
10565
10566
10567
10568
10569
 
# File 'lib/parser/ruby34.rb', line 10562

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 



10571
10572
10573
10574
10575
10576
10577
10578
10579
 
# File 'lib/parser/ruby34.rb', line 10571

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 



10581
10582
10583
10584
10585
10586
10587
 
# File 'lib/parser/ruby34.rb', line 10581

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

    result
end

#_reduce_403(val, _values, result) ⇒ Object 



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

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 



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

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

    result
end

#_reduce_405(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_406(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_407(val, _values, result) ⇒ Object 



10620
10621
10622
10623
10624
10625
10626
 
# File 'lib/parser/ruby34.rb', line 10620

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



10630
10631
10632
10633
10634
 
# File 'lib/parser/ruby34.rb', line 10630

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/ruby34.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 



10636
10637
10638
10639
10640
 
# File 'lib/parser/ruby34.rb', line 10636

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

    result
end

#_reduce_411(val, _values, result) ⇒ Object 



10642
10643
10644
10645
10646
10647
10648
10649
 
# File 'lib/parser/ruby34.rb', line 10642

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 



10651
10652
10653
10654
10655
10656
10657
10658
 
# File 'lib/parser/ruby34.rb', line 10651

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 



10660
10661
10662
10663
10664
 
# File 'lib/parser/ruby34.rb', line 10660

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

    result
end

#_reduce_414(val, _values, result) ⇒ Object 



10666
10667
10668
10669
10670
 
# File 'lib/parser/ruby34.rb', line 10666

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

    result
end

#_reduce_415(val, _values, result) ⇒ Object 



10672
10673
10674
10675
10676
 
# File 'lib/parser/ruby34.rb', line 10672

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

    result
end

#_reduce_416(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_417(val, _values, result) ⇒ Object 



10684
10685
10686
10687
10688
10689
 
# File 'lib/parser/ruby34.rb', line 10684

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



10693
10694
10695
10696
10697
10698
10699
10700
 
# File 'lib/parser/ruby34.rb', line 10693

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/ruby34.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 



10702
10703
10704
10705
10706
 
# File 'lib/parser/ruby34.rb', line 10702

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

    result
end

#_reduce_421(val, _values, result) ⇒ Object 



10708
10709
10710
10711
10712
10713
10714
10715
10716
10717
10718
10719
10720
10721
10722
 
# File 'lib/parser/ruby34.rb', line 10708

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 



10724
10725
10726
10727
10728
10729
10730
 
# File 'lib/parser/ruby34.rb', line 10724

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 



10732
10733
10734
10735
10736
10737
10738
10739
10740
 
# File 'lib/parser/ruby34.rb', line 10732

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 



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

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

    result
end

#_reduce_425(val, _values, result) ⇒ Object 



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

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 



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

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

    result
end

#_reduce_427(val, _values, result) ⇒ Object 



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

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 



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

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

    result
end

#_reduce_429(val, _values, result) ⇒ Object 



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

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/ruby34.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 



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

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 



10792
10793
10794
10795
10796
10797
10798
 
# File 'lib/parser/ruby34.rb', line 10792

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 



10800
10801
10802
10803
10804
10805
10806
10807
10808
10809
10810
 
# File 'lib/parser/ruby34.rb', line 10800

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 



10812
10813
10814
10815
10816
10817
10818
10819
10820
10821
 
# File 'lib/parser/ruby34.rb', line 10812

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 



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

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 



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

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 



10839
10840
10841
10842
10843
10844
10845
 
# File 'lib/parser/ruby34.rb', line 10839

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 



10847
10848
10849
10850
10851
 
# File 'lib/parser/ruby34.rb', line 10847

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

    result
end

#_reduce_438(val, _values, result) ⇒ Object 



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

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 



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

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/ruby34.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 



10869
10870
10871
10872
10873
10874
10875
 
# File 'lib/parser/ruby34.rb', line 10869

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 



10877
10878
10879
10880
10881
 
# File 'lib/parser/ruby34.rb', line 10877

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

    result
end

#_reduce_442(val, _values, result) ⇒ Object 



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

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 



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

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

    result
end

#_reduce_444(val, _values, result) ⇒ Object 



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

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 



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

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

    result
end

#_reduce_446(val, _values, result) ⇒ Object 



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

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 



10917
10918
10919
10920
10921
10922
 
# File 'lib/parser/ruby34.rb', line 10917

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

    result
end

#_reduce_448(val, _values, result) ⇒ Object 



10924
10925
10926
10927
10928
10929
10930
10931
10932
 
# File 'lib/parser/ruby34.rb', line 10924

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 



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

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/ruby34.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 



10941
10942
10943
10944
10945
 
# File 'lib/parser/ruby34.rb', line 10941

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

    result
end

#_reduce_451(val, _values, result) ⇒ Object 



10947
10948
10949
10950
10951
10952
10953
10954
10955
10956
 
# File 'lib/parser/ruby34.rb', line 10947

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 



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

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 



10965
10966
10967
10968
10969
 
# File 'lib/parser/ruby34.rb', line 10965

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

    result
end

#_reduce_455(val, _values, result) ⇒ Object

reduce 454 omitted



10973
10974
10975
10976
10977
 
# File 'lib/parser/ruby34.rb', line 10973

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

    result
end

#_reduce_456(val, _values, result) ⇒ Object 



10979
10980
10981
10982
10983
 
# File 'lib/parser/ruby34.rb', line 10979

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

    result
end

#_reduce_457(val, _values, result) ⇒ Object 



10985
10986
10987
10988
10989
10990
10991
10992
10993
 
# File 'lib/parser/ruby34.rb', line 10985

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 



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

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 



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

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/ruby34.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 



11010
11011
11012
11013
11014
 
# File 'lib/parser/ruby34.rb', line 11010

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

    result
end

#_reduce_462(val, _values, result) ⇒ Object

reduce 461 omitted



11018
11019
11020
11021
11022
 
# File 'lib/parser/ruby34.rb', line 11018

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

    result
end

#_reduce_463(val, _values, result) ⇒ Object 



11024
11025
11026
11027
11028
 
# File 'lib/parser/ruby34.rb', line 11024

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

    result
end

#_reduce_464(val, _values, result) ⇒ Object 



11030
11031
11032
11033
11034
 
# File 'lib/parser/ruby34.rb', line 11030

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



11038
11039
11040
11041
11042
11043
11044
11045
11046
 
# File 'lib/parser/ruby34.rb', line 11038

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 



11048
11049
11050
11051
11052
 
# File 'lib/parser/ruby34.rb', line 11048

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 



11054
11055
11056
11057
11058
 
# File 'lib/parser/ruby34.rb', line 11054

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

    result
end

#_reduce_469(val, _values, result) ⇒ Object 



11060
11061
11062
11063
11064
 
# File 'lib/parser/ruby34.rb', line 11060

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

    result
end

#_reduce_470(val, _values, result) ⇒ Object 



11066
11067
11068
11069
11070
 
# File 'lib/parser/ruby34.rb', line 11066

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



11074
11075
11076
11077
11078
 
# File 'lib/parser/ruby34.rb', line 11074

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



11082
11083
11084
11085
11086
 
# File 'lib/parser/ruby34.rb', line 11082

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



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

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

    result
end

#_reduce_477(val, _values, result) ⇒ Object 



11097
11098
11099
11100
11101
11102
 
# File 'lib/parser/ruby34.rb', line 11097

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/ruby34.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



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



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

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 



11170
11171
11172
11173
11174
 
# File 'lib/parser/ruby34.rb', line 11170

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

    result
end

#_reduce_489(val, _values, result) ⇒ Object 



11176
11177
11178
11179
11180
 
# File 'lib/parser/ruby34.rb', line 11176

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/ruby34.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 



11182
11183
11184
11185
11186
 
# File 'lib/parser/ruby34.rb', line 11182

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

    result
end

#_reduce_491(val, _values, result) ⇒ Object 



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

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 



11196
11197
11198
11199
11200
11201
11202
 
# File 'lib/parser/ruby34.rb', line 11196

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 



11204
11205
11206
11207
11208
 
# File 'lib/parser/ruby34.rb', line 11204

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

    result
end

#_reduce_494(val, _values, result) ⇒ Object 



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

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

    result
end

#_reduce_495(val, _values, result) ⇒ Object 



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

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 



11223
11224
11225
11226
11227
 
# File 'lib/parser/ruby34.rb', line 11223

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

    result
end

#_reduce_497(val, _values, result) ⇒ Object 



11229
11230
11231
11232
11233
 
# File 'lib/parser/ruby34.rb', line 11229

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

    result
end

#_reduce_498(val, _values, result) ⇒ Object 



11235
11236
11237
11238
11239
 
# File 'lib/parser/ruby34.rb', line 11235

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

    result
end

#_reduce_499(val, _values, result) ⇒ Object 



11241
11242
11243
11244
11245
 
# File 'lib/parser/ruby34.rb', line 11241

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/ruby34.rb', line 8399

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

    result
end

#_reduce_500(val, _values, result) ⇒ Object 



11247
11248
11249
11250
11251
 
# File 'lib/parser/ruby34.rb', line 11247

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

    result
end

#_reduce_502(val, _values, result) ⇒ Object

reduce 501 omitted



11255
11256
11257
11258
11259
11260
11261
11262
11263
 
# File 'lib/parser/ruby34.rb', line 11255

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 



11265
11266
11267
11268
11269
11270
11271
11272
11273
 
# File 'lib/parser/ruby34.rb', line 11265

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 



11275
11276
11277
11278
11279
 
# File 'lib/parser/ruby34.rb', line 11275

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

    result
end

#_reduce_505(val, _values, result) ⇒ Object 



11281
11282
11283
11284
11285
 
# File 'lib/parser/ruby34.rb', line 11281

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

    result
end

#_reduce_506(val, _values, result) ⇒ Object 



11287
11288
11289
11290
11291
 
# File 'lib/parser/ruby34.rb', line 11287

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

    result
end

#_reduce_507(val, _values, result) ⇒ Object 



11293
11294
11295
11296
11297
 
# File 'lib/parser/ruby34.rb', line 11293

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

    result
end

#_reduce_508(val, _values, result) ⇒ Object 



11299
11300
11301
11302
11303
 
# File 'lib/parser/ruby34.rb', line 11299

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

    result
end

#_reduce_509(val, _values, result) ⇒ Object 



11305
11306
11307
11308
11309
 
# File 'lib/parser/ruby34.rb', line 11305

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/ruby34.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 



11311
11312
11313
11314
11315
 
# File 'lib/parser/ruby34.rb', line 11311

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

    result
end

#_reduce_512(val, _values, result) ⇒ Object

reduce 511 omitted



11319
11320
11321
11322
11323
 
# File 'lib/parser/ruby34.rb', line 11319

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

    result
end

#_reduce_513(val, _values, result) ⇒ Object 



11325
11326
11327
11328
11329
 
# File 'lib/parser/ruby34.rb', line 11325

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

    result
end

#_reduce_514(val, _values, result) ⇒ Object 



11331
11332
11333
11334
11335
 
# File 'lib/parser/ruby34.rb', line 11331

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

    result
end

#_reduce_515(val, _values, result) ⇒ Object 



11337
11338
11339
11340
11341
 
# File 'lib/parser/ruby34.rb', line 11337

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

    result
end

#_reduce_516(val, _values, result) ⇒ Object 



11343
11344
11345
11346
11347
 
# File 'lib/parser/ruby34.rb', line 11343

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

    result
end

#_reduce_517(val, _values, result) ⇒ Object 



11349
11350
11351
11352
11353
 
# File 'lib/parser/ruby34.rb', line 11349

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

    result
end

#_reduce_518(val, _values, result) ⇒ Object 



11355
11356
11357
11358
11359
 
# File 'lib/parser/ruby34.rb', line 11355

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

    result
end

#_reduce_519(val, _values, result) ⇒ Object 



11361
11362
11363
11364
11365
 
# File 'lib/parser/ruby34.rb', line 11361

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

    result
end

#_reduce_520(val, _values, result) ⇒ Object 



11367
11368
11369
11370
11371
 
# File 'lib/parser/ruby34.rb', line 11367

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

    result
end

#_reduce_521(val, _values, result) ⇒ Object 



11373
11374
11375
11376
11377
 
# File 'lib/parser/ruby34.rb', line 11373

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

    result
end

#_reduce_522(val, _values, result) ⇒ Object 



11379
11380
11381
11382
11383
 
# File 'lib/parser/ruby34.rb', line 11379

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

    result
end

#_reduce_523(val, _values, result) ⇒ Object 



11385
11386
11387
11388
11389
 
# File 'lib/parser/ruby34.rb', line 11385

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

    result
end

#_reduce_524(val, _values, result) ⇒ Object 



11391
11392
11393
11394
11395
 
# File 'lib/parser/ruby34.rb', line 11391

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

    result
end

#_reduce_526(val, _values, result) ⇒ Object

reduce 525 omitted



11399
11400
11401
11402
11403
 
# File 'lib/parser/ruby34.rb', line 11399

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



11407
11408
11409
11410
11411
 
# File 'lib/parser/ruby34.rb', line 11407

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

    result
end

#_reduce_529(val, _values, result) ⇒ Object 



11413
11414
11415
11416
11417
 
# File 'lib/parser/ruby34.rb', line 11413

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

    result
end

#_reduce_530(val, _values, result) ⇒ Object 



11419
11420
11421
11422
11423
 
# File 'lib/parser/ruby34.rb', line 11419

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

    result
end

#_reduce_531(val, _values, result) ⇒ Object 



11425
11426
11427
11428
11429
 
# File 'lib/parser/ruby34.rb', line 11425

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



11437
11438
11439
11440
11441
 
# File 'lib/parser/ruby34.rb', line 11437

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

    result
end

#_reduce_536(val, _values, result) ⇒ Object 



11443
11444
11445
11446
11447
 
# File 'lib/parser/ruby34.rb', line 11443

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/ruby34.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



11465
11466
11467
11468
11469
 
# File 'lib/parser/ruby34.rb', line 11465

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

    result
end

#_reduce_547(val, _values, result) ⇒ Object

reduce 546 omitted



11473
11474
11475
11476
11477
 
# File 'lib/parser/ruby34.rb', line 11473

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

    result
end

#_reduce_548(val, _values, result) ⇒ Object 



11479
11480
11481
11482
11483
11484
11485
11486
11487
11488
11489
11490
 
# File 'lib/parser/ruby34.rb', line 11479

def _reduce_548(val, _values, result)
                      name = val[1][0]
                      lvar = @builder.accessible(@builder.ident(val[1]))

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

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

    result
end

#_reduce_549(val, _values, result) ⇒ Object 



11492
11493
11494
11495
11496
11497
 
# File 'lib/parser/ruby34.rb', line 11492

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/ruby34.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 



11499
11500
11501
11502
11503
11504
 
# File 'lib/parser/ruby34.rb', line 11499

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 



11506
11507
11508
11509
11510
 
# File 'lib/parser/ruby34.rb', line 11506

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

    result
end

#_reduce_552(val, _values, result) ⇒ Object 



11512
11513
11514
11515
11516
 
# File 'lib/parser/ruby34.rb', line 11512

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

    result
end

#_reduce_553(val, _values, result) ⇒ Object 



11518
11519
11520
11521
11522
 
# File 'lib/parser/ruby34.rb', line 11518

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

    result
end

#_reduce_554(val, _values, result) ⇒ Object 



11524
11525
11526
11527
11528
11529
11530
11531
11532
11533
11534
11535
11536
11537
 
# File 'lib/parser/ruby34.rb', line 11524

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 



11539
11540
11541
11542
11543
 
# File 'lib/parser/ruby34.rb', line 11539

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

    result
end

#_reduce_556(val, _values, result) ⇒ Object 



11545
11546
11547
11548
11549
 
# File 'lib/parser/ruby34.rb', line 11545

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

    result
end

#_reduce_559(val, _values, result) ⇒ Object

reduce 558 omitted



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

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/ruby34.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



11563
11564
11565
11566
11567
 
# File 'lib/parser/ruby34.rb', line 11563

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

    result
end

#_reduce_565(val, _values, result) ⇒ Object

reduce 564 omitted



11575
11576
11577
11578
11579
 
# File 'lib/parser/ruby34.rb', line 11575

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

    result
end

#_reduce_566(val, _values, result) ⇒ Object 



11581
11582
11583
11584
11585
 
# File 'lib/parser/ruby34.rb', line 11581

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

    result
end

#_reduce_567(val, _values, result) ⇒ Object 



11587
11588
11589
11590
11591
 
# File 'lib/parser/ruby34.rb', line 11587

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

    result
end

#_reduce_568(val, _values, result) ⇒ Object 



11593
11594
11595
11596
11597
11598
 
# File 'lib/parser/ruby34.rb', line 11593

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 



11600
11601
11602
11603
11604
11605
 
# File 'lib/parser/ruby34.rb', line 11600

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/ruby34.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 



11607
11608
11609
11610
11611
 
# File 'lib/parser/ruby34.rb', line 11607

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

    result
end

#_reduce_571(val, _values, result) ⇒ Object 



11613
11614
11615
11616
11617
11618
 
# File 'lib/parser/ruby34.rb', line 11613

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 



11620
11621
11622
11623
11624
11625
 
# File 'lib/parser/ruby34.rb', line 11620

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



11631
11632
11633
11634
11635
 
# File 'lib/parser/ruby34.rb', line 11631

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

    result
end

#_reduce_576(val, _values, result) ⇒ Object 



11637
11638
11639
11640
11641
 
# File 'lib/parser/ruby34.rb', line 11637

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

    result
end

#_reduce_577(val, _values, result) ⇒ Object 



11643
11644
11645
11646
11647
 
# File 'lib/parser/ruby34.rb', line 11643

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

    result
end

#_reduce_578(val, _values, result) ⇒ Object 



11649
11650
11651
11652
11653
 
# File 'lib/parser/ruby34.rb', line 11649

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

    result
end

#_reduce_579(val, _values, result) ⇒ Object 



11655
11656
11657
11658
11659
 
# File 'lib/parser/ruby34.rb', line 11655

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/ruby34.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 



11661
11662
11663
11664
11665
 
# File 'lib/parser/ruby34.rb', line 11661

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

    result
end

#_reduce_581(val, _values, result) ⇒ Object 



11667
11668
11669
11670
11671
 
# File 'lib/parser/ruby34.rb', line 11667

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

    result
end

#_reduce_582(val, _values, result) ⇒ Object 



11673
11674
11675
11676
11677
 
# File 'lib/parser/ruby34.rb', line 11673

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

    result
end

#_reduce_583(val, _values, result) ⇒ Object 



11679
11680
11681
11682
11683
 
# File 'lib/parser/ruby34.rb', line 11679

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

    result
end

#_reduce_584(val, _values, result) ⇒ Object 



11685
11686
11687
11688
11689
 
# File 'lib/parser/ruby34.rb', line 11685

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

    result
end

#_reduce_585(val, _values, result) ⇒ Object 



11691
11692
11693
11694
11695
 
# File 'lib/parser/ruby34.rb', line 11691

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

    result
end

#_reduce_586(val, _values, result) ⇒ Object 



11697
11698
11699
11700
11701
 
# File 'lib/parser/ruby34.rb', line 11697

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

    result
end

#_reduce_587(val, _values, result) ⇒ Object 



11703
11704
11705
11706
11707
 
# File 'lib/parser/ruby34.rb', line 11703

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

    result
end

#_reduce_588(val, _values, result) ⇒ Object 



11709
11710
11711
11712
11713
 
# File 'lib/parser/ruby34.rb', line 11709

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

    result
end

#_reduce_589(val, _values, result) ⇒ Object 



11715
11716
11717
11718
11719
 
# File 'lib/parser/ruby34.rb', line 11715

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/ruby34.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 



11721
11722
11723
11724
11725
 
# File 'lib/parser/ruby34.rb', line 11721

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

    result
end

#_reduce_591(val, _values, result) ⇒ Object 



11727
11728
11729
11730
11731
 
# File 'lib/parser/ruby34.rb', line 11727

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

    result
end

#_reduce_592(val, _values, result) ⇒ Object 



11733
11734
11735
11736
11737
 
# File 'lib/parser/ruby34.rb', line 11733

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

    result
end

#_reduce_593(val, _values, result) ⇒ Object 



11739
11740
11741
11742
11743
 
# File 'lib/parser/ruby34.rb', line 11739

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

    result
end

#_reduce_594(val, _values, result) ⇒ Object 



11745
11746
11747
11748
11749
 
# File 'lib/parser/ruby34.rb', line 11745

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

    result
end

#_reduce_595(val, _values, result) ⇒ Object 



11751
11752
11753
11754
11755
 
# File 'lib/parser/ruby34.rb', line 11751

def _reduce_595(val, _values, result)
                      result = @builder.string_internal(val[0])

    result
end

#_reduce_596(val, _values, result) ⇒ Object 



11757
11758
11759
11760
11761
 
# File 'lib/parser/ruby34.rb', line 11757

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

    result
end

#_reduce_597(val, _values, result) ⇒ Object 



11763
11764
11765
11766
11767
11768
 
# File 'lib/parser/ruby34.rb', line 11763

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

    result
end

#_reduce_598(val, _values, result) ⇒ Object 



11770
11771
11772
11773
11774
11775
11776
11777
 
# File 'lib/parser/ruby34.rb', line 11770

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/ruby34.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



11781
11782
11783
11784
11785
 
# File 'lib/parser/ruby34.rb', line 11781

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

    result
end

#_reduce_604(val, _values, result) ⇒ Object

reduce 603 omitted



11793
11794
11795
11796
11797
11798
 
# File 'lib/parser/ruby34.rb', line 11793

def _reduce_604(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.symbol(val[0])

    result
end

#_reduce_605(val, _values, result) ⇒ Object 



11800
11801
11802
11803
11804
11805
 
# File 'lib/parser/ruby34.rb', line 11800

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 



11807
11808
11809
11810
11811
 
# File 'lib/parser/ruby34.rb', line 11807

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

    result
end

#_reduce_607(val, _values, result) ⇒ Object 



11813
11814
11815
11816
11817
11818
11819
11820
11821
11822
 
# File 'lib/parser/ruby34.rb', line 11813

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 



11824
11825
11826
11827
11828
11829
 
# File 'lib/parser/ruby34.rb', line 11824

def _reduce_608(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.integer(val[0])

    result
end

#_reduce_609(val, _values, result) ⇒ Object 



11831
11832
11833
11834
11835
11836
 
# File 'lib/parser/ruby34.rb', line 11831

def _reduce_609(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.float(val[0])

    result
end

#_reduce_610(val, _values, result) ⇒ Object 



11838
11839
11840
11841
11842
11843
 
# File 'lib/parser/ruby34.rb', line 11838

def _reduce_610(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.rational(val[0])

    result
end

#_reduce_611(val, _values, result) ⇒ Object 



11845
11846
11847
11848
11849
11850
 
# File 'lib/parser/ruby34.rb', line 11845

def _reduce_611(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.complex(val[0])

    result
end

#_reduce_612(val, _values, result) ⇒ Object 



11852
11853
11854
11855
11856
 
# File 'lib/parser/ruby34.rb', line 11852

def _reduce_612(val, _values, result)
                      result = @builder.ivar(val[0])

    result
end

#_reduce_613(val, _values, result) ⇒ Object 



11858
11859
11860
11861
11862
 
# File 'lib/parser/ruby34.rb', line 11858

def _reduce_613(val, _values, result)
                      result = @builder.gvar(val[0])

    result
end

#_reduce_614(val, _values, result) ⇒ Object 



11864
11865
11866
11867
11868
 
# File 'lib/parser/ruby34.rb', line 11864

def _reduce_614(val, _values, result)
                      result = @builder.cvar(val[0])

    result
end

#_reduce_615(val, _values, result) ⇒ Object 



11870
11871
11872
11873
11874
 
# File 'lib/parser/ruby34.rb', line 11870

def _reduce_615(val, _values, result)
                      result = @builder.ident(val[0])

    result
end

#_reduce_616(val, _values, result) ⇒ Object 



11876
11877
11878
11879
11880
 
# File 'lib/parser/ruby34.rb', line 11876

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

    result
end

#_reduce_618(val, _values, result) ⇒ Object

reduce 617 omitted



11884
11885
11886
11887
11888
 
# File 'lib/parser/ruby34.rb', line 11884

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

    result
end

#_reduce_619(val, _values, result) ⇒ Object 



11890
11891
11892
11893
11894
 
# File 'lib/parser/ruby34.rb', line 11890

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/ruby34.rb', line 8772

def _reduce_62(val, _values, result)
                      @lexer.cond.push(true)

    result
end

#_reduce_620(val, _values, result) ⇒ Object 



11896
11897
11898
11899
11900
 
# File 'lib/parser/ruby34.rb', line 11896

def _reduce_620(val, _values, result)
                      result = @builder.true(val[0])

    result
end

#_reduce_621(val, _values, result) ⇒ Object 



11902
11903
11904
11905
11906
 
# File 'lib/parser/ruby34.rb', line 11902

def _reduce_621(val, _values, result)
                      result = @builder.false(val[0])

    result
end

#_reduce_622(val, _values, result) ⇒ Object 



11908
11909
11910
11911
11912
 
# File 'lib/parser/ruby34.rb', line 11908

def _reduce_622(val, _values, result)
                      result = @builder.__FILE__(val[0])

    result
end

#_reduce_623(val, _values, result) ⇒ Object 



11914
11915
11916
11917
11918
 
# File 'lib/parser/ruby34.rb', line 11914

def _reduce_623(val, _values, result)
                      result = @builder.__LINE__(val[0])

    result
end

#_reduce_624(val, _values, result) ⇒ Object 



11920
11921
11922
11923
11924
 
# File 'lib/parser/ruby34.rb', line 11920

def _reduce_624(val, _values, result)
                      result = @builder.__ENCODING__(val[0])

    result
end

#_reduce_625(val, _values, result) ⇒ Object 



11926
11927
11928
11929
11930
 
# File 'lib/parser/ruby34.rb', line 11926

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

    result
end

#_reduce_626(val, _values, result) ⇒ Object 



11932
11933
11934
11935
11936
 
# File 'lib/parser/ruby34.rb', line 11932

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

    result
end

#_reduce_627(val, _values, result) ⇒ Object 



11938
11939
11940
11941
11942
 
# File 'lib/parser/ruby34.rb', line 11938

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

    result
end

#_reduce_628(val, _values, result) ⇒ Object 



11944
11945
11946
11947
11948
 
# File 'lib/parser/ruby34.rb', line 11944

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

    result
end

#_reduce_629(val, _values, result) ⇒ Object 



11950
11951
11952
11953
11954
 
# File 'lib/parser/ruby34.rb', line 11950

def _reduce_629(val, _values, result)
                      result = @builder.nth_ref(val[0])

    result
end

#_reduce_63(val, _values, result) ⇒ Object 



8778
8779
8780
8781
8782
8783
 
# File 'lib/parser/ruby34.rb', line 8778

def _reduce_63(val, _values, result)
                      @lexer.cond.pop
                      result = [ val[1], val[2] ]

    result
end

#_reduce_630(val, _values, result) ⇒ Object 



11956
11957
11958
11959
11960
 
# File 'lib/parser/ruby34.rb', line 11956

def _reduce_630(val, _values, result)
                      result = @builder.back_ref(val[0])

    result
end

#_reduce_631(val, _values, result) ⇒ Object 



11962
11963
11964
11965
11966
 
# File 'lib/parser/ruby34.rb', line 11962

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

    result
end

#_reduce_632(val, _values, result) ⇒ Object 



11968
11969
11970
11971
11972
 
# File 'lib/parser/ruby34.rb', line 11968

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

    result
end

#_reduce_633(val, _values, result) ⇒ Object 



11974
11975
11976
11977
11978
 
# File 'lib/parser/ruby34.rb', line 11974

def _reduce_633(val, _values, result)
                      result = nil

    result
end

#_reduce_635(val, _values, result) ⇒ Object

reduce 634 omitted



11982
11983
11984
11985
11986
11987
 
# File 'lib/parser/ruby34.rb', line 11982

def _reduce_635(val, _values, result)
                      @context.in_argdef = false
                      result = @builder.args(nil, [], nil)

    result
end

#_reduce_636(val, _values, result) ⇒ Object 



11989
11990
11991
11992
11993
11994
11995
11996
 
# File 'lib/parser/ruby34.rb', line 11989

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

                      @lexer.state = :expr_value
                      @context.in_argdef = false

    result
end

#_reduce_638(val, _values, result) ⇒ Object

reduce 637 omitted



12000
12001
12002
12003
12004
12005
12006
 
# File 'lib/parser/ruby34.rb', line 12000

def _reduce_638(val, _values, result)
                      result = @context.dup
                      @context.in_kwarg = true
                      @context.in_argdef = true

    result
end

#_reduce_639(val, _values, result) ⇒ Object 



12008
12009
12010
12011
12012
12013
12014
 
# File 'lib/parser/ruby34.rb', line 12008

def _reduce_639(val, _values, result)
                      @context.in_kwarg = val[0].in_kwarg
                      @context.in_argdef = false
                      result = @builder.args(nil, val[1], nil)

    result
end

#_reduce_64(val, _values, result) ⇒ Object 



8785
8786
8787
8788
8789
8790
8791
8792
8793
8794
 
# File 'lib/parser/ruby34.rb', line 8785

def _reduce_64(val, _values, result)
                      local_push
                      @current_arg_stack.push(nil)

                      result = [ val[0], @context.dup ]
                      @context.in_def = true
                      @context.cant_return = false

    result
end

#_reduce_640(val, _values, result) ⇒ Object 



12016
12017
12018
12019
12020
 
# File 'lib/parser/ruby34.rb', line 12016

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

    result
end

#_reduce_641(val, _values, result) ⇒ Object 



12022
12023
12024
12025
12026
 
# File 'lib/parser/ruby34.rb', line 12022

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

    result
end

#_reduce_642(val, _values, result) ⇒ Object 



12028
12029
12030
12031
12032
 
# File 'lib/parser/ruby34.rb', line 12028

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

    result
end

#_reduce_643(val, _values, result) ⇒ Object 



12034
12035
12036
12037
12038
 
# File 'lib/parser/ruby34.rb', line 12034

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

    result
end

#_reduce_644(val, _values, result) ⇒ Object 



12040
12041
12042
12043
12044
12045
 
# File 'lib/parser/ruby34.rb', line 12040

def _reduce_644(val, _values, result)
                      @static_env.declare_forward_args
                      result = [ @builder.forward_arg(val[0]) ]

    result
end

#_reduce_645(val, _values, result) ⇒ Object 



12047
12048
12049
12050
12051
 
# File 'lib/parser/ruby34.rb', line 12047

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

    result
end

#_reduce_646(val, _values, result) ⇒ Object 



12053
12054
12055
12056
12057
 
# File 'lib/parser/ruby34.rb', line 12053

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

    result
end

#_reduce_647(val, _values, result) ⇒ Object 



12059
12060
12061
12062
12063
12064
12065
12066
 
# File 'lib/parser/ruby34.rb', line 12059

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

    result
end

#_reduce_648(val, _values, result) ⇒ Object 



12068
12069
12070
12071
12072
12073
12074
12075
12076
 
# File 'lib/parser/ruby34.rb', line 12068

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

    result
end

#_reduce_649(val, _values, result) ⇒ Object 



12078
12079
12080
12081
12082
12083
12084
 
# File 'lib/parser/ruby34.rb', line 12078

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

    result
end

#_reduce_65(val, _values, result) ⇒ Object 



8796
8797
8798
8799
8800
 
# File 'lib/parser/ruby34.rb', line 8796

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

    result
end

#_reduce_650(val, _values, result) ⇒ Object 



12086
12087
12088
12089
12090
12091
12092
12093
 
# File 'lib/parser/ruby34.rb', line 12086

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

    result
end

#_reduce_651(val, _values, result) ⇒ Object 



12095
12096
12097
12098
12099
12100
12101
 
# File 'lib/parser/ruby34.rb', line 12095

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

    result
end

#_reduce_652(val, _values, result) ⇒ Object 



12103
12104
12105
12106
12107
12108
12109
12110
 
# File 'lib/parser/ruby34.rb', line 12103

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

    result
end

#_reduce_653(val, _values, result) ⇒ Object 



12112
12113
12114
12115
12116
12117
 
# File 'lib/parser/ruby34.rb', line 12112

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

    result
end

#_reduce_654(val, _values, result) ⇒ Object 



12119
12120
12121
12122
12123
12124
12125
 
# File 'lib/parser/ruby34.rb', line 12119

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

    result
end

#_reduce_655(val, _values, result) ⇒ Object 



12127
12128
12129
12130
12131
12132
12133
12134
 
# File 'lib/parser/ruby34.rb', line 12127

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

    result
end

#_reduce_656(val, _values, result) ⇒ Object 



12136
12137
12138
12139
12140
12141
 
# File 'lib/parser/ruby34.rb', line 12136

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

    result
end

#_reduce_657(val, _values, result) ⇒ Object 



12143
12144
12145
12146
12147
12148
12149
 
# File 'lib/parser/ruby34.rb', line 12143

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

    result
end

#_reduce_658(val, _values, result) ⇒ Object 



12151
12152
12153
12154
12155
12156
 
# File 'lib/parser/ruby34.rb', line 12151

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

    result
end

#_reduce_659(val, _values, result) ⇒ Object 



12158
12159
12160
12161
12162
12163
12164
 
# File 'lib/parser/ruby34.rb', line 12158

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

    result
end

#_reduce_66(val, _values, result) ⇒ Object 



8802
8803
8804
8805
8806
8807
 
# File 'lib/parser/ruby34.rb', line 8802

def _reduce_66(val, _values, result)
                      @lexer.state = :expr_fname
                      @context.in_argdef = true

    result
end

#_reduce_660(val, _values, result) ⇒ Object 



12166
12167
12168
12169
12170
 
# File 'lib/parser/ruby34.rb', line 12166

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

    result
end

#_reduce_661(val, _values, result) ⇒ Object 



12172
12173
12174
12175
12176
 
# File 'lib/parser/ruby34.rb', line 12172

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

    result
end

#_reduce_662(val, _values, result) ⇒ Object 



12178
12179
12180
12181
12182
 
# File 'lib/parser/ruby34.rb', line 12178

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

    result
end

#_reduce_663(val, _values, result) ⇒ Object 



12184
12185
12186
12187
12188
 
# File 'lib/parser/ruby34.rb', line 12184

def _reduce_663(val, _values, result)
                      diagnostic :error, :argument_const, nil, val[0]

    result
end

#_reduce_664(val, _values, result) ⇒ Object 



12190
12191
12192
12193
12194
 
# File 'lib/parser/ruby34.rb', line 12190

def _reduce_664(val, _values, result)
                      diagnostic :error, :argument_ivar, nil, val[0]

    result
end

#_reduce_665(val, _values, result) ⇒ Object 



12196
12197
12198
12199
12200
 
# File 'lib/parser/ruby34.rb', line 12196

def _reduce_665(val, _values, result)
                      diagnostic :error, :argument_gvar, nil, val[0]

    result
end

#_reduce_666(val, _values, result) ⇒ Object 



12202
12203
12204
12205
12206
 
# File 'lib/parser/ruby34.rb', line 12202

def _reduce_666(val, _values, result)
                      diagnostic :error, :argument_cvar, nil, val[0]

    result
end

#_reduce_668(val, _values, result) ⇒ Object

reduce 667 omitted



12210
12211
12212
12213
12214
12215
12216
12217
12218
 
# File 'lib/parser/ruby34.rb', line 12210

def _reduce_668(val, _values, result)
                      @static_env.declare val[0][0]

                      @max_numparam_stack.has_ordinary_params!

                      result = val[0]

    result
end

#_reduce_669(val, _values, result) ⇒ Object 



12220
12221
12222
12223
12224
12225
 
# File 'lib/parser/ruby34.rb', line 12220

def _reduce_669(val, _values, result)
                      @current_arg_stack.set(val[0][0])
                      result = val[0]

    result
end

#_reduce_67(val, _values, result) ⇒ Object 



8809
8810
8811
8812
8813
 
# File 'lib/parser/ruby34.rb', line 8809

def _reduce_67(val, _values, result)
                      result = [ val[0], val[1], val[2], val[4] ]

    result
end

#_reduce_670(val, _values, result) ⇒ Object 



12227
12228
12229
12230
12231
12232
 
# File 'lib/parser/ruby34.rb', line 12227

def _reduce_670(val, _values, result)
                      @current_arg_stack.set(0)
                      result = @builder.arg(val[0])

    result
end

#_reduce_671(val, _values, result) ⇒ Object 



12234
12235
12236
12237
12238
 
# File 'lib/parser/ruby34.rb', line 12234

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

    result
end

#_reduce_672(val, _values, result) ⇒ Object 



12240
12241
12242
12243
12244
 
# File 'lib/parser/ruby34.rb', line 12240

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

    result
end

#_reduce_673(val, _values, result) ⇒ Object 



12246
12247
12248
12249
12250
 
# File 'lib/parser/ruby34.rb', line 12246

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

    result
end

#_reduce_674(val, _values, result) ⇒ Object 



12252
12253
12254
12255
12256
12257
12258
12259
12260
12261
12262
12263
12264
12265
 
# File 'lib/parser/ruby34.rb', line 12252

def _reduce_674(val, _values, result)
                      check_kwarg_name(val[0])

                      @static_env.declare val[0][0]

                      @max_numparam_stack.has_ordinary_params!

                      @current_arg_stack.set(val[0][0])
                      @context.in_argdef = false

                      result = val[0]

    result
end

#_reduce_675(val, _values, result) ⇒ Object 



12267
12268
12269
12270
12271
12272
12273
 
# File 'lib/parser/ruby34.rb', line 12267

def _reduce_675(val, _values, result)
                      @current_arg_stack.set(nil)
                      @context.in_argdef = true
                      result = @builder.kwoptarg(val[0], val[1])

    result
end

#_reduce_676(val, _values, result) ⇒ Object 



12275
12276
12277
12278
12279
12280
12281
 
# File 'lib/parser/ruby34.rb', line 12275

def _reduce_676(val, _values, result)
                      @current_arg_stack.set(nil)
                      @context.in_argdef = true
                      result = @builder.kwarg(val[0])

    result
end

#_reduce_677(val, _values, result) ⇒ Object 



12283
12284
12285
12286
12287
12288
 
# File 'lib/parser/ruby34.rb', line 12283

def _reduce_677(val, _values, result)
                      @context.in_argdef = true
                      result = @builder.kwoptarg(val[0], val[1])

    result
end

#_reduce_678(val, _values, result) ⇒ Object 



12290
12291
12292
12293
12294
12295
 
# File 'lib/parser/ruby34.rb', line 12290

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

    result
end

#_reduce_679(val, _values, result) ⇒ Object 



12297
12298
12299
12300
12301
 
# File 'lib/parser/ruby34.rb', line 12297

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

    result
end

#_reduce_680(val, _values, result) ⇒ Object 



12303
12304
12305
12306
12307
 
# File 'lib/parser/ruby34.rb', line 12303

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

    result
end

#_reduce_681(val, _values, result) ⇒ Object 



12309
12310
12311
12312
12313
 
# File 'lib/parser/ruby34.rb', line 12309

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

    result
end

#_reduce_682(val, _values, result) ⇒ Object 



12315
12316
12317
12318
12319
 
# File 'lib/parser/ruby34.rb', line 12315

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

    result
end

#_reduce_685(val, _values, result) ⇒ Object

reduce 684 omitted



12325
12326
12327
12328
12329
 
# File 'lib/parser/ruby34.rb', line 12325

def _reduce_685(val, _values, result)
                      result = [ @builder.kwnilarg(val[0][0], val[0][1]) ]

    result
end

#_reduce_686(val, _values, result) ⇒ Object 



12331
12332
12333
12334
12335
12336
12337
 
# File 'lib/parser/ruby34.rb', line 12331

def _reduce_686(val, _values, result)
                      @static_env.declare val[1][0]

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

    result
end

#_reduce_687(val, _values, result) ⇒ Object 



12339
12340
12341
12342
12343
12344
12345
 
# File 'lib/parser/ruby34.rb', line 12339

def _reduce_687(val, _values, result)
                      @static_env.declare_anonymous_kwrestarg

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

    result
end

#_reduce_688(val, _values, result) ⇒ Object 



12347
12348
12349
12350
12351
12352
12353
 
# File 'lib/parser/ruby34.rb', line 12347

def _reduce_688(val, _values, result)
                      @current_arg_stack.set(0)
                      @context.in_argdef = true
                      result = @builder.optarg(val[0], val[1], val[2])

    result
end

#_reduce_689(val, _values, result) ⇒ Object 



12355
12356
12357
12358
12359
12360
12361
 
# File 'lib/parser/ruby34.rb', line 12355

def _reduce_689(val, _values, result)
                      @current_arg_stack.set(0)
                      @context.in_argdef = true
                      result = @builder.optarg(val[0], val[1], val[2])

    result
end

#_reduce_690(val, _values, result) ⇒ Object 



12363
12364
12365
12366
12367
 
# File 'lib/parser/ruby34.rb', line 12363

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

    result
end

#_reduce_691(val, _values, result) ⇒ Object 



12369
12370
12371
12372
12373
 
# File 'lib/parser/ruby34.rb', line 12369

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

    result
end

#_reduce_692(val, _values, result) ⇒ Object 



12375
12376
12377
12378
12379
 
# File 'lib/parser/ruby34.rb', line 12375

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

    result
end

#_reduce_693(val, _values, result) ⇒ Object 



12381
12382
12383
12384
12385
 
# File 'lib/parser/ruby34.rb', line 12381

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

    result
end

#_reduce_696(val, _values, result) ⇒ Object

reduce 695 omitted



12391
12392
12393
12394
12395
12396
12397
 
# File 'lib/parser/ruby34.rb', line 12391

def _reduce_696(val, _values, result)
                      @static_env.declare val[1][0]

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

    result
end

#_reduce_697(val, _values, result) ⇒ Object 



12399
12400
12401
12402
12403
12404
12405
 
# File 'lib/parser/ruby34.rb', line 12399

def _reduce_697(val, _values, result)
                      @static_env.declare_anonymous_restarg

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

    result
end

#_reduce_7(val, _values, result) ⇒ Object 



8411
8412
8413
8414
8415
 
# File 'lib/parser/ruby34.rb', line 8411

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

    result
end

#_reduce_700(val, _values, result) ⇒ Object

reduce 699 omitted



12411
12412
12413
12414
12415
12416
12417
 
# File 'lib/parser/ruby34.rb', line 12411

def _reduce_700(val, _values, result)
                      @static_env.declare val[1][0]

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

    result
end

#_reduce_701(val, _values, result) ⇒ Object 



12419
12420
12421
12422
12423
12424
12425
 
# File 'lib/parser/ruby34.rb', line 12419

def _reduce_701(val, _values, result)
                      @static_env.declare_anonymous_blockarg

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

    result
end

#_reduce_702(val, _values, result) ⇒ Object 



12427
12428
12429
12430
12431
 
# File 'lib/parser/ruby34.rb', line 12427

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

    result
end

#_reduce_703(val, _values, result) ⇒ Object 



12433
12434
12435
12436
12437
 
# File 'lib/parser/ruby34.rb', line 12433

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

    result
end

#_reduce_705(val, _values, result) ⇒ Object

reduce 704 omitted



12441
12442
12443
12444
12445
 
# File 'lib/parser/ruby34.rb', line 12441

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

    result
end

#_reduce_706(val, _values, result) ⇒ Object 



12447
12448
12449
12450
12451
 
# File 'lib/parser/ruby34.rb', line 12447

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

    result
end

#_reduce_708(val, _values, result) ⇒ Object

reduce 707 omitted



12455
12456
12457
12458
12459
 
# File 'lib/parser/ruby34.rb', line 12455

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

    result
end

#_reduce_709(val, _values, result) ⇒ Object 



12461
12462
12463
12464
12465
 
# File 'lib/parser/ruby34.rb', line 12461

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

    result
end

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted



8821
8822
8823
8824
8825
8826
 
# File 'lib/parser/ruby34.rb', line 8821

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

    result
end

#_reduce_710(val, _values, result) ⇒ Object 



12467
12468
12469
12470
12471
 
# File 'lib/parser/ruby34.rb', line 12467

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

    result
end

#_reduce_711(val, _values, result) ⇒ Object 



12473
12474
12475
12476
12477
 
# File 'lib/parser/ruby34.rb', line 12473

def _reduce_711(val, _values, result)
                      result = @builder.pair_keyword(val[0], val[1])

    result
end

#_reduce_712(val, _values, result) ⇒ Object 



12479
12480
12481
12482
12483
 
# File 'lib/parser/ruby34.rb', line 12479

def _reduce_712(val, _values, result)
                      result = @builder.pair_label(val[0])

    result
end

#_reduce_713(val, _values, result) ⇒ Object 



12485
12486
12487
12488
12489
 
# File 'lib/parser/ruby34.rb', line 12485

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

    result
end

#_reduce_714(val, _values, result) ⇒ Object 



12491
12492
12493
12494
12495
 
# File 'lib/parser/ruby34.rb', line 12491

def _reduce_714(val, _values, result)
                      result = @builder.kwsplat(val[0], val[1])

    result
end

#_reduce_715(val, _values, result) ⇒ Object 



12497
12498
12499
12500
12501
12502
12503
12504
12505
12506
12507
12508
12509
12510
 
# File 'lib/parser/ruby34.rb', line 12497

def _reduce_715(val, _values, result)
                      if !@static_env.declared_anonymous_kwrestarg?
                        diagnostic :error, :no_anonymous_kwrestarg, nil, val[0]
                      end

                      if @context.in_dynamic_block? && context.in_def &&
                        @static_env.declared_anonymous_kwrestarg_in_current_scope? && @static_env.parent_has_anonymous_kwrestarg?
                        diagnostic :error, :ambiguous_anonymous_kwrestarg, nil, val[0]
                      end

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

    result
end

#_reduce_72(val, _values, result) ⇒ Object 



8828
8829
8830
8831
8832
8833
 
# File 'lib/parser/ruby34.rb', line 8828

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

    result
end

#_reduce_726(val, _values, result) ⇒ Object

reduce 725 omitted



12532
12533
12534
12535
12536
 
# File 'lib/parser/ruby34.rb', line 12532

def _reduce_726(val, _values, result)
                      result = [:dot, val[0][1]]

    result
end

#_reduce_727(val, _values, result) ⇒ Object 



12538
12539
12540
12541
12542
 
# File 'lib/parser/ruby34.rb', line 12538

def _reduce_727(val, _values, result)
                      result = [:anddot, val[0][1]]

    result
end

#_reduce_73(val, _values, result) ⇒ Object 



8835
8836
8837
8838
8839
8840
 
# File 'lib/parser/ruby34.rb', line 8835

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

    result
end

#_reduce_732(val, _values, result) ⇒ Object

reduce 731 omitted



12552
12553
12554
12555
12556
 
# File 'lib/parser/ruby34.rb', line 12552

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

    result
end

#_reduce_733(val, _values, result) ⇒ Object 



12558
12559
12560
12561
12562
 
# File 'lib/parser/ruby34.rb', line 12558

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

    result
end

#_reduce_734(val, _values, result) ⇒ Object 



12564
12565
12566
12567
12568
 
# File 'lib/parser/ruby34.rb', line 12564

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

    result
end

#_reduce_737(val, _values, result) ⇒ Object

reduce 736 omitted



12574
12575
12576
12577
12578
 
# File 'lib/parser/ruby34.rb', line 12574

def _reduce_737(val, _values, result)
                    yyerrok

    result
end

#_reduce_741(val, _values, result) ⇒ Object

reduce 740 omitted



12586
12587
12588
12589
12590
 
# File 'lib/parser/ruby34.rb', line 12586

def _reduce_741(val, _values, result)
                    result = nil

    result
end

#_reduce_75(val, _values, result) ⇒ Object

reduce 74 omitted



8844
8845
8846
8847
8848
8849
 
# File 'lib/parser/ruby34.rb', line 8844

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

    result
end

#_reduce_76(val, _values, result) ⇒ Object 



8851
8852
8853
8854
8855
8856
8857
8858
8859
8860
 
# File 'lib/parser/ruby34.rb', line 8851

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

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

    result
end

#_reduce_77(val, _values, result) ⇒ Object 



8862
8863
8864
8865
8866
8867
 
# File 'lib/parser/ruby34.rb', line 8862

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

    result
end

#_reduce_78(val, _values, result) ⇒ Object 



8869
8870
8871
8872
8873
8874
8875
8876
8877
8878
 
# File 'lib/parser/ruby34.rb', line 8869

def _reduce_78(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_79(val, _values, result) ⇒ Object 



8880
8881
8882
8883
8884
8885
 
# File 'lib/parser/ruby34.rb', line 8880

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

    result
end

#_reduce_80(val, _values, result) ⇒ Object 



8887
8888
8889
8890
8891
8892
8893
8894
8895
8896
 
# File 'lib/parser/ruby34.rb', line 8887

def _reduce_80(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_81(val, _values, result) ⇒ Object 



8898
8899
8900
8901
8902
8903
8904
8905
8906
 
# File 'lib/parser/ruby34.rb', line 8898

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

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

    result
end

#_reduce_82(val, _values, result) ⇒ Object 



8908
8909
8910
8911
8912
8913
 
# File 'lib/parser/ruby34.rb', line 8908

def _reduce_82(val, _values, result)
                      result = @builder.keyword_cmd(:super, val[0],
                                  nil, val[1], nil)

    result
end

#_reduce_83(val, _values, result) ⇒ Object 



8915
8916
8917
8918
8919
8920
 
# File 'lib/parser/ruby34.rb', line 8915

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

    result
end

#_reduce_84(val, _values, result) ⇒ Object 



8922
8923
8924
8925
8926
8927
 
# File 'lib/parser/ruby34.rb', line 8922

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

    result
end

#_reduce_85(val, _values, result) ⇒ Object 



8929
8930
8931
8932
8933
8934
 
# File 'lib/parser/ruby34.rb', line 8929

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

    result
end

#_reduce_86(val, _values, result) ⇒ Object 



8936
8937
8938
8939
8940
8941
 
# File 'lib/parser/ruby34.rb', line 8936

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

    result
end

#_reduce_87(val, _values, result) ⇒ Object 



8943
8944
8945
8946
8947
 
# File 'lib/parser/ruby34.rb', line 8943

def _reduce_87(val, _values, result)
                      result = @builder.multi_lhs(nil, val[0], nil)

    result
end

#_reduce_88(val, _values, result) ⇒ Object 



8949
8950
8951
8952
8953
 
# File 'lib/parser/ruby34.rb', line 8949

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

    result
end

#_reduce_89(val, _values, result) ⇒ Object 



8955
8956
8957
8958
8959
 
# File 'lib/parser/ruby34.rb', line 8955

def _reduce_89(val, _values, result)
                      result = @builder.multi_lhs(nil, val[0], nil)

    result
end

#_reduce_9(val, _values, result) ⇒ Object

reduce 8 omitted



8419
8420
8421
8422
8423
 
# File 'lib/parser/ruby34.rb', line 8419

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

    result
end

#_reduce_90(val, _values, result) ⇒ Object 



8961
8962
8963
8964
8965
 
# File 'lib/parser/ruby34.rb', line 8961

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

    result
end

#_reduce_92(val, _values, result) ⇒ Object

reduce 91 omitted



8969
8970
8971
8972
8973
8974
 
# File 'lib/parser/ruby34.rb', line 8969

def _reduce_92(val, _values, result)
                      result = val[0].
                                  push(val[1])

    result
end

#_reduce_93(val, _values, result) ⇒ Object 



8976
8977
8978
8979
8980
8981
 
# File 'lib/parser/ruby34.rb', line 8976

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

    result
end

#_reduce_94(val, _values, result) ⇒ Object 



8983
8984
8985
8986
8987
8988
8989
 
# File 'lib/parser/ruby34.rb', line 8983

def _reduce_94(val, _values, result)
                      result = val[0].
                                  push(@builder.splat(val[1], val[2])).
                                  concat(val[4])

    result
end

#_reduce_95(val, _values, result) ⇒ Object 



8991
8992
8993
8994
8995
8996
 
# File 'lib/parser/ruby34.rb', line 8991

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

    result
end

#_reduce_96(val, _values, result) ⇒ Object 



8998
8999
9000
9001
9002
9003
9004
 
# File 'lib/parser/ruby34.rb', line 8998

def _reduce_96(val, _values, result)
                      result = val[0].
                                  push(@builder.splat(val[1])).
                                  concat(val[3])

    result
end

#_reduce_97(val, _values, result) ⇒ Object 



9006
9007
9008
9009
9010
 
# File 'lib/parser/ruby34.rb', line 9006

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

    result
end

#_reduce_98(val, _values, result) ⇒ Object 



9012
9013
9014
9015
9016
9017
 
# File 'lib/parser/ruby34.rb', line 9012

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

    result
end

#_reduce_99(val, _values, result) ⇒ Object 



9019
9020
9021
9022
9023
 
# File 'lib/parser/ruby34.rb', line 9019

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

    result
end

#_reduce_none(val, _values, result) ⇒ Object 



12592
12593
12594
 
# File 'lib/parser/ruby34.rb', line 12592

def _reduce_none(val, _values, result)
  val[0]
end

#default_encoding ⇒ Object 



21
22
23
 
# File 'lib/parser/ruby34.rb', line 21

def default_encoding
  Encoding::UTF_8
end

#endless_method_name(name_t) ⇒ Object 



25
26
27
28
29
 
# File 'lib/parser/ruby34.rb', line 25

def endless_method_name(name_t)
  if !%w[=== == != <= >=].include?(name_t[0]) && name_t[0].end_with?('=')
    diagnostic :error, :endless_setter, nil, name_t
  end
end

#local_pop ⇒ Object 



38
39
40
41
42
43
 
# File 'lib/parser/ruby34.rb', line 38

def local_pop
  @static_env.unextend
  @lexer.cmdarg.pop
  @lexer.cond.pop
  @max_numparam_stack.pop
end

#local_push ⇒ Object 



31
32
33
34
35
36
 
# File 'lib/parser/ruby34.rb', line 31

def local_push
  @static_env.extend_static
  @lexer.cmdarg.push(false)
  @lexer.cond.push(false)
  @max_numparam_stack.push(static: true)
end

#try_declare_numparam(node) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/parser/ruby34.rb', line 45

def try_declare_numparam(node)
  name = node.children[0]

  if name =~ /\A_[1-9]\z/ && !static_env.declared?(name) && @context.in_dynamic_block?
    # definitely an implicit param
    location = node.loc.expression

    if max_numparam_stack.has_ordinary_params?
      diagnostic :error, :ordinary_param_defined, nil, [nil, location]
    end

    raw_max_numparam_stack = max_numparam_stack.stack.dup
    # ignore current block scope
    raw_max_numparam_stack.pop

    raw_max_numparam_stack.reverse_each do |outer_scope|
      if outer_scope[:static]
        # found an outer scope that can't have numparams
        # like def/class/etc
        break
      else
        outer_scope_has_numparams = outer_scope[:value] > 0

        if outer_scope_has_numparams
          diagnostic :error, :numparam_used_in_outer_scope, nil, [nil, location]
        else
          # for now it's ok, but an outer scope can also be a block
          # like proc { _1; proc { proc { proc { _2 }} }}
          # with numparams, so we need to continue
        end
      end
    end

    static_env.declare(name)
    max_numparam_stack.register(name[1].to_i)

    true
  else
    false
  end
end

#version ⇒ Object 



17
18
19
 
# File 'lib/parser/ruby34.rb', line 17

def version
  34
end