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



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

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

    result
end

#_reduce_102(val, _values, result) ⇒ Object

reduce 101 omitted



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

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

    result
end

#_reduce_103(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_104(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_105(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_106(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_107(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_108(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_109(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_11(val, _values, result) ⇒ Object



8431
8432
8433
8434
8435
8436
8437
8438
8439
8440
8441
8442
8443
8444
8445
8446
# File 'lib/parser/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



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

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

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

    result
end

#_reduce_111(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_112(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_113(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_114(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_115(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_116(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_117(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_118(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_119(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_12(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_120(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_121(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_122(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_123(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_124(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_125(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_127(val, _values, result) ⇒ Object

reduce 126 omitted



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

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

    result
end

#_reduce_128(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_129(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_13(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_135(val, _values, result) ⇒ Object

reduce 134 omitted



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

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

    result
end

#_reduce_137(val, _values, result) ⇒ Object

reduce 136 omitted



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

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

    result
end

#_reduce_138(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_139(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_14(val, _values, result) ⇒ Object



8460
8461
8462
8463
8464
# File 'lib/parser/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



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

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

    result
end

#_reduce_212(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_213(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_214(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_215(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_216(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_217(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_218(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_219(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_22(val, _values, result) ⇒ Object



8506
8507
8508
8509
8510
8511
8512
# File 'lib/parser/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



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

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

    result
end

#_reduce_221(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_222(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_223(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_224(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_225(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_226(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_227(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_228(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_229(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_23(val, _values, result) ⇒ Object



8514
8515
8516
8517
8518
# File 'lib/parser/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



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

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

    result
end

#_reduce_231(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_232(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_233(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_234(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_235(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_236(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_237(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_238(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_24(val, _values, result) ⇒ Object



8520
8521
8522
8523
8524
# File 'lib/parser/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



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

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

    result
end

#_reduce_241(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_242(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_243(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_244(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_245(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_246(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_247(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_248(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_249(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_25(val, _values, result) ⇒ Object



8526
8527
8528
8529
8530
8531
# File 'lib/parser/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



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

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

    result
end

#_reduce_251(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_252(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_253(val, _values, result) ⇒ Object



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

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

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

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

    result
end

#_reduce_254(val, _values, result) ⇒ Object



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

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

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

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

    result
end

#_reduce_257(val, _values, result) ⇒ Object

reduce 256 omitted



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

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

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

    result
end

#_reduce_258(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_26(val, _values, result) ⇒ Object



8533
8534
8535
8536
8537
8538
# File 'lib/parser/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



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

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

    result
end

#_reduce_264(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_265(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_269(val, _values, result) ⇒ Object

reduce 268 omitted



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

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

    result
end

#_reduce_27(val, _values, result) ⇒ Object



8540
8541
8542
8543
8544
# File 'lib/parser/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



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

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

    result
end

#_reduce_272(val, _values, result) ⇒ Object

reduce 271 omitted



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

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

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

    result
end

#_reduce_273(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_274(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_275(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_276(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_278(val, _values, result) ⇒ Object

reduce 277 omitted



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

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

    result
end

#_reduce_28(val, _values, result) ⇒ Object



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



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

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

    result
end

#_reduce_282(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_283(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_284(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_285(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_286(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_287(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_288(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_289(val, _values, result) ⇒ Object



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

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

                      result = val[1]

    result
end

#_reduce_29(val, _values, result) ⇒ Object



8552
8553
8554
8555
8556
8557
8558
8559
8560
# File 'lib/parser/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



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

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

    result
end

#_reduce_291(val, _values, result) ⇒ Object



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

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

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

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

    result
end

#_reduce_292(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_293(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_294(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_296(val, _values, result) ⇒ Object

reduce 295 omitted



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

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

    result
end

#_reduce_297(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_298(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_299(val, _values, result) ⇒ Object



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

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

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

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

    result
end

#_reduce_3(val, _values, result) ⇒ Object



8387
8388
8389
8390
8391
# File 'lib/parser/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



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

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

    result
end

#_reduce_302(val, _values, result) ⇒ Object

reduce 301 omitted



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

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

    result
end

#_reduce_303(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_304(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_315(val, _values, result) ⇒ Object

reduce 314 omitted



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

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

    result
end

#_reduce_316(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_317(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_318(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_319(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_32(val, _values, result) ⇒ Object

reduce 31 omitted



8570
8571
8572
8573
8574
# File 'lib/parser/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



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

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

    result
end

#_reduce_321(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_322(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_323(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_324(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_325(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_326(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_327(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_328(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_329(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_33(val, _values, result) ⇒ Object



