parser 2.7.1.4 → 3.0.1.1

Sign up to get free protection for your applications and to get access to all the features.
Files changed (99) hide show
  1. checksums.yaml +4 -4
  2. data/lib/parser.rb +1 -1
  3. data/lib/parser/all.rb +2 -1
  4. data/lib/parser/ast/processor.rb +3 -7
  5. data/lib/parser/base.rb +7 -5
  6. data/lib/parser/builders/default.rb +178 -29
  7. data/lib/parser/context.rb +4 -0
  8. data/lib/parser/current.rb +20 -11
  9. data/lib/parser/current_arg_stack.rb +5 -2
  10. data/lib/parser/lexer.rb +23780 -0
  11. data/lib/parser/macruby.rb +6149 -0
  12. data/lib/parser/max_numparam_stack.rb +13 -5
  13. data/lib/parser/messages.rb +3 -0
  14. data/lib/parser/meta.rb +7 -6
  15. data/lib/parser/ruby18.rb +5667 -0
  16. data/lib/parser/ruby19.rb +6092 -0
  17. data/lib/parser/ruby20.rb +6527 -0
  18. data/lib/parser/ruby21.rb +6578 -0
  19. data/lib/parser/ruby22.rb +6613 -0
  20. data/lib/parser/ruby23.rb +6624 -0
  21. data/lib/parser/ruby24.rb +6694 -0
  22. data/lib/parser/ruby25.rb +6662 -0
  23. data/lib/parser/ruby26.rb +6676 -0
  24. data/lib/parser/ruby27.rb +7862 -0
  25. data/lib/parser/ruby28.rb +8047 -0
  26. data/lib/parser/ruby30.rb +8060 -0
  27. data/lib/parser/ruby31.rb +8075 -0
  28. data/lib/parser/rubymotion.rb +6086 -0
  29. data/lib/parser/runner.rb +9 -4
  30. data/lib/parser/source/buffer.rb +50 -27
  31. data/lib/parser/source/comment.rb +14 -1
  32. data/lib/parser/source/comment/associator.rb +18 -5
  33. data/lib/parser/source/map/{endless_definition.rb → method_definition.rb} +5 -3
  34. data/lib/parser/source/range.rb +2 -2
  35. data/lib/parser/source/tree_rewriter.rb +27 -0
  36. data/lib/parser/static_environment.rb +4 -0
  37. data/lib/parser/variables_stack.rb +4 -0
  38. data/lib/parser/version.rb +1 -1
  39. data/parser.gemspec +1 -17
  40. metadata +9 -97
  41. data/.gitignore +0 -34
  42. data/.travis.yml +0 -40
  43. data/.yardopts +0 -21
  44. data/CHANGELOG.md +0 -1116
  45. data/CONTRIBUTING.md +0 -17
  46. data/Gemfile +0 -10
  47. data/README.md +0 -309
  48. data/Rakefile +0 -167
  49. data/ci/run_rubocop_specs +0 -14
  50. data/doc/AST_FORMAT.md +0 -2283
  51. data/doc/CUSTOMIZATION.md +0 -37
  52. data/doc/INTERNALS.md +0 -21
  53. data/doc/css/.gitkeep +0 -0
  54. data/doc/css/common.css +0 -68
  55. data/lib/parser/lexer.rl +0 -2550
  56. data/lib/parser/macruby.y +0 -2208
  57. data/lib/parser/ruby18.y +0 -1936
  58. data/lib/parser/ruby19.y +0 -2185
  59. data/lib/parser/ruby20.y +0 -2363
  60. data/lib/parser/ruby21.y +0 -2364
  61. data/lib/parser/ruby22.y +0 -2371
  62. data/lib/parser/ruby23.y +0 -2377
  63. data/lib/parser/ruby24.y +0 -2415
  64. data/lib/parser/ruby25.y +0 -2412
  65. data/lib/parser/ruby26.y +0 -2420
  66. data/lib/parser/ruby27.y +0 -2950
  67. data/lib/parser/ruby28.y +0 -3043
  68. data/lib/parser/rubymotion.y +0 -2192
  69. data/test/bug_163/fixtures/input.rb +0 -5
  70. data/test/bug_163/fixtures/output.rb +0 -5
  71. data/test/bug_163/rewriter.rb +0 -20
  72. data/test/helper.rb +0 -103
  73. data/test/parse_helper.rb +0 -323
  74. data/test/racc_coverage_helper.rb +0 -133
  75. data/test/test_ast_processor.rb +0 -32
  76. data/test/test_base.rb +0 -31
  77. data/test/test_current.rb +0 -31
  78. data/test/test_diagnostic.rb +0 -95
  79. data/test/test_diagnostic_engine.rb +0 -59
  80. data/test/test_encoding.rb +0 -99
  81. data/test/test_lexer.rb +0 -3617
  82. data/test/test_lexer_stack_state.rb +0 -78
  83. data/test/test_meta.rb +0 -12
  84. data/test/test_parse_helper.rb +0 -80
  85. data/test/test_parser.rb +0 -9780
  86. data/test/test_runner_parse.rb +0 -56
  87. data/test/test_runner_rewrite.rb +0 -47
  88. data/test/test_source_buffer.rb +0 -165
  89. data/test/test_source_comment.rb +0 -36
  90. data/test/test_source_comment_associator.rb +0 -399
  91. data/test/test_source_map.rb +0 -14
  92. data/test/test_source_range.rb +0 -192
  93. data/test/test_source_rewriter.rb +0 -541
  94. data/test/test_source_rewriter_action.rb +0 -46
  95. data/test/test_source_tree_rewriter.rb +0 -361
  96. data/test/test_static_environment.rb +0 -45
  97. data/test/using_tree_rewriter/fixtures/input.rb +0 -3
  98. data/test/using_tree_rewriter/fixtures/output.rb +0 -3
  99. data/test/using_tree_rewriter/using_tree_rewriter.rb +0 -9