8576
8577
8578
8579
8580
8581
# File 'lib/parser/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



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

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

    result
end

#_reduce_331(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_332(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_334(val, _values, result) ⇒ Object

reduce 333 omitted



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

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

    result
end

#_reduce_336(val, _values, result) ⇒ Object

reduce 335 omitted



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

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

    result
end

#_reduce_337(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_338(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_339(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_34(val, _values, result) ⇒ Object



8583
8584
8585
8586
8587
8588
8589
8590
8591
8592
# File 'lib/parser/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



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

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

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

    result
end

#_reduce_341(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_342(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_343(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_344(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_345(val, _values, result) ⇒ Object



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

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

                      local_pop
                      @context.in_class = ctx.in_class

    result
end

#_reduce_346(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_347(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_348(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_349(val, _values, result) ⇒ Object



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

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

                      local_pop
                      @context.in_class = ctx.in_class

    result
end

#_reduce_35(val, _values, result) ⇒ Object



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



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

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

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

    result
end

#_reduce_351(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_352(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_353(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_354(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_355(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_357(val, _values, result) ⇒ Object

reduce 356 omitted



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

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

    result
end

#_reduce_358(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_359(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_360(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_363(val, _values, result) ⇒ Object

reduce 362 omitted



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

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

    result
end

#_reduce_367(val, _values, result) ⇒ Object

reduce 366 omitted



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

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

    result
end

#_reduce_369(val, _values, result) ⇒ Object

reduce 368 omitted



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

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

    result
end

#_reduce_37(val, _values, result) ⇒ Object

reduce 36 omitted



8602
8603
8604
8605
8606
# File 'lib/parser/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



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

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

    result
end

#_reduce_373(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_374(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_375(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_377(val, _values, result) ⇒ Object

reduce 376 omitted



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

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

    result
end

#_reduce_378(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_379(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_38(val, _values, result) ⇒ Object



8608
8609
8610
8611
8612
# File 'lib/parser/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



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

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

    result
end

#_reduce_381(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_382(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_385(val, _values, result) ⇒ Object

reduce 384 omitted



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

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

    result
end

#_reduce_386(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_387(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_388(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_389(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_39(val, _values, result) ⇒ Object



8614
8615
8616
8617
8618
8619
8620
8621
# File 'lib/parser/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



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

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

    result
end

#_reduce_391(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_392(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_394(val, _values, result) ⇒ Object

reduce 393 omitted



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

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

    result
end

#_reduce_395(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_396(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_397(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_398(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_4(val, _values, result) ⇒ Object



8393
8394
8395
8396
8397
# File 'lib/parser/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



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

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

    result
end

#_reduce_401(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_402(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_403(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_404(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_405(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_406(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_407(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_409(val, _values, result) ⇒ Object

reduce 408 omitted



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

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

    result
end

#_reduce_41(val, _values, result) ⇒ Object



8632
8633
8634
8635
8636
8637
8638
8639
# File 'lib/parser/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



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

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

    result
end

#_reduce_411(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_412(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_413(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_414(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_415(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_416(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_417(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_419(val, _values, result) ⇒ Object

reduce 418 omitted



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

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

    result
end

#_reduce_42(val, _values, result) ⇒ Object



8641
8642
8643
8644
8645
8646
8647
# File 'lib/parser/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



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

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

    result
end

#_reduce_421(val, _values, result) ⇒ Object



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

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

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

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

    result
end

#_reduce_422(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_423(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_424(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_425(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_426(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_427(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_428(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_429(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_43(val, _values, result) ⇒ Object



8649
8650
8651
8652
8653
8654
8655
8656
# File 'lib/parser/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



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

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

    result
end

#_reduce_431(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_432(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_433(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_434(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_435(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_436(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_437(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_438(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_439(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_44(val, _values, result) ⇒ Object



8658
8659
8660
8661
8662
8663
8664
8665
8666
8667
8668
8669
8670
# File 'lib/parser/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



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

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

    result
end

#_reduce_441(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_442(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_443(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_444(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_445(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_446(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_447(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_448(val, _values, result) ⇒ Object



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

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

                      @max_numparam_stack.pop
                      @static_env.unextend

    result
end

#_reduce_449(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_45(val, _values, result) ⇒ Object



8672
8673
8674
8675
8676
8677
8678
8679
8680
8681
8682
8683
8684
# File 'lib/parser/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



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

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

    result
end

#_reduce_451(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_452(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_453(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_455(val, _values, result) ⇒ Object

reduce 454 omitted



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

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

    result
end

#_reduce_456(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_457(val, _values, result) ⇒ Object



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

def _reduce_457(val, _values, result)
                      result = @context.in_kwarg
                      
                      @lexer.state = :expr_beg
                      @lexer.command_start = false
                      @context.in_kwarg = true

    result
end

#_reduce_458(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_459(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_46(val, _values, result) ⇒ Object



8686
8687
8688
8689
8690
# File 'lib/parser/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



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

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

    result
end

#_reduce_462(val, _values, result) ⇒ Object

reduce 461 omitted



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

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

    result
end

#_reduce_463(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_464(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_466(val, _values, result) ⇒ Object

reduce 465 omitted



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

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

    result
end

#_reduce_467(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_468(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_469(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_470(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_472(val, _values, result) ⇒ Object

reduce 471 omitted



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

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

    result
end

#_reduce_474(val, _values, result) ⇒ Object

reduce 473 omitted



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

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

    result
end

#_reduce_476(val, _values, result) ⇒ Object

reduce 475 omitted



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

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

    result
end

#_reduce_477(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_48(val, _values, result) ⇒ Object

reduce 47 omitted



8694
8695
8696
8697
8698
8699
8700
8701
8702
# File 'lib/parser/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



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

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

    result
end

#_reduce_481(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_482(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_483(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_484(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_485(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_486(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_487(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_488(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_489(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_49(val, _values, result) ⇒ Object



8704
8705
8706
8707
8708
# File 'lib/parser/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



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

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

    result
end

#_reduce_491(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_492(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_493(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_494(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_495(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_496(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_497(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_498(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_499(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_5(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_500(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_502(val, _values, result) ⇒ Object

reduce 501 omitted



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

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

    result
end

#_reduce_503(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_504(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_505(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_506(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_507(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_508(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_509(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_51(val, _values, result) ⇒ Object

reduce 50 omitted



8712
8713
8714
8715
8716
8717
8718
8719
8720
# File 'lib/parser/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



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

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

    result
end

#_reduce_512(val, _values, result) ⇒ Object

reduce 511 omitted



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

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

    result
end

#_reduce_513(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_514(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_515(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_516(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_517(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_518(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_519(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_520(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_521(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_522(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_523(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_524(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_526(val, _values, result) ⇒ Object

reduce 525 omitted



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

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

    result
end

#_reduce_528(val, _values, result) ⇒ Object

reduce 527 omitted



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

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

    result
end

#_reduce_529(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_530(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_531(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_535(val, _values, result) ⇒ Object

reduce 534 omitted



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

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

    result
end

#_reduce_536(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_54(val, _values, result) ⇒ Object

reduce 53 omitted



8726
8727
8728
8729
8730
# File 'lib/parser/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



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

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

    result
end

#_reduce_547(val, _values, result) ⇒ Object

reduce 546 omitted



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

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

    result
end

#_reduce_548(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_549(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_55(val, _values, result) ⇒ Object



8732
8733
8734
8735
8736
# File 'lib/parser/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



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

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

    result
end

#_reduce_551(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_552(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_553(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_554(val, _values, result) ⇒ Object



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

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

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

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

    result
end

#_reduce_555(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_556(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_559(val, _values, result) ⇒ Object

reduce 558 omitted



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

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

    result
end

#_reduce_56(val, _values, result) ⇒ Object



8738
8739
8740
8741
8742
# File 'lib/parser/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



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

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

    result
end

#_reduce_565(val, _values, result) ⇒ Object

reduce 564 omitted



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

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

    result
end

#_reduce_566(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_567(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_568(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_569(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_57(val, _values, result) ⇒ Object



8744
8745
8746
8747
8748
# File 'lib/parser/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



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

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

    result
end

#_reduce_571(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_572(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_575(val, _values, result) ⇒ Object

reduce 574 omitted



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

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

    result
end

#_reduce_576(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_577(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_578(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_579(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_58(val, _values, result) ⇒ Object



8750
8751
8752
8753
8754
8755
8756
8757
# File 'lib/parser/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



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

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

    result
end

#_reduce_581(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_582(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_583(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_584(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_585(val, _values, result) ⇒ Object



11683
11684
11685
11686
11687
# File 'lib/parser/ruby34.rb', line 11683

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

    result
end

#_reduce_586(val, _values, result) ⇒ Object



11689
11690
11691
11692
11693
# File 'lib/parser/ruby34.rb', line 11689

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

    result
end

#_reduce_587(val, _values, result) ⇒ Object



11695
11696
11697
11698
11699
# File 'lib/parser/ruby34.rb', line 11695

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

    result
end

#_reduce_588(val, _values, result) ⇒ Object



11701
11702
11703
11704
11705
# File 'lib/parser/ruby34.rb', line 11701

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

    result