data/lib/parser/ruby28.y DELETED
@@ -1,3043 +0,0 @@
1
- class Parser::Ruby28
2
-
3
- token kCLASS kMODULE kDEF kUNDEF kBEGIN kRESCUE kENSURE kEND kIF kUNLESS
4
- kTHEN kELSIF kELSE kCASE kWHEN kWHILE kUNTIL kFOR kBREAK kNEXT
5
- kREDO kRETRY kIN kDO kDO_COND kDO_BLOCK kDO_LAMBDA kRETURN kYIELD kSUPER
6
- kSELF kNIL kTRUE kFALSE kAND kOR kNOT kIF_MOD kUNLESS_MOD kWHILE_MOD
7
- kUNTIL_MOD kRESCUE_MOD kALIAS kDEFINED klBEGIN klEND k__LINE__
8
- k__FILE__ k__ENCODING__ tIDENTIFIER tFID tGVAR tIVAR tCONSTANT
9
- tLABEL tCVAR tNTH_REF tBACK_REF tSTRING_CONTENT tINTEGER tFLOAT
10
- tUPLUS tUMINUS tUNARY_NUM tPOW tCMP tEQ tEQQ tNEQ
11
- tGEQ tLEQ tANDOP tOROP tMATCH tNMATCH tDOT tDOT2 tDOT3 tAREF
12
- tASET tLSHFT tRSHFT tCOLON2 tCOLON3 tOP_ASGN tASSOC tLPAREN
13
- tLPAREN2 tRPAREN tLPAREN_ARG tLBRACK tLBRACK2 tRBRACK tLBRACE
14
- tLBRACE_ARG tSTAR tSTAR2 tAMPER tAMPER2 tTILDE tPERCENT tDIVIDE
15
- tDSTAR tPLUS tMINUS tLT tGT tPIPE tBANG tCARET tLCURLY tRCURLY
16
- tBACK_REF2 tSYMBEG tSTRING_BEG tXSTRING_BEG tREGEXP_BEG tREGEXP_OPT
17
- tWORDS_BEG tQWORDS_BEG tSYMBOLS_BEG tQSYMBOLS_BEG tSTRING_DBEG
18
- tSTRING_DVAR tSTRING_END tSTRING_DEND tSTRING tSYMBOL
19
- tNL tEH tCOLON tCOMMA tSPACE tSEMI tLAMBDA tLAMBEG tCHARACTER
20
- tRATIONAL tIMAGINARY tLABEL_END tANDDOT tBDOT2 tBDOT3
21
-
22
- prechigh
23
- right tBANG tTILDE tUPLUS
24
- right tPOW
25
- right tUNARY_NUM tUMINUS
26
- left tSTAR2 tDIVIDE tPERCENT
27
- left tPLUS tMINUS
28
- left tLSHFT tRSHFT
29
- left tAMPER2
30
- left tPIPE tCARET
31
- left tGT tGEQ tLT tLEQ
32
- nonassoc tCMP tEQ tEQQ tNEQ tMATCH tNMATCH
33
- left tANDOP
34
- left tOROP
35
- nonassoc tDOT2 tDOT3 tBDOT2 tBDOT3
36
- right tEH tCOLON
37
- left kRESCUE_MOD
38
- right tEQL tOP_ASGN
39
- nonassoc kDEFINED
40
- right kNOT
41
- left kOR kAND
42
- nonassoc kIF_MOD kUNLESS_MOD kWHILE_MOD kUNTIL_MOD kIN
43
- nonassoc tLBRACE_ARG
44
- nonassoc tLOWEST
45
- preclow
46
-
47
- rule
48
-
49
- program: top_compstmt
50
-
51
- top_compstmt: top_stmts opt_terms
52
- {
53
- result = @builder.compstmt(val[0])
54
- }
55
-
56
- top_stmts: # nothing
57
- {
58
- result = []
59
- }
60
- | top_stmt
61
- {
62
- result = [ val[0] ]
63
- }
64
- | top_stmts terms top_stmt
65
- {
66
- result = val[0] << val[2]
67
- }
68
- | error top_stmt
69
- {
70
- result = [ val[1] ]
71
- }
72
-
73
- top_stmt: stmt
74
- | klBEGIN begin_block
75
- {
76
- result = @builder.preexe(val[0], *val[1])
77
- }
78
-
79
- begin_block: tLCURLY top_compstmt tRCURLY
80
- {
81
- result = val
82
- }
83
-
84
- bodystmt: compstmt opt_rescue opt_else opt_ensure
85
- {
86
- rescue_bodies = val[1]
87
- else_t, else_ = val[2]
88
- ensure_t, ensure_ = val[3]
89
-
90
- if rescue_bodies.empty? && !else_t.nil?
91
- diagnostic :error, :useless_else, nil, else_t
92
- end
93
-
94
- result = @builder.begin_body(val[0],
95
- rescue_bodies,
96
- else_t, else_,
97
- ensure_t, ensure_)
98
- }
99
-
100
- compstmt: stmts opt_terms
101
- {
102
- result = @builder.compstmt(val[0])
103
- }
104
-
105
- stmts: # nothing
106
- {
107
- result = []
108
- }
109
- | stmt_or_begin
110
- {
111
- result = [ val[0] ]
112
- }
113
- | stmts terms stmt_or_begin
114
- {
115
- result = val[0] << val[2]
116
- }
117
- | error stmt
118
- {
119
- result = [ val[1] ]
120
- }
121
-
122
- stmt_or_begin: stmt
123
- | klBEGIN begin_block
124
- {
125
- diagnostic :error, :begin_in_method, nil, val[0]
126
- }
127
-
128
- stmt: kALIAS fitem
129
- {
130
- @lexer.state = :expr_fname
131
- }
132
- fitem
133
- {
134
- result = @builder.alias(val[0], val[1], val[3])
135
- }
136
- | kALIAS tGVAR tGVAR
137
- {
138
- result = @builder.alias(val[0],
139
- @builder.gvar(val[1]),
140
- @builder.gvar(val[2]))
141
- }
142
- | kALIAS tGVAR tBACK_REF
143
- {
144
- result = @builder.alias(val[0],
145
- @builder.gvar(val[1]),
146
- @builder.back_ref(val[2]))
147
- }
148
- | kALIAS tGVAR tNTH_REF
149
- {
150
- diagnostic :error, :nth_ref_alias, nil, val[2]
151
- }
152
- | kUNDEF undef_list
153
- {
154
- result = @builder.undef_method(val[0], val[1])
155
- }
156
- | stmt kIF_MOD expr_value
157
- {
158
- result = @builder.condition_mod(val[0], nil,
159
- val[1], val[2])
160
- }
161
- | stmt kUNLESS_MOD expr_value
162
- {
163
- result = @builder.condition_mod(nil, val[0],
164
- val[1], val[2])
165
- }
166
- | stmt kWHILE_MOD expr_value
167
- {
168
- result = @builder.loop_mod(:while, val[0], val[1], val[2])
169
- }
170
- | stmt kUNTIL_MOD expr_value
171
- {
172
- result = @builder.loop_mod(:until, val[0], val[1], val[2])
173
- }
174
- | stmt kRESCUE_MOD stmt
175
- {
176
- rescue_body = @builder.rescue_body(val[1],
177
- nil, nil, nil,
178
- nil, val[2])
179
-
180
- result = @builder.begin_body(val[0], [ rescue_body ])
181
- }
182
- | klEND tLCURLY compstmt tRCURLY
183
- {
184
- result = @builder.postexe(val[0], val[1], val[2], val[3])
185
- }
186
- | command_asgn
187
- | mlhs tEQL command_call
188
- {
189
- result = @builder.multi_assign(val[0], val[1], val[2])
190
- }
191
- | lhs tEQL mrhs
192
- {
193
- result = @builder.assign(val[0], val[1],
194
- @builder.array(nil, val[2], nil))
195
- }
196
- | mlhs tEQL mrhs_arg kRESCUE_MOD stmt
197
- {
198
- rescue_body = @builder.rescue_body(val[3],
199
- nil, nil, nil,
200
- nil, val[4])
201
- begin_body = @builder.begin_body(val[2], [ rescue_body ])
202
-
203
- result = @builder.multi_assign(val[0], val[1], begin_body)
204
- }
205
- | mlhs tEQL mrhs_arg
206
- {
207
- result = @builder.multi_assign(val[0], val[1], val[2])
208
- }
209
- | rassign
210
- | expr
211
-
212
- rassign: arg_value tASSOC lhs
213
- {
214
- result = @builder.rassign(val[0], val[1], val[2])
215
- }
216
- | arg_value tASSOC mlhs
217
- {
218
- result = @builder.multi_rassign(val[0], val[1], val[2])
219
- }
220
- | rassign tASSOC lhs
221
- {
222
- result = @builder.rassign(val[0], val[1], val[2])
223
- }
224
- | rassign tASSOC mlhs
225
- {
226
- result = @builder.multi_rassign(val[0], val[1], val[2])
227
- }
228
-
229
- command_asgn: lhs tEQL command_rhs
230
- {
231
- result = @builder.assign(val[0], val[1], val[2])
232
- }
233
- | var_lhs tOP_ASGN command_rhs
234
- {
235
- result = @builder.op_assign(val[0], val[1], val[2])
236
- }
237
- | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN command_rhs
238
- {
239
- result = @builder.op_assign(
240
- @builder.index(
241
- val[0], val[1], val[2], val[3]),
242
- val[4], val[5])
243
- }
244
- | primary_value call_op tIDENTIFIER tOP_ASGN command_rhs
245
- {
246
- result = @builder.op_assign(
247
- @builder.call_method(
248
- val[0], val[1], val[2]),
249
- val[3], val[4])
250
- }
251
- | primary_value call_op tCONSTANT tOP_ASGN command_rhs
252
- {
253
- result = @builder.op_assign(
254
- @builder.call_method(
255
- val[0], val[1], val[2]),
256
- val[3], val[4])
257
- }
258
- | primary_value tCOLON2 tCONSTANT tOP_ASGN command_rhs
259
- {
260
- const = @builder.const_op_assignable(
261
- @builder.const_fetch(val[0], val[1], val[2]))
262
- result = @builder.op_assign(const, val[3], val[4])
263
- }
264
- | primary_value tCOLON2 tIDENTIFIER tOP_ASGN command_rhs
265
- {
266
- result = @builder.op_assign(
267
- @builder.call_method(
268
- val[0], val[1], val[2]),
269
- val[3], val[4])
270
- }
271
- | backref tOP_ASGN command_rhs
272
- {
273
- @builder.op_assign(val[0], val[1], val[2])
274
- }
275
-
276
- command_rhs: command_call =tOP_ASGN
277
- | command_call kRESCUE_MOD stmt
278
- {
279
- rescue_body = @builder.rescue_body(val[1],
280
- nil, nil, nil,
281
- nil, val[2])
282
-
283
- result = @builder.begin_body(val[0], [ rescue_body ])
284
- }
285
- | command_asgn
286
-
287
- expr: command_call
288
- | expr kAND expr
289
- {
290
- result = @builder.logical_op(:and, val[0], val[1], val[2])
291
- }
292
- | expr kOR expr
293
- {
294
- result = @builder.logical_op(:or, val[0], val[1], val[2])
295
- }
296
- | kNOT opt_nl expr
297
- {
298
- result = @builder.not_op(val[0], nil, val[2], nil)
299
- }
300
- | tBANG command_call
301
- {
302
- result = @builder.not_op(val[0], nil, val[1], nil)
303
- }
304
- | arg kIN
305
- {
306
- @lexer.state = :expr_beg
307
- @lexer.command_start = false
308
- pattern_variables.push
309
-
310
- result = @lexer.in_kwarg
311
- @lexer.in_kwarg = true
312
- }
313
- p_expr
314
- {
315
- @lexer.in_kwarg = val[2]
316
- result = @builder.in_match(val[0], val[1], val[3])
317
- }
318
- | arg =tLBRACE_ARG
319
-
320
- expr_value: expr
321
-
322
- expr_value_do: {
323
- @lexer.cond.push(true)
324
- }
325
- expr_value do
326
- {
327
- @lexer.cond.pop
328
- result = [ val[1], val[2] ]
329
- }
330
-
331
- def_name: fname
332
- {
333
- @static_env.extend_static
334
- @lexer.cmdarg.push(false)
335
- @lexer.cond.push(false)
336
- @current_arg_stack.push(nil)
337
-
338
- result = val[0]
339
- }
340
-
341
- defn_head: kDEF def_name
342
- {
343
- @context.push(:def)
344
-
345
- result = [ val[0], val[1] ]
346
- }
347
-
348
- defs_head: kDEF singleton dot_or_colon
349
- {
350
- @lexer.state = :expr_fname
351
- }
352
- def_name
353
- {
354
- @context.push(:defs)
355
-
356
- result = [ val[0], val[1], val[2], val[4] ]
357
- }
358
-
359
-
360
- command_call: command
361
- | block_command
362
-
363
- block_command: block_call
364
- | block_call dot_or_colon operation2 command_args
365
- {
366
- result = @builder.call_method(val[0], val[1], val[2],
367
- nil, val[3], nil)
368
- }
369
-
370
- cmd_brace_block: tLBRACE_ARG
371
- {
372
- @context.push(:block)
373
- }
374
- brace_body tRCURLY
375
- {
376
- result = [ val[0], *val[2], val[3] ]
377
- @context.pop
378
- }
379
-
380
- fcall: operation
381
-
382
- command: fcall command_args =tLOWEST
383
- {
384
- result = @builder.call_method(nil, nil, val[0],
385
- nil, val[1], nil)
386
- }
387
- | fcall command_args cmd_brace_block
388
- {
389
- method_call = @builder.call_method(nil, nil, val[0],
390
- nil, val[1], nil)
391
-
392
- begin_t, args, body, end_t = val[2]
393
- result = @builder.block(method_call,
394
- begin_t, args, body, end_t)
395
- }
396
- | primary_value call_op operation2 command_args =tLOWEST
397
- {
398
- result = @builder.call_method(val[0], val[1], val[2],
399
- nil, val[3], nil)
400
- }
401
- | primary_value call_op operation2 command_args cmd_brace_block
402
- {
403
- method_call = @builder.call_method(val[0], val[1], val[2],
404
- nil, val[3], nil)
405
-
406
- begin_t, args, body, end_t = val[4]
407
- result = @builder.block(method_call,
408
- begin_t, args, body, end_t)
409
- }
410
- | primary_value tCOLON2 operation2 command_args =tLOWEST
411
- {
412
- result = @builder.call_method(val[0], val[1], val[2],
413
- nil, val[3], nil)
414
- }
415
- | primary_value tCOLON2 operation2 command_args cmd_brace_block
416
- {
417
- method_call = @builder.call_method(val[0], val[1], val[2],
418
- nil, val[3], nil)
419
-
420
- begin_t, args, body, end_t = val[4]
421
- result = @builder.block(method_call,
422
- begin_t, args, body, end_t)
423
- }
424
- | kSUPER command_args
425
- {
426
- result = @builder.keyword_cmd(:super, val[0],
427
- nil, val[1], nil)
428
- }
429
- | kYIELD command_args
430
- {
431
- result = @builder.keyword_cmd(:yield, val[0],
432
- nil, val[1], nil)
433
- }
434
- | k_return call_args
435
- {
436
- result = @builder.keyword_cmd(:return, val[0],
437
- nil, val[1], nil)
438
- }
439
- | kBREAK call_args
440
- {
441
- result = @builder.keyword_cmd(:break, val[0],
442
- nil, val[1], nil)
443
- }
444
- | kNEXT call_args
445
- {
446
- result = @builder.keyword_cmd(:next, val[0],
447
- nil, val[1], nil)
448
- }
449
-
450
- mlhs: mlhs_basic
451
- {
452
- result = @builder.multi_lhs(nil, val[0], nil)
453
- }
454
- | tLPAREN mlhs_inner rparen
455
- {
456
- result = @builder.begin(val[0], val[1], val[2])
457
- }
458
-
459
- mlhs_inner: mlhs_basic
460
- {
461
- result = @builder.multi_lhs(nil, val[0], nil)
462
- }
463
- | tLPAREN mlhs_inner rparen
464
- {
465
- result = @builder.multi_lhs(val[0], val[1], val[2])
466
- }
467
-
468
- mlhs_basic: mlhs_head
469
- | mlhs_head mlhs_item
470
- {
471
- result = val[0].
472
- push(val[1])
473
- }
474
- | mlhs_head tSTAR mlhs_node
475
- {
476
- result = val[0].
477
- push(@builder.splat(val[1], val[2]))
478
- }
479
- | mlhs_head tSTAR mlhs_node tCOMMA mlhs_post
480
- {
481
- result = val[0].
482
- push(@builder.splat(val[1], val[2])).
483
- concat(val[4])
484
- }
485
- | mlhs_head tSTAR
486
- {
487
- result = val[0].
488
- push(@builder.splat(val[1]))
489
- }
490
- | mlhs_head tSTAR tCOMMA mlhs_post
491
- {
492
- result = val[0].
493
- push(@builder.splat(val[1])).
494
- concat(val[3])
495
- }
496
- | tSTAR mlhs_node
497
- {
498
- result = [ @builder.splat(val[0], val[1]) ]
499
- }
500
- | tSTAR mlhs_node tCOMMA mlhs_post
501
- {
502
- result = [ @builder.splat(val[0], val[1]),
503
- *val[3] ]
504
- }
505
- | tSTAR
506
- {
507
- result = [ @builder.splat(val[0]) ]
508
- }
509
- | tSTAR tCOMMA mlhs_post
510
- {
511
- result = [ @builder.splat(val[0]),
512
- *val[2] ]
513
- }
514
-
515
- mlhs_item: mlhs_node
516
- | tLPAREN mlhs_inner rparen
517
- {
518
- result = @builder.begin(val[0], val[1], val[2])
519
- }
520
-
521
- mlhs_head: mlhs_item tCOMMA
522
- {
523
- result = [ val[0] ]
524
- }
525
- | mlhs_head mlhs_item tCOMMA
526
- {
527
- result = val[0] << val[1]
528
- }
529
-
530
- mlhs_post: mlhs_item
531
- {
532
- result = [ val[0] ]
533
- }
534
- | mlhs_post tCOMMA mlhs_item
535
- {
536
- result = val[0] << val[2]
537
- }
538
-
539
- mlhs_node: user_variable
540
- {
541
- result = @builder.assignable(val[0])
542
- }
543
- | keyword_variable
544
- {
545
- result = @builder.assignable(val[0])
546
- }
547
- | primary_value tLBRACK2 opt_call_args rbracket
548
- {
549
- result = @builder.index_asgn(val[0], val[1], val[2], val[3])
550
- }
551
- | primary_value call_op tIDENTIFIER
552
- {
553
- if (val[1][0] == :anddot)
554
- diagnostic :error, :csend_in_lhs_of_masgn, nil, val[1]
555
- end
556
-
557
- result = @builder.attr_asgn(val[0], val[1], val[2])
558
- }
559
- | primary_value tCOLON2 tIDENTIFIER
560
- {
561
- result = @builder.attr_asgn(val[0], val[1], val[2])
562
- }
563
- | primary_value call_op tCONSTANT
564
- {
565
- if (val[1][0] == :anddot)
566
- diagnostic :error, :csend_in_lhs_of_masgn, nil, val[1]
567
- end
568
-
569
- result = @builder.attr_asgn(val[0], val[1], val[2])
570
- }
571
- | primary_value tCOLON2 tCONSTANT
572
- {
573
- result = @builder.assignable(
574
- @builder.const_fetch(val[0], val[1], val[2]))
575
- }
576
- | tCOLON3 tCONSTANT
577
- {
578
- result = @builder.assignable(
579
- @builder.const_global(val[0], val[1]))
580
- }
581
- | backref
582
- {
583
- result = @builder.assignable(val[0])
584
- }
585
-
586
- lhs: user_variable
587
- {
588
- result = @builder.assignable(val[0])
589
- }
590
- | keyword_variable
591
- {
592
- result = @builder.assignable(val[0])
593
- }
594
- | primary_value tLBRACK2 opt_call_args rbracket
595
- {
596
- result = @builder.index_asgn(val[0], val[1], val[2], val[3])
597
- }
598
- | primary_value call_op tIDENTIFIER
599
- {
600
- result = @builder.attr_asgn(val[0], val[1], val[2])
601
- }
602
- | primary_value tCOLON2 tIDENTIFIER
603
- {
604
- result = @builder.attr_asgn(val[0], val[1], val[2])
605
- }
606
- | primary_value call_op tCONSTANT
607
- {
608
- result = @builder.attr_asgn(val[0], val[1], val[2])
609
- }
610
- | primary_value tCOLON2 tCONSTANT
611
- {
612
- result = @builder.assignable(
613
- @builder.const_fetch(val[0], val[1], val[2]))
614
- }
615
- | tCOLON3 tCONSTANT
616
- {
617
- result = @builder.assignable(
618
- @builder.const_global(val[0], val[1]))
619
- }
620
- | backref
621
- {
622
- result = @builder.assignable(val[0])
623
- }
624
-
625
- cname: tIDENTIFIER
626
- {
627
- diagnostic :error, :module_name_const, nil, val[0]
628
- }
629
- | tCONSTANT
630
-
631
- cpath: tCOLON3 cname
632
- {
633
- result = @builder.const_global(val[0], val[1])
634
- }
635
- | cname
636
- {
637
- result = @builder.const(val[0])
638
- }
639
- | primary_value tCOLON2 cname
640
- {
641
- result = @builder.const_fetch(val[0], val[1], val[2])
642
- }
643
-
644
- fname: tIDENTIFIER | tCONSTANT | tFID
645
- | op
646
- | reswords
647
-
648
- fitem: fname
649
- {
650
- result = @builder.symbol(val[0])
651
- }
652
- | symbol
653
-
654
- undef_list: fitem
655
- {
656
- result = [ val[0] ]
657
- }
658
- | undef_list tCOMMA
659
- {
660
- @lexer.state = :expr_fname
661
- }
662
- fitem
663
- {
664
- result = val[0] << val[3]
665
- }
666
-
667
- op: tPIPE | tCARET | tAMPER2 | tCMP | tEQ | tEQQ
668
- | tMATCH | tNMATCH | tGT | tGEQ | tLT | tLEQ
669
- | tNEQ | tLSHFT | tRSHFT | tPLUS | tMINUS | tSTAR2
670
- | tSTAR | tDIVIDE | tPERCENT | tPOW | tBANG | tTILDE
671
- | tUPLUS | tUMINUS | tAREF | tASET | tDSTAR | tBACK_REF2
672
-
673
- reswords: k__LINE__ | k__FILE__ | k__ENCODING__ | klBEGIN | klEND
674
- | kALIAS | kAND | kBEGIN | kBREAK | kCASE
675
- | kCLASS | kDEF | kDEFINED | kDO | kELSE
676
- | kELSIF | kEND | kENSURE | kFALSE | kFOR
677
- | kIN | kMODULE | kNEXT | kNIL | kNOT
678
- | kOR | kREDO | kRESCUE | kRETRY | kRETURN
679
- | kSELF | kSUPER | kTHEN | kTRUE | kUNDEF
680
- | kWHEN | kYIELD | kIF | kUNLESS | kWHILE
681
- | kUNTIL
682
-
683
- arg: lhs tEQL arg_rhs
684
- {
685
- result = @builder.assign(val[0], val[1], val[2])
686
- }
687
- | var_lhs tOP_ASGN arg_rhs
688
- {
689
- result = @builder.op_assign(val[0], val[1], val[2])
690
- }
691
- | primary_value tLBRACK2 opt_call_args rbracket tOP_ASGN arg_rhs
692
- {
693
- result = @builder.op_assign(
694
- @builder.index(
695
- val[0], val[1], val[2], val[3]),
696
- val[4], val[5])
697
- }
698
- | primary_value call_op tIDENTIFIER tOP_ASGN arg_rhs
699
- {
700
- result = @builder.op_assign(
701
- @builder.call_method(
702
- val[0], val[1], val[2]),
703
- val[3], val[4])
704
- }
705
- | primary_value call_op tCONSTANT tOP_ASGN arg_rhs
706
- {
707
- result = @builder.op_assign(
708
- @builder.call_method(
709
- val[0], val[1], val[2]),
710
- val[3], val[4])
711
- }
712
- | primary_value tCOLON2 tIDENTIFIER tOP_ASGN arg_rhs
713
- {
714
- result = @builder.op_assign(
715
- @builder.call_method(
716
- val[0], val[1], val[2]),
717
- val[3], val[4])
718
- }
719
- | primary_value tCOLON2 tCONSTANT tOP_ASGN arg_rhs
720
- {
721
- const = @builder.const_op_assignable(
722
- @builder.const_fetch(val[0], val[1], val[2]))
723
- result = @builder.op_assign(const, val[3], val[4])
724
- }
725
- | tCOLON3 tCONSTANT tOP_ASGN arg_rhs
726
- {
727
- const = @builder.const_op_assignable(
728
- @builder.const_global(val[0], val[1]))
729
- result = @builder.op_assign(const, val[2], val[3])
730
- }
731
- | backref tOP_ASGN arg_rhs
732
- {
733
- result = @builder.op_assign(val[0], val[1], val[2])
734
- }
735
- | arg tDOT2 arg
736
- {
737
- result = @builder.range_inclusive(val[0], val[1], val[2])
738
- }
739
- | arg tDOT3 arg
740
- {
741
- result = @builder.range_exclusive(val[0], val[1], val[2])
742
- }
743
- | arg tDOT2
744
- {
745
- result = @builder.range_inclusive(val[0], val[1], nil)
746
- }
747
- | arg tDOT3
748
- {
749
- result = @builder.range_exclusive(val[0], val[1], nil)
750
- }
751
- | tBDOT2 arg
752
- {
753
- result = @builder.range_inclusive(nil, val[0], val[1])
754
- }
755
- | tBDOT3 arg
756
- {
757
- result = @builder.range_exclusive(nil, val[0], val[1])
758
- }
759
- | arg tPLUS arg
760
- {
761
- result = @builder.binary_op(val[0], val[1], val[2])
762
- }
763
- | arg tMINUS arg
764
- {
765
- result = @builder.binary_op(val[0], val[1], val[2])
766
- }
767
- | arg tSTAR2 arg
768
- {
769
- result = @builder.binary_op(val[0], val[1], val[2])
770
- }
771
- | arg tDIVIDE arg
772
- {
773
- result = @builder.binary_op(val[0], val[1], val[2])
774
- }
775
- | arg tPERCENT arg
776
- {
777
- result = @builder.binary_op(val[0], val[1], val[2])
778
- }
779
- | arg tPOW arg
780
- {
781
- result = @builder.binary_op(val[0], val[1], val[2])
782
- }
783
- | tUNARY_NUM simple_numeric tPOW arg
784
- {
785
- result = @builder.unary_op(val[0],
786
- @builder.binary_op(
787
- val[1], val[2], val[3]))
788
- }
789
- | tUPLUS arg
790
- {
791
- result = @builder.unary_op(val[0], val[1])
792
- }
793
- | tUMINUS arg
794
- {
795
- result = @builder.unary_op(val[0], val[1])
796
- }
797
- | arg tPIPE arg
798
- {
799
- result = @builder.binary_op(val[0], val[1], val[2])
800
- }
801
- | arg tCARET arg
802
- {
803
- result = @builder.binary_op(val[0], val[1], val[2])
804
- }
805
- | arg tAMPER2 arg
806
- {
807
- result = @builder.binary_op(val[0], val[1], val[2])
808
- }
809
- | arg tCMP arg
810
- {
811
- result = @builder.binary_op(val[0], val[1], val[2])
812
- }
813
- | rel_expr =tCMP
814
- | arg tEQ arg
815
- {
816
- result = @builder.binary_op(val[0], val[1], val[2])
817
- }
818
- | arg tEQQ arg
819
- {
820
- result = @builder.binary_op(val[0], val[1], val[2])
821
- }
822
- | arg tNEQ arg
823
- {
824
- result = @builder.binary_op(val[0], val[1], val[2])
825
- }
826
- | arg tMATCH arg
827
- {
828
- result = @builder.match_op(val[0], val[1], val[2])
829
- }
830
- | arg tNMATCH arg
831
- {
832
- result = @builder.binary_op(val[0], val[1], val[2])
833
- }
834
- | tBANG arg
835
- {
836
- result = @builder.not_op(val[0], nil, val[1], nil)
837
- }
838
- | tTILDE arg
839
- {
840
- result = @builder.unary_op(val[0], val[1])
841
- }
842
- | arg tLSHFT arg
843
- {
844
- result = @builder.binary_op(val[0], val[1], val[2])
845
- }
846
- | arg tRSHFT arg
847
- {
848
- result = @builder.binary_op(val[0], val[1], val[2])
849
- }
850
- | arg tANDOP arg
851
- {
852
- result = @builder.logical_op(:and, val[0], val[1], val[2])
853
- }
854
- | arg tOROP arg
855
- {
856
- result = @builder.logical_op(:or, val[0], val[1], val[2])
857
- }
858
- | kDEFINED opt_nl arg
859
- {
860
- result = @builder.keyword_cmd(:defined?, val[0], nil, [ val[2] ], nil)
861
- }
862
- | arg tEH arg opt_nl tCOLON arg
863
- {
864
- result = @builder.ternary(val[0], val[1],
865
- val[2], val[4], val[5])
866
- }
867
- | defn_head f_paren_args tEQL arg
868
- {
869
- result = @builder.def_endless_method(*val[0],
870
- val[1], val[2], val[3])
871
-
872
- @lexer.cmdarg.pop
873
- @lexer.cond.pop
874
- @static_env.unextend
875
- @context.pop
876
- @current_arg_stack.pop
877
- }
878
- | defn_head f_paren_args tEQL arg kRESCUE_MOD arg
879
- {
880
- rescue_body = @builder.rescue_body(val[4],
881
- nil, nil, nil,
882
- nil, val[5])
883
-
884
- method_body = @builder.begin_body(val[3], [ rescue_body ])
885
-
886
- result = @builder.def_endless_method(*val[0],
887
- val[1], val[2], method_body)
888
-
889
- @lexer.cmdarg.pop
890
- @lexer.cond.pop
891
- @static_env.unextend
892
- @context.pop
893
- @current_arg_stack.pop
894
- }
895
- | defs_head f_paren_args tEQL arg
896
- {
897
- result = @builder.def_endless_singleton(*val[0],
898
- val[1], val[2], val[3])
899
-
900
- @lexer.cmdarg.pop
901
- @lexer.cond.pop
902
- @static_env.unextend
903
- @context.pop
904
- @current_arg_stack.pop
905
- }
906
- | defs_head f_paren_args tEQL arg kRESCUE_MOD arg
907
- {
908
- rescue_body = @builder.rescue_body(val[4],
909
- nil, nil, nil,
910
- nil, val[5])
911
-
912
- method_body = @builder.begin_body(val[3], [ rescue_body ])
913
-
914
- result = @builder.def_endless_singleton(*val[0],
915
- val[1], val[2], method_body)
916
-
917
- @lexer.cmdarg.pop
918
- @lexer.cond.pop
919
- @static_env.unextend
920
- @context.pop
921
- @current_arg_stack.pop
922
- }
923
- | primary
924
-
925
- relop: tGT | tLT | tGEQ | tLEQ
926
-
927
- rel_expr: arg relop arg =tGT
928
- {
929
- result = @builder.binary_op(val[0], val[1], val[2])
930
- }
931
- | rel_expr relop arg =tGT
932
- {
933
- result = @builder.binary_op(val[0], val[1], val[2])
934
- }
935
-
936
- arg_value: arg
937
-
938
- aref_args: none
939
- | args trailer
940
- | args tCOMMA assocs trailer
941
- {
942
- result = val[0] << @builder.associate(nil, val[2], nil)
943
- }
944
- | assocs trailer
945
- {
946
- result = [ @builder.associate(nil, val[0], nil) ]
947
- }
948
-
949
- arg_rhs: arg =tOP_ASGN
950
- | arg kRESCUE_MOD arg
951
- {
952
- rescue_body = @builder.rescue_body(val[1],
953
- nil, nil, nil,
954
- nil, val[2])
955
-
956
- result = @builder.begin_body(val[0], [ rescue_body ])
957
- }
958
-
959
- paren_args: tLPAREN2 opt_call_args rparen
960
- {
961
- result = val
962
- }
963
- | tLPAREN2 args tCOMMA args_forward rparen
964
- {
965
- unless @static_env.declared_forward_args?
966
- diagnostic :error, :unexpected_token, { :token => 'tBDOT3' } , val[3]
967
- end
968
-
969
- result = [val[0], [*val[1], @builder.forwarded_args(val[3])], val[4]]
970
- }
971
- | tLPAREN2 args_forward rparen
972
- {
973
- unless @static_env.declared_forward_args?
974
- diagnostic :error, :unexpected_token, { :token => 'tBDOT3' } , val[1]
975
- end
976
-
977
- result = [val[0], [@builder.forwarded_args(val[1])], val[2]]
978
- }
979
-
980
- opt_paren_args: # nothing
981
- {
982
- result = [ nil, [], nil ]
983
- }
984
- | paren_args
985
-
986
- opt_call_args: # nothing
987
- {
988
- result = []
989
- }
990
- | call_args
991
- | args tCOMMA
992
- | args tCOMMA assocs tCOMMA
993
- {
994
- result = val[0] << @builder.associate(nil, val[2], nil)
995
- }
996
- | assocs tCOMMA
997
- {
998
- result = [ @builder.associate(nil, val[0], nil) ]
999
- }
1000
-
1001
- call_args: command
1002
- {
1003
- result = [ val[0] ]
1004
- }
1005
- | args opt_block_arg
1006
- {
1007
- result = val[0].concat(val[1])
1008
- }
1009
- | assocs opt_block_arg
1010
- {
1011
- result = [ @builder.associate(nil, val[0], nil) ]
1012
- result.concat(val[1])
1013
- }
1014
- | args tCOMMA assocs opt_block_arg
1015
- {
1016
- assocs = @builder.associate(nil, val[2], nil)
1017
- result = val[0] << assocs
1018
- result.concat(val[3])
1019
- }
1020
- | block_arg
1021
- {
1022
- result = [ val[0] ]
1023
- }
1024
-
1025
- command_args: {
1026
- # When branch gets invoked by RACC's lookahead
1027
- # and command args start with '[' or '('
1028
- # we need to put `true` to the cmdarg stack
1029
- # **before** `false` pushed by lexer
1030
- # m [], n
1031
- # ^
1032
- # Right here we have cmdarg [...0] because
1033
- # lexer pushed it on '['
1034
- # We need to modify cmdarg stack to [...10]
1035
- #
1036
- # For all other cases (like `m n` or `m n, []`) we simply put 1 to the stack
1037
- # and later lexer pushes corresponding bits on top of it.
1038
- last_token = @last_token[0]
1039
- lookahead = last_token == :tLBRACK || last_token == :tLPAREN_ARG
1040
-
1041
- if lookahead
1042
- top = @lexer.cmdarg.pop
1043
- @lexer.cmdarg.push(true)
1044
- @lexer.cmdarg.push(top)
1045
- else
1046
- @lexer.cmdarg.push(true)
1047
- end
1048
- }
1049
- call_args
1050
- {
1051
- # call_args can be followed by tLBRACE_ARG (that does cmdarg.push(0) in the lexer)
1052
- # but the push must be done after cmdarg.pop() in the parser.
1053
- # So this code does cmdarg.pop() to pop 0 pushed by tLBRACE_ARG,
1054
- # cmdarg.pop() to pop 1 pushed by command_args,
1055
- # and cmdarg.push(0) to restore back the flag set by tLBRACE_ARG.
1056
- last_token = @last_token[0]
1057
- lookahead = last_token == :tLBRACE_ARG
1058
- if lookahead
1059
- top = @lexer.cmdarg.pop
1060
- @lexer.cmdarg.pop
1061
- @lexer.cmdarg.push(top)
1062
- else
1063
- @lexer.cmdarg.pop
1064
- end
1065
-
1066
- result = val[1]
1067
- }
1068
-
1069
- block_arg: tAMPER arg_value
1070
- {
1071
- result = @builder.block_pass(val[0], val[1])
1072
- }
1073
-
1074
- opt_block_arg: tCOMMA block_arg
1075
- {
1076
- result = [ val[1] ]
1077
- }
1078
- | # nothing
1079
- {
1080
- result = []
1081
- }
1082
-
1083
- args: arg_value
1084
- {
1085
- result = [ val[0] ]
1086
- }
1087
- | tSTAR arg_value
1088
- {
1089
- result = [ @builder.splat(val[0], val[1]) ]
1090
- }
1091
- | args tCOMMA arg_value
1092
- {
1093
- result = val[0] << val[2]
1094
- }
1095
- | args tCOMMA tSTAR arg_value
1096
- {
1097
- result = val[0] << @builder.splat(val[2], val[3])
1098
- }
1099
-
1100
- mrhs_arg: mrhs
1101
- {
1102
- result = @builder.array(nil, val[0], nil)
1103
- }
1104
- | arg_value
1105
-
1106
- mrhs: args tCOMMA arg_value
1107
- {
1108
- result = val[0] << val[2]
1109
- }
1110
- | args tCOMMA tSTAR arg_value
1111
- {
1112
- result = val[0] << @builder.splat(val[2], val[3])
1113
- }
1114
- | tSTAR arg_value
1115
- {
1116
- result = [ @builder.splat(val[0], val[1]) ]
1117
- }
1118
-
1119
- primary: literal
1120
- | strings
1121
- | xstring
1122
- | regexp
1123
- | words
1124
- | qwords
1125
- | symbols
1126
- | qsymbols
1127
- | var_ref
1128
- | backref
1129
- | tFID
1130
- {
1131
- result = @builder.call_method(nil, nil, val[0])
1132
- }
1133
- | kBEGIN
1134
- {
1135
- @lexer.cmdarg.push(false)
1136
- }
1137
- bodystmt kEND
1138
- {
1139
- @lexer.cmdarg.pop
1140
-
1141
- result = @builder.begin_keyword(val[0], val[2], val[3])
1142
- }
1143
- | tLPAREN_ARG stmt
1144
- {
1145
- @lexer.state = :expr_endarg
1146
- }
1147
- rparen
1148
- {
1149
- result = @builder.begin(val[0], val[1], val[3])
1150
- }
1151
- | tLPAREN_ARG
1152
- {
1153
- @lexer.state = :expr_endarg
1154
- }
1155
- opt_nl tRPAREN
1156
- {
1157
- result = @builder.begin(val[0], nil, val[3])
1158
- }
1159
- | tLPAREN compstmt tRPAREN
1160
- {
1161
- result = @builder.begin(val[0], val[1], val[2])
1162
- }
1163
- | primary_value tCOLON2 tCONSTANT
1164
- {
1165
- result = @builder.const_fetch(val[0], val[1], val[2])
1166
- }
1167
- | tCOLON3 tCONSTANT
1168
- {
1169
- result = @builder.const_global(val[0], val[1])
1170
- }
1171
- | tLBRACK aref_args tRBRACK
1172
- {
1173
- result = @builder.array(val[0], val[1], val[2])
1174
- }
1175
- | tLBRACE assoc_list tRCURLY
1176
- {
1177
- result = @builder.associate(val[0], val[1], val[2])
1178
- }
1179
- | k_return
1180
- {
1181
- result = @builder.keyword_cmd(:return, val[0])
1182
- }
1183
- | kYIELD tLPAREN2 call_args rparen
1184
- {
1185
- result = @builder.keyword_cmd(:yield, val[0], val[1], val[2], val[3])
1186
- }
1187
- | kYIELD tLPAREN2 rparen
1188
- {
1189
- result = @builder.keyword_cmd(:yield, val[0], val[1], [], val[2])
1190
- }
1191
- | kYIELD
1192
- {
1193
- result = @builder.keyword_cmd(:yield, val[0])
1194
- }
1195
- | kDEFINED opt_nl tLPAREN2 expr rparen
1196
- {
1197
- result = @builder.keyword_cmd(:defined?, val[0],
1198
- val[2], [ val[3] ], val[4])
1199
- }
1200
- | kNOT tLPAREN2 expr rparen
1201
- {
1202
- result = @builder.not_op(val[0], val[1], val[2], val[3])
1203
- }
1204
- | kNOT tLPAREN2 rparen
1205
- {
1206
- result = @builder.not_op(val[0], val[1], nil, val[2])
1207
- }
1208
- | fcall brace_block
1209
- {
1210
- method_call = @builder.call_method(nil, nil, val[0])
1211
-
1212
- begin_t, args, body, end_t = val[1]
1213
- result = @builder.block(method_call,
1214
- begin_t, args, body, end_t)
1215
- }
1216
- | method_call
1217
- | method_call brace_block
1218
- {
1219
- begin_t, args, body, end_t = val[1]
1220
- result = @builder.block(val[0],
1221
- begin_t, args, body, end_t)
1222
- }
1223
- | lambda
1224
- | kIF expr_value then compstmt if_tail kEND
1225
- {
1226
- else_t, else_ = val[4]
1227
- result = @builder.condition(val[0], val[1], val[2],
1228
- val[3], else_t,
1229
- else_, val[5])
1230
- }
1231
- | kUNLESS expr_value then compstmt opt_else kEND
1232
- {
1233
- else_t, else_ = val[4]
1234
- result = @builder.condition(val[0], val[1], val[2],
1235
- else_, else_t,
1236
- val[3], val[5])
1237
- }
1238
- | kWHILE expr_value_do compstmt kEND
1239
- {
1240
- result = @builder.loop(:while, val[0], *val[1], val[2], val[3])
1241
- }
1242
- | kUNTIL expr_value_do compstmt kEND
1243
- {
1244
- result = @builder.loop(:until, val[0], *val[1], val[2], val[3])
1245
- }
1246
- | kCASE expr_value opt_terms case_body kEND
1247
- {
1248
- *when_bodies, (else_t, else_body) = *val[3]
1249
-
1250
- result = @builder.case(val[0], val[1],
1251
- when_bodies, else_t, else_body,
1252
- val[4])
1253
- }
1254
- | kCASE opt_terms case_body kEND
1255
- {
1256
- *when_bodies, (else_t, else_body) = *val[2]
1257
-
1258
- result = @builder.case(val[0], nil,
1259
- when_bodies, else_t, else_body,
1260
- val[3])
1261
- }
1262
- | kCASE expr_value opt_terms p_case_body kEND
1263
- {
1264
- *in_bodies, (else_t, else_body) = *val[3]
1265
-
1266
- result = @builder.case_match(val[0], val[1],
1267
- in_bodies, else_t, else_body,
1268
- val[4])
1269
- }
1270
- | kFOR for_var kIN expr_value_do compstmt kEND
1271
- {
1272
- result = @builder.for(val[0], val[1], val[2], *val[3], val[4], val[5])
1273
- }
1274
- | kCLASS cpath superclass
1275
- {
1276
- @static_env.extend_static
1277
- @lexer.cmdarg.push(false)
1278
- @lexer.cond.push(false)
1279
- @context.push(:class)
1280
- }
1281
- bodystmt kEND
1282
- {
1283
- unless @context.class_definition_allowed?
1284
- diagnostic :error, :class_in_def, nil, val[0]
1285
- end
1286
-
1287
- lt_t, superclass = val[2]
1288
- result = @builder.def_class(val[0], val[1],
1289
- lt_t, superclass,
1290
- val[4], val[5])
1291
-
1292
- @lexer.cmdarg.pop
1293
- @lexer.cond.pop
1294
- @static_env.unextend
1295
- @context.pop
1296
- }
1297
- | kCLASS tLSHFT expr term
1298
- {
1299
- @static_env.extend_static
1300
- @lexer.cmdarg.push(false)
1301
- @lexer.cond.push(false)
1302
- @context.push(:sclass)
1303
- }
1304
- bodystmt kEND
1305
- {
1306
- result = @builder.def_sclass(val[0], val[1], val[2],
1307
- val[5], val[6])
1308
-
1309
- @lexer.cmdarg.pop
1310
- @lexer.cond.pop
1311
- @static_env.unextend
1312
- @context.pop
1313
- }
1314
- | kMODULE cpath
1315
- {
1316
- @static_env.extend_static
1317
- @lexer.cmdarg.push(false)
1318
- @context.push(:module)
1319
- }
1320
- bodystmt kEND
1321
- {
1322
- unless @context.module_definition_allowed?
1323
- diagnostic :error, :module_in_def, nil, val[0]
1324
- end
1325
-
1326
- result = @builder.def_module(val[0], val[1],
1327
- val[3], val[4])
1328
-
1329
- @lexer.cmdarg.pop
1330
- @static_env.unextend
1331
- @context.pop
1332
- }
1333
- | defn_head f_arglist bodystmt kEND
1334
- {
1335
- result = @builder.def_method(*val[0], val[1],
1336
- val[2], val[3])
1337
-
1338
- @lexer.cmdarg.pop
1339
- @lexer.cond.pop
1340
- @static_env.unextend
1341
- @context.pop
1342
- @current_arg_stack.pop
1343
- }
1344
- | defs_head f_arglist bodystmt kEND
1345
- {
1346
- result = @builder.def_singleton(*val[0], val[1],
1347
- val[2], val[3])
1348
-
1349
- @lexer.cmdarg.pop
1350
- @lexer.cond.pop
1351
- @static_env.unextend
1352
- @context.pop
1353
- @current_arg_stack.pop
1354
- }
1355
- | kBREAK
1356
- {
1357
- result = @builder.keyword_cmd(:break, val[0])
1358
- }
1359
- | kNEXT
1360
- {
1361
- result = @builder.keyword_cmd(:next, val[0])
1362
- }
1363
- | kREDO
1364
- {
1365
- result = @builder.keyword_cmd(:redo, val[0])
1366
- }
1367
- | kRETRY
1368
- {
1369
- result = @builder.keyword_cmd(:retry, val[0])
1370
- }
1371
-
1372
- primary_value: primary
1373
-
1374
- k_return: kRETURN
1375
- {
1376
- if @context.in_class?
1377
- diagnostic :error, :invalid_return, nil, val[0]
1378
- end
1379
- }
1380
-
1381
- then: term
1382
- | kTHEN
1383
- | term kTHEN
1384
- {
1385
- result = val[1]
1386
- }
1387
-
1388
- do: term
1389
- | kDO_COND
1390
-
1391
- if_tail: opt_else
1392
- | kELSIF expr_value then compstmt if_tail
1393
- {
1394
- else_t, else_ = val[4]
1395
- result = [ val[0],
1396
- @builder.condition(val[0], val[1], val[2],
1397
- val[3], else_t,
1398
- else_, nil),
1399
- ]
1400
- }
1401
-
1402
- opt_else: none
1403
- | kELSE compstmt
1404
- {
1405
- result = val
1406
- }
1407
-
1408
- for_var: lhs
1409
- | mlhs
1410
-
1411
- f_marg: f_norm_arg
1412
- {
1413
- result = @builder.arg(val[0])
1414
- }
1415
- | tLPAREN f_margs rparen
1416
- {
1417
- result = @builder.multi_lhs(val[0], val[1], val[2])
1418
- }
1419
-
1420
- f_marg_list: f_marg
1421
- {
1422
- result = [ val[0] ]
1423
- }
1424
- | f_marg_list tCOMMA f_marg
1425
- {
1426
- result = val[0] << val[2]
1427
- }
1428
-
1429
- f_margs: f_marg_list
1430
- | f_marg_list tCOMMA f_rest_marg
1431
- {
1432
- result = val[0].
1433
- push(val[2])
1434
- }
1435
- | f_marg_list tCOMMA f_rest_marg tCOMMA f_marg_list
1436
- {
1437
- result = val[0].
1438
- push(val[2]).
1439
- concat(val[4])
1440
- }
1441
- | f_rest_marg
1442
- {
1443
- result = [ val[0] ]
1444
- }
1445
- | f_rest_marg tCOMMA f_marg_list
1446
- {
1447
- result = [ val[0], *val[2] ]
1448
- }
1449
-
1450
- f_rest_marg: tSTAR f_norm_arg
1451
- {
1452
- result = @builder.restarg(val[0], val[1])
1453
- }
1454
- | tSTAR
1455
- {
1456
- result = @builder.restarg(val[0])
1457
- }
1458
-
1459
- f_any_kwrest: f_kwrest
1460
- | f_no_kwarg
1461
-
1462
- block_args_tail: f_block_kwarg tCOMMA f_kwrest opt_f_block_arg
1463
- {
1464
- result = val[0].concat(val[2]).concat(val[3])
1465
- }
1466
- | f_block_kwarg opt_f_block_arg
1467
- {
1468
- result = val[0].concat(val[1])
1469
- }
1470
- | f_any_kwrest opt_f_block_arg
1471
- {
1472
- result = val[0].concat(val[1])
1473
- }
1474
- | f_block_arg
1475
- {
1476
- result = [ val[0] ]
1477
- }
1478
-
1479
- opt_block_args_tail:
1480
- tCOMMA block_args_tail
1481
- {
1482
- result = val[1]
1483
- }
1484
- | # nothing
1485
- {
1486
- result = []
1487
- }
1488
-
1489
- excessed_comma: tCOMMA
1490
-
1491
- block_param: f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
1492
- {
1493
- result = val[0].
1494
- concat(val[2]).
1495
- concat(val[4]).
1496
- concat(val[5])
1497
- }
1498
- | f_arg tCOMMA f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
1499
- {
1500
- result = val[0].
1501
- concat(val[2]).
1502
- concat(val[4]).
1503
- concat(val[6]).
1504
- concat(val[7])
1505
- }
1506
- | f_arg tCOMMA f_block_optarg opt_block_args_tail
1507
- {
1508
- result = val[0].
1509
- concat(val[2]).
1510
- concat(val[3])
1511
- }
1512
- | f_arg tCOMMA f_block_optarg tCOMMA f_arg opt_block_args_tail
1513
- {
1514
- result = val[0].
1515
- concat(val[2]).
1516
- concat(val[4]).
1517
- concat(val[5])
1518
- }
1519
- | f_arg tCOMMA f_rest_arg opt_block_args_tail
1520
- {
1521
- result = val[0].
1522
- concat(val[2]).
1523
- concat(val[3])
1524
- }
1525
- | f_arg excessed_comma
1526
- | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
1527
- {
1528
- result = val[0].
1529
- concat(val[2]).
1530
- concat(val[4]).
1531
- concat(val[5])
1532
- }
1533
- | f_arg opt_block_args_tail
1534
- {
1535
- if val[1].empty? && val[0].size == 1
1536
- result = [@builder.procarg0(val[0][0])]
1537
- else
1538
- result = val[0].concat(val[1])
1539
- end
1540
- }
1541
- | f_block_optarg tCOMMA f_rest_arg opt_block_args_tail
1542
- {
1543
- result = val[0].
1544
- concat(val[2]).
1545
- concat(val[3])
1546
- }
1547
- | f_block_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_block_args_tail
1548
- {
1549
- result = val[0].
1550
- concat(val[2]).
1551
- concat(val[4]).
1552
- concat(val[5])
1553
- }
1554
- | f_block_optarg opt_block_args_tail
1555
- {
1556
- result = val[0].
1557
- concat(val[1])
1558
- }
1559
- | f_block_optarg tCOMMA f_arg opt_block_args_tail
1560
- {
1561
- result = val[0].
1562
- concat(val[2]).
1563
- concat(val[3])
1564
- }
1565
- | f_rest_arg opt_block_args_tail
1566
- {
1567
- result = val[0].
1568
- concat(val[1])
1569
- }
1570
- | f_rest_arg tCOMMA f_arg opt_block_args_tail
1571
- {
1572
- result = val[0].
1573
- concat(val[2]).
1574
- concat(val[3])
1575
- }
1576
- | block_args_tail
1577
-
1578
- opt_block_param: # nothing
1579
- {
1580
- result = @builder.args(nil, [], nil)
1581
- }
1582
- | block_param_def
1583
- {
1584
- @lexer.state = :expr_value
1585
- }
1586
-
1587
- block_param_def: tPIPE opt_bv_decl tPIPE
1588
- {
1589
- @max_numparam_stack.has_ordinary_params!
1590
- @current_arg_stack.set(nil)
1591
- result = @builder.args(val[0], val[1], val[2])
1592
- }
1593
- | tPIPE block_param opt_bv_decl tPIPE
1594
- {
1595
- @max_numparam_stack.has_ordinary_params!
1596
- @current_arg_stack.set(nil)
1597
- result = @builder.args(val[0], val[1].concat(val[2]), val[3])
1598
- }
1599
-
1600
- opt_bv_decl: opt_nl
1601
- {
1602
- result = []
1603
- }
1604
- | opt_nl tSEMI bv_decls opt_nl
1605
- {
1606
- result = val[2]
1607
- }
1608
-
1609
- bv_decls: bvar
1610
- {
1611
- result = [ val[0] ]
1612
- }
1613
- | bv_decls tCOMMA bvar
1614
- {
1615
- result = val[0] << val[2]
1616
- }
1617
-
1618
- bvar: tIDENTIFIER
1619
- {
1620
- @static_env.declare val[0][0]
1621
- result = @builder.shadowarg(val[0])
1622
- }
1623
- | f_bad_arg
1624
-
1625
- lambda: tLAMBDA
1626
- {
1627
- @static_env.extend_dynamic
1628
- @max_numparam_stack.push
1629
- @context.push(:lambda)
1630
- }
1631
- f_larglist
1632
- {
1633
- @context.pop
1634
- @lexer.cmdarg.push(false)
1635
- }
1636
- lambda_body
1637
- {
1638
- lambda_call = @builder.call_lambda(val[0])
1639
- args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[2]
1640
- begin_t, body, end_t = val[4]
1641
-
1642
- @max_numparam_stack.pop
1643
- @static_env.unextend
1644
- @lexer.cmdarg.pop
1645
-
1646
- result = @builder.block(lambda_call,
1647
- begin_t, args, body, end_t)
1648
- }
1649
-
1650
- f_larglist: tLPAREN2 f_args opt_bv_decl tRPAREN
1651
- {
1652
- @max_numparam_stack.has_ordinary_params!
1653
- result = @builder.args(val[0], val[1].concat(val[2]), val[3])
1654
- }
1655
- | f_args
1656
- {
1657
- if val[0].any?
1658
- @max_numparam_stack.has_ordinary_params!
1659
- end
1660
- result = @builder.args(nil, val[0], nil)
1661
- }
1662
-
1663
- lambda_body: tLAMBEG
1664
- {
1665
- @context.push(:lambda)
1666
- }
1667
- compstmt tRCURLY
1668
- {
1669
- result = [ val[0], val[2], val[3] ]
1670
- @context.pop
1671
- }
1672
- | kDO_LAMBDA
1673
- {
1674
- @context.push(:lambda)
1675
- }
1676
- bodystmt kEND
1677
- {
1678
- result = [ val[0], val[2], val[3] ]
1679
- @context.pop
1680
- }
1681
-
1682
- do_block: kDO_BLOCK
1683
- {
1684
- @context.push(:block)
1685
- }
1686
- do_body kEND
1687
- {
1688
- result = [ val[0], *val[2], val[3] ]
1689
- @context.pop
1690
- }
1691
-
1692
- block_call: command do_block
1693
- {
1694
- begin_t, block_args, body, end_t = val[1]
1695
- result = @builder.block(val[0],
1696
- begin_t, block_args, body, end_t)
1697
- }
1698
- | block_call dot_or_colon operation2 opt_paren_args
1699
- {
1700
- lparen_t, args, rparen_t = val[3]
1701
- result = @builder.call_method(val[0], val[1], val[2],
1702
- lparen_t, args, rparen_t)
1703
- }
1704
- | block_call dot_or_colon operation2 opt_paren_args brace_block
1705
- {
1706
- lparen_t, args, rparen_t = val[3]
1707
- method_call = @builder.call_method(val[0], val[1], val[2],
1708
- lparen_t, args, rparen_t)
1709
-
1710
- begin_t, args, body, end_t = val[4]
1711
- result = @builder.block(method_call,
1712
- begin_t, args, body, end_t)
1713
- }
1714
- | block_call dot_or_colon operation2 command_args do_block
1715
- {
1716
- method_call = @builder.call_method(val[0], val[1], val[2],
1717
- nil, val[3], nil)
1718
-
1719
- begin_t, args, body, end_t = val[4]
1720
- result = @builder.block(method_call,
1721
- begin_t, args, body, end_t)
1722
- }
1723
-
1724
- method_call: fcall paren_args
1725
- {
1726
- lparen_t, args, rparen_t = val[1]
1727
- result = @builder.call_method(nil, nil, val[0],
1728
- lparen_t, args, rparen_t)
1729
- }
1730
- | primary_value call_op operation2 opt_paren_args
1731
- {
1732
- lparen_t, args, rparen_t = val[3]
1733
- result = @builder.call_method(val[0], val[1], val[2],
1734
- lparen_t, args, rparen_t)
1735
- }
1736
- | primary_value tCOLON2 operation2 paren_args
1737
- {
1738
- lparen_t, args, rparen_t = val[3]
1739
- result = @builder.call_method(val[0], val[1], val[2],
1740
- lparen_t, args, rparen_t)
1741
- }
1742
- | primary_value tCOLON2 operation3
1743
- {
1744
- result = @builder.call_method(val[0], val[1], val[2])
1745
- }
1746
- | primary_value call_op paren_args
1747
- {
1748
- lparen_t, args, rparen_t = val[2]
1749
- result = @builder.call_method(val[0], val[1], nil,
1750
- lparen_t, args, rparen_t)
1751
- }
1752
- | primary_value tCOLON2 paren_args
1753
- {
1754
- lparen_t, args, rparen_t = val[2]
1755
- result = @builder.call_method(val[0], val[1], nil,
1756
- lparen_t, args, rparen_t)
1757
- }
1758
- | kSUPER paren_args
1759
- {
1760
- lparen_t, args, rparen_t = val[1]
1761
- result = @builder.keyword_cmd(:super, val[0],
1762
- lparen_t, args, rparen_t)
1763
- }
1764
- | kSUPER
1765
- {
1766
- result = @builder.keyword_cmd(:zsuper, val[0])
1767
- }
1768
- | primary_value tLBRACK2 opt_call_args rbracket
1769
- {
1770
- result = @builder.index(val[0], val[1], val[2], val[3])
1771
- }
1772
-
1773
- brace_block: tLCURLY
1774
- {
1775
- @context.push(:block)
1776
- }
1777
- brace_body tRCURLY
1778
- {
1779
- result = [ val[0], *val[2], val[3] ]
1780
- @context.pop
1781
- }
1782
- | kDO
1783
- {
1784
- @context.push(:block)
1785
- }
1786
- do_body kEND
1787
- {
1788
- result = [ val[0], *val[2], val[3] ]
1789
- @context.pop
1790
- }
1791
-
1792
- brace_body: {
1793
- @static_env.extend_dynamic
1794
- @max_numparam_stack.push
1795
- }
1796
- opt_block_param compstmt
1797
- {
1798
- args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[1]
1799
- result = [ args, val[2] ]
1800
-
1801
- @max_numparam_stack.pop
1802
- @static_env.unextend
1803
- }
1804
-
1805
- do_body: {
1806
- @static_env.extend_dynamic
1807
- @max_numparam_stack.push
1808
- }
1809
- {
1810
- @lexer.cmdarg.push(false)
1811
- }
1812
- opt_block_param bodystmt
1813
- {
1814
- args = @max_numparam_stack.has_numparams? ? @builder.numargs(@max_numparam_stack.top) : val[2]
1815
- result = [ args, val[3] ]
1816
-
1817
- @max_numparam_stack.pop
1818
- @static_env.unextend
1819
- @lexer.cmdarg.pop
1820
- }
1821
-
1822
- case_body: kWHEN args then compstmt cases
1823
- {
1824
- result = [ @builder.when(val[0], val[1], val[2], val[3]),
1825
- *val[4] ]
1826
- }
1827
-
1828
- cases: opt_else
1829
- {
1830
- result = [ val[0] ]
1831
- }
1832
- | case_body
1833
-
1834
- p_case_body: kIN
1835
- {
1836
- @lexer.state = :expr_beg
1837
- @lexer.command_start = false
1838
- @pattern_variables.push
1839
- @pattern_hash_keys.push
1840
-
1841
- result = @lexer.in_kwarg
1842
- @lexer.in_kwarg = true
1843
- }
1844
- p_top_expr then
1845
- {
1846
- @lexer.in_kwarg = val[1]
1847
- }
1848
- compstmt p_cases
1849
- {
1850
- result = [ @builder.in_pattern(val[0], *val[2], val[3], val[5]),
1851
- *val[6] ]
1852
- }
1853
-
1854
- p_cases: opt_else
1855
- {
1856
- result = [ val[0] ]
1857
- }
1858
- | p_case_body
1859
-
1860
- p_top_expr: p_top_expr_body
1861
- {
1862
- result = [ val[0], nil ]
1863
- }
1864
- | p_top_expr_body kIF_MOD expr_value
1865
- {
1866
- result = [ val[0], @builder.if_guard(val[1], val[2]) ]
1867
- }
1868
- | p_top_expr_body kUNLESS_MOD expr_value
1869
- {
1870
- result = [ val[0], @builder.unless_guard(val[1], val[2]) ]
1871
- }
1872
-
1873
- p_top_expr_body: p_expr
1874
- | p_expr tCOMMA
1875
- {
1876
- # array patterns that end with comma
1877
- # like 1, 2,
1878
- # must be emitted as `array_pattern_with_tail`
1879
- item = @builder.match_with_trailing_comma(val[0], val[1])
1880
- result = @builder.array_pattern(nil, [ item ], nil)
1881
- }
1882
- | p_expr tCOMMA p_args
1883
- {
1884
- result = @builder.array_pattern(nil, [val[0]].concat(val[2]), nil)
1885
- }
1886
- | p_find
1887
- {
1888
- result = @builder.find_pattern(nil, val[0], nil)
1889
- }
1890
- | p_args_tail
1891
- {
1892
- result = @builder.array_pattern(nil, val[0], nil)
1893
- }
1894
- | p_kwargs
1895
- {
1896
- result = @builder.hash_pattern(nil, val[0], nil)
1897
- }
1898
-
1899
- p_expr: p_as
1900
-
1901
- p_as: p_expr tASSOC p_variable
1902
- {
1903
- result = @builder.match_as(val[0], val[1], val[2])
1904
- }
1905
- | p_alt
1906
-
1907
- p_alt: p_alt tPIPE p_expr_basic
1908
- {
1909
- result = @builder.match_alt(val[0], val[1], val[2])
1910
- }
1911
- | p_expr_basic
1912
-
1913
- p_lparen: tLPAREN2
1914
- {
1915
- result = val[0]
1916
- @pattern_hash_keys.push
1917
- }
1918
-
1919
- p_lbracket: tLBRACK2
1920
- {
1921
- result = val[0]
1922
- @pattern_hash_keys.push
1923
- }
1924
-
1925
- p_expr_basic: p_value
1926
- | p_const p_lparen p_args rparen
1927
- {
1928
- @pattern_hash_keys.pop
1929
- pattern = @builder.array_pattern(nil, val[2], nil)
1930
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1931
- }
1932
- | p_const p_lparen p_find rparen
1933
- {
1934
- @pattern_hash_keys.pop
1935
- pattern = @builder.find_pattern(nil, val[2], nil)
1936
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1937
- }
1938
- | p_const p_lparen p_kwargs rparen
1939
- {
1940
- @pattern_hash_keys.pop
1941
- pattern = @builder.hash_pattern(nil, val[2], nil)
1942
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1943
- }
1944
- | p_const tLPAREN2 rparen
1945
- {
1946
- pattern = @builder.array_pattern(val[1], nil, val[2])
1947
- result = @builder.const_pattern(val[0], val[1], pattern, val[2])
1948
- }
1949
- | p_const p_lbracket p_args rbracket
1950
- {
1951
- @pattern_hash_keys.pop
1952
- pattern = @builder.array_pattern(nil, val[2], nil)
1953
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1954
- }
1955
- | p_const p_lbracket p_find rbracket
1956
- {
1957
- @pattern_hash_keys.pop
1958
- pattern = @builder.find_pattern(nil, val[2], nil)
1959
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1960
- }
1961
- | p_const p_lbracket p_kwargs rbracket
1962
- {
1963
- @pattern_hash_keys.pop
1964
- pattern = @builder.hash_pattern(nil, val[2], nil)
1965
- result = @builder.const_pattern(val[0], val[1], pattern, val[3])
1966
- }
1967
- | p_const tLBRACK2 rbracket
1968
- {
1969
- pattern = @builder.array_pattern(val[1], nil, val[2])
1970
- result = @builder.const_pattern(val[0], val[1], pattern, val[2])
1971
- }
1972
- | tLBRACK p_args rbracket
1973
- {
1974
- result = @builder.array_pattern(val[0], val[1], val[2])
1975
- }
1976
- | tLBRACK p_find rbracket
1977
- {
1978
- result = @builder.find_pattern(val[0], val[1], val[2])
1979
- }
1980
- | tLBRACK rbracket
1981
- {
1982
- result = @builder.array_pattern(val[0], [], val[1])
1983
- }
1984
- | tLBRACE
1985
- {
1986
- @pattern_hash_keys.push
1987
- result = @lexer.in_kwarg
1988
- @lexer.in_kwarg = false
1989
- }
1990
- p_kwargs rbrace
1991
- {
1992
- @pattern_hash_keys.pop
1993
- @lexer.in_kwarg = val[1]
1994
- result = @builder.hash_pattern(val[0], val[2], val[3])
1995
- }
1996
- | tLBRACE rbrace
1997
- {
1998
- result = @builder.hash_pattern(val[0], [], val[1])
1999
- }
2000
- | tLPAREN
2001
- {
2002
- @pattern_hash_keys.push
2003
- }
2004
- p_expr rparen
2005
- {
2006
- @pattern_hash_keys.pop
2007
- result = @builder.begin(val[0], val[2], val[3])
2008
- }
2009
-
2010
- p_args: p_expr
2011
- {
2012
- result = [ val[0] ]
2013
- }
2014
- | p_args_head
2015
- {
2016
- result = val[0]
2017
- }
2018
- | p_args_head p_arg
2019
- {
2020
- result = [ *val[0], val[1] ]
2021
- }
2022
- | p_args_head tSTAR tIDENTIFIER
2023
- {
2024
- match_rest = @builder.match_rest(val[1], val[2])
2025
- result = [ *val[0], match_rest ]
2026
- }
2027
- | p_args_head tSTAR tIDENTIFIER tCOMMA p_args_post
2028
- {
2029
- match_rest = @builder.match_rest(val[1], val[2])
2030
- result = [ *val[0], match_rest, *val[4] ]
2031
- }
2032
- | p_args_head tSTAR
2033
- {
2034
- result = [ *val[0], @builder.match_rest(val[1]) ]
2035
- }
2036
- | p_args_head tSTAR tCOMMA p_args_post
2037
- {
2038
- result = [ *val[0], @builder.match_rest(val[1]), *val[3] ]
2039
- }
2040
- | p_args_tail
2041
-
2042
- p_args_head: p_arg tCOMMA
2043
- {
2044
- # array patterns that end with comma
2045
- # like [1, 2,]
2046
- # must be emitted as `array_pattern_with_tail`
2047
- item = @builder.match_with_trailing_comma(val[0], val[1])
2048
- result = [ item ]
2049
- }
2050
- | p_args_head p_arg tCOMMA
2051
- {
2052
- # array patterns that end with comma
2053
- # like [1, 2,]
2054
- # must be emitted as `array_pattern_with_tail`
2055
- last_item = @builder.match_with_trailing_comma(val[1], val[2])
2056
- result = [ *val[0], last_item ]
2057
- }
2058
-
2059
- p_args_tail: p_rest
2060
- {
2061
- result = [ val[0] ]
2062
- }
2063
- | p_rest tCOMMA p_args_post
2064
- {
2065
- result = [ val[0], *val[2] ]
2066
- }
2067
-
2068
- p_find: p_rest tCOMMA p_args_post tCOMMA p_rest
2069
- {
2070
- result = [ val[0], *val[2], val[4] ]
2071
- }
2072
-
2073
- p_rest: tSTAR tIDENTIFIER
2074
- {
2075
- result = @builder.match_rest(val[0], val[1])
2076
- }
2077
- | tSTAR
2078
- {
2079
- result = @builder.match_rest(val[0])
2080
- }
2081
-
2082
- p_args_post: p_arg
2083
- {
2084
- result = [ val[0] ]
2085
- }
2086
- | p_args_post tCOMMA p_arg
2087
- {
2088
- result = [ *val[0], val[2] ]
2089
- }
2090
-
2091
- p_arg: p_expr
2092
-
2093
- p_kwargs: p_kwarg tCOMMA p_any_kwrest
2094
- {
2095
- result = [ *val[0], *val[2] ]
2096
- }
2097
- | p_kwarg
2098
- {
2099
- result = val[0]
2100
- }
2101
- | p_kwarg tCOMMA
2102
- {
2103
- result = val[0]
2104
- }
2105
- | p_any_kwrest
2106
- {
2107
- result = val[0]
2108
- }
2109
-
2110
- p_kwarg: p_kw
2111
- {
2112
- result = [ val[0] ]
2113
- }
2114
- | p_kwarg tCOMMA p_kw
2115
- {
2116
- result = [ *val[0], val[2] ]
2117
- }
2118
-
2119
- p_kw: p_kw_label p_expr
2120
- {
2121
- result = @builder.match_pair(*val[0], val[1])
2122
- }
2123
- | p_kw_label
2124
- {
2125
- result = @builder.match_label(*val[0])
2126
- }
2127
-
2128
- p_kw_label: tLABEL
2129
- {
2130
- check_kwarg_name(val[0])
2131
- result = [:label, val[0]]
2132
- }
2133
- | tSTRING_BEG string_contents tLABEL_END
2134
- {
2135
- result = [:quoted, [val[0], val[1], val[2]]]
2136
- }
2137
-
2138
- p_kwrest: kwrest_mark tIDENTIFIER
2139
- {
2140
- result = [ @builder.match_rest(val[0], val[1]) ]
2141
- }
2142
- | kwrest_mark
2143
- {
2144
- result = [ @builder.match_rest(val[0], nil) ]
2145
- }
2146
-
2147
- p_kwnorest: kwrest_mark kNIL
2148
- {
2149
- result = [ @builder.match_nil_pattern(val[0], val[1]) ]
2150
- }
2151
-
2152
- p_any_kwrest: p_kwrest
2153
- | p_kwnorest
2154
-
2155
- p_value: p_primitive
2156
- | p_primitive tDOT2 p_primitive
2157
- {
2158
- result = @builder.range_inclusive(val[0], val[1], val[2])
2159
- }
2160
- | p_primitive tDOT3 p_primitive
2161
- {
2162
- result = @builder.range_exclusive(val[0], val[1], val[2])
2163
- }
2164
- | p_primitive tDOT2
2165
- {
2166
- result = @builder.range_inclusive(val[0], val[1], nil)
2167
- }
2168
- | p_primitive tDOT3
2169
- {
2170
- result = @builder.range_exclusive(val[0], val[1], nil)
2171
- }
2172
- | p_variable
2173
- | p_var_ref
2174
- | p_const
2175
- | tBDOT2 p_primitive
2176
- {
2177
- result = @builder.range_inclusive(nil, val[0], val[1])
2178
- }
2179
- | tBDOT3 p_primitive
2180
- {
2181
- result = @builder.range_exclusive(nil, val[0], val[1])
2182
- }
2183
-
2184
- p_primitive: literal
2185
- | strings
2186
- | xstring
2187
- | regexp
2188
- | words
2189
- | qwords
2190
- | symbols
2191
- | qsymbols
2192
- | keyword_variable
2193
- {
2194
- result = @builder.accessible(val[0])
2195
- }
2196
- | lambda
2197
-
2198
- p_variable: tIDENTIFIER
2199
- {
2200
- result = @builder.match_var(val[0])
2201
- }
2202
-
2203
- p_var_ref: tCARET tIDENTIFIER
2204
- {
2205
- name = val[1][0]
2206
- unless static_env.declared?(name)
2207
- diagnostic :error, :undefined_lvar, { :name => name }, val[1]
2208
- end
2209
-
2210
- lvar = @builder.accessible(@builder.ident(val[1]))
2211
- result = @builder.pin(val[0], lvar)
2212
- }
2213
-
2214
- p_const: tCOLON3 cname
2215
- {
2216
- result = @builder.const_global(val[0], val[1])
2217
- }
2218
- | p_const tCOLON2 cname
2219
- {
2220
- result = @builder.const_fetch(val[0], val[1], val[2])
2221
- }
2222
- | tCONSTANT
2223
- {
2224
- result = @builder.const(val[0])
2225
- }
2226
-
2227
- opt_rescue: kRESCUE exc_list exc_var then compstmt opt_rescue
2228
- {
2229
- assoc_t, exc_var = val[2]
2230
-
2231
- if val[1]
2232
- exc_list = @builder.array(nil, val[1], nil)
2233
- end
2234
-
2235
- result = [ @builder.rescue_body(val[0],
2236
- exc_list, assoc_t, exc_var,
2237
- val[3], val[4]),
2238
- *val[5] ]
2239
- }
2240
- |
2241
- {
2242
- result = []
2243
- }
2244
-
2245
- exc_list: arg_value
2246
- {
2247
- result = [ val[0] ]
2248
- }
2249
- | mrhs
2250
- | none
2251
-
2252
- exc_var: tASSOC lhs
2253
- {
2254
- result = [ val[0], val[1] ]
2255
- }
2256
- | none
2257
-
2258
- opt_ensure: kENSURE compstmt
2259
- {
2260
- result = [ val[0], val[1] ]
2261
- }
2262
- | none
2263
-
2264
- literal: numeric
2265
- | symbol
2266
-
2267
- strings: string
2268
- {
2269
- result = @builder.string_compose(nil, val[0], nil)
2270
- }
2271
-
2272
- string: string1
2273
- {
2274
- result = [ val[0] ]
2275
- }
2276
- | string string1
2277
- {
2278
- result = val[0] << val[1]
2279
- }
2280
-
2281
- string1: tSTRING_BEG string_contents tSTRING_END
2282
- {
2283
- string = @builder.string_compose(val[0], val[1], val[2])
2284
- result = @builder.dedent_string(string, @lexer.dedent_level)
2285
- }
2286
- | tSTRING
2287
- {
2288
- string = @builder.string(val[0])
2289
- result = @builder.dedent_string(string, @lexer.dedent_level)
2290
- }
2291
- | tCHARACTER
2292
- {
2293
- result = @builder.character(val[0])
2294
- }
2295
-
2296
- xstring: tXSTRING_BEG xstring_contents tSTRING_END
2297
- {
2298
- string = @builder.xstring_compose(val[0], val[1], val[2])
2299
- result = @builder.dedent_string(string, @lexer.dedent_level)
2300
- }
2301
-
2302
- regexp: tREGEXP_BEG regexp_contents tSTRING_END tREGEXP_OPT
2303
- {
2304
- opts = @builder.regexp_options(val[3])
2305
- result = @builder.regexp_compose(val[0], val[1], val[2], opts)
2306
- }
2307
-
2308
- words: tWORDS_BEG word_list tSTRING_END
2309
- {
2310
- result = @builder.words_compose(val[0], val[1], val[2])
2311
- }
2312
-
2313
- word_list: # nothing
2314
- {
2315
- result = []
2316
- }
2317
- | word_list word tSPACE
2318
- {
2319
- result = val[0] << @builder.word(val[1])
2320
- }
2321
-
2322
- word: string_content
2323
- {
2324
- result = [ val[0] ]
2325
- }
2326
- | word string_content
2327
- {
2328
- result = val[0] << val[1]
2329
- }
2330
-
2331
- symbols: tSYMBOLS_BEG symbol_list tSTRING_END
2332
- {
2333
- result = @builder.symbols_compose(val[0], val[1], val[2])
2334
- }
2335
-
2336
- symbol_list: # nothing
2337
- {
2338
- result = []
2339
- }
2340
- | symbol_list word tSPACE
2341
- {
2342
- result = val[0] << @builder.word(val[1])
2343
- }
2344
-
2345
- qwords: tQWORDS_BEG qword_list tSTRING_END
2346
- {
2347
- result = @builder.words_compose(val[0], val[1], val[2])
2348
- }
2349
-
2350
- qsymbols: tQSYMBOLS_BEG qsym_list tSTRING_END
2351
- {
2352
- result = @builder.symbols_compose(val[0], val[1], val[2])
2353
- }
2354
-
2355
- qword_list: # nothing
2356
- {
2357
- result = []
2358
- }
2359
- | qword_list tSTRING_CONTENT tSPACE
2360
- {
2361
- result = val[0] << @builder.string_internal(val[1])
2362
- }
2363
-
2364
- qsym_list: # nothing
2365
- {
2366
- result = []
2367
- }
2368
- | qsym_list tSTRING_CONTENT tSPACE
2369
- {
2370
- result = val[0] << @builder.symbol_internal(val[1])
2371
- }
2372
-
2373
- string_contents: # nothing
2374
- {
2375
- result = []
2376
- }
2377
- | string_contents string_content
2378
- {
2379
- result = val[0] << val[1]
2380
- }
2381
-
2382
- xstring_contents: # nothing
2383
- {
2384
- result = []
2385
- }
2386
- | xstring_contents string_content
2387
- {
2388
- result = val[0] << val[1]
2389
- }
2390
-
2391
- regexp_contents: # nothing
2392
- {
2393
- result = []
2394
- }
2395
- | regexp_contents string_content
2396
- {
2397
- result = val[0] << val[1]
2398
- }
2399
-
2400
- string_content: tSTRING_CONTENT
2401
- {
2402
- result = @builder.string_internal(val[0])
2403
- }
2404
- | tSTRING_DVAR string_dvar
2405
- {
2406
- result = val[1]
2407
- }
2408
- | tSTRING_DBEG
2409
- {
2410
- @lexer.cmdarg.push(false)
2411
- @lexer.cond.push(false)
2412
- }
2413
- compstmt tSTRING_DEND
2414
- {
2415
- @lexer.cmdarg.pop
2416
- @lexer.cond.pop
2417
-
2418
- result = @builder.begin(val[0], val[2], val[3])
2419
- }
2420
-
2421
- string_dvar: tGVAR
2422
- {
2423
- result = @builder.gvar(val[0])
2424
- }
2425
- | tIVAR
2426
- {
2427
- result = @builder.ivar(val[0])
2428
- }
2429
- | tCVAR
2430
- {
2431
- result = @builder.cvar(val[0])
2432
- }
2433
- | backref
2434
-
2435
- symbol: ssym
2436
- | dsym
2437
-
2438
- ssym: tSYMBOL
2439
- {
2440
- @lexer.state = :expr_end
2441
- result = @builder.symbol(val[0])
2442
- }
2443
-
2444
- dsym: tSYMBEG string_contents tSTRING_END
2445
- {
2446
- @lexer.state = :expr_end
2447
- result = @builder.symbol_compose(val[0], val[1], val[2])
2448
- }
2449
-
2450
- numeric: simple_numeric
2451
- {
2452
- result = val[0]
2453
- }
2454
- | tUNARY_NUM simple_numeric =tLOWEST
2455
- {
2456
- if @builder.respond_to? :negate
2457
- # AST builder interface compatibility
2458
- result = @builder.negate(val[0], val[1])
2459
- else
2460
- result = @builder.unary_num(val[0], val[1])
2461
- end
2462
- }
2463
-
2464
- simple_numeric: tINTEGER
2465
- {
2466
- @lexer.state = :expr_end
2467
- result = @builder.integer(val[0])
2468
- }
2469
- | tFLOAT
2470
- {
2471
- @lexer.state = :expr_end
2472
- result = @builder.float(val[0])
2473
- }
2474
- | tRATIONAL
2475
- {
2476
- @lexer.state = :expr_end
2477
- result = @builder.rational(val[0])
2478
- }
2479
- | tIMAGINARY
2480
- {
2481
- @lexer.state = :expr_end
2482
- result = @builder.complex(val[0])
2483
- }
2484
-
2485
- user_variable: tIDENTIFIER
2486
- {
2487
- result = @builder.ident(val[0])
2488
- }
2489
- | tIVAR
2490
- {
2491
- result = @builder.ivar(val[0])
2492
- }
2493
- | tGVAR
2494
- {
2495
- result = @builder.gvar(val[0])
2496
- }
2497
- | tCONSTANT
2498
- {
2499
- result = @builder.const(val[0])
2500
- }
2501
- | tCVAR
2502
- {
2503
- result = @builder.cvar(val[0])
2504
- }
2505
-
2506
- keyword_variable: kNIL
2507
- {
2508
- result = @builder.nil(val[0])
2509
- }
2510
- | kSELF
2511
- {
2512
- result = @builder.self(val[0])
2513
- }
2514
- | kTRUE
2515
- {
2516
- result = @builder.true(val[0])
2517
- }
2518
- | kFALSE
2519
- {
2520
- result = @builder.false(val[0])
2521
- }
2522
- | k__FILE__
2523
- {
2524
- result = @builder.__FILE__(val[0])
2525
- }
2526
- | k__LINE__
2527
- {
2528
- result = @builder.__LINE__(val[0])
2529
- }
2530
- | k__ENCODING__
2531
- {
2532
- result = @builder.__ENCODING__(val[0])
2533
- }
2534
-
2535
- var_ref: user_variable
2536
- {
2537
- if (node = val[0]) && node.type == :ident
2538
- name = node.children[0]
2539
-
2540
- if name =~ /\A_[1-9]\z/ && !static_env.declared?(name) && context.in_dynamic_block?
2541
- # definitely an implicit param
2542
- location = node.loc.expression
2543
-
2544
- if max_numparam_stack.has_ordinary_params?
2545
- diagnostic :error, :ordinary_param_defined, nil, [nil, location]
2546
- end
2547
-
2548
- raw_context = context.stack.dup
2549
- raw_max_numparam_stack = max_numparam_stack.stack.dup
2550
-
2551
- # ignore current block scope
2552
- raw_context.pop
2553
- raw_max_numparam_stack.pop
2554
-
2555
- raw_context.reverse_each do |outer_scope|
2556
- if outer_scope == :block || outer_scope == :lambda
2557
- outer_scope_has_numparams = raw_max_numparam_stack.pop > 0
2558
-
2559
- if outer_scope_has_numparams
2560
- diagnostic :error, :numparam_used_in_outer_scope, nil, [nil, location]
2561
- else
2562
- # for now it's ok, but an outer scope can also be a block
2563
- # with numparams, so we need to continue
2564
- end
2565
- else
2566
- # found an outer scope that can't have numparams
2567
- # like def/class/etc
2568
- break
2569
- end
2570
- end
2571
-
2572
- static_env.declare(name)
2573
- max_numparam_stack.register(name[1].to_i)
2574
- end
2575
- end
2576
-
2577
- result = @builder.accessible(val[0])
2578
- }
2579
- | keyword_variable
2580
- {
2581
- result = @builder.accessible(val[0])
2582
- }
2583
-
2584
- var_lhs: user_variable
2585
- {
2586
- result = @builder.assignable(val[0])
2587
- }
2588
- | keyword_variable
2589
- {
2590
- result = @builder.assignable(val[0])
2591
- }
2592
-
2593
- backref: tNTH_REF
2594
- {
2595
- result = @builder.nth_ref(val[0])
2596
- }
2597
- | tBACK_REF
2598
- {
2599
- result = @builder.back_ref(val[0])
2600
- }
2601
-
2602
- superclass: tLT
2603
- {
2604
- @lexer.state = :expr_value
2605
- }
2606
- expr_value term
2607
- {
2608
- result = [ val[0], val[2] ]
2609
- }
2610
- | # nothing
2611
- {
2612
- result = nil
2613
- }
2614
-
2615
- f_paren_args: tLPAREN2 f_args rparen
2616
- {
2617
- result = @builder.args(val[0], val[1], val[2])
2618
-
2619
- @lexer.state = :expr_value
2620
- }
2621
- | tLPAREN2 f_arg tCOMMA args_forward rparen
2622
- {
2623
- args = [ *val[1], @builder.forward_arg(val[3]) ]
2624
- result = @builder.args(val[0], args, val[4])
2625
-
2626
- @static_env.declare_forward_args
2627
- }
2628
- | tLPAREN2 args_forward rparen
2629
- {
2630
- result = @builder.forward_only_args(val[0], val[1], val[2])
2631
- @static_env.declare_forward_args
2632
-
2633
- @lexer.state = :expr_value
2634
- }
2635
-
2636
- f_arglist: f_paren_args
2637
- | {
2638
- result = @lexer.in_kwarg
2639
- @lexer.in_kwarg = true
2640
- }
2641
- f_args term
2642
- {
2643
- @lexer.in_kwarg = val[0]
2644
- result = @builder.args(nil, val[1], nil)
2645
- }
2646
-
2647
- args_tail: f_kwarg tCOMMA f_kwrest opt_f_block_arg
2648
- {
2649
- result = val[0].concat(val[2]).concat(val[3])
2650
- }
2651
- | f_kwarg opt_f_block_arg
2652
- {
2653
- result = val[0].concat(val[1])
2654
- }
2655
- | f_any_kwrest opt_f_block_arg
2656
- {
2657
- result = val[0].concat(val[1])
2658
- }
2659
- | f_block_arg
2660
- {
2661
- result = [ val[0] ]
2662
- }
2663
-
2664
- opt_args_tail: tCOMMA args_tail
2665
- {
2666
- result = val[1]
2667
- }
2668
- | # nothing
2669
- {
2670
- result = []
2671
- }
2672
-
2673
- f_args: f_arg tCOMMA f_optarg tCOMMA f_rest_arg opt_args_tail
2674
- {
2675
- result = val[0].
2676
- concat(val[2]).
2677
- concat(val[4]).
2678
- concat(val[5])
2679
- }
2680
- | f_arg tCOMMA f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
2681
- {
2682
- result = val[0].
2683
- concat(val[2]).
2684
- concat(val[4]).
2685
- concat(val[6]).
2686
- concat(val[7])
2687
- }
2688
- | f_arg tCOMMA f_optarg opt_args_tail
2689
- {
2690
- result = val[0].
2691
- concat(val[2]).
2692
- concat(val[3])
2693
- }
2694
- | f_arg tCOMMA f_optarg tCOMMA f_arg opt_args_tail
2695
- {
2696
- result = val[0].
2697
- concat(val[2]).
2698
- concat(val[4]).
2699
- concat(val[5])
2700
- }
2701
- | f_arg tCOMMA f_rest_arg opt_args_tail
2702
- {
2703
- result = val[0].
2704
- concat(val[2]).
2705
- concat(val[3])
2706
- }
2707
- | f_arg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
2708
- {
2709
- result = val[0].
2710
- concat(val[2]).
2711
- concat(val[4]).
2712
- concat(val[5])
2713
- }
2714
- | f_arg opt_args_tail
2715
- {
2716
- result = val[0].
2717
- concat(val[1])
2718
- }
2719
- | f_optarg tCOMMA f_rest_arg opt_args_tail
2720
- {
2721
- result = val[0].
2722
- concat(val[2]).
2723
- concat(val[3])
2724
- }
2725
- | f_optarg tCOMMA f_rest_arg tCOMMA f_arg opt_args_tail
2726
- {
2727
- result = val[0].
2728
- concat(val[2]).
2729
- concat(val[4]).
2730
- concat(val[5])
2731
- }
2732
- | f_optarg opt_args_tail
2733
- {
2734
- result = val[0].
2735
- concat(val[1])
2736
- }
2737
- | f_optarg tCOMMA f_arg opt_args_tail
2738
- {
2739
- result = val[0].
2740
- concat(val[2]).
2741
- concat(val[3])
2742
- }
2743
- | f_rest_arg opt_args_tail
2744
- {
2745
- result = val[0].
2746
- concat(val[1])
2747
- }
2748
- | f_rest_arg tCOMMA f_arg opt_args_tail
2749
- {
2750
- result = val[0].
2751
- concat(val[2]).
2752
- concat(val[3])
2753
- }
2754
- | args_tail
2755
- {
2756
- result = val[0]
2757
- }
2758
- | # nothing
2759
- {
2760
- result = []
2761
- }
2762
-
2763
- args_forward: tBDOT3
2764
- {
2765
- result = val[0]
2766
- }
2767
-
2768
- f_bad_arg: tCONSTANT
2769
- {
2770
- diagnostic :error, :argument_const, nil, val[0]
2771
- }
2772
- | tIVAR
2773
- {
2774
- diagnostic :error, :argument_ivar, nil, val[0]
2775
- }
2776
- | tGVAR
2777
- {
2778
- diagnostic :error, :argument_gvar, nil, val[0]
2779
- }
2780
- | tCVAR
2781
- {
2782
- diagnostic :error, :argument_cvar, nil, val[0]
2783
- }
2784
-
2785
- f_norm_arg: f_bad_arg
2786
- | tIDENTIFIER
2787
- {
2788
- @static_env.declare val[0][0]
2789
-
2790
- @max_numparam_stack.has_ordinary_params!
2791
-
2792
- result = val[0]
2793
- }
2794
-
2795
- f_arg_asgn: f_norm_arg
2796
- {
2797
- @current_arg_stack.set(val[0][0])
2798
- result = val[0]
2799
- }
2800
-
2801
- f_arg_item: f_arg_asgn
2802
- {
2803
- @current_arg_stack.set(0)
2804
- result = @builder.arg(val[0])
2805
- }
2806
- | tLPAREN f_margs rparen
2807
- {
2808
- result = @builder.multi_lhs(val[0], val[1], val[2])
2809
- }
2810
-
2811
- f_arg: f_arg_item
2812
- {
2813
- result = [ val[0] ]
2814
- }
2815
- | f_arg tCOMMA f_arg_item
2816
- {
2817
- result = val[0] << val[2]
2818
- }
2819
-
2820
- f_label: tLABEL
2821
- {
2822
- check_kwarg_name(val[0])
2823
-
2824
- @static_env.declare val[0][0]
2825
-
2826
- @max_numparam_stack.has_ordinary_params!
2827
-
2828
- @current_arg_stack.set(val[0][0])
2829
-
2830
- result = val[0]
2831
- }
2832
-
2833
- f_kw: f_label arg_value
2834
- {
2835
- @current_arg_stack.set(nil)
2836
- result = @builder.kwoptarg(val[0], val[1])
2837
- }
2838
- | f_label
2839
- {
2840
- @current_arg_stack.set(nil)
2841
- result = @builder.kwarg(val[0])
2842
- }
2843
-
2844
- f_block_kw: f_label primary_value
2845
- {
2846
- result = @builder.kwoptarg(val[0], val[1])
2847
- }
2848
- | f_label
2849
- {
2850
- result = @builder.kwarg(val[0])
2851
- }
2852
-
2853
- f_block_kwarg: f_block_kw
2854
- {
2855
- result = [ val[0] ]
2856
- }
2857
- | f_block_kwarg tCOMMA f_block_kw
2858
- {
2859
- result = val[0] << val[2]
2860
- }
2861
-
2862
- f_kwarg: f_kw
2863
- {
2864
- result = [ val[0] ]
2865
- }
2866
- | f_kwarg tCOMMA f_kw
2867
- {
2868
- result = val[0] << val[2]
2869
- }
2870
-
2871
- kwrest_mark: tPOW | tDSTAR
2872
-
2873
- f_no_kwarg: kwrest_mark kNIL
2874
- {
2875
- result = [ @builder.kwnilarg(val[0], val[1]) ]
2876
- }
2877
-
2878
- f_kwrest: kwrest_mark tIDENTIFIER
2879
- {
2880
- @static_env.declare val[1][0]
2881
-
2882
- result = [ @builder.kwrestarg(val[0], val[1]) ]
2883
- }
2884
- | kwrest_mark
2885
- {
2886
- result = [ @builder.kwrestarg(val[0]) ]
2887
- }
2888
-
2889
- f_opt: f_arg_asgn tEQL arg_value
2890
- {
2891
- @current_arg_stack.set(0)
2892
- result = @builder.optarg(val[0], val[1], val[2])
2893
- }
2894
-
2895
- f_block_opt: f_arg_asgn tEQL primary_value
2896
- {
2897
- @current_arg_stack.set(0)
2898
- result = @builder.optarg(val[0], val[1], val[2])
2899
- }
2900
-
2901
- f_block_optarg: f_block_opt
2902
- {
2903
- result = [ val[0] ]
2904
- }
2905
- | f_block_optarg tCOMMA f_block_opt
2906
- {
2907
- result = val[0] << val[2]
2908
- }
2909
-
2910
- f_optarg: f_opt
2911
- {
2912
- result = [ val[0] ]
2913
- }
2914
- | f_optarg tCOMMA f_opt
2915
- {
2916
- result = val[0] << val[2]
2917
- }
2918
-
2919
- restarg_mark: tSTAR2 | tSTAR
2920
-
2921
- f_rest_arg: restarg_mark tIDENTIFIER
2922
- {
2923
- @static_env.declare val[1][0]
2924
-
2925
- result = [ @builder.restarg(val[0], val[1]) ]
2926
- }
2927
- | restarg_mark
2928
- {
2929
- result = [ @builder.restarg(val[0]) ]
2930
- }
2931
-
2932
- blkarg_mark: tAMPER2 | tAMPER
2933
-
2934
- f_block_arg: blkarg_mark tIDENTIFIER
2935
- {
2936
- @static_env.declare val[1][0]
2937
-
2938
- result = @builder.blockarg(val[0], val[1])
2939
- }
2940
-
2941
- opt_f_block_arg: tCOMMA f_block_arg
2942
- {
2943
- result = [ val[1] ]
2944
- }
2945
- |
2946
- {
2947
- result = []
2948
- }
2949
-
2950
- singleton: var_ref
2951
- | tLPAREN2 expr rparen
2952
- {
2953
- result = val[1]
2954
- }
2955
-
2956
- assoc_list: # nothing
2957
- {
2958
- result = []
2959
- }
2960
- | assocs trailer
2961
-
2962
- assocs: assoc
2963
- {
2964
- result = [ val[0] ]
2965
- }
2966
- | assocs tCOMMA assoc
2967
- {
2968
- result = val[0] << val[2]
2969
- }
2970
-
2971
- assoc: arg_value tASSOC arg_value
2972
- {
2973
- result = @builder.pair(val[0], val[1], val[2])
2974
- }
2975
- | tLABEL arg_value
2976
- {
2977
- result = @builder.pair_keyword(val[0], val[1])
2978
- }
2979
- | tSTRING_BEG string_contents tLABEL_END arg_value
2980
- {
2981
- result = @builder.pair_quoted(val[0], val[1], val[2], val[3])
2982
- }
2983
- | tDSTAR arg_value
2984
- {
2985
- result = @builder.kwsplat(val[0], val[1])
2986
- }
2987
-
2988
- operation: tIDENTIFIER | tCONSTANT | tFID
2989
- operation2: tIDENTIFIER | tCONSTANT | tFID | op
2990
- operation3: tIDENTIFIER | tFID | op
2991
- dot_or_colon: call_op | tCOLON2
2992
- call_op: tDOT
2993
- {
2994
- result = [:dot, val[0][1]]
2995
- }
2996
- | tANDDOT
2997
- {
2998
- result = [:anddot, val[0][1]]
2999
- }
3000
- opt_terms: | terms
3001
- opt_nl: | tNL
3002
- rparen: opt_nl tRPAREN
3003
- {
3004
- result = val[1]
3005
- }
3006
- rbracket: opt_nl tRBRACK
3007
- {
3008
- result = val[1]
3009
- }
3010
- rbrace: opt_nl tRCURLY
3011
- {
3012
- result = val[1]
3013
- }
3014
- trailer: | tNL | tCOMMA
3015
-
3016
- term: tSEMI
3017
- {
3018
- yyerrok
3019
- }
3020
- | tNL
3021
-
3022
- terms: term
3023
- | terms tSEMI
3024
-
3025
- none: # nothing
3026
- {
3027
- result = nil
3028
- }
3029
- end
3030
-
3031
- ---- header
3032
-
3033
- require 'parser'
3034
-
3035
- ---- inner
3036
-
3037
- def version
3038
- 28
3039
- end
3040
-
3041
- def default_encoding
3042
- Encoding::UTF_8
3043
- end