end

#_reduce_589(val, _values, result) ⇒ Object



11707
11708
11709
11710
11711
# File 'lib/parser/ruby34.rb', line 11707

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

    result
end

#_reduce_59(val, _values, result) ⇒ Object



8759
8760
8761
8762
8763
8764
8765
8766
# File 'lib/parser/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



11713
11714
11715
11716
11717
# File 'lib/parser/ruby34.rb', line 11713

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

    result
end

#_reduce_591(val, _values, result) ⇒ Object



11719
11720
11721
11722
11723
# File 'lib/parser/ruby34.rb', line 11719

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

    result
end

#_reduce_592(val, _values, result) ⇒ Object



11725
11726
11727
11728
11729
# File 'lib/parser/ruby34.rb', line 11725

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

    result
end

#_reduce_593(val, _values, result) ⇒ Object



11731
11732
11733
11734
11735
# File 'lib/parser/ruby34.rb', line 11731

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

    result
end

#_reduce_594(val, _values, result) ⇒ Object



11737
11738
11739
11740
11741
# File 'lib/parser/ruby34.rb', line 11737

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

    result
end

#_reduce_595(val, _values, result) ⇒ Object



11743
11744
11745
11746
11747
# File 'lib/parser/ruby34.rb', line 11743

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

    result
end

#_reduce_596(val, _values, result) ⇒ Object



11749
11750
11751
11752
11753
# File 'lib/parser/ruby34.rb', line 11749

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

    result
end

#_reduce_597(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_598(val, _values, result) ⇒ Object



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

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

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

    result
end

#_reduce_6(val, _values, result) ⇒ Object



8405
8406
8407
8408
8409
# File 'lib/parser/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



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

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

    result
end

#_reduce_604(val, _values, result) ⇒ Object

reduce 603 omitted



11785
11786
11787
11788
11789
11790
# File 'lib/parser/ruby34.rb', line 11785

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

    result
end

#_reduce_605(val, _values, result) ⇒ Object



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

def _reduce_605(val, _values, result)
                      @lexer.state = :expr_end
                      result = @builder.symbol_compose(val[0], val[1], val[2])

    result
end

#_reduce_606(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_607(val, _values, result) ⇒ Object



11805
11806
11807
11808
11809
11810
11811
11812
11813
11814
# File 'lib/parser/ruby34.rb', line 11805

def _reduce_607(val, _values, result)
                      if @builder.respond_to? :negate
                        # AST builder interface compatibility
                        result = @builder.negate(val[0], val[1])
                      else
                        result = @builder.unary_num(val[0], val[1])
                      end

    result
end

#_reduce_608(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_609(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_610(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_611(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_612(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_613(val, _values, result) ⇒ Object



11850
11851
11852
11853
11854
# File 'lib/parser/ruby34.rb', line 11850

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

    result
end

#_reduce_614(val, _values, result) ⇒ Object



11856
11857
11858
11859
11860
# File 'lib/parser/ruby34.rb', line 11856

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

    result
end

#_reduce_615(val, _values, result) ⇒ Object



11862
11863
11864
11865
11866
# File 'lib/parser/ruby34.rb', line 11862

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

    result
end

#_reduce_616(val, _values, result) ⇒ Object



11868
11869
11870
11871
11872
# File 'lib/parser/ruby34.rb', line 11868

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

    result
end

#_reduce_618(val, _values, result) ⇒ Object

reduce 617 omitted



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

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

    result
end

#_reduce_619(val, _values, result) ⇒ Object



11882
11883
11884
11885
11886
# File 'lib/parser/ruby34.rb', line 11882

def _reduce_619(val, _values, result)
                      result = @builder.self(val[0])

    result
end

#_reduce_62(val, _values, result) ⇒ Object

reduce 61 omitted



8772
8773
8774
8775
8776
# File 'lib/parser/ruby34.rb', line 8772

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

    result
end

#_reduce_620(val, _values, result) ⇒ Object



11888
11889
11890
11891
11892
# File 'lib/parser/ruby34.rb', line 11888

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

    result
end

#_reduce_621(val, _values, result) ⇒ Object



11894
11895
11896
11897
11898
# File 'lib/parser/ruby34.rb', line 11894

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

    result
end

#_reduce_622(val, _values, result) ⇒ Object



11900
11901
11902
11903
11904
# File 'lib/parser/ruby34.rb', line 11900

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

    result
end

#_reduce_623(val, _values, result) ⇒ Object



11906
11907
11908
11909
11910
# File 'lib/parser/ruby34.rb', line 11906

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

    result
end

#_reduce_624(val, _values, result) ⇒ Object



11912
11913
11914
11915
11916
# File 'lib/parser/ruby34.rb', line 11912

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

    result
end

#_reduce_625(val, _values, result) ⇒ Object



11918
11919
11920
11921
11922
# File 'lib/parser/ruby34.rb', line 11918

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

    result
end

#_reduce_626(val, _values, result) ⇒ Object



11924
11925
11926
11927
11928
# File 'lib/parser/ruby34.rb', line 11924

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

    result
end

#_reduce_627(val, _values, result) ⇒ Object



11930
11931
11932
11933
11934
# File 'lib/parser/ruby34.rb', line 11930

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

    result
end

#_reduce_628(val, _values, result) ⇒ Object



11936
11937
11938
11939
11940
# File 'lib/parser/ruby34.rb', line 11936

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

    result
end

#_reduce_629(val, _values, result) ⇒ Object



11942
11943
11944
11945
11946
# File 'lib/parser/ruby34.rb', line 11942

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



11948
11949
11950
11951
11952
# File 'lib/parser/ruby34.rb', line 11948

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

    result
end

#_reduce_631(val, _values, result) ⇒ Object



11954
11955
11956
11957
11958
# File 'lib/parser/ruby34.rb', line 11954

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

    result
end

#_reduce_632(val, _values, result) ⇒ Object



11960
11961
11962
11963
11964
# File 'lib/parser/ruby34.rb', line 11960

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

    result
end

#_reduce_633(val, _values, result) ⇒ Object



11966
11967
11968
11969
11970
# File 'lib/parser/ruby34.rb', line 11966

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

    result
end

#_reduce_635(val, _values, result) ⇒ Object

reduce 634 omitted



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

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

    result
end

#_reduce_636(val, _values, result) ⇒ Object



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

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



11992
11993
11994
11995
11996
11997
11998
# File 'lib/parser/ruby34.rb', line 11992

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



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

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
# 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

    result
end

#_reduce_640(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_641(val, _values, result) ⇒ Object



12014
12015
12016
12017
12018
# File 'lib/parser/ruby34.rb', line 12014

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

    result
end

#_reduce_642(val, _values, result) ⇒ Object



12020
12021
12022
12023
12024
# File 'lib/parser/ruby34.rb', line 12020

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

    result
end

#_reduce_643(val, _values, result) ⇒ Object



12026
12027
12028
12029
12030
# File 'lib/parser/ruby34.rb', line 12026

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

    result
end

#_reduce_644(val, _values, result) ⇒ Object



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

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



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

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

    result
end

#_reduce_646(val, _values, result) ⇒ Object



12045
12046
12047
12048
12049
# File 'lib/parser/ruby34.rb', line 12045

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

    result
end

#_reduce_647(val, _values, result) ⇒ Object



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

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



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

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



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

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

    result
end

#_reduce_65(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_650(val, _values, result) ⇒ Object



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

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



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

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

    result
end

#_reduce_652(val, _values, result) ⇒ Object



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

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



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

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

    result
end

#_reduce_654(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_655(val, _values, result) ⇒ Object



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

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



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

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

    result
end

#_reduce_657(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_658(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_659(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_66(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_660(val, _values, result) ⇒ Object



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

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

    result
end

#_reduce_661(val, _values, result) ⇒ Object



12164
12165
12166
12167
12168
# File 'lib/parser/ruby34.rb', line 12164

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

    result
end

#_reduce_662(val, _values, result) ⇒ Object



12170
12171
12172
12173
12174
# File 'lib/parser/ruby34.rb', line 12170

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

    result
end

#_reduce_663(val, _values, result) ⇒ Object



12176
12177
12178
12179
12180
# File 'lib/parser/ruby34.rb', line 12176

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

    result
end

#_reduce_664(val, _values, result) ⇒ Object



12182
12183
12184
12185
12186
# File 'lib/parser/ruby34.rb', line 12182

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

    result
end

#_reduce_665(val, _values, result) ⇒ Object



12188
12189
12190
12191
12192
# File 'lib/parser/ruby34.rb', line 12188

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

    result
end

#_reduce_666(val, _values, result) ⇒ Object



12194
12195
12196
12197
12198
# File 'lib/parser/ruby34.rb', line 12194

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

    result
end

#_reduce_668(val, _values, result) ⇒ Object

reduce 667 omitted



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

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



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

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

    result
end

#_reduce_67(val, _values, result) ⇒ Object



8808
8809
8810
8811
8812
# File 'lib/parser/ruby34.rb', line 8808

def _reduce_67(val, _values, result)
                      result = [ val[0], val[1], val[2], val[4] ]

    result
end

#_reduce_670(val, _values, result) ⇒ Object



12219
12220
12221
12222
12223
12224
# File 'lib/parser/ruby34.rb', line 12219

def _reduce_670(val, _values, result)
                      @current_arg_stack.set(0)
                      result = @builder.arg(val[0])

    result
end

#_reduce_671(val, _values, result) ⇒ Object



12226
12227
12228
12229
12230
# File 'lib/parser/ruby34.rb', line 12226

def _reduce_671(val, _values, result)
                      result = @builder.multi_lhs(val[0], val[1], val[2])

    result
end

#_reduce_672(val, _values, result) ⇒ Object



12232
12233
12234
12235
12236
# File 'lib/parser/ruby34.rb', line 12232

def _reduce_672(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_673(val, _values, result) ⇒ Object



12238
12239
12240
12241
12242
# File 'lib/parser/ruby34.rb', line 12238

def _reduce_673(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_674(val, _values, result) ⇒ Object



12244
12245
12246
12247
12248
12249
12250
12251
12252
12253
12254
12255
12256
12257
# File 'lib/parser/ruby34.rb', line 12244

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



12259
12260
12261
12262
12263
12264
12265
# File 'lib/parser/ruby34.rb', line 12259

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



12267
12268
12269
12270
12271
12272
12273
# File 'lib/parser/ruby34.rb', line 12267

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



12275
12276
12277
12278
12279
12280
# File 'lib/parser/ruby34.rb', line 12275

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



12282
12283
12284
12285
12286
12287
# File 'lib/parser/ruby34.rb', line 12282

def _reduce_678(val, _values, result)
                      @context.in_argdef = true
                      result = @builder.kwarg(val[0])

    result
end

#_reduce_679(val, _values, result) ⇒ Object



12289
12290
12291
12292
12293
# File 'lib/parser/ruby34.rb', line 12289

def _reduce_679(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_680(val, _values, result) ⇒ Object



12295
12296
12297
12298
12299
# File 'lib/parser/ruby34.rb', line 12295

def _reduce_680(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_681(val, _values, result) ⇒ Object



12301
12302
12303
12304
12305
# File 'lib/parser/ruby34.rb', line 12301

def _reduce_681(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_682(val, _values, result) ⇒ Object



12307
12308
12309
12310
12311
# File 'lib/parser/ruby34.rb', line 12307

def _reduce_682(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_685(val, _values, result) ⇒ Object

reduce 684 omitted



12317
12318
12319
12320
12321
# File 'lib/parser/ruby34.rb', line 12317

def _reduce_685(val, _values, result)
                      result = [ @builder.kwnilarg(val[0][0], val[0][1]) ]

    result
end

#_reduce_686(val, _values, result) ⇒ Object



12323
12324
12325
12326
12327
12328
12329
# File 'lib/parser/ruby34.rb', line 12323

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



12331
12332
12333
12334
12335
12336
12337
# File 'lib/parser/ruby34.rb', line 12331

def _reduce_687(val, _values, result)
                      @static_env.declare_anonymous_kwrestarg

                      result = [ @builder.kwrestarg(val[0]) ]

    result
end

#_reduce_688(val, _values, result) ⇒ Object



12339
12340
12341
12342
12343
12344
12345
# File 'lib/parser/ruby34.rb', line 12339

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



12347
12348
12349
12350
12351
12352
12353
# File 'lib/parser/ruby34.rb', line 12347

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



12355
12356
12357
12358
12359
# File 'lib/parser/ruby34.rb', line 12355

def _reduce_690(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_691(val, _values, result) ⇒ Object



12361
12362
12363
12364
12365
# File 'lib/parser/ruby34.rb', line 12361

def _reduce_691(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_692(val, _values, result) ⇒ Object



12367
12368
12369
12370
12371
# File 'lib/parser/ruby34.rb', line 12367

def _reduce_692(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_693(val, _values, result) ⇒ Object



12373
12374
12375
12376
12377
# File 'lib/parser/ruby34.rb', line 12373

def _reduce_693(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_696(val, _values, result) ⇒ Object

reduce 695 omitted



12383
12384
12385
12386
12387
12388
12389
# File 'lib/parser/ruby34.rb', line 12383

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



12391
12392
12393
12394
12395
12396
12397
# File 'lib/parser/ruby34.rb', line 12391

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



12403
12404
12405
12406
12407
12408
12409
# File 'lib/parser/ruby34.rb', line 12403

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



12411
12412
12413
12414
12415
12416
12417
# File 'lib/parser/ruby34.rb', line 12411

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



12419
12420
12421
12422
12423
# File 'lib/parser/ruby34.rb', line 12419

def _reduce_702(val, _values, result)
                      result = [ val[1] ]

    result
end

#_reduce_703(val, _values, result) ⇒ Object



12425
12426
12427
12428
12429
# File 'lib/parser/ruby34.rb', line 12425

def _reduce_703(val, _values, result)
                      result = []

    result
end

#_reduce_705(val, _values, result) ⇒ Object

reduce 704 omitted



12433
12434
12435
12436
12437
# File 'lib/parser/ruby34.rb', line 12433

def _reduce_705(val, _values, result)
                      result = val[1]

    result
end

#_reduce_706(val, _values, result) ⇒ Object



12439
12440
12441
12442
12443
# File 'lib/parser/ruby34.rb', line 12439

def _reduce_706(val, _values, result)
                      result = []

    result
end

#_reduce_708(val, _values, result) ⇒ Object

reduce 707 omitted



12447
12448
12449
12450
12451
# File 'lib/parser/ruby34.rb', line 12447

def _reduce_708(val, _values, result)
                      result = [ val[0] ]

    result
end

#_reduce_709(val, _values, result) ⇒ Object



12453
12454
12455
12456
12457
# File 'lib/parser/ruby34.rb', line 12453

def _reduce_709(val, _values, result)
                      result = val[0] << val[2]

    result
end

#_reduce_71(val, _values, result) ⇒ Object

reduce 70 omitted



8820
8821
8822
8823
8824
8825
# File 'lib/parser/ruby34.rb', line 8820

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



12459
12460
12461
12462
12463
# File 'lib/parser/ruby34.rb', line 12459

def _reduce_710(val, _values, result)
                      result = @builder.pair(val[0], val[1], val[2])

    result
end

#_reduce_711(val, _values, result) ⇒ Object



12465
12466
12467
12468
12469
# File 'lib/parser/ruby34.rb', line 12465

def _reduce_711(val, _values, result)
                      result = @builder.pair_keyword(val[0], val[1])

    result
end

#_reduce_712(val, _values, result) ⇒ Object



12471
12472
12473
12474
12475
# File 'lib/parser/ruby34.rb', line 12471

def _reduce_712(val, _values, result)
                      result = @builder.pair_label(val[0])

    result
end

#_reduce_713(val, _values, result) ⇒ Object



12477
12478
12479
12480
12481
# File 'lib/parser/ruby34.rb', line 12477

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



12483
12484
12485
12486
12487
# File 'lib/parser/ruby34.rb', line 12483

def _reduce_714(val, _values, result)
                      result = @builder.kwsplat(val[0], val[1])

    result
end

#_reduce_715(val, _values, result) ⇒ Object



12489
12490
12491
12492
12493
12494
12495
12496
12497
12498
12499
12500
12501
12502
# File 'lib/parser/ruby34.rb', line 12489

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



8827
8828
8829
8830
8831
8832
# File 'lib/parser/ruby34.rb', line 8827

def _reduce_72(val, _values, result)
                      result = @context.dup
                      @context.in_block = true

    result
end

#_reduce_726(val, _values, result) ⇒ Object

reduce 725 omitted



12524
12525
12526
12527
12528
# File 'lib/parser/ruby34.rb', line 12524

def _reduce_726(val, _values, result)
                      result = [:dot, val[0][1]]

    result
end

#_reduce_727(val, _values, result) ⇒ Object



12530
12531
12532
12533
12534
# File 'lib/parser/ruby34.rb', line 12530

def _reduce_727(val, _values, result)
                      result = [:anddot, val[0][1]]

    result
end

#_reduce_73(val, _values, result) ⇒ Object



8834
8835
8836
8837
8838
8839
# File 'lib/parser/ruby34.rb', line 8834

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



12544
12545
12546
12547
12548
# File 'lib/parser/ruby34.rb', line 12544

def _reduce_732(val, _values, result)
                      result = val[1]

    result
end

#_reduce_733(val, _values, result) ⇒ Object



12550
12551
12552
12553
12554
# File 'lib/parser/ruby34.rb', line 12550

def _reduce_733(val, _values, result)
                      result = val[1]

    result
end

#_reduce_734(val, _values, result) ⇒ Object



12556
12557
12558
12559
12560
# File 'lib/parser/ruby34.rb', line 12556

def _reduce_734(val, _values, result)
                      result = val[1]

    result
end

#_reduce_737(val, _values, result) ⇒ Object

reduce 736 omitted



12566
12567
12568
12569
12570
# File 'lib/parser/ruby34.rb', line 12566

def _reduce_737(val, _values, result)
                    yyerrok

    result
end

#_reduce_741(val, _values, result) ⇒ Object

reduce 740 omitted



12578
12579
12580
12581
12582
# File 'lib/parser/ruby34.rb', line 12578

def _reduce_741(val, _values, result)
                    result = nil

    result
end

#_reduce_75(val, _values, result) ⇒ Object

reduce 74 omitted



8843
8844
8845
8846
8847
8848
# File 'lib/parser/ruby34.rb', line 8843

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



8850
8851
8852
8853
8854
8855
8856
8857
8858
8859
# File 'lib/parser/ruby34.rb', line 8850

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



8861
8862
8863
8864
8865
8866
# File 'lib/parser/ruby34.rb', line 8861

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



8868
8869
8870
8871
8872
8873
8874
8875
8876
8877
# File 'lib/parser/ruby34.rb', line 8868

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



8879
8880
8881
8882
8883
8884
# File 'lib/parser/ruby34.rb', line 8879

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



8886
8887
8888
8889
8890
8891
8892
8893
8894
8895
# File 'lib/parser/ruby34.rb', line 8886

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



8897
8898
8899
8900
8901
8902
8903
8904
8905
# File 'lib/parser/ruby34.rb', line 8897

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



8907
8908
8909
8910
8911
8912
# File 'lib/parser/ruby34.rb', line 8907

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



8914
8915
8916
8917
8918
8919
# File 'lib/parser/ruby34.rb', line 8914

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



8921
8922
8923
8924
8925
8926
# File 'lib/parser/ruby34.rb', line 8921

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



8928
8929
8930
8931
8932
8933
# File 'lib/parser/ruby34.rb', line 8928

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



8935
8936
8937
8938
8939
8940
# File 'lib/parser/ruby34.rb', line 8935

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



8942
8943
8944
8945
8946
# File 'lib/parser/ruby34.rb', line 8942

def _reduce_87(val, _values, result)
                      result = @builder.multi_lhs(nil, val[0], nil)

    result
end

#_reduce_88(val, _values, result) ⇒ Object



8948
8949
8950
8951
8952
# File 'lib/parser/ruby34.rb', line 8948

def _reduce_88(val, _values, result)
                      result = @builder.begin(val[0], val[1], val[2])

    result
end

#_reduce_89(val, _values, result) ⇒ Object



8954
8955
8956
8957
8958
# File 'lib/parser/ruby34.rb', line 8954

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



8960
8961
8962
8963
8964
# File 'lib/parser/ruby34.rb', line 8960

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



8968
8969
8970
8971
8972
8973
# File 'lib/parser/ruby34.rb', line 8968

def _reduce_92(val, _values, result)
                      result = val[0].
                                  push(val[1])

    result
end

#_reduce_93(val, _values, result) ⇒ Object



8975
8976
8977
8978
8979
8980
# File 'lib/parser/ruby34.rb', line 8975

def _reduce_93(val, _values, result)
                      result = val[0].
                                  push(@builder.splat(val[1], val[2]))

    result
end

#_reduce_94(val, _values, result) ⇒ Object



8982
8983
8984
8985
8986
8987
8988
# File 'lib/parser/ruby34.rb', line 8982

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



8990
8991
8992
8993
8994
8995
# File 'lib/parser/ruby34.rb', line 8990

def _reduce_95(val, _values, result)
                      result = val[0].
                                  push(@builder.splat(val[1]))

    result
end

#_reduce_96(val, _values, result) ⇒ Object



8997
8998
8999
9000
9001
9002
9003
# File 'lib/parser/ruby34.rb', line 8997

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



9005
9006
9007
9008
9009
# File 'lib/parser/ruby34.rb', line 9005

def _reduce_97(val, _values, result)
                      result = [ @builder.splat(val[0], val[1]) ]

    result
end

#_reduce_98(val, _values, result) ⇒ Object



9011
9012
9013
9014
9015
9016
# File 'lib/parser/ruby34.rb', line 9011

def _reduce_98(val, _values, result)
                      result = [ @builder.splat(val[0], val[1]),
                                 *val[3] ]

    result
end

#_reduce_99(val, _values, result) ⇒ Object



9018
9019
9020
9021
9022
# File 'lib/parser/ruby34.rb', line 9018

def _reduce_99(val, _values, result)
                      result = [ @builder.splat(val[0]) ]

    result
end

#_reduce_none(val, _values, result) ⇒ Object



12584
12585
12586
# File 'lib/parser/ruby34.rb', line 12584

def _reduce_none(val, _values, result)
  val[0]
end

#default_encodingObject



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_popObject



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_pushObject



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

#versionObject



17
18
19
# File 'lib/parser/ruby34.rb', line 17

def version
  34
end