yarp 0.10.0 → 0.11.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (36) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +25 -1
  3. data/CONTRIBUTING.md +7 -0
  4. data/config.yml +154 -43
  5. data/docs/configuration.md +0 -1
  6. data/docs/mapping.md +91 -91
  7. data/docs/serialization.md +23 -20
  8. data/ext/yarp/api_node.c +1074 -391
  9. data/ext/yarp/extension.c +1 -1
  10. data/ext/yarp/extension.h +2 -2
  11. data/include/yarp/ast.h +501 -301
  12. data/include/yarp/diagnostic.h +198 -1
  13. data/include/yarp/node.h +0 -4
  14. data/include/yarp/util/yp_char.h +1 -1
  15. data/include/yarp/util/yp_constant_pool.h +11 -4
  16. data/include/yarp/version.h +2 -2
  17. data/lib/yarp/desugar_visitor.rb +19 -19
  18. data/lib/yarp/mutation_visitor.rb +22 -12
  19. data/lib/yarp/node.rb +2883 -293
  20. data/lib/yarp/parse_result/comments.rb +172 -0
  21. data/lib/yarp/parse_result/newlines.rb +60 -0
  22. data/lib/yarp/pattern.rb +239 -0
  23. data/lib/yarp/serialize.rb +152 -129
  24. data/lib/yarp.rb +104 -44
  25. data/src/diagnostic.c +254 -2
  26. data/src/node.c +901 -868
  27. data/src/prettyprint.c +380 -186
  28. data/src/serialize.c +325 -170
  29. data/src/unescape.c +20 -20
  30. data/src/util/yp_char.c +2 -7
  31. data/src/util/yp_constant_pool.c +41 -8
  32. data/src/util/yp_newline_list.c +5 -1
  33. data/src/util/yp_string_list.c +4 -1
  34. data/src/yarp.c +946 -818
  35. data/yarp.gemspec +4 -1
  36. metadata +6 -3
data/ext/yarp/api_node.c CHANGED
@@ -25,14 +25,15 @@ static VALUE rb_cYARPAssocSplatNode;
25
25
  static VALUE rb_cYARPBackReferenceReadNode;
26
26
  static VALUE rb_cYARPBeginNode;
27
27
  static VALUE rb_cYARPBlockArgumentNode;
28
+ static VALUE rb_cYARPBlockLocalVariableNode;
28
29
  static VALUE rb_cYARPBlockNode;
29
30
  static VALUE rb_cYARPBlockParameterNode;
30
31
  static VALUE rb_cYARPBlockParametersNode;
31
32
  static VALUE rb_cYARPBreakNode;
33
+ static VALUE rb_cYARPCallAndWriteNode;
32
34
  static VALUE rb_cYARPCallNode;
33
- static VALUE rb_cYARPCallOperatorAndWriteNode;
34
- static VALUE rb_cYARPCallOperatorOrWriteNode;
35
35
  static VALUE rb_cYARPCallOperatorWriteNode;
36
+ static VALUE rb_cYARPCallOrWriteNode;
36
37
  static VALUE rb_cYARPCapturePatternNode;
37
38
  static VALUE rb_cYARPCaseNode;
38
39
  static VALUE rb_cYARPClassNode;
@@ -104,6 +105,7 @@ static VALUE rb_cYARPMatchPredicateNode;
104
105
  static VALUE rb_cYARPMatchRequiredNode;
105
106
  static VALUE rb_cYARPMissingNode;
106
107
  static VALUE rb_cYARPModuleNode;
108
+ static VALUE rb_cYARPMultiTargetNode;
107
109
  static VALUE rb_cYARPMultiWriteNode;
108
110
  static VALUE rb_cYARPNextNode;
109
111
  static VALUE rb_cYARPNilNode;
@@ -176,8 +178,8 @@ yp_string_new(yp_string_t *string, rb_encoding *encoding) {
176
178
 
177
179
  // Create a YARP::Source object from the given parser.
178
180
  VALUE
179
- yp_source_new(yp_parser_t *parser) {
180
- VALUE source = rb_str_new((const char *) parser->start, parser->end - parser->start);
181
+ yp_source_new(yp_parser_t *parser, rb_encoding *encoding) {
182
+ VALUE source = rb_enc_str_new((const char *) parser->start, parser->end - parser->start, encoding);
181
183
  VALUE offsets = rb_ary_new_capa(parser->newline_list.size);
182
184
 
183
185
  for (size_t index = 0; index < parser->newline_list.size; index++) {
@@ -216,7 +218,7 @@ yp_node_stack_pop(yp_node_stack_node_t **stack) {
216
218
 
217
219
  VALUE
218
220
  yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
219
- VALUE source = yp_source_new(parser);
221
+ VALUE source = yp_source_new(parser, encoding);
220
222
  ID *constants = calloc(parser->constant_pool.size, sizeof(ID));
221
223
 
222
224
  for (size_t index = 0; index < parser->constant_pool.capacity; index++) {
@@ -244,28 +246,28 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
244
246
 
245
247
  switch (YP_NODE_TYPE(node)) {
246
248
  #line 111 "api_node.c.erb"
247
- case YP_NODE_ALIAS_NODE: {
249
+ case YP_ALIAS_NODE: {
248
250
  yp_alias_node_t *cast = (yp_alias_node_t *) node;
249
251
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->new_name);
250
252
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->old_name);
251
253
  break;
252
254
  }
253
255
  #line 111 "api_node.c.erb"
254
- case YP_NODE_ALTERNATION_PATTERN_NODE: {
256
+ case YP_ALTERNATION_PATTERN_NODE: {
255
257
  yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
256
258
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
257
259
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
258
260
  break;
259
261
  }
260
262
  #line 111 "api_node.c.erb"
261
- case YP_NODE_AND_NODE: {
263
+ case YP_AND_NODE: {
262
264
  yp_and_node_t *cast = (yp_and_node_t *) node;
263
265
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
264
266
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
265
267
  break;
266
268
  }
267
269
  #line 111 "api_node.c.erb"
268
- case YP_NODE_ARGUMENTS_NODE: {
270
+ case YP_ARGUMENTS_NODE: {
269
271
  yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
270
272
  for (size_t index = 0; index < cast->arguments.size; index++) {
271
273
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments.nodes[index]);
@@ -273,7 +275,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
273
275
  break;
274
276
  }
275
277
  #line 111 "api_node.c.erb"
276
- case YP_NODE_ARRAY_NODE: {
278
+ case YP_ARRAY_NODE: {
277
279
  yp_array_node_t *cast = (yp_array_node_t *) node;
278
280
  for (size_t index = 0; index < cast->elements.size; index++) {
279
281
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->elements.nodes[index]);
@@ -281,7 +283,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
281
283
  break;
282
284
  }
283
285
  #line 111 "api_node.c.erb"
284
- case YP_NODE_ARRAY_PATTERN_NODE: {
286
+ case YP_ARRAY_PATTERN_NODE: {
285
287
  yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
286
288
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant);
287
289
  for (size_t index = 0; index < cast->requireds.size; index++) {
@@ -294,20 +296,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
294
296
  break;
295
297
  }
296
298
  #line 111 "api_node.c.erb"
297
- case YP_NODE_ASSOC_NODE: {
299
+ case YP_ASSOC_NODE: {
298
300
  yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
299
301
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->key);
300
302
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
301
303
  break;
302
304
  }
303
305
  #line 111 "api_node.c.erb"
304
- case YP_NODE_ASSOC_SPLAT_NODE: {
306
+ case YP_ASSOC_SPLAT_NODE: {
305
307
  yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
306
308
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
307
309
  break;
308
310
  }
309
311
  #line 111 "api_node.c.erb"
310
- case YP_NODE_BEGIN_NODE: {
312
+ case YP_BEGIN_NODE: {
311
313
  yp_begin_node_t *cast = (yp_begin_node_t *) node;
312
314
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
313
315
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->rescue_clause);
@@ -316,68 +318,74 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
316
318
  break;
317
319
  }
318
320
  #line 111 "api_node.c.erb"
319
- case YP_NODE_BLOCK_ARGUMENT_NODE: {
321
+ case YP_BLOCK_ARGUMENT_NODE: {
320
322
  yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
321
323
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
322
324
  break;
323
325
  }
324
326
  #line 111 "api_node.c.erb"
325
- case YP_NODE_BLOCK_NODE: {
327
+ case YP_BLOCK_NODE: {
326
328
  yp_block_node_t *cast = (yp_block_node_t *) node;
327
329
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
328
330
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
329
331
  break;
330
332
  }
331
333
  #line 111 "api_node.c.erb"
332
- case YP_NODE_BLOCK_PARAMETERS_NODE: {
334
+ case YP_BLOCK_PARAMETERS_NODE: {
333
335
  yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
334
336
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
337
+ for (size_t index = 0; index < cast->locals.size; index++) {
338
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->locals.nodes[index]);
339
+ }
335
340
  break;
336
341
  }
337
342
  #line 111 "api_node.c.erb"
338
- case YP_NODE_BREAK_NODE: {
343
+ case YP_BREAK_NODE: {
339
344
  yp_break_node_t *cast = (yp_break_node_t *) node;
340
345
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
341
346
  break;
342
347
  }
343
348
  #line 111 "api_node.c.erb"
344
- case YP_NODE_CALL_NODE: {
345
- yp_call_node_t *cast = (yp_call_node_t *) node;
349
+ case YP_CALL_AND_WRITE_NODE: {
350
+ yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
346
351
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
347
352
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
348
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
353
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
349
354
  break;
350
355
  }
351
356
  #line 111 "api_node.c.erb"
352
- case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
353
- yp_call_operator_and_write_node_t *cast = (yp_call_operator_and_write_node_t *) node;
354
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
355
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
357
+ case YP_CALL_NODE: {
358
+ yp_call_node_t *cast = (yp_call_node_t *) node;
359
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
360
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
361
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
356
362
  break;
357
363
  }
358
364
  #line 111 "api_node.c.erb"
359
- case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
360
- yp_call_operator_or_write_node_t *cast = (yp_call_operator_or_write_node_t *) node;
361
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
365
+ case YP_CALL_OPERATOR_WRITE_NODE: {
366
+ yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
367
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
368
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
362
369
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
363
370
  break;
364
371
  }
365
372
  #line 111 "api_node.c.erb"
366
- case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
367
- yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
368
- yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
373
+ case YP_CALL_OR_WRITE_NODE: {
374
+ yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
375
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
376
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
369
377
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
370
378
  break;
371
379
  }
372
380
  #line 111 "api_node.c.erb"
373
- case YP_NODE_CAPTURE_PATTERN_NODE: {
381
+ case YP_CAPTURE_PATTERN_NODE: {
374
382
  yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
375
383
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
376
384
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
377
385
  break;
378
386
  }
379
387
  #line 111 "api_node.c.erb"
380
- case YP_NODE_CASE_NODE: {
388
+ case YP_CASE_NODE: {
381
389
  yp_case_node_t *cast = (yp_case_node_t *) node;
382
390
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
383
391
  for (size_t index = 0; index < cast->conditions.size; index++) {
@@ -387,7 +395,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
387
395
  break;
388
396
  }
389
397
  #line 111 "api_node.c.erb"
390
- case YP_NODE_CLASS_NODE: {
398
+ case YP_CLASS_NODE: {
391
399
  yp_class_node_t *cast = (yp_class_node_t *) node;
392
400
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant_path);
393
401
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->superclass);
@@ -395,97 +403,97 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
395
403
  break;
396
404
  }
397
405
  #line 111 "api_node.c.erb"
398
- case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
406
+ case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
399
407
  yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
400
408
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
401
409
  break;
402
410
  }
403
411
  #line 111 "api_node.c.erb"
404
- case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
412
+ case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
405
413
  yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
406
414
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
407
415
  break;
408
416
  }
409
417
  #line 111 "api_node.c.erb"
410
- case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
418
+ case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
411
419
  yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
412
420
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
413
421
  break;
414
422
  }
415
423
  #line 111 "api_node.c.erb"
416
- case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
424
+ case YP_CLASS_VARIABLE_WRITE_NODE: {
417
425
  yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
418
426
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
419
427
  break;
420
428
  }
421
429
  #line 111 "api_node.c.erb"
422
- case YP_NODE_CONSTANT_AND_WRITE_NODE: {
430
+ case YP_CONSTANT_AND_WRITE_NODE: {
423
431
  yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
424
432
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
425
433
  break;
426
434
  }
427
435
  #line 111 "api_node.c.erb"
428
- case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
436
+ case YP_CONSTANT_OPERATOR_WRITE_NODE: {
429
437
  yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
430
438
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
431
439
  break;
432
440
  }
433
441
  #line 111 "api_node.c.erb"
434
- case YP_NODE_CONSTANT_OR_WRITE_NODE: {
442
+ case YP_CONSTANT_OR_WRITE_NODE: {
435
443
  yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
436
444
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
437
445
  break;
438
446
  }
439
447
  #line 111 "api_node.c.erb"
440
- case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
448
+ case YP_CONSTANT_PATH_AND_WRITE_NODE: {
441
449
  yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
442
450
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
443
451
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
444
452
  break;
445
453
  }
446
454
  #line 111 "api_node.c.erb"
447
- case YP_NODE_CONSTANT_PATH_NODE: {
455
+ case YP_CONSTANT_PATH_NODE: {
448
456
  yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
449
457
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parent);
450
458
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->child);
451
459
  break;
452
460
  }
453
461
  #line 111 "api_node.c.erb"
454
- case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
462
+ case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
455
463
  yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
456
464
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
457
465
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
458
466
  break;
459
467
  }
460
468
  #line 111 "api_node.c.erb"
461
- case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
469
+ case YP_CONSTANT_PATH_OR_WRITE_NODE: {
462
470
  yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
463
471
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
464
472
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
465
473
  break;
466
474
  }
467
475
  #line 111 "api_node.c.erb"
468
- case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
476
+ case YP_CONSTANT_PATH_TARGET_NODE: {
469
477
  yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
470
478
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parent);
471
479
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->child);
472
480
  break;
473
481
  }
474
482
  #line 111 "api_node.c.erb"
475
- case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
483
+ case YP_CONSTANT_PATH_WRITE_NODE: {
476
484
  yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
477
485
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->target);
478
486
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
479
487
  break;
480
488
  }
481
489
  #line 111 "api_node.c.erb"
482
- case YP_NODE_CONSTANT_WRITE_NODE: {
490
+ case YP_CONSTANT_WRITE_NODE: {
483
491
  yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
484
492
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
485
493
  break;
486
494
  }
487
495
  #line 111 "api_node.c.erb"
488
- case YP_NODE_DEF_NODE: {
496
+ case YP_DEF_NODE: {
489
497
  yp_def_node_t *cast = (yp_def_node_t *) node;
490
498
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->receiver);
491
499
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
@@ -493,37 +501,37 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
493
501
  break;
494
502
  }
495
503
  #line 111 "api_node.c.erb"
496
- case YP_NODE_DEFINED_NODE: {
504
+ case YP_DEFINED_NODE: {
497
505
  yp_defined_node_t *cast = (yp_defined_node_t *) node;
498
506
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
499
507
  break;
500
508
  }
501
509
  #line 111 "api_node.c.erb"
502
- case YP_NODE_ELSE_NODE: {
510
+ case YP_ELSE_NODE: {
503
511
  yp_else_node_t *cast = (yp_else_node_t *) node;
504
512
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
505
513
  break;
506
514
  }
507
515
  #line 111 "api_node.c.erb"
508
- case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
516
+ case YP_EMBEDDED_STATEMENTS_NODE: {
509
517
  yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
510
518
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
511
519
  break;
512
520
  }
513
521
  #line 111 "api_node.c.erb"
514
- case YP_NODE_EMBEDDED_VARIABLE_NODE: {
522
+ case YP_EMBEDDED_VARIABLE_NODE: {
515
523
  yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
516
524
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->variable);
517
525
  break;
518
526
  }
519
527
  #line 111 "api_node.c.erb"
520
- case YP_NODE_ENSURE_NODE: {
528
+ case YP_ENSURE_NODE: {
521
529
  yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
522
530
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
523
531
  break;
524
532
  }
525
533
  #line 111 "api_node.c.erb"
526
- case YP_NODE_FIND_PATTERN_NODE: {
534
+ case YP_FIND_PATTERN_NODE: {
527
535
  yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
528
536
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant);
529
537
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
@@ -534,14 +542,14 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
534
542
  break;
535
543
  }
536
544
  #line 111 "api_node.c.erb"
537
- case YP_NODE_FLIP_FLOP_NODE: {
545
+ case YP_FLIP_FLOP_NODE: {
538
546
  yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
539
547
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
540
548
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
541
549
  break;
542
550
  }
543
551
  #line 111 "api_node.c.erb"
544
- case YP_NODE_FOR_NODE: {
552
+ case YP_FOR_NODE: {
545
553
  yp_for_node_t *cast = (yp_for_node_t *) node;
546
554
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->index);
547
555
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->collection);
@@ -549,37 +557,37 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
549
557
  break;
550
558
  }
551
559
  #line 111 "api_node.c.erb"
552
- case YP_NODE_FORWARDING_SUPER_NODE: {
560
+ case YP_FORWARDING_SUPER_NODE: {
553
561
  yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
554
562
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
555
563
  break;
556
564
  }
557
565
  #line 111 "api_node.c.erb"
558
- case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
566
+ case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
559
567
  yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
560
568
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
561
569
  break;
562
570
  }
563
571
  #line 111 "api_node.c.erb"
564
- case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
572
+ case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
565
573
  yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
566
574
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
567
575
  break;
568
576
  }
569
577
  #line 111 "api_node.c.erb"
570
- case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
578
+ case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
571
579
  yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
572
580
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
573
581
  break;
574
582
  }
575
583
  #line 111 "api_node.c.erb"
576
- case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
584
+ case YP_GLOBAL_VARIABLE_WRITE_NODE: {
577
585
  yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
578
586
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
579
587
  break;
580
588
  }
581
589
  #line 111 "api_node.c.erb"
582
- case YP_NODE_HASH_NODE: {
590
+ case YP_HASH_NODE: {
583
591
  yp_hash_node_t *cast = (yp_hash_node_t *) node;
584
592
  for (size_t index = 0; index < cast->elements.size; index++) {
585
593
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->elements.nodes[index]);
@@ -587,7 +595,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
587
595
  break;
588
596
  }
589
597
  #line 111 "api_node.c.erb"
590
- case YP_NODE_HASH_PATTERN_NODE: {
598
+ case YP_HASH_PATTERN_NODE: {
591
599
  yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
592
600
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant);
593
601
  for (size_t index = 0; index < cast->assocs.size; index++) {
@@ -597,7 +605,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
597
605
  break;
598
606
  }
599
607
  #line 111 "api_node.c.erb"
600
- case YP_NODE_IF_NODE: {
608
+ case YP_IF_NODE: {
601
609
  yp_if_node_t *cast = (yp_if_node_t *) node;
602
610
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
603
611
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
@@ -605,44 +613,44 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
605
613
  break;
606
614
  }
607
615
  #line 111 "api_node.c.erb"
608
- case YP_NODE_IMAGINARY_NODE: {
616
+ case YP_IMAGINARY_NODE: {
609
617
  yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
610
618
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->numeric);
611
619
  break;
612
620
  }
613
621
  #line 111 "api_node.c.erb"
614
- case YP_NODE_IN_NODE: {
622
+ case YP_IN_NODE: {
615
623
  yp_in_node_t *cast = (yp_in_node_t *) node;
616
624
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->pattern);
617
625
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
618
626
  break;
619
627
  }
620
628
  #line 111 "api_node.c.erb"
621
- case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
629
+ case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
622
630
  yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
623
631
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
624
632
  break;
625
633
  }
626
634
  #line 111 "api_node.c.erb"
627
- case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
635
+ case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
628
636
  yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
629
637
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
630
638
  break;
631
639
  }
632
640
  #line 111 "api_node.c.erb"
633
- case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
641
+ case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
634
642
  yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
635
643
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
636
644
  break;
637
645
  }
638
646
  #line 111 "api_node.c.erb"
639
- case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
647
+ case YP_INSTANCE_VARIABLE_WRITE_NODE: {
640
648
  yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
641
649
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
642
650
  break;
643
651
  }
644
652
  #line 111 "api_node.c.erb"
645
- case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
653
+ case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
646
654
  yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
647
655
  for (size_t index = 0; index < cast->parts.size; index++) {
648
656
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
@@ -650,7 +658,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
650
658
  break;
651
659
  }
652
660
  #line 111 "api_node.c.erb"
653
- case YP_NODE_INTERPOLATED_STRING_NODE: {
661
+ case YP_INTERPOLATED_STRING_NODE: {
654
662
  yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
655
663
  for (size_t index = 0; index < cast->parts.size; index++) {
656
664
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
@@ -658,7 +666,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
658
666
  break;
659
667
  }
660
668
  #line 111 "api_node.c.erb"
661
- case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
669
+ case YP_INTERPOLATED_SYMBOL_NODE: {
662
670
  yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
663
671
  for (size_t index = 0; index < cast->parts.size; index++) {
664
672
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
@@ -666,7 +674,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
666
674
  break;
667
675
  }
668
676
  #line 111 "api_node.c.erb"
669
- case YP_NODE_INTERPOLATED_X_STRING_NODE: {
677
+ case YP_INTERPOLATED_X_STRING_NODE: {
670
678
  yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
671
679
  for (size_t index = 0; index < cast->parts.size; index++) {
672
680
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parts.nodes[index]);
@@ -674,7 +682,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
674
682
  break;
675
683
  }
676
684
  #line 111 "api_node.c.erb"
677
- case YP_NODE_KEYWORD_HASH_NODE: {
685
+ case YP_KEYWORD_HASH_NODE: {
678
686
  yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
679
687
  for (size_t index = 0; index < cast->elements.size; index++) {
680
688
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->elements.nodes[index]);
@@ -682,65 +690,73 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
682
690
  break;
683
691
  }
684
692
  #line 111 "api_node.c.erb"
685
- case YP_NODE_KEYWORD_PARAMETER_NODE: {
693
+ case YP_KEYWORD_PARAMETER_NODE: {
686
694
  yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
687
695
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
688
696
  break;
689
697
  }
690
698
  #line 111 "api_node.c.erb"
691
- case YP_NODE_LAMBDA_NODE: {
699
+ case YP_LAMBDA_NODE: {
692
700
  yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
693
701
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters);
694
702
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
695
703
  break;
696
704
  }
697
705
  #line 111 "api_node.c.erb"
698
- case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
706
+ case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
699
707
  yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
700
708
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
701
709
  break;
702
710
  }
703
711
  #line 111 "api_node.c.erb"
704
- case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
712
+ case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
705
713
  yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
706
714
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
707
715
  break;
708
716
  }
709
717
  #line 111 "api_node.c.erb"
710
- case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
718
+ case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
711
719
  yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
712
720
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
713
721
  break;
714
722
  }
715
723
  #line 111 "api_node.c.erb"
716
- case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
724
+ case YP_LOCAL_VARIABLE_WRITE_NODE: {
717
725
  yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
718
726
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
719
727
  break;
720
728
  }
721
729
  #line 111 "api_node.c.erb"
722
- case YP_NODE_MATCH_PREDICATE_NODE: {
730
+ case YP_MATCH_PREDICATE_NODE: {
723
731
  yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
724
732
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
725
733
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->pattern);
726
734
  break;
727
735
  }
728
736
  #line 111 "api_node.c.erb"
729
- case YP_NODE_MATCH_REQUIRED_NODE: {
737
+ case YP_MATCH_REQUIRED_NODE: {
730
738
  yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
731
739
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
732
740
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->pattern);
733
741
  break;
734
742
  }
735
743
  #line 111 "api_node.c.erb"
736
- case YP_NODE_MODULE_NODE: {
744
+ case YP_MODULE_NODE: {
737
745
  yp_module_node_t *cast = (yp_module_node_t *) node;
738
746
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->constant_path);
739
747
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
740
748
  break;
741
749
  }
742
750
  #line 111 "api_node.c.erb"
743
- case YP_NODE_MULTI_WRITE_NODE: {
751
+ case YP_MULTI_TARGET_NODE: {
752
+ yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
753
+ for (size_t index = 0; index < cast->targets.size; index++) {
754
+ yp_node_stack_push(&node_stack, (yp_node_t *) cast->targets.nodes[index]);
755
+ }
756
+ break;
757
+ }
758
+ #line 111 "api_node.c.erb"
759
+ case YP_MULTI_WRITE_NODE: {
744
760
  yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
745
761
  for (size_t index = 0; index < cast->targets.size; index++) {
746
762
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->targets.nodes[index]);
@@ -749,26 +765,26 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
749
765
  break;
750
766
  }
751
767
  #line 111 "api_node.c.erb"
752
- case YP_NODE_NEXT_NODE: {
768
+ case YP_NEXT_NODE: {
753
769
  yp_next_node_t *cast = (yp_next_node_t *) node;
754
770
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
755
771
  break;
756
772
  }
757
773
  #line 111 "api_node.c.erb"
758
- case YP_NODE_OPTIONAL_PARAMETER_NODE: {
774
+ case YP_OPTIONAL_PARAMETER_NODE: {
759
775
  yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
760
776
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->value);
761
777
  break;
762
778
  }
763
779
  #line 111 "api_node.c.erb"
764
- case YP_NODE_OR_NODE: {
780
+ case YP_OR_NODE: {
765
781
  yp_or_node_t *cast = (yp_or_node_t *) node;
766
782
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
767
783
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
768
784
  break;
769
785
  }
770
786
  #line 111 "api_node.c.erb"
771
- case YP_NODE_PARAMETERS_NODE: {
787
+ case YP_PARAMETERS_NODE: {
772
788
  yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
773
789
  for (size_t index = 0; index < cast->requireds.size; index++) {
774
790
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->requireds.nodes[index]);
@@ -788,56 +804,56 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
788
804
  break;
789
805
  }
790
806
  #line 111 "api_node.c.erb"
791
- case YP_NODE_PARENTHESES_NODE: {
807
+ case YP_PARENTHESES_NODE: {
792
808
  yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
793
809
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
794
810
  break;
795
811
  }
796
812
  #line 111 "api_node.c.erb"
797
- case YP_NODE_PINNED_EXPRESSION_NODE: {
813
+ case YP_PINNED_EXPRESSION_NODE: {
798
814
  yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
799
815
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
800
816
  break;
801
817
  }
802
818
  #line 111 "api_node.c.erb"
803
- case YP_NODE_PINNED_VARIABLE_NODE: {
819
+ case YP_PINNED_VARIABLE_NODE: {
804
820
  yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
805
821
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->variable);
806
822
  break;
807
823
  }
808
824
  #line 111 "api_node.c.erb"
809
- case YP_NODE_POST_EXECUTION_NODE: {
825
+ case YP_POST_EXECUTION_NODE: {
810
826
  yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
811
827
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
812
828
  break;
813
829
  }
814
830
  #line 111 "api_node.c.erb"
815
- case YP_NODE_PRE_EXECUTION_NODE: {
831
+ case YP_PRE_EXECUTION_NODE: {
816
832
  yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
817
833
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
818
834
  break;
819
835
  }
820
836
  #line 111 "api_node.c.erb"
821
- case YP_NODE_PROGRAM_NODE: {
837
+ case YP_PROGRAM_NODE: {
822
838
  yp_program_node_t *cast = (yp_program_node_t *) node;
823
839
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
824
840
  break;
825
841
  }
826
842
  #line 111 "api_node.c.erb"
827
- case YP_NODE_RANGE_NODE: {
843
+ case YP_RANGE_NODE: {
828
844
  yp_range_node_t *cast = (yp_range_node_t *) node;
829
845
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
830
846
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
831
847
  break;
832
848
  }
833
849
  #line 111 "api_node.c.erb"
834
- case YP_NODE_RATIONAL_NODE: {
850
+ case YP_RATIONAL_NODE: {
835
851
  yp_rational_node_t *cast = (yp_rational_node_t *) node;
836
852
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->numeric);
837
853
  break;
838
854
  }
839
855
  #line 111 "api_node.c.erb"
840
- case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
856
+ case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
841
857
  yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
842
858
  for (size_t index = 0; index < cast->parameters.size; index++) {
843
859
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->parameters.nodes[index]);
@@ -845,14 +861,14 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
845
861
  break;
846
862
  }
847
863
  #line 111 "api_node.c.erb"
848
- case YP_NODE_RESCUE_MODIFIER_NODE: {
864
+ case YP_RESCUE_MODIFIER_NODE: {
849
865
  yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
850
866
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
851
867
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->rescue_expression);
852
868
  break;
853
869
  }
854
870
  #line 111 "api_node.c.erb"
855
- case YP_NODE_RESCUE_NODE: {
871
+ case YP_RESCUE_NODE: {
856
872
  yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
857
873
  for (size_t index = 0; index < cast->exceptions.size; index++) {
858
874
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->exceptions.nodes[index]);
@@ -863,26 +879,26 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
863
879
  break;
864
880
  }
865
881
  #line 111 "api_node.c.erb"
866
- case YP_NODE_RETURN_NODE: {
882
+ case YP_RETURN_NODE: {
867
883
  yp_return_node_t *cast = (yp_return_node_t *) node;
868
884
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
869
885
  break;
870
886
  }
871
887
  #line 111 "api_node.c.erb"
872
- case YP_NODE_SINGLETON_CLASS_NODE: {
888
+ case YP_SINGLETON_CLASS_NODE: {
873
889
  yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
874
890
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
875
891
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->body);
876
892
  break;
877
893
  }
878
894
  #line 111 "api_node.c.erb"
879
- case YP_NODE_SPLAT_NODE: {
895
+ case YP_SPLAT_NODE: {
880
896
  yp_splat_node_t *cast = (yp_splat_node_t *) node;
881
897
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->expression);
882
898
  break;
883
899
  }
884
900
  #line 111 "api_node.c.erb"
885
- case YP_NODE_STATEMENTS_NODE: {
901
+ case YP_STATEMENTS_NODE: {
886
902
  yp_statements_node_t *cast = (yp_statements_node_t *) node;
887
903
  for (size_t index = 0; index < cast->body.size; index++) {
888
904
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->body.nodes[index]);
@@ -890,21 +906,21 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
890
906
  break;
891
907
  }
892
908
  #line 111 "api_node.c.erb"
893
- case YP_NODE_STRING_CONCAT_NODE: {
909
+ case YP_STRING_CONCAT_NODE: {
894
910
  yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
895
911
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->left);
896
912
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->right);
897
913
  break;
898
914
  }
899
915
  #line 111 "api_node.c.erb"
900
- case YP_NODE_SUPER_NODE: {
916
+ case YP_SUPER_NODE: {
901
917
  yp_super_node_t *cast = (yp_super_node_t *) node;
902
918
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
903
919
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->block);
904
920
  break;
905
921
  }
906
922
  #line 111 "api_node.c.erb"
907
- case YP_NODE_UNDEF_NODE: {
923
+ case YP_UNDEF_NODE: {
908
924
  yp_undef_node_t *cast = (yp_undef_node_t *) node;
909
925
  for (size_t index = 0; index < cast->names.size; index++) {
910
926
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->names.nodes[index]);
@@ -912,7 +928,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
912
928
  break;
913
929
  }
914
930
  #line 111 "api_node.c.erb"
915
- case YP_NODE_UNLESS_NODE: {
931
+ case YP_UNLESS_NODE: {
916
932
  yp_unless_node_t *cast = (yp_unless_node_t *) node;
917
933
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
918
934
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
@@ -920,14 +936,14 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
920
936
  break;
921
937
  }
922
938
  #line 111 "api_node.c.erb"
923
- case YP_NODE_UNTIL_NODE: {
939
+ case YP_UNTIL_NODE: {
924
940
  yp_until_node_t *cast = (yp_until_node_t *) node;
925
941
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
926
942
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
927
943
  break;
928
944
  }
929
945
  #line 111 "api_node.c.erb"
930
- case YP_NODE_WHEN_NODE: {
946
+ case YP_WHEN_NODE: {
931
947
  yp_when_node_t *cast = (yp_when_node_t *) node;
932
948
  for (size_t index = 0; index < cast->conditions.size; index++) {
933
949
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->conditions.nodes[index]);
@@ -936,14 +952,14 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
936
952
  break;
937
953
  }
938
954
  #line 111 "api_node.c.erb"
939
- case YP_NODE_WHILE_NODE: {
955
+ case YP_WHILE_NODE: {
940
956
  yp_while_node_t *cast = (yp_while_node_t *) node;
941
957
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->predicate);
942
958
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->statements);
943
959
  break;
944
960
  }
945
961
  #line 111 "api_node.c.erb"
946
- case YP_NODE_YIELD_NODE: {
962
+ case YP_YIELD_NODE: {
947
963
  yp_yield_node_t *cast = (yp_yield_node_t *) node;
948
964
  yp_node_stack_push(&node_stack, (yp_node_t *) cast->arguments);
949
965
  break;
@@ -957,17 +973,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
957
973
 
958
974
  switch (YP_NODE_TYPE(node)) {
959
975
  #line 137 "api_node.c.erb"
960
- case YP_NODE_ALIAS_NODE: {
976
+ case YP_ALIAS_NODE: {
961
977
  yp_alias_node_t *cast = (yp_alias_node_t *) node;
962
978
  VALUE argv[4];
963
979
 
964
980
  // new_name
981
+ #line 148 "api_node.c.erb"
965
982
  argv[0] = rb_ary_pop(value_stack);
966
983
 
967
984
  // old_name
985
+ #line 148 "api_node.c.erb"
968
986
  argv[1] = rb_ary_pop(value_stack);
969
987
 
970
988
  // keyword_loc
989
+ #line 173 "api_node.c.erb"
971
990
  argv[2] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
972
991
 
973
992
  // location
@@ -977,17 +996,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
977
996
  break;
978
997
  }
979
998
  #line 137 "api_node.c.erb"
980
- case YP_NODE_ALTERNATION_PATTERN_NODE: {
999
+ case YP_ALTERNATION_PATTERN_NODE: {
981
1000
  yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
982
1001
  VALUE argv[4];
983
1002
 
984
1003
  // left
1004
+ #line 148 "api_node.c.erb"
985
1005
  argv[0] = rb_ary_pop(value_stack);
986
1006
 
987
1007
  // right
1008
+ #line 148 "api_node.c.erb"
988
1009
  argv[1] = rb_ary_pop(value_stack);
989
1010
 
990
1011
  // operator_loc
1012
+ #line 173 "api_node.c.erb"
991
1013
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
992
1014
 
993
1015
  // location
@@ -997,17 +1019,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
997
1019
  break;
998
1020
  }
999
1021
  #line 137 "api_node.c.erb"
1000
- case YP_NODE_AND_NODE: {
1022
+ case YP_AND_NODE: {
1001
1023
  yp_and_node_t *cast = (yp_and_node_t *) node;
1002
1024
  VALUE argv[4];
1003
1025
 
1004
1026
  // left
1027
+ #line 148 "api_node.c.erb"
1005
1028
  argv[0] = rb_ary_pop(value_stack);
1006
1029
 
1007
1030
  // right
1031
+ #line 148 "api_node.c.erb"
1008
1032
  argv[1] = rb_ary_pop(value_stack);
1009
1033
 
1010
1034
  // operator_loc
1035
+ #line 173 "api_node.c.erb"
1011
1036
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1012
1037
 
1013
1038
  // location
@@ -1017,11 +1042,12 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1017
1042
  break;
1018
1043
  }
1019
1044
  #line 137 "api_node.c.erb"
1020
- case YP_NODE_ARGUMENTS_NODE: {
1045
+ case YP_ARGUMENTS_NODE: {
1021
1046
  yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
1022
1047
  VALUE argv[2];
1023
1048
 
1024
1049
  // arguments
1050
+ #line 151 "api_node.c.erb"
1025
1051
  argv[0] = rb_ary_new_capa(cast->arguments.size);
1026
1052
  for (size_t index = 0; index < cast->arguments.size; index++) {
1027
1053
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
@@ -1034,20 +1060,23 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1034
1060
  break;
1035
1061
  }
1036
1062
  #line 137 "api_node.c.erb"
1037
- case YP_NODE_ARRAY_NODE: {
1063
+ case YP_ARRAY_NODE: {
1038
1064
  yp_array_node_t *cast = (yp_array_node_t *) node;
1039
1065
  VALUE argv[4];
1040
1066
 
1041
1067
  // elements
1068
+ #line 151 "api_node.c.erb"
1042
1069
  argv[0] = rb_ary_new_capa(cast->elements.size);
1043
1070
  for (size_t index = 0; index < cast->elements.size; index++) {
1044
1071
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
1045
1072
  }
1046
1073
 
1047
1074
  // opening_loc
1075
+ #line 176 "api_node.c.erb"
1048
1076
  argv[1] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1049
1077
 
1050
1078
  // closing_loc
1079
+ #line 176 "api_node.c.erb"
1051
1080
  argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1052
1081
 
1053
1082
  // location
@@ -1057,32 +1086,38 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1057
1086
  break;
1058
1087
  }
1059
1088
  #line 137 "api_node.c.erb"
1060
- case YP_NODE_ARRAY_PATTERN_NODE: {
1089
+ case YP_ARRAY_PATTERN_NODE: {
1061
1090
  yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
1062
1091
  VALUE argv[7];
1063
1092
 
1064
1093
  // constant
1094
+ #line 148 "api_node.c.erb"
1065
1095
  argv[0] = rb_ary_pop(value_stack);
1066
1096
 
1067
1097
  // requireds
1098
+ #line 151 "api_node.c.erb"
1068
1099
  argv[1] = rb_ary_new_capa(cast->requireds.size);
1069
1100
  for (size_t index = 0; index < cast->requireds.size; index++) {
1070
1101
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
1071
1102
  }
1072
1103
 
1073
1104
  // rest
1105
+ #line 148 "api_node.c.erb"
1074
1106
  argv[2] = rb_ary_pop(value_stack);
1075
1107
 
1076
1108
  // posts
1109
+ #line 151 "api_node.c.erb"
1077
1110
  argv[3] = rb_ary_new_capa(cast->posts.size);
1078
1111
  for (size_t index = 0; index < cast->posts.size; index++) {
1079
1112
  rb_ary_push(argv[3], rb_ary_pop(value_stack));
1080
1113
  }
1081
1114
 
1082
1115
  // opening_loc
1116
+ #line 176 "api_node.c.erb"
1083
1117
  argv[4] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1084
1118
 
1085
1119
  // closing_loc
1120
+ #line 176 "api_node.c.erb"
1086
1121
  argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1087
1122
 
1088
1123
  // location
@@ -1092,17 +1127,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1092
1127
  break;
1093
1128
  }
1094
1129
  #line 137 "api_node.c.erb"
1095
- case YP_NODE_ASSOC_NODE: {
1130
+ case YP_ASSOC_NODE: {
1096
1131
  yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
1097
1132
  VALUE argv[4];
1098
1133
 
1099
1134
  // key
1135
+ #line 148 "api_node.c.erb"
1100
1136
  argv[0] = rb_ary_pop(value_stack);
1101
1137
 
1102
1138
  // value
1139
+ #line 148 "api_node.c.erb"
1103
1140
  argv[1] = rb_ary_pop(value_stack);
1104
1141
 
1105
1142
  // operator_loc
1143
+ #line 176 "api_node.c.erb"
1106
1144
  argv[2] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1107
1145
 
1108
1146
  // location
@@ -1112,14 +1150,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1112
1150
  break;
1113
1151
  }
1114
1152
  #line 137 "api_node.c.erb"
1115
- case YP_NODE_ASSOC_SPLAT_NODE: {
1153
+ case YP_ASSOC_SPLAT_NODE: {
1116
1154
  yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
1117
1155
  VALUE argv[3];
1118
1156
 
1119
1157
  // value
1158
+ #line 148 "api_node.c.erb"
1120
1159
  argv[0] = rb_ary_pop(value_stack);
1121
1160
 
1122
1161
  // operator_loc
1162
+ #line 173 "api_node.c.erb"
1123
1163
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1124
1164
 
1125
1165
  // location
@@ -1129,7 +1169,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1129
1169
  break;
1130
1170
  }
1131
1171
  #line 137 "api_node.c.erb"
1132
- case YP_NODE_BACK_REFERENCE_READ_NODE: {
1172
+ case YP_BACK_REFERENCE_READ_NODE: {
1133
1173
  VALUE argv[1];
1134
1174
 
1135
1175
  // location
@@ -1139,26 +1179,32 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1139
1179
  break;
1140
1180
  }
1141
1181
  #line 137 "api_node.c.erb"
1142
- case YP_NODE_BEGIN_NODE: {
1182
+ case YP_BEGIN_NODE: {
1143
1183
  yp_begin_node_t *cast = (yp_begin_node_t *) node;
1144
1184
  VALUE argv[7];
1145
1185
 
1146
1186
  // begin_keyword_loc
1187
+ #line 176 "api_node.c.erb"
1147
1188
  argv[0] = cast->begin_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->begin_keyword_loc.start, cast->begin_keyword_loc.end, source);
1148
1189
 
1149
1190
  // statements
1191
+ #line 148 "api_node.c.erb"
1150
1192
  argv[1] = rb_ary_pop(value_stack);
1151
1193
 
1152
1194
  // rescue_clause
1195
+ #line 148 "api_node.c.erb"
1153
1196
  argv[2] = rb_ary_pop(value_stack);
1154
1197
 
1155
1198
  // else_clause
1199
+ #line 148 "api_node.c.erb"
1156
1200
  argv[3] = rb_ary_pop(value_stack);
1157
1201
 
1158
1202
  // ensure_clause
1203
+ #line 148 "api_node.c.erb"
1159
1204
  argv[4] = rb_ary_pop(value_stack);
1160
1205
 
1161
1206
  // end_keyword_loc
1207
+ #line 176 "api_node.c.erb"
1162
1208
  argv[5] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1163
1209
 
1164
1210
  // location
@@ -1168,14 +1214,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1168
1214
  break;
1169
1215
  }
1170
1216
  #line 137 "api_node.c.erb"
1171
- case YP_NODE_BLOCK_ARGUMENT_NODE: {
1217
+ case YP_BLOCK_ARGUMENT_NODE: {
1172
1218
  yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
1173
1219
  VALUE argv[3];
1174
1220
 
1175
1221
  // expression
1222
+ #line 148 "api_node.c.erb"
1176
1223
  argv[0] = rb_ary_pop(value_stack);
1177
1224
 
1178
1225
  // operator_loc
1226
+ #line 173 "api_node.c.erb"
1179
1227
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1180
1228
 
1181
1229
  // location
@@ -1185,26 +1233,48 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1185
1233
  break;
1186
1234
  }
1187
1235
  #line 137 "api_node.c.erb"
1188
- case YP_NODE_BLOCK_NODE: {
1236
+ case YP_BLOCK_LOCAL_VARIABLE_NODE: {
1237
+ yp_block_local_variable_node_t *cast = (yp_block_local_variable_node_t *) node;
1238
+ VALUE argv[2];
1239
+
1240
+ // name
1241
+ #line 160 "api_node.c.erb"
1242
+ assert(cast->name != 0);
1243
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1244
+
1245
+ // location
1246
+ argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
1247
+
1248
+ rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPBlockLocalVariableNode));
1249
+ break;
1250
+ }
1251
+ #line 137 "api_node.c.erb"
1252
+ case YP_BLOCK_NODE: {
1189
1253
  yp_block_node_t *cast = (yp_block_node_t *) node;
1190
1254
  VALUE argv[6];
1191
1255
 
1192
1256
  // locals
1257
+ #line 166 "api_node.c.erb"
1193
1258
  argv[0] = rb_ary_new_capa(cast->locals.size);
1194
1259
  for (size_t index = 0; index < cast->locals.size; index++) {
1260
+ assert(cast->locals.ids[index] != 0);
1195
1261
  rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
1196
1262
  }
1197
1263
 
1198
1264
  // parameters
1265
+ #line 148 "api_node.c.erb"
1199
1266
  argv[1] = rb_ary_pop(value_stack);
1200
1267
 
1201
1268
  // body
1269
+ #line 148 "api_node.c.erb"
1202
1270
  argv[2] = rb_ary_pop(value_stack);
1203
1271
 
1204
1272
  // opening_loc
1273
+ #line 173 "api_node.c.erb"
1205
1274
  argv[3] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1206
1275
 
1207
1276
  // closing_loc
1277
+ #line 173 "api_node.c.erb"
1208
1278
  argv[4] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1209
1279
 
1210
1280
  // location
@@ -1214,41 +1284,49 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1214
1284
  break;
1215
1285
  }
1216
1286
  #line 137 "api_node.c.erb"
1217
- case YP_NODE_BLOCK_PARAMETER_NODE: {
1287
+ case YP_BLOCK_PARAMETER_NODE: {
1218
1288
  yp_block_parameter_node_t *cast = (yp_block_parameter_node_t *) node;
1219
- VALUE argv[3];
1289
+ VALUE argv[4];
1290
+
1291
+ // name
1292
+ argv[0] = cast->name == 0 ? Qnil : rb_id2sym(constants[cast->name - 1]);
1220
1293
 
1221
1294
  // name_loc
1222
- argv[0] = cast->name_loc.start == NULL ? Qnil : yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1295
+ #line 176 "api_node.c.erb"
1296
+ argv[1] = cast->name_loc.start == NULL ? Qnil : yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1223
1297
 
1224
1298
  // operator_loc
1225
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1299
+ #line 173 "api_node.c.erb"
1300
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1226
1301
 
1227
1302
  // location
1228
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
1303
+ argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1229
1304
 
1230
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPBlockParameterNode));
1305
+ rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPBlockParameterNode));
1231
1306
  break;
1232
1307
  }
1233
1308
  #line 137 "api_node.c.erb"
1234
- case YP_NODE_BLOCK_PARAMETERS_NODE: {
1309
+ case YP_BLOCK_PARAMETERS_NODE: {
1235
1310
  yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
1236
1311
  VALUE argv[5];
1237
1312
 
1238
1313
  // parameters
1314
+ #line 148 "api_node.c.erb"
1239
1315
  argv[0] = rb_ary_pop(value_stack);
1240
1316
 
1241
1317
  // locals
1318
+ #line 151 "api_node.c.erb"
1242
1319
  argv[1] = rb_ary_new_capa(cast->locals.size);
1243
1320
  for (size_t index = 0; index < cast->locals.size; index++) {
1244
- yp_location_t location = cast->locals.locations[index];
1245
- rb_ary_push(argv[1], yp_location_new(parser, location.start, location.end, source));
1321
+ rb_ary_push(argv[1], rb_ary_pop(value_stack));
1246
1322
  }
1247
1323
 
1248
1324
  // opening_loc
1325
+ #line 176 "api_node.c.erb"
1249
1326
  argv[2] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1250
1327
 
1251
1328
  // closing_loc
1329
+ #line 176 "api_node.c.erb"
1252
1330
  argv[3] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1253
1331
 
1254
1332
  // location
@@ -1258,14 +1336,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1258
1336
  break;
1259
1337
  }
1260
1338
  #line 137 "api_node.c.erb"
1261
- case YP_NODE_BREAK_NODE: {
1339
+ case YP_BREAK_NODE: {
1262
1340
  yp_break_node_t *cast = (yp_break_node_t *) node;
1263
1341
  VALUE argv[3];
1264
1342
 
1265
1343
  // arguments
1344
+ #line 148 "api_node.c.erb"
1266
1345
  argv[0] = rb_ary_pop(value_stack);
1267
1346
 
1268
1347
  // keyword_loc
1348
+ #line 173 "api_node.c.erb"
1269
1349
  argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
1270
1350
 
1271
1351
  // location
@@ -1275,35 +1355,99 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1275
1355
  break;
1276
1356
  }
1277
1357
  #line 137 "api_node.c.erb"
1278
- case YP_NODE_CALL_NODE: {
1358
+ case YP_CALL_AND_WRITE_NODE: {
1359
+ yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
1360
+ VALUE argv[12];
1361
+
1362
+ // receiver
1363
+ #line 148 "api_node.c.erb"
1364
+ argv[0] = rb_ary_pop(value_stack);
1365
+
1366
+ // call_operator_loc
1367
+ #line 176 "api_node.c.erb"
1368
+ argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1369
+
1370
+ // message_loc
1371
+ #line 176 "api_node.c.erb"
1372
+ argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1373
+
1374
+ // opening_loc
1375
+ #line 176 "api_node.c.erb"
1376
+ argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1377
+
1378
+ // arguments
1379
+ #line 148 "api_node.c.erb"
1380
+ argv[4] = rb_ary_pop(value_stack);
1381
+
1382
+ // closing_loc
1383
+ #line 176 "api_node.c.erb"
1384
+ argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1385
+
1386
+ // flags
1387
+ #line 182 "api_node.c.erb"
1388
+ argv[6] = ULONG2NUM(node->flags >> 1);
1389
+
1390
+ // read_name
1391
+ #line 157 "api_node.c.erb"
1392
+ argv[7] = yp_string_new(&cast->read_name, encoding);
1393
+
1394
+ // write_name
1395
+ #line 157 "api_node.c.erb"
1396
+ argv[8] = yp_string_new(&cast->write_name, encoding);
1397
+
1398
+ // operator_loc
1399
+ #line 173 "api_node.c.erb"
1400
+ argv[9] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1401
+
1402
+ // value
1403
+ #line 148 "api_node.c.erb"
1404
+ argv[10] = rb_ary_pop(value_stack);
1405
+
1406
+ // location
1407
+ argv[11] = yp_location_new(parser, node->location.start, node->location.end, source);
1408
+
1409
+ rb_ary_push(value_stack, rb_class_new_instance(12, argv, rb_cYARPCallAndWriteNode));
1410
+ break;
1411
+ }
1412
+ #line 137 "api_node.c.erb"
1413
+ case YP_CALL_NODE: {
1279
1414
  yp_call_node_t *cast = (yp_call_node_t *) node;
1280
1415
  VALUE argv[10];
1281
1416
 
1282
1417
  // receiver
1418
+ #line 148 "api_node.c.erb"
1283
1419
  argv[0] = rb_ary_pop(value_stack);
1284
1420
 
1285
- // operator_loc
1286
- argv[1] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1421
+ // call_operator_loc
1422
+ #line 176 "api_node.c.erb"
1423
+ argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1287
1424
 
1288
1425
  // message_loc
1426
+ #line 176 "api_node.c.erb"
1289
1427
  argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1290
1428
 
1291
1429
  // opening_loc
1430
+ #line 176 "api_node.c.erb"
1292
1431
  argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1293
1432
 
1294
1433
  // arguments
1434
+ #line 148 "api_node.c.erb"
1295
1435
  argv[4] = rb_ary_pop(value_stack);
1296
1436
 
1297
1437
  // closing_loc
1438
+ #line 176 "api_node.c.erb"
1298
1439
  argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1299
1440
 
1300
1441
  // block
1442
+ #line 148 "api_node.c.erb"
1301
1443
  argv[6] = rb_ary_pop(value_stack);
1302
1444
 
1303
1445
  // flags
1446
+ #line 182 "api_node.c.erb"
1304
1447
  argv[7] = ULONG2NUM(node->flags >> 1);
1305
1448
 
1306
1449
  // name
1450
+ #line 157 "api_node.c.erb"
1307
1451
  argv[8] = yp_string_new(&cast->name, encoding);
1308
1452
 
1309
1453
  // location
@@ -1313,80 +1457,135 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1313
1457
  break;
1314
1458
  }
1315
1459
  #line 137 "api_node.c.erb"
1316
- case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
1317
- yp_call_operator_and_write_node_t *cast = (yp_call_operator_and_write_node_t *) node;
1318
- VALUE argv[4];
1460
+ case YP_CALL_OPERATOR_WRITE_NODE: {
1461
+ yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
1462
+ VALUE argv[13];
1319
1463
 
1320
- // target
1464
+ // receiver
1465
+ #line 148 "api_node.c.erb"
1321
1466
  argv[0] = rb_ary_pop(value_stack);
1322
1467
 
1468
+ // call_operator_loc
1469
+ #line 176 "api_node.c.erb"
1470
+ argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1471
+
1472
+ // message_loc
1473
+ #line 176 "api_node.c.erb"
1474
+ argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1475
+
1476
+ // opening_loc
1477
+ #line 176 "api_node.c.erb"
1478
+ argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1479
+
1480
+ // arguments
1481
+ #line 148 "api_node.c.erb"
1482
+ argv[4] = rb_ary_pop(value_stack);
1483
+
1484
+ // closing_loc
1485
+ #line 176 "api_node.c.erb"
1486
+ argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1487
+
1488
+ // flags
1489
+ #line 182 "api_node.c.erb"
1490
+ argv[6] = ULONG2NUM(node->flags >> 1);
1491
+
1492
+ // read_name
1493
+ #line 157 "api_node.c.erb"
1494
+ argv[7] = yp_string_new(&cast->read_name, encoding);
1495
+
1496
+ // write_name
1497
+ #line 157 "api_node.c.erb"
1498
+ argv[8] = yp_string_new(&cast->write_name, encoding);
1499
+
1500
+ // operator
1501
+ #line 160 "api_node.c.erb"
1502
+ assert(cast->operator != 0);
1503
+ argv[9] = rb_id2sym(constants[cast->operator - 1]);
1504
+
1323
1505
  // operator_loc
1324
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1506
+ #line 173 "api_node.c.erb"
1507
+ argv[10] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1325
1508
 
1326
1509
  // value
1327
- argv[2] = rb_ary_pop(value_stack);
1510
+ #line 148 "api_node.c.erb"
1511
+ argv[11] = rb_ary_pop(value_stack);
1328
1512
 
1329
1513
  // location
1330
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1514
+ argv[12] = yp_location_new(parser, node->location.start, node->location.end, source);
1331
1515
 
1332
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPCallOperatorAndWriteNode));
1516
+ rb_ary_push(value_stack, rb_class_new_instance(13, argv, rb_cYARPCallOperatorWriteNode));
1333
1517
  break;
1334
1518
  }
1335
1519
  #line 137 "api_node.c.erb"
1336
- case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
1337
- yp_call_operator_or_write_node_t *cast = (yp_call_operator_or_write_node_t *) node;
1338
- VALUE argv[4];
1520
+ case YP_CALL_OR_WRITE_NODE: {
1521
+ yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
1522
+ VALUE argv[12];
1339
1523
 
1340
- // target
1524
+ // receiver
1525
+ #line 148 "api_node.c.erb"
1341
1526
  argv[0] = rb_ary_pop(value_stack);
1342
1527
 
1343
- // value
1344
- argv[1] = rb_ary_pop(value_stack);
1528
+ // call_operator_loc
1529
+ #line 176 "api_node.c.erb"
1530
+ argv[1] = cast->call_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->call_operator_loc.start, cast->call_operator_loc.end, source);
1345
1531
 
1346
- // operator_loc
1347
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1532
+ // message_loc
1533
+ #line 176 "api_node.c.erb"
1534
+ argv[2] = cast->message_loc.start == NULL ? Qnil : yp_location_new(parser, cast->message_loc.start, cast->message_loc.end, source);
1348
1535
 
1349
- // location
1350
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1536
+ // opening_loc
1537
+ #line 176 "api_node.c.erb"
1538
+ argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1351
1539
 
1352
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPCallOperatorOrWriteNode));
1353
- break;
1354
- }
1355
- #line 137 "api_node.c.erb"
1356
- case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
1357
- yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
1358
- VALUE argv[5];
1540
+ // arguments
1541
+ #line 148 "api_node.c.erb"
1542
+ argv[4] = rb_ary_pop(value_stack);
1359
1543
 
1360
- // target
1361
- argv[0] = rb_ary_pop(value_stack);
1544
+ // closing_loc
1545
+ #line 176 "api_node.c.erb"
1546
+ argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1547
+
1548
+ // flags
1549
+ #line 182 "api_node.c.erb"
1550
+ argv[6] = ULONG2NUM(node->flags >> 1);
1551
+
1552
+ // read_name
1553
+ #line 157 "api_node.c.erb"
1554
+ argv[7] = yp_string_new(&cast->read_name, encoding);
1555
+
1556
+ // write_name
1557
+ #line 157 "api_node.c.erb"
1558
+ argv[8] = yp_string_new(&cast->write_name, encoding);
1362
1559
 
1363
1560
  // operator_loc
1364
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1561
+ #line 173 "api_node.c.erb"
1562
+ argv[9] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1365
1563
 
1366
1564
  // value
1367
- argv[2] = rb_ary_pop(value_stack);
1368
-
1369
- // operator
1370
- argv[3] = rb_id2sym(constants[cast->operator - 1]);
1565
+ #line 148 "api_node.c.erb"
1566
+ argv[10] = rb_ary_pop(value_stack);
1371
1567
 
1372
1568
  // location
1373
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1569
+ argv[11] = yp_location_new(parser, node->location.start, node->location.end, source);
1374
1570
 
1375
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPCallOperatorWriteNode));
1571
+ rb_ary_push(value_stack, rb_class_new_instance(12, argv, rb_cYARPCallOrWriteNode));
1376
1572
  break;
1377
1573
  }
1378
1574
  #line 137 "api_node.c.erb"
1379
- case YP_NODE_CAPTURE_PATTERN_NODE: {
1575
+ case YP_CAPTURE_PATTERN_NODE: {
1380
1576
  yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
1381
1577
  VALUE argv[4];
1382
1578
 
1383
1579
  // value
1580
+ #line 148 "api_node.c.erb"
1384
1581
  argv[0] = rb_ary_pop(value_stack);
1385
1582
 
1386
1583
  // target
1584
+ #line 148 "api_node.c.erb"
1387
1585
  argv[1] = rb_ary_pop(value_stack);
1388
1586
 
1389
1587
  // operator_loc
1588
+ #line 173 "api_node.c.erb"
1390
1589
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1391
1590
 
1392
1591
  // location
@@ -1396,26 +1595,31 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1396
1595
  break;
1397
1596
  }
1398
1597
  #line 137 "api_node.c.erb"
1399
- case YP_NODE_CASE_NODE: {
1598
+ case YP_CASE_NODE: {
1400
1599
  yp_case_node_t *cast = (yp_case_node_t *) node;
1401
1600
  VALUE argv[6];
1402
1601
 
1403
1602
  // predicate
1603
+ #line 148 "api_node.c.erb"
1404
1604
  argv[0] = rb_ary_pop(value_stack);
1405
1605
 
1406
1606
  // conditions
1607
+ #line 151 "api_node.c.erb"
1407
1608
  argv[1] = rb_ary_new_capa(cast->conditions.size);
1408
1609
  for (size_t index = 0; index < cast->conditions.size; index++) {
1409
1610
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
1410
1611
  }
1411
1612
 
1412
1613
  // consequent
1614
+ #line 148 "api_node.c.erb"
1413
1615
  argv[2] = rb_ary_pop(value_stack);
1414
1616
 
1415
1617
  // case_keyword_loc
1618
+ #line 173 "api_node.c.erb"
1416
1619
  argv[3] = yp_location_new(parser, cast->case_keyword_loc.start, cast->case_keyword_loc.end, source);
1417
1620
 
1418
1621
  // end_keyword_loc
1622
+ #line 173 "api_node.c.erb"
1419
1623
  argv[4] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1420
1624
 
1421
1625
  // location
@@ -1425,36 +1629,46 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1425
1629
  break;
1426
1630
  }
1427
1631
  #line 137 "api_node.c.erb"
1428
- case YP_NODE_CLASS_NODE: {
1632
+ case YP_CLASS_NODE: {
1429
1633
  yp_class_node_t *cast = (yp_class_node_t *) node;
1430
1634
  VALUE argv[9];
1431
1635
 
1432
1636
  // locals
1637
+ #line 166 "api_node.c.erb"
1433
1638
  argv[0] = rb_ary_new_capa(cast->locals.size);
1434
1639
  for (size_t index = 0; index < cast->locals.size; index++) {
1640
+ assert(cast->locals.ids[index] != 0);
1435
1641
  rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
1436
1642
  }
1437
1643
 
1438
1644
  // class_keyword_loc
1645
+ #line 173 "api_node.c.erb"
1439
1646
  argv[1] = yp_location_new(parser, cast->class_keyword_loc.start, cast->class_keyword_loc.end, source);
1440
1647
 
1441
1648
  // constant_path
1649
+ #line 148 "api_node.c.erb"
1442
1650
  argv[2] = rb_ary_pop(value_stack);
1443
1651
 
1444
1652
  // inheritance_operator_loc
1653
+ #line 176 "api_node.c.erb"
1445
1654
  argv[3] = cast->inheritance_operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->inheritance_operator_loc.start, cast->inheritance_operator_loc.end, source);
1446
1655
 
1447
1656
  // superclass
1657
+ #line 148 "api_node.c.erb"
1448
1658
  argv[4] = rb_ary_pop(value_stack);
1449
1659
 
1450
1660
  // body
1661
+ #line 148 "api_node.c.erb"
1451
1662
  argv[5] = rb_ary_pop(value_stack);
1452
1663
 
1453
1664
  // end_keyword_loc
1665
+ #line 173 "api_node.c.erb"
1454
1666
  argv[6] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1455
1667
 
1456
1668
  // name
1457
- argv[7] = yp_string_new(&cast->name, encoding);
1669
+ #line 160 "api_node.c.erb"
1670
+ assert(cast->name != 0);
1671
+ argv[7] = rb_id2sym(constants[cast->name - 1]);
1458
1672
 
1459
1673
  // location
1460
1674
  argv[8] = yp_location_new(parser, node->location.start, node->location.end, source);
@@ -1463,20 +1677,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1463
1677
  break;
1464
1678
  }
1465
1679
  #line 137 "api_node.c.erb"
1466
- case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
1680
+ case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
1467
1681
  yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
1468
1682
  VALUE argv[5];
1469
1683
 
1470
1684
  // name
1685
+ #line 160 "api_node.c.erb"
1686
+ assert(cast->name != 0);
1471
1687
  argv[0] = rb_id2sym(constants[cast->name - 1]);
1472
1688
 
1473
1689
  // name_loc
1690
+ #line 173 "api_node.c.erb"
1474
1691
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1475
1692
 
1476
1693
  // operator_loc
1694
+ #line 173 "api_node.c.erb"
1477
1695
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1478
1696
 
1479
1697
  // value
1698
+ #line 148 "api_node.c.erb"
1480
1699
  argv[3] = rb_ary_pop(value_stack);
1481
1700
 
1482
1701
  // location
@@ -1486,23 +1705,30 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1486
1705
  break;
1487
1706
  }
1488
1707
  #line 137 "api_node.c.erb"
1489
- case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1708
+ case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1490
1709
  yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
1491
1710
  VALUE argv[6];
1492
1711
 
1493
1712
  // name
1713
+ #line 160 "api_node.c.erb"
1714
+ assert(cast->name != 0);
1494
1715
  argv[0] = rb_id2sym(constants[cast->name - 1]);
1495
1716
 
1496
1717
  // name_loc
1718
+ #line 173 "api_node.c.erb"
1497
1719
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1498
1720
 
1499
1721
  // operator_loc
1722
+ #line 173 "api_node.c.erb"
1500
1723
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1501
1724
 
1502
1725
  // value
1726
+ #line 148 "api_node.c.erb"
1503
1727
  argv[3] = rb_ary_pop(value_stack);
1504
1728
 
1505
1729
  // operator
1730
+ #line 160 "api_node.c.erb"
1731
+ assert(cast->operator != 0);
1506
1732
  argv[4] = rb_id2sym(constants[cast->operator - 1]);
1507
1733
 
1508
1734
  // location
@@ -1512,20 +1738,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1512
1738
  break;
1513
1739
  }
1514
1740
  #line 137 "api_node.c.erb"
1515
- case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
1741
+ case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
1516
1742
  yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
1517
1743
  VALUE argv[5];
1518
1744
 
1519
1745
  // name
1746
+ #line 160 "api_node.c.erb"
1747
+ assert(cast->name != 0);
1520
1748
  argv[0] = rb_id2sym(constants[cast->name - 1]);
1521
1749
 
1522
1750
  // name_loc
1751
+ #line 173 "api_node.c.erb"
1523
1752
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1524
1753
 
1525
1754
  // operator_loc
1755
+ #line 173 "api_node.c.erb"
1526
1756
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1527
1757
 
1528
1758
  // value
1759
+ #line 148 "api_node.c.erb"
1529
1760
  argv[3] = rb_ary_pop(value_stack);
1530
1761
 
1531
1762
  // location
@@ -1535,11 +1766,13 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1535
1766
  break;
1536
1767
  }
1537
1768
  #line 137 "api_node.c.erb"
1538
- case YP_NODE_CLASS_VARIABLE_READ_NODE: {
1769
+ case YP_CLASS_VARIABLE_READ_NODE: {
1539
1770
  yp_class_variable_read_node_t *cast = (yp_class_variable_read_node_t *) node;
1540
1771
  VALUE argv[2];
1541
1772
 
1542
1773
  // name
1774
+ #line 160 "api_node.c.erb"
1775
+ assert(cast->name != 0);
1543
1776
  argv[0] = rb_id2sym(constants[cast->name - 1]);
1544
1777
 
1545
1778
  // location
@@ -1549,11 +1782,13 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1549
1782
  break;
1550
1783
  }
1551
1784
  #line 137 "api_node.c.erb"
1552
- case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
1785
+ case YP_CLASS_VARIABLE_TARGET_NODE: {
1553
1786
  yp_class_variable_target_node_t *cast = (yp_class_variable_target_node_t *) node;
1554
1787
  VALUE argv[2];
1555
1788
 
1556
1789
  // name
1790
+ #line 160 "api_node.c.erb"
1791
+ assert(cast->name != 0);
1557
1792
  argv[0] = rb_id2sym(constants[cast->name - 1]);
1558
1793
 
1559
1794
  // location
@@ -1563,20 +1798,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1563
1798
  break;
1564
1799
  }
1565
1800
  #line 137 "api_node.c.erb"
1566
- case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
1801
+ case YP_CLASS_VARIABLE_WRITE_NODE: {
1567
1802
  yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
1568
1803
  VALUE argv[5];
1569
1804
 
1570
1805
  // name
1806
+ #line 160 "api_node.c.erb"
1807
+ assert(cast->name != 0);
1571
1808
  argv[0] = rb_id2sym(constants[cast->name - 1]);
1572
1809
 
1573
1810
  // name_loc
1811
+ #line 173 "api_node.c.erb"
1574
1812
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1575
1813
 
1576
1814
  // value
1815
+ #line 148 "api_node.c.erb"
1577
1816
  argv[2] = rb_ary_pop(value_stack);
1578
1817
 
1579
1818
  // operator_loc
1819
+ #line 176 "api_node.c.erb"
1580
1820
  argv[3] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1581
1821
 
1582
1822
  // location
@@ -1586,80 +1826,109 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1586
1826
  break;
1587
1827
  }
1588
1828
  #line 137 "api_node.c.erb"
1589
- case YP_NODE_CONSTANT_AND_WRITE_NODE: {
1829
+ case YP_CONSTANT_AND_WRITE_NODE: {
1590
1830
  yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
1591
- VALUE argv[4];
1831
+ VALUE argv[5];
1832
+
1833
+ // name
1834
+ #line 160 "api_node.c.erb"
1835
+ assert(cast->name != 0);
1836
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1592
1837
 
1593
1838
  // name_loc
1594
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1839
+ #line 173 "api_node.c.erb"
1840
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1595
1841
 
1596
1842
  // operator_loc
1597
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1843
+ #line 173 "api_node.c.erb"
1844
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1598
1845
 
1599
1846
  // value
1600
- argv[2] = rb_ary_pop(value_stack);
1847
+ #line 148 "api_node.c.erb"
1848
+ argv[3] = rb_ary_pop(value_stack);
1601
1849
 
1602
1850
  // location
1603
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1851
+ argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1604
1852
 
1605
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantAndWriteNode));
1853
+ rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantAndWriteNode));
1606
1854
  break;
1607
1855
  }
1608
1856
  #line 137 "api_node.c.erb"
1609
- case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
1857
+ case YP_CONSTANT_OPERATOR_WRITE_NODE: {
1610
1858
  yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
1611
- VALUE argv[5];
1859
+ VALUE argv[6];
1860
+
1861
+ // name
1862
+ #line 160 "api_node.c.erb"
1863
+ assert(cast->name != 0);
1864
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1612
1865
 
1613
1866
  // name_loc
1614
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1867
+ #line 173 "api_node.c.erb"
1868
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1615
1869
 
1616
1870
  // operator_loc
1617
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1871
+ #line 173 "api_node.c.erb"
1872
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1618
1873
 
1619
1874
  // value
1620
- argv[2] = rb_ary_pop(value_stack);
1875
+ #line 148 "api_node.c.erb"
1876
+ argv[3] = rb_ary_pop(value_stack);
1621
1877
 
1622
1878
  // operator
1623
- argv[3] = rb_id2sym(constants[cast->operator - 1]);
1879
+ #line 160 "api_node.c.erb"
1880
+ assert(cast->operator != 0);
1881
+ argv[4] = rb_id2sym(constants[cast->operator - 1]);
1624
1882
 
1625
1883
  // location
1626
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1884
+ argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
1627
1885
 
1628
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantOperatorWriteNode));
1886
+ rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPConstantOperatorWriteNode));
1629
1887
  break;
1630
1888
  }
1631
1889
  #line 137 "api_node.c.erb"
1632
- case YP_NODE_CONSTANT_OR_WRITE_NODE: {
1890
+ case YP_CONSTANT_OR_WRITE_NODE: {
1633
1891
  yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
1634
- VALUE argv[4];
1892
+ VALUE argv[5];
1893
+
1894
+ // name
1895
+ #line 160 "api_node.c.erb"
1896
+ assert(cast->name != 0);
1897
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1635
1898
 
1636
1899
  // name_loc
1637
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1900
+ #line 173 "api_node.c.erb"
1901
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1638
1902
 
1639
1903
  // operator_loc
1640
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1904
+ #line 173 "api_node.c.erb"
1905
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1641
1906
 
1642
1907
  // value
1643
- argv[2] = rb_ary_pop(value_stack);
1908
+ #line 148 "api_node.c.erb"
1909
+ argv[3] = rb_ary_pop(value_stack);
1644
1910
 
1645
1911
  // location
1646
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
1912
+ argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1647
1913
 
1648
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantOrWriteNode));
1914
+ rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantOrWriteNode));
1649
1915
  break;
1650
1916
  }
1651
1917
  #line 137 "api_node.c.erb"
1652
- case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
1918
+ case YP_CONSTANT_PATH_AND_WRITE_NODE: {
1653
1919
  yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
1654
1920
  VALUE argv[4];
1655
1921
 
1656
1922
  // target
1923
+ #line 148 "api_node.c.erb"
1657
1924
  argv[0] = rb_ary_pop(value_stack);
1658
1925
 
1659
1926
  // operator_loc
1927
+ #line 173 "api_node.c.erb"
1660
1928
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1661
1929
 
1662
1930
  // value
1931
+ #line 148 "api_node.c.erb"
1663
1932
  argv[2] = rb_ary_pop(value_stack);
1664
1933
 
1665
1934
  // location
@@ -1669,17 +1938,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1669
1938
  break;
1670
1939
  }
1671
1940
  #line 137 "api_node.c.erb"
1672
- case YP_NODE_CONSTANT_PATH_NODE: {
1941
+ case YP_CONSTANT_PATH_NODE: {
1673
1942
  yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
1674
1943
  VALUE argv[4];
1675
1944
 
1676
1945
  // parent
1946
+ #line 148 "api_node.c.erb"
1677
1947
  argv[0] = rb_ary_pop(value_stack);
1678
1948
 
1679
1949
  // child
1950
+ #line 148 "api_node.c.erb"
1680
1951
  argv[1] = rb_ary_pop(value_stack);
1681
1952
 
1682
1953
  // delimiter_loc
1954
+ #line 173 "api_node.c.erb"
1683
1955
  argv[2] = yp_location_new(parser, cast->delimiter_loc.start, cast->delimiter_loc.end, source);
1684
1956
 
1685
1957
  // location
@@ -1689,20 +1961,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1689
1961
  break;
1690
1962
  }
1691
1963
  #line 137 "api_node.c.erb"
1692
- case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1964
+ case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1693
1965
  yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
1694
1966
  VALUE argv[5];
1695
1967
 
1696
1968
  // target
1969
+ #line 148 "api_node.c.erb"
1697
1970
  argv[0] = rb_ary_pop(value_stack);
1698
1971
 
1699
1972
  // operator_loc
1973
+ #line 173 "api_node.c.erb"
1700
1974
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1701
1975
 
1702
1976
  // value
1977
+ #line 148 "api_node.c.erb"
1703
1978
  argv[2] = rb_ary_pop(value_stack);
1704
1979
 
1705
1980
  // operator
1981
+ #line 160 "api_node.c.erb"
1982
+ assert(cast->operator != 0);
1706
1983
  argv[3] = rb_id2sym(constants[cast->operator - 1]);
1707
1984
 
1708
1985
  // location
@@ -1712,17 +1989,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1712
1989
  break;
1713
1990
  }
1714
1991
  #line 137 "api_node.c.erb"
1715
- case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
1992
+ case YP_CONSTANT_PATH_OR_WRITE_NODE: {
1716
1993
  yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
1717
1994
  VALUE argv[4];
1718
1995
 
1719
1996
  // target
1997
+ #line 148 "api_node.c.erb"
1720
1998
  argv[0] = rb_ary_pop(value_stack);
1721
1999
 
1722
2000
  // operator_loc
2001
+ #line 173 "api_node.c.erb"
1723
2002
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1724
2003
 
1725
2004
  // value
2005
+ #line 148 "api_node.c.erb"
1726
2006
  argv[2] = rb_ary_pop(value_stack);
1727
2007
 
1728
2008
  // location
@@ -1732,17 +2012,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1732
2012
  break;
1733
2013
  }
1734
2014
  #line 137 "api_node.c.erb"
1735
- case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
2015
+ case YP_CONSTANT_PATH_TARGET_NODE: {
1736
2016
  yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
1737
2017
  VALUE argv[4];
1738
2018
 
1739
2019
  // parent
2020
+ #line 148 "api_node.c.erb"
1740
2021
  argv[0] = rb_ary_pop(value_stack);
1741
2022
 
1742
2023
  // child
2024
+ #line 148 "api_node.c.erb"
1743
2025
  argv[1] = rb_ary_pop(value_stack);
1744
2026
 
1745
2027
  // delimiter_loc
2028
+ #line 173 "api_node.c.erb"
1746
2029
  argv[2] = yp_location_new(parser, cast->delimiter_loc.start, cast->delimiter_loc.end, source);
1747
2030
 
1748
2031
  // location
@@ -1752,17 +2035,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1752
2035
  break;
1753
2036
  }
1754
2037
  #line 137 "api_node.c.erb"
1755
- case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
2038
+ case YP_CONSTANT_PATH_WRITE_NODE: {
1756
2039
  yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
1757
2040
  VALUE argv[4];
1758
2041
 
1759
2042
  // target
2043
+ #line 148 "api_node.c.erb"
1760
2044
  argv[0] = rb_ary_pop(value_stack);
1761
2045
 
1762
2046
  // operator_loc
2047
+ #line 173 "api_node.c.erb"
1763
2048
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1764
2049
 
1765
2050
  // value
2051
+ #line 148 "api_node.c.erb"
1766
2052
  argv[2] = rb_ary_pop(value_stack);
1767
2053
 
1768
2054
  // location
@@ -1772,107 +2058,148 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1772
2058
  break;
1773
2059
  }
1774
2060
  #line 137 "api_node.c.erb"
1775
- case YP_NODE_CONSTANT_READ_NODE: {
1776
- VALUE argv[1];
2061
+ case YP_CONSTANT_READ_NODE: {
2062
+ yp_constant_read_node_t *cast = (yp_constant_read_node_t *) node;
2063
+ VALUE argv[2];
2064
+
2065
+ // name
2066
+ #line 160 "api_node.c.erb"
2067
+ assert(cast->name != 0);
2068
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1777
2069
 
1778
2070
  // location
1779
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2071
+ argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
1780
2072
 
1781
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPConstantReadNode));
2073
+ rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPConstantReadNode));
1782
2074
  break;
1783
2075
  }
1784
2076
  #line 137 "api_node.c.erb"
1785
- case YP_NODE_CONSTANT_TARGET_NODE: {
1786
- VALUE argv[1];
2077
+ case YP_CONSTANT_TARGET_NODE: {
2078
+ yp_constant_target_node_t *cast = (yp_constant_target_node_t *) node;
2079
+ VALUE argv[2];
2080
+
2081
+ // name
2082
+ #line 160 "api_node.c.erb"
2083
+ assert(cast->name != 0);
2084
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1787
2085
 
1788
2086
  // location
1789
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2087
+ argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
1790
2088
 
1791
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPConstantTargetNode));
2089
+ rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPConstantTargetNode));
1792
2090
  break;
1793
2091
  }
1794
2092
  #line 137 "api_node.c.erb"
1795
- case YP_NODE_CONSTANT_WRITE_NODE: {
2093
+ case YP_CONSTANT_WRITE_NODE: {
1796
2094
  yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
1797
- VALUE argv[4];
2095
+ VALUE argv[5];
2096
+
2097
+ // name
2098
+ #line 160 "api_node.c.erb"
2099
+ assert(cast->name != 0);
2100
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1798
2101
 
1799
2102
  // name_loc
1800
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2103
+ #line 173 "api_node.c.erb"
2104
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1801
2105
 
1802
2106
  // value
1803
- argv[1] = rb_ary_pop(value_stack);
2107
+ #line 148 "api_node.c.erb"
2108
+ argv[2] = rb_ary_pop(value_stack);
1804
2109
 
1805
2110
  // operator_loc
1806
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2111
+ #line 173 "api_node.c.erb"
2112
+ argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1807
2113
 
1808
2114
  // location
1809
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2115
+ argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
1810
2116
 
1811
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPConstantWriteNode));
2117
+ rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPConstantWriteNode));
1812
2118
  break;
1813
2119
  }
1814
2120
  #line 137 "api_node.c.erb"
1815
- case YP_NODE_DEF_NODE: {
2121
+ case YP_DEF_NODE: {
1816
2122
  yp_def_node_t *cast = (yp_def_node_t *) node;
1817
- VALUE argv[12];
2123
+ VALUE argv[13];
2124
+
2125
+ // name
2126
+ #line 160 "api_node.c.erb"
2127
+ assert(cast->name != 0);
2128
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
1818
2129
 
1819
2130
  // name_loc
1820
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2131
+ #line 173 "api_node.c.erb"
2132
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
1821
2133
 
1822
2134
  // receiver
1823
- argv[1] = rb_ary_pop(value_stack);
2135
+ #line 148 "api_node.c.erb"
2136
+ argv[2] = rb_ary_pop(value_stack);
1824
2137
 
1825
2138
  // parameters
1826
- argv[2] = rb_ary_pop(value_stack);
2139
+ #line 148 "api_node.c.erb"
2140
+ argv[3] = rb_ary_pop(value_stack);
1827
2141
 
1828
2142
  // body
1829
- argv[3] = rb_ary_pop(value_stack);
2143
+ #line 148 "api_node.c.erb"
2144
+ argv[4] = rb_ary_pop(value_stack);
1830
2145
 
1831
2146
  // locals
1832
- argv[4] = rb_ary_new_capa(cast->locals.size);
2147
+ #line 166 "api_node.c.erb"
2148
+ argv[5] = rb_ary_new_capa(cast->locals.size);
1833
2149
  for (size_t index = 0; index < cast->locals.size; index++) {
1834
- rb_ary_push(argv[4], rb_id2sym(constants[cast->locals.ids[index] - 1]));
2150
+ assert(cast->locals.ids[index] != 0);
2151
+ rb_ary_push(argv[5], rb_id2sym(constants[cast->locals.ids[index] - 1]));
1835
2152
  }
1836
2153
 
1837
2154
  // def_keyword_loc
1838
- argv[5] = yp_location_new(parser, cast->def_keyword_loc.start, cast->def_keyword_loc.end, source);
2155
+ #line 173 "api_node.c.erb"
2156
+ argv[6] = yp_location_new(parser, cast->def_keyword_loc.start, cast->def_keyword_loc.end, source);
1839
2157
 
1840
2158
  // operator_loc
1841
- argv[6] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2159
+ #line 176 "api_node.c.erb"
2160
+ argv[7] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1842
2161
 
1843
2162
  // lparen_loc
1844
- argv[7] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
2163
+ #line 176 "api_node.c.erb"
2164
+ argv[8] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
1845
2165
 
1846
2166
  // rparen_loc
1847
- argv[8] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
2167
+ #line 176 "api_node.c.erb"
2168
+ argv[9] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
1848
2169
 
1849
2170
  // equal_loc
1850
- argv[9] = cast->equal_loc.start == NULL ? Qnil : yp_location_new(parser, cast->equal_loc.start, cast->equal_loc.end, source);
2171
+ #line 176 "api_node.c.erb"
2172
+ argv[10] = cast->equal_loc.start == NULL ? Qnil : yp_location_new(parser, cast->equal_loc.start, cast->equal_loc.end, source);
1851
2173
 
1852
2174
  // end_keyword_loc
1853
- argv[10] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2175
+ #line 176 "api_node.c.erb"
2176
+ argv[11] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1854
2177
 
1855
2178
  // location
1856
- argv[11] = yp_location_new(parser, node->location.start, node->location.end, source);
2179
+ argv[12] = yp_location_new(parser, node->location.start, node->location.end, source);
1857
2180
 
1858
- rb_ary_push(value_stack, rb_class_new_instance(12, argv, rb_cYARPDefNode));
2181
+ rb_ary_push(value_stack, rb_class_new_instance(13, argv, rb_cYARPDefNode));
1859
2182
  break;
1860
2183
  }
1861
2184
  #line 137 "api_node.c.erb"
1862
- case YP_NODE_DEFINED_NODE: {
2185
+ case YP_DEFINED_NODE: {
1863
2186
  yp_defined_node_t *cast = (yp_defined_node_t *) node;
1864
2187
  VALUE argv[5];
1865
2188
 
1866
2189
  // lparen_loc
2190
+ #line 176 "api_node.c.erb"
1867
2191
  argv[0] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
1868
2192
 
1869
2193
  // value
2194
+ #line 148 "api_node.c.erb"
1870
2195
  argv[1] = rb_ary_pop(value_stack);
1871
2196
 
1872
2197
  // rparen_loc
2198
+ #line 176 "api_node.c.erb"
1873
2199
  argv[2] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
1874
2200
 
1875
2201
  // keyword_loc
2202
+ #line 173 "api_node.c.erb"
1876
2203
  argv[3] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
1877
2204
 
1878
2205
  // location
@@ -1882,17 +2209,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1882
2209
  break;
1883
2210
  }
1884
2211
  #line 137 "api_node.c.erb"
1885
- case YP_NODE_ELSE_NODE: {
2212
+ case YP_ELSE_NODE: {
1886
2213
  yp_else_node_t *cast = (yp_else_node_t *) node;
1887
2214
  VALUE argv[4];
1888
2215
 
1889
2216
  // else_keyword_loc
2217
+ #line 173 "api_node.c.erb"
1890
2218
  argv[0] = yp_location_new(parser, cast->else_keyword_loc.start, cast->else_keyword_loc.end, source);
1891
2219
 
1892
2220
  // statements
2221
+ #line 148 "api_node.c.erb"
1893
2222
  argv[1] = rb_ary_pop(value_stack);
1894
2223
 
1895
2224
  // end_keyword_loc
2225
+ #line 176 "api_node.c.erb"
1896
2226
  argv[2] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1897
2227
 
1898
2228
  // location
@@ -1902,17 +2232,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1902
2232
  break;
1903
2233
  }
1904
2234
  #line 137 "api_node.c.erb"
1905
- case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
2235
+ case YP_EMBEDDED_STATEMENTS_NODE: {
1906
2236
  yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
1907
2237
  VALUE argv[4];
1908
2238
 
1909
2239
  // opening_loc
2240
+ #line 173 "api_node.c.erb"
1910
2241
  argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1911
2242
 
1912
2243
  // statements
2244
+ #line 148 "api_node.c.erb"
1913
2245
  argv[1] = rb_ary_pop(value_stack);
1914
2246
 
1915
2247
  // closing_loc
2248
+ #line 173 "api_node.c.erb"
1916
2249
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1917
2250
 
1918
2251
  // location
@@ -1922,14 +2255,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1922
2255
  break;
1923
2256
  }
1924
2257
  #line 137 "api_node.c.erb"
1925
- case YP_NODE_EMBEDDED_VARIABLE_NODE: {
2258
+ case YP_EMBEDDED_VARIABLE_NODE: {
1926
2259
  yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
1927
2260
  VALUE argv[3];
1928
2261
 
1929
2262
  // operator_loc
2263
+ #line 173 "api_node.c.erb"
1930
2264
  argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
1931
2265
 
1932
2266
  // variable
2267
+ #line 148 "api_node.c.erb"
1933
2268
  argv[1] = rb_ary_pop(value_stack);
1934
2269
 
1935
2270
  // location
@@ -1939,17 +2274,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1939
2274
  break;
1940
2275
  }
1941
2276
  #line 137 "api_node.c.erb"
1942
- case YP_NODE_ENSURE_NODE: {
2277
+ case YP_ENSURE_NODE: {
1943
2278
  yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
1944
2279
  VALUE argv[4];
1945
2280
 
1946
2281
  // ensure_keyword_loc
2282
+ #line 173 "api_node.c.erb"
1947
2283
  argv[0] = yp_location_new(parser, cast->ensure_keyword_loc.start, cast->ensure_keyword_loc.end, source);
1948
2284
 
1949
2285
  // statements
2286
+ #line 148 "api_node.c.erb"
1950
2287
  argv[1] = rb_ary_pop(value_stack);
1951
2288
 
1952
2289
  // end_keyword_loc
2290
+ #line 173 "api_node.c.erb"
1953
2291
  argv[2] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
1954
2292
 
1955
2293
  // location
@@ -1959,7 +2297,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1959
2297
  break;
1960
2298
  }
1961
2299
  #line 137 "api_node.c.erb"
1962
- case YP_NODE_FALSE_NODE: {
2300
+ case YP_FALSE_NODE: {
1963
2301
  VALUE argv[1];
1964
2302
 
1965
2303
  // location
@@ -1969,29 +2307,35 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
1969
2307
  break;
1970
2308
  }
1971
2309
  #line 137 "api_node.c.erb"
1972
- case YP_NODE_FIND_PATTERN_NODE: {
2310
+ case YP_FIND_PATTERN_NODE: {
1973
2311
  yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
1974
2312
  VALUE argv[7];
1975
2313
 
1976
2314
  // constant
2315
+ #line 148 "api_node.c.erb"
1977
2316
  argv[0] = rb_ary_pop(value_stack);
1978
2317
 
1979
2318
  // left
2319
+ #line 148 "api_node.c.erb"
1980
2320
  argv[1] = rb_ary_pop(value_stack);
1981
2321
 
1982
2322
  // requireds
2323
+ #line 151 "api_node.c.erb"
1983
2324
  argv[2] = rb_ary_new_capa(cast->requireds.size);
1984
2325
  for (size_t index = 0; index < cast->requireds.size; index++) {
1985
2326
  rb_ary_push(argv[2], rb_ary_pop(value_stack));
1986
2327
  }
1987
2328
 
1988
2329
  // right
2330
+ #line 148 "api_node.c.erb"
1989
2331
  argv[3] = rb_ary_pop(value_stack);
1990
2332
 
1991
2333
  // opening_loc
2334
+ #line 176 "api_node.c.erb"
1992
2335
  argv[4] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
1993
2336
 
1994
2337
  // closing_loc
2338
+ #line 176 "api_node.c.erb"
1995
2339
  argv[5] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
1996
2340
 
1997
2341
  // location
@@ -2001,20 +2345,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2001
2345
  break;
2002
2346
  }
2003
2347
  #line 137 "api_node.c.erb"
2004
- case YP_NODE_FLIP_FLOP_NODE: {
2348
+ case YP_FLIP_FLOP_NODE: {
2005
2349
  yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
2006
2350
  VALUE argv[5];
2007
2351
 
2008
2352
  // left
2353
+ #line 148 "api_node.c.erb"
2009
2354
  argv[0] = rb_ary_pop(value_stack);
2010
2355
 
2011
2356
  // right
2357
+ #line 148 "api_node.c.erb"
2012
2358
  argv[1] = rb_ary_pop(value_stack);
2013
2359
 
2014
2360
  // operator_loc
2361
+ #line 173 "api_node.c.erb"
2015
2362
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2016
2363
 
2017
2364
  // flags
2365
+ #line 182 "api_node.c.erb"
2018
2366
  argv[3] = ULONG2NUM(node->flags >> 1);
2019
2367
 
2020
2368
  // location
@@ -2024,7 +2372,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2024
2372
  break;
2025
2373
  }
2026
2374
  #line 137 "api_node.c.erb"
2027
- case YP_NODE_FLOAT_NODE: {
2375
+ case YP_FLOAT_NODE: {
2028
2376
  VALUE argv[1];
2029
2377
 
2030
2378
  // location
@@ -2034,29 +2382,36 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2034
2382
  break;
2035
2383
  }
2036
2384
  #line 137 "api_node.c.erb"
2037
- case YP_NODE_FOR_NODE: {
2385
+ case YP_FOR_NODE: {
2038
2386
  yp_for_node_t *cast = (yp_for_node_t *) node;
2039
2387
  VALUE argv[8];
2040
2388
 
2041
2389
  // index
2390
+ #line 148 "api_node.c.erb"
2042
2391
  argv[0] = rb_ary_pop(value_stack);
2043
2392
 
2044
2393
  // collection
2394
+ #line 148 "api_node.c.erb"
2045
2395
  argv[1] = rb_ary_pop(value_stack);
2046
2396
 
2047
2397
  // statements
2398
+ #line 148 "api_node.c.erb"
2048
2399
  argv[2] = rb_ary_pop(value_stack);
2049
2400
 
2050
2401
  // for_keyword_loc
2402
+ #line 173 "api_node.c.erb"
2051
2403
  argv[3] = yp_location_new(parser, cast->for_keyword_loc.start, cast->for_keyword_loc.end, source);
2052
2404
 
2053
2405
  // in_keyword_loc
2406
+ #line 173 "api_node.c.erb"
2054
2407
  argv[4] = yp_location_new(parser, cast->in_keyword_loc.start, cast->in_keyword_loc.end, source);
2055
2408
 
2056
2409
  // do_keyword_loc
2410
+ #line 176 "api_node.c.erb"
2057
2411
  argv[5] = cast->do_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->do_keyword_loc.start, cast->do_keyword_loc.end, source);
2058
2412
 
2059
2413
  // end_keyword_loc
2414
+ #line 173 "api_node.c.erb"
2060
2415
  argv[6] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2061
2416
 
2062
2417
  // location
@@ -2066,7 +2421,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2066
2421
  break;
2067
2422
  }
2068
2423
  #line 137 "api_node.c.erb"
2069
- case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
2424
+ case YP_FORWARDING_ARGUMENTS_NODE: {
2070
2425
  VALUE argv[1];
2071
2426
 
2072
2427
  // location
@@ -2076,7 +2431,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2076
2431
  break;
2077
2432
  }
2078
2433
  #line 137 "api_node.c.erb"
2079
- case YP_NODE_FORWARDING_PARAMETER_NODE: {
2434
+ case YP_FORWARDING_PARAMETER_NODE: {
2080
2435
  VALUE argv[1];
2081
2436
 
2082
2437
  // location
@@ -2086,10 +2441,11 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2086
2441
  break;
2087
2442
  }
2088
2443
  #line 137 "api_node.c.erb"
2089
- case YP_NODE_FORWARDING_SUPER_NODE: {
2444
+ case YP_FORWARDING_SUPER_NODE: {
2090
2445
  VALUE argv[2];
2091
2446
 
2092
2447
  // block
2448
+ #line 148 "api_node.c.erb"
2093
2449
  argv[0] = rb_ary_pop(value_stack);
2094
2450
 
2095
2451
  // location
@@ -2099,123 +2455,172 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2099
2455
  break;
2100
2456
  }
2101
2457
  #line 137 "api_node.c.erb"
2102
- case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
2458
+ case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
2103
2459
  yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
2104
- VALUE argv[4];
2460
+ VALUE argv[5];
2461
+
2462
+ // name
2463
+ #line 160 "api_node.c.erb"
2464
+ assert(cast->name != 0);
2465
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
2105
2466
 
2106
2467
  // name_loc
2107
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2468
+ #line 173 "api_node.c.erb"
2469
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2108
2470
 
2109
2471
  // operator_loc
2110
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2472
+ #line 173 "api_node.c.erb"
2473
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2111
2474
 
2112
2475
  // value
2113
- argv[2] = rb_ary_pop(value_stack);
2476
+ #line 148 "api_node.c.erb"
2477
+ argv[3] = rb_ary_pop(value_stack);
2114
2478
 
2115
2479
  // location
2116
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2480
+ argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2117
2481
 
2118
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPGlobalVariableAndWriteNode));
2482
+ rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPGlobalVariableAndWriteNode));
2119
2483
  break;
2120
2484
  }
2121
2485
  #line 137 "api_node.c.erb"
2122
- case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
2486
+ case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
2123
2487
  yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
2124
- VALUE argv[5];
2488
+ VALUE argv[6];
2489
+
2490
+ // name
2491
+ #line 160 "api_node.c.erb"
2492
+ assert(cast->name != 0);
2493
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
2125
2494
 
2126
2495
  // name_loc
2127
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2496
+ #line 173 "api_node.c.erb"
2497
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2128
2498
 
2129
2499
  // operator_loc
2130
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2500
+ #line 173 "api_node.c.erb"
2501
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2131
2502
 
2132
2503
  // value
2133
- argv[2] = rb_ary_pop(value_stack);
2504
+ #line 148 "api_node.c.erb"
2505
+ argv[3] = rb_ary_pop(value_stack);
2134
2506
 
2135
2507
  // operator
2136
- argv[3] = rb_id2sym(constants[cast->operator - 1]);
2508
+ #line 160 "api_node.c.erb"
2509
+ assert(cast->operator != 0);
2510
+ argv[4] = rb_id2sym(constants[cast->operator - 1]);
2137
2511
 
2138
2512
  // location
2139
- argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2513
+ argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
2140
2514
 
2141
- rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPGlobalVariableOperatorWriteNode));
2515
+ rb_ary_push(value_stack, rb_class_new_instance(6, argv, rb_cYARPGlobalVariableOperatorWriteNode));
2142
2516
  break;
2143
2517
  }
2144
2518
  #line 137 "api_node.c.erb"
2145
- case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
2519
+ case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
2146
2520
  yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
2147
- VALUE argv[4];
2521
+ VALUE argv[5];
2522
+
2523
+ // name
2524
+ #line 160 "api_node.c.erb"
2525
+ assert(cast->name != 0);
2526
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
2148
2527
 
2149
2528
  // name_loc
2150
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2529
+ #line 173 "api_node.c.erb"
2530
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2151
2531
 
2152
2532
  // operator_loc
2153
- argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2533
+ #line 173 "api_node.c.erb"
2534
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2154
2535
 
2155
2536
  // value
2156
- argv[2] = rb_ary_pop(value_stack);
2537
+ #line 148 "api_node.c.erb"
2538
+ argv[3] = rb_ary_pop(value_stack);
2157
2539
 
2158
2540
  // location
2159
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2541
+ argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2160
2542
 
2161
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPGlobalVariableOrWriteNode));
2543
+ rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPGlobalVariableOrWriteNode));
2162
2544
  break;
2163
2545
  }
2164
2546
  #line 137 "api_node.c.erb"
2165
- case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
2166
- VALUE argv[1];
2547
+ case YP_GLOBAL_VARIABLE_READ_NODE: {
2548
+ yp_global_variable_read_node_t *cast = (yp_global_variable_read_node_t *) node;
2549
+ VALUE argv[2];
2550
+
2551
+ // name
2552
+ #line 160 "api_node.c.erb"
2553
+ assert(cast->name != 0);
2554
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
2167
2555
 
2168
2556
  // location
2169
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2557
+ argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2170
2558
 
2171
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPGlobalVariableReadNode));
2559
+ rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPGlobalVariableReadNode));
2172
2560
  break;
2173
2561
  }
2174
2562
  #line 137 "api_node.c.erb"
2175
- case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
2176
- VALUE argv[1];
2563
+ case YP_GLOBAL_VARIABLE_TARGET_NODE: {
2564
+ yp_global_variable_target_node_t *cast = (yp_global_variable_target_node_t *) node;
2565
+ VALUE argv[2];
2566
+
2567
+ // name
2568
+ #line 160 "api_node.c.erb"
2569
+ assert(cast->name != 0);
2570
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
2177
2571
 
2178
2572
  // location
2179
- argv[0] = yp_location_new(parser, node->location.start, node->location.end, source);
2573
+ argv[1] = yp_location_new(parser, node->location.start, node->location.end, source);
2180
2574
 
2181
- rb_ary_push(value_stack, rb_class_new_instance(1, argv, rb_cYARPGlobalVariableTargetNode));
2575
+ rb_ary_push(value_stack, rb_class_new_instance(2, argv, rb_cYARPGlobalVariableTargetNode));
2182
2576
  break;
2183
2577
  }
2184
2578
  #line 137 "api_node.c.erb"
2185
- case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
2579
+ case YP_GLOBAL_VARIABLE_WRITE_NODE: {
2186
2580
  yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
2187
- VALUE argv[4];
2581
+ VALUE argv[5];
2582
+
2583
+ // name
2584
+ #line 160 "api_node.c.erb"
2585
+ assert(cast->name != 0);
2586
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
2188
2587
 
2189
2588
  // name_loc
2190
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2589
+ #line 173 "api_node.c.erb"
2590
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2191
2591
 
2192
2592
  // value
2193
- argv[1] = rb_ary_pop(value_stack);
2593
+ #line 148 "api_node.c.erb"
2594
+ argv[2] = rb_ary_pop(value_stack);
2194
2595
 
2195
2596
  // operator_loc
2196
- argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2597
+ #line 173 "api_node.c.erb"
2598
+ argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2197
2599
 
2198
2600
  // location
2199
- argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2601
+ argv[4] = yp_location_new(parser, node->location.start, node->location.end, source);
2200
2602
 
2201
- rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPGlobalVariableWriteNode));
2603
+ rb_ary_push(value_stack, rb_class_new_instance(5, argv, rb_cYARPGlobalVariableWriteNode));
2202
2604
  break;
2203
2605
  }
2204
2606
  #line 137 "api_node.c.erb"
2205
- case YP_NODE_HASH_NODE: {
2607
+ case YP_HASH_NODE: {
2206
2608
  yp_hash_node_t *cast = (yp_hash_node_t *) node;
2207
2609
  VALUE argv[4];
2208
2610
 
2209
2611
  // opening_loc
2612
+ #line 173 "api_node.c.erb"
2210
2613
  argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2211
2614
 
2212
2615
  // elements
2616
+ #line 151 "api_node.c.erb"
2213
2617
  argv[1] = rb_ary_new_capa(cast->elements.size);
2214
2618
  for (size_t index = 0; index < cast->elements.size; index++) {
2215
2619
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
2216
2620
  }
2217
2621
 
2218
2622
  // closing_loc
2623
+ #line 173 "api_node.c.erb"
2219
2624
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2220
2625
 
2221
2626
  // location
@@ -2225,26 +2630,31 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2225
2630
  break;
2226
2631
  }
2227
2632
  #line 137 "api_node.c.erb"
2228
- case YP_NODE_HASH_PATTERN_NODE: {
2633
+ case YP_HASH_PATTERN_NODE: {
2229
2634
  yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
2230
2635
  VALUE argv[6];
2231
2636
 
2232
2637
  // constant
2638
+ #line 148 "api_node.c.erb"
2233
2639
  argv[0] = rb_ary_pop(value_stack);
2234
2640
 
2235
2641
  // assocs
2642
+ #line 151 "api_node.c.erb"
2236
2643
  argv[1] = rb_ary_new_capa(cast->assocs.size);
2237
2644
  for (size_t index = 0; index < cast->assocs.size; index++) {
2238
2645
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
2239
2646
  }
2240
2647
 
2241
2648
  // kwrest
2649
+ #line 148 "api_node.c.erb"
2242
2650
  argv[2] = rb_ary_pop(value_stack);
2243
2651
 
2244
2652
  // opening_loc
2653
+ #line 176 "api_node.c.erb"
2245
2654
  argv[3] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2246
2655
 
2247
2656
  // closing_loc
2657
+ #line 176 "api_node.c.erb"
2248
2658
  argv[4] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2249
2659
 
2250
2660
  // location
@@ -2254,23 +2664,28 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2254
2664
  break;
2255
2665
  }
2256
2666
  #line 137 "api_node.c.erb"
2257
- case YP_NODE_IF_NODE: {
2667
+ case YP_IF_NODE: {
2258
2668
  yp_if_node_t *cast = (yp_if_node_t *) node;
2259
2669
  VALUE argv[6];
2260
2670
 
2261
2671
  // if_keyword_loc
2672
+ #line 176 "api_node.c.erb"
2262
2673
  argv[0] = cast->if_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->if_keyword_loc.start, cast->if_keyword_loc.end, source);
2263
2674
 
2264
2675
  // predicate
2676
+ #line 148 "api_node.c.erb"
2265
2677
  argv[1] = rb_ary_pop(value_stack);
2266
2678
 
2267
2679
  // statements
2680
+ #line 148 "api_node.c.erb"
2268
2681
  argv[2] = rb_ary_pop(value_stack);
2269
2682
 
2270
2683
  // consequent
2684
+ #line 148 "api_node.c.erb"
2271
2685
  argv[3] = rb_ary_pop(value_stack);
2272
2686
 
2273
2687
  // end_keyword_loc
2688
+ #line 176 "api_node.c.erb"
2274
2689
  argv[4] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2275
2690
 
2276
2691
  // location
@@ -2280,10 +2695,11 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2280
2695
  break;
2281
2696
  }
2282
2697
  #line 137 "api_node.c.erb"
2283
- case YP_NODE_IMAGINARY_NODE: {
2698
+ case YP_IMAGINARY_NODE: {
2284
2699
  VALUE argv[2];
2285
2700
 
2286
2701
  // numeric
2702
+ #line 148 "api_node.c.erb"
2287
2703
  argv[0] = rb_ary_pop(value_stack);
2288
2704
 
2289
2705
  // location
@@ -2293,20 +2709,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2293
2709
  break;
2294
2710
  }
2295
2711
  #line 137 "api_node.c.erb"
2296
- case YP_NODE_IN_NODE: {
2712
+ case YP_IN_NODE: {
2297
2713
  yp_in_node_t *cast = (yp_in_node_t *) node;
2298
2714
  VALUE argv[5];
2299
2715
 
2300
2716
  // pattern
2717
+ #line 148 "api_node.c.erb"
2301
2718
  argv[0] = rb_ary_pop(value_stack);
2302
2719
 
2303
2720
  // statements
2721
+ #line 148 "api_node.c.erb"
2304
2722
  argv[1] = rb_ary_pop(value_stack);
2305
2723
 
2306
2724
  // in_loc
2725
+ #line 173 "api_node.c.erb"
2307
2726
  argv[2] = yp_location_new(parser, cast->in_loc.start, cast->in_loc.end, source);
2308
2727
 
2309
2728
  // then_loc
2729
+ #line 176 "api_node.c.erb"
2310
2730
  argv[3] = cast->then_loc.start == NULL ? Qnil : yp_location_new(parser, cast->then_loc.start, cast->then_loc.end, source);
2311
2731
 
2312
2732
  // location
@@ -2316,20 +2736,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2316
2736
  break;
2317
2737
  }
2318
2738
  #line 137 "api_node.c.erb"
2319
- case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
2739
+ case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
2320
2740
  yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
2321
2741
  VALUE argv[5];
2322
2742
 
2323
2743
  // name
2744
+ #line 160 "api_node.c.erb"
2745
+ assert(cast->name != 0);
2324
2746
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2325
2747
 
2326
2748
  // name_loc
2749
+ #line 173 "api_node.c.erb"
2327
2750
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2328
2751
 
2329
2752
  // operator_loc
2753
+ #line 173 "api_node.c.erb"
2330
2754
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2331
2755
 
2332
2756
  // value
2757
+ #line 148 "api_node.c.erb"
2333
2758
  argv[3] = rb_ary_pop(value_stack);
2334
2759
 
2335
2760
  // location
@@ -2339,23 +2764,30 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2339
2764
  break;
2340
2765
  }
2341
2766
  #line 137 "api_node.c.erb"
2342
- case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
2767
+ case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
2343
2768
  yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
2344
2769
  VALUE argv[6];
2345
2770
 
2346
2771
  // name
2772
+ #line 160 "api_node.c.erb"
2773
+ assert(cast->name != 0);
2347
2774
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2348
2775
 
2349
2776
  // name_loc
2777
+ #line 173 "api_node.c.erb"
2350
2778
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2351
2779
 
2352
2780
  // operator_loc
2781
+ #line 173 "api_node.c.erb"
2353
2782
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2354
2783
 
2355
2784
  // value
2785
+ #line 148 "api_node.c.erb"
2356
2786
  argv[3] = rb_ary_pop(value_stack);
2357
2787
 
2358
2788
  // operator
2789
+ #line 160 "api_node.c.erb"
2790
+ assert(cast->operator != 0);
2359
2791
  argv[4] = rb_id2sym(constants[cast->operator - 1]);
2360
2792
 
2361
2793
  // location
@@ -2365,20 +2797,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2365
2797
  break;
2366
2798
  }
2367
2799
  #line 137 "api_node.c.erb"
2368
- case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
2800
+ case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
2369
2801
  yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
2370
2802
  VALUE argv[5];
2371
2803
 
2372
2804
  // name
2805
+ #line 160 "api_node.c.erb"
2806
+ assert(cast->name != 0);
2373
2807
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2374
2808
 
2375
2809
  // name_loc
2810
+ #line 173 "api_node.c.erb"
2376
2811
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2377
2812
 
2378
2813
  // operator_loc
2814
+ #line 173 "api_node.c.erb"
2379
2815
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2380
2816
 
2381
2817
  // value
2818
+ #line 148 "api_node.c.erb"
2382
2819
  argv[3] = rb_ary_pop(value_stack);
2383
2820
 
2384
2821
  // location
@@ -2388,11 +2825,13 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2388
2825
  break;
2389
2826
  }
2390
2827
  #line 137 "api_node.c.erb"
2391
- case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
2828
+ case YP_INSTANCE_VARIABLE_READ_NODE: {
2392
2829
  yp_instance_variable_read_node_t *cast = (yp_instance_variable_read_node_t *) node;
2393
2830
  VALUE argv[2];
2394
2831
 
2395
2832
  // name
2833
+ #line 160 "api_node.c.erb"
2834
+ assert(cast->name != 0);
2396
2835
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2397
2836
 
2398
2837
  // location
@@ -2402,11 +2841,13 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2402
2841
  break;
2403
2842
  }
2404
2843
  #line 137 "api_node.c.erb"
2405
- case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
2844
+ case YP_INSTANCE_VARIABLE_TARGET_NODE: {
2406
2845
  yp_instance_variable_target_node_t *cast = (yp_instance_variable_target_node_t *) node;
2407
2846
  VALUE argv[2];
2408
2847
 
2409
2848
  // name
2849
+ #line 160 "api_node.c.erb"
2850
+ assert(cast->name != 0);
2410
2851
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2411
2852
 
2412
2853
  // location
@@ -2416,20 +2857,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2416
2857
  break;
2417
2858
  }
2418
2859
  #line 137 "api_node.c.erb"
2419
- case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
2860
+ case YP_INSTANCE_VARIABLE_WRITE_NODE: {
2420
2861
  yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
2421
2862
  VALUE argv[5];
2422
2863
 
2423
2864
  // name
2865
+ #line 160 "api_node.c.erb"
2866
+ assert(cast->name != 0);
2424
2867
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2425
2868
 
2426
2869
  // name_loc
2870
+ #line 173 "api_node.c.erb"
2427
2871
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2428
2872
 
2429
2873
  // value
2874
+ #line 148 "api_node.c.erb"
2430
2875
  argv[2] = rb_ary_pop(value_stack);
2431
2876
 
2432
2877
  // operator_loc
2878
+ #line 173 "api_node.c.erb"
2433
2879
  argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2434
2880
 
2435
2881
  // location
@@ -2439,7 +2885,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2439
2885
  break;
2440
2886
  }
2441
2887
  #line 137 "api_node.c.erb"
2442
- case YP_NODE_INTEGER_NODE: {
2888
+ case YP_INTEGER_NODE: {
2443
2889
  VALUE argv[1];
2444
2890
 
2445
2891
  // location
@@ -2449,23 +2895,27 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2449
2895
  break;
2450
2896
  }
2451
2897
  #line 137 "api_node.c.erb"
2452
- case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
2898
+ case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
2453
2899
  yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
2454
2900
  VALUE argv[5];
2455
2901
 
2456
2902
  // opening_loc
2903
+ #line 173 "api_node.c.erb"
2457
2904
  argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2458
2905
 
2459
2906
  // parts
2907
+ #line 151 "api_node.c.erb"
2460
2908
  argv[1] = rb_ary_new_capa(cast->parts.size);
2461
2909
  for (size_t index = 0; index < cast->parts.size; index++) {
2462
2910
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
2463
2911
  }
2464
2912
 
2465
2913
  // closing_loc
2914
+ #line 173 "api_node.c.erb"
2466
2915
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2467
2916
 
2468
2917
  // flags
2918
+ #line 182 "api_node.c.erb"
2469
2919
  argv[3] = ULONG2NUM(node->flags >> 1);
2470
2920
 
2471
2921
  // location
@@ -2475,20 +2925,23 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2475
2925
  break;
2476
2926
  }
2477
2927
  #line 137 "api_node.c.erb"
2478
- case YP_NODE_INTERPOLATED_STRING_NODE: {
2928
+ case YP_INTERPOLATED_STRING_NODE: {
2479
2929
  yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
2480
2930
  VALUE argv[4];
2481
2931
 
2482
2932
  // opening_loc
2933
+ #line 176 "api_node.c.erb"
2483
2934
  argv[0] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2484
2935
 
2485
2936
  // parts
2937
+ #line 151 "api_node.c.erb"
2486
2938
  argv[1] = rb_ary_new_capa(cast->parts.size);
2487
2939
  for (size_t index = 0; index < cast->parts.size; index++) {
2488
2940
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
2489
2941
  }
2490
2942
 
2491
2943
  // closing_loc
2944
+ #line 176 "api_node.c.erb"
2492
2945
  argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2493
2946
 
2494
2947
  // location
@@ -2498,20 +2951,23 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2498
2951
  break;
2499
2952
  }
2500
2953
  #line 137 "api_node.c.erb"
2501
- case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
2954
+ case YP_INTERPOLATED_SYMBOL_NODE: {
2502
2955
  yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
2503
2956
  VALUE argv[4];
2504
2957
 
2505
2958
  // opening_loc
2959
+ #line 176 "api_node.c.erb"
2506
2960
  argv[0] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2507
2961
 
2508
2962
  // parts
2963
+ #line 151 "api_node.c.erb"
2509
2964
  argv[1] = rb_ary_new_capa(cast->parts.size);
2510
2965
  for (size_t index = 0; index < cast->parts.size; index++) {
2511
2966
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
2512
2967
  }
2513
2968
 
2514
2969
  // closing_loc
2970
+ #line 176 "api_node.c.erb"
2515
2971
  argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2516
2972
 
2517
2973
  // location
@@ -2521,20 +2977,23 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2521
2977
  break;
2522
2978
  }
2523
2979
  #line 137 "api_node.c.erb"
2524
- case YP_NODE_INTERPOLATED_X_STRING_NODE: {
2980
+ case YP_INTERPOLATED_X_STRING_NODE: {
2525
2981
  yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
2526
2982
  VALUE argv[4];
2527
2983
 
2528
2984
  // opening_loc
2985
+ #line 173 "api_node.c.erb"
2529
2986
  argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2530
2987
 
2531
2988
  // parts
2989
+ #line 151 "api_node.c.erb"
2532
2990
  argv[1] = rb_ary_new_capa(cast->parts.size);
2533
2991
  for (size_t index = 0; index < cast->parts.size; index++) {
2534
2992
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
2535
2993
  }
2536
2994
 
2537
2995
  // closing_loc
2996
+ #line 173 "api_node.c.erb"
2538
2997
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2539
2998
 
2540
2999
  // location
@@ -2544,11 +3003,12 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2544
3003
  break;
2545
3004
  }
2546
3005
  #line 137 "api_node.c.erb"
2547
- case YP_NODE_KEYWORD_HASH_NODE: {
3006
+ case YP_KEYWORD_HASH_NODE: {
2548
3007
  yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
2549
3008
  VALUE argv[2];
2550
3009
 
2551
3010
  // elements
3011
+ #line 151 "api_node.c.erb"
2552
3012
  argv[0] = rb_ary_new_capa(cast->elements.size);
2553
3013
  for (size_t index = 0; index < cast->elements.size; index++) {
2554
3014
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
@@ -2561,63 +3021,82 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2561
3021
  break;
2562
3022
  }
2563
3023
  #line 137 "api_node.c.erb"
2564
- case YP_NODE_KEYWORD_PARAMETER_NODE: {
3024
+ case YP_KEYWORD_PARAMETER_NODE: {
2565
3025
  yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
2566
- VALUE argv[3];
3026
+ VALUE argv[4];
3027
+
3028
+ // name
3029
+ #line 160 "api_node.c.erb"
3030
+ assert(cast->name != 0);
3031
+ argv[0] = rb_id2sym(constants[cast->name - 1]);
2567
3032
 
2568
3033
  // name_loc
2569
- argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3034
+ #line 173 "api_node.c.erb"
3035
+ argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2570
3036
 
2571
3037
  // value
2572
- argv[1] = rb_ary_pop(value_stack);
3038
+ #line 148 "api_node.c.erb"
3039
+ argv[2] = rb_ary_pop(value_stack);
2573
3040
 
2574
3041
  // location
2575
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3042
+ argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2576
3043
 
2577
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPKeywordParameterNode));
3044
+ rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPKeywordParameterNode));
2578
3045
  break;
2579
3046
  }
2580
3047
  #line 137 "api_node.c.erb"
2581
- case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
3048
+ case YP_KEYWORD_REST_PARAMETER_NODE: {
2582
3049
  yp_keyword_rest_parameter_node_t *cast = (yp_keyword_rest_parameter_node_t *) node;
2583
- VALUE argv[3];
3050
+ VALUE argv[4];
2584
3051
 
2585
- // operator_loc
2586
- argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3052
+ // name
3053
+ argv[0] = cast->name == 0 ? Qnil : rb_id2sym(constants[cast->name - 1]);
2587
3054
 
2588
3055
  // name_loc
3056
+ #line 176 "api_node.c.erb"
2589
3057
  argv[1] = cast->name_loc.start == NULL ? Qnil : yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2590
3058
 
3059
+ // operator_loc
3060
+ #line 173 "api_node.c.erb"
3061
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3062
+
2591
3063
  // location
2592
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3064
+ argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
2593
3065
 
2594
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPKeywordRestParameterNode));
3066
+ rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPKeywordRestParameterNode));
2595
3067
  break;
2596
3068
  }
2597
3069
  #line 137 "api_node.c.erb"
2598
- case YP_NODE_LAMBDA_NODE: {
3070
+ case YP_LAMBDA_NODE: {
2599
3071
  yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
2600
3072
  VALUE argv[7];
2601
3073
 
2602
3074
  // locals
3075
+ #line 166 "api_node.c.erb"
2603
3076
  argv[0] = rb_ary_new_capa(cast->locals.size);
2604
3077
  for (size_t index = 0; index < cast->locals.size; index++) {
3078
+ assert(cast->locals.ids[index] != 0);
2605
3079
  rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
2606
3080
  }
2607
3081
 
2608
3082
  // operator_loc
3083
+ #line 173 "api_node.c.erb"
2609
3084
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2610
3085
 
2611
3086
  // opening_loc
3087
+ #line 173 "api_node.c.erb"
2612
3088
  argv[2] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
2613
3089
 
2614
3090
  // closing_loc
3091
+ #line 173 "api_node.c.erb"
2615
3092
  argv[3] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
2616
3093
 
2617
3094
  // parameters
3095
+ #line 148 "api_node.c.erb"
2618
3096
  argv[4] = rb_ary_pop(value_stack);
2619
3097
 
2620
3098
  // body
3099
+ #line 148 "api_node.c.erb"
2621
3100
  argv[5] = rb_ary_pop(value_stack);
2622
3101
 
2623
3102
  // location
@@ -2627,23 +3106,29 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2627
3106
  break;
2628
3107
  }
2629
3108
  #line 137 "api_node.c.erb"
2630
- case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
3109
+ case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
2631
3110
  yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
2632
3111
  VALUE argv[6];
2633
3112
 
2634
3113
  // name_loc
3114
+ #line 173 "api_node.c.erb"
2635
3115
  argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2636
3116
 
2637
3117
  // operator_loc
3118
+ #line 173 "api_node.c.erb"
2638
3119
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2639
3120
 
2640
3121
  // value
3122
+ #line 148 "api_node.c.erb"
2641
3123
  argv[2] = rb_ary_pop(value_stack);
2642
3124
 
2643
3125
  // name
3126
+ #line 160 "api_node.c.erb"
3127
+ assert(cast->name != 0);
2644
3128
  argv[3] = rb_id2sym(constants[cast->name - 1]);
2645
3129
 
2646
3130
  // depth
3131
+ #line 179 "api_node.c.erb"
2647
3132
  argv[4] = ULONG2NUM(cast->depth);
2648
3133
 
2649
3134
  // location
@@ -2653,26 +3138,34 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2653
3138
  break;
2654
3139
  }
2655
3140
  #line 137 "api_node.c.erb"
2656
- case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
3141
+ case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
2657
3142
  yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
2658
3143
  VALUE argv[7];
2659
3144
 
2660
3145
  // name_loc
3146
+ #line 173 "api_node.c.erb"
2661
3147
  argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2662
3148
 
2663
3149
  // operator_loc
3150
+ #line 173 "api_node.c.erb"
2664
3151
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2665
3152
 
2666
3153
  // value
3154
+ #line 148 "api_node.c.erb"
2667
3155
  argv[2] = rb_ary_pop(value_stack);
2668
3156
 
2669
3157
  // name
3158
+ #line 160 "api_node.c.erb"
3159
+ assert(cast->name != 0);
2670
3160
  argv[3] = rb_id2sym(constants[cast->name - 1]);
2671
3161
 
2672
3162
  // operator
3163
+ #line 160 "api_node.c.erb"
3164
+ assert(cast->operator != 0);
2673
3165
  argv[4] = rb_id2sym(constants[cast->operator - 1]);
2674
3166
 
2675
3167
  // depth
3168
+ #line 179 "api_node.c.erb"
2676
3169
  argv[5] = ULONG2NUM(cast->depth);
2677
3170
 
2678
3171
  // location
@@ -2682,23 +3175,29 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2682
3175
  break;
2683
3176
  }
2684
3177
  #line 137 "api_node.c.erb"
2685
- case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
3178
+ case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
2686
3179
  yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
2687
3180
  VALUE argv[6];
2688
3181
 
2689
3182
  // name_loc
3183
+ #line 173 "api_node.c.erb"
2690
3184
  argv[0] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2691
3185
 
2692
3186
  // operator_loc
3187
+ #line 173 "api_node.c.erb"
2693
3188
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2694
3189
 
2695
3190
  // value
3191
+ #line 148 "api_node.c.erb"
2696
3192
  argv[2] = rb_ary_pop(value_stack);
2697
3193
 
2698
3194
  // name
3195
+ #line 160 "api_node.c.erb"
3196
+ assert(cast->name != 0);
2699
3197
  argv[3] = rb_id2sym(constants[cast->name - 1]);
2700
3198
 
2701
3199
  // depth
3200
+ #line 179 "api_node.c.erb"
2702
3201
  argv[4] = ULONG2NUM(cast->depth);
2703
3202
 
2704
3203
  // location
@@ -2708,14 +3207,17 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2708
3207
  break;
2709
3208
  }
2710
3209
  #line 137 "api_node.c.erb"
2711
- case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
3210
+ case YP_LOCAL_VARIABLE_READ_NODE: {
2712
3211
  yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
2713
3212
  VALUE argv[3];
2714
3213
 
2715
3214
  // name
3215
+ #line 160 "api_node.c.erb"
3216
+ assert(cast->name != 0);
2716
3217
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2717
3218
 
2718
3219
  // depth
3220
+ #line 179 "api_node.c.erb"
2719
3221
  argv[1] = ULONG2NUM(cast->depth);
2720
3222
 
2721
3223
  // location
@@ -2725,14 +3227,17 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2725
3227
  break;
2726
3228
  }
2727
3229
  #line 137 "api_node.c.erb"
2728
- case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
3230
+ case YP_LOCAL_VARIABLE_TARGET_NODE: {
2729
3231
  yp_local_variable_target_node_t *cast = (yp_local_variable_target_node_t *) node;
2730
3232
  VALUE argv[3];
2731
3233
 
2732
3234
  // name
3235
+ #line 160 "api_node.c.erb"
3236
+ assert(cast->name != 0);
2733
3237
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2734
3238
 
2735
3239
  // depth
3240
+ #line 179 "api_node.c.erb"
2736
3241
  argv[1] = ULONG2NUM(cast->depth);
2737
3242
 
2738
3243
  // location
@@ -2742,23 +3247,29 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2742
3247
  break;
2743
3248
  }
2744
3249
  #line 137 "api_node.c.erb"
2745
- case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
3250
+ case YP_LOCAL_VARIABLE_WRITE_NODE: {
2746
3251
  yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
2747
3252
  VALUE argv[6];
2748
3253
 
2749
3254
  // name
3255
+ #line 160 "api_node.c.erb"
3256
+ assert(cast->name != 0);
2750
3257
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2751
3258
 
2752
3259
  // depth
3260
+ #line 179 "api_node.c.erb"
2753
3261
  argv[1] = ULONG2NUM(cast->depth);
2754
3262
 
2755
3263
  // name_loc
3264
+ #line 173 "api_node.c.erb"
2756
3265
  argv[2] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2757
3266
 
2758
3267
  // value
3268
+ #line 148 "api_node.c.erb"
2759
3269
  argv[3] = rb_ary_pop(value_stack);
2760
3270
 
2761
3271
  // operator_loc
3272
+ #line 173 "api_node.c.erb"
2762
3273
  argv[4] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2763
3274
 
2764
3275
  // location
@@ -2768,17 +3279,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2768
3279
  break;
2769
3280
  }
2770
3281
  #line 137 "api_node.c.erb"
2771
- case YP_NODE_MATCH_PREDICATE_NODE: {
3282
+ case YP_MATCH_PREDICATE_NODE: {
2772
3283
  yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
2773
3284
  VALUE argv[4];
2774
3285
 
2775
3286
  // value
3287
+ #line 148 "api_node.c.erb"
2776
3288
  argv[0] = rb_ary_pop(value_stack);
2777
3289
 
2778
3290
  // pattern
3291
+ #line 148 "api_node.c.erb"
2779
3292
  argv[1] = rb_ary_pop(value_stack);
2780
3293
 
2781
3294
  // operator_loc
3295
+ #line 173 "api_node.c.erb"
2782
3296
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2783
3297
 
2784
3298
  // location
@@ -2788,17 +3302,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2788
3302
  break;
2789
3303
  }
2790
3304
  #line 137 "api_node.c.erb"
2791
- case YP_NODE_MATCH_REQUIRED_NODE: {
3305
+ case YP_MATCH_REQUIRED_NODE: {
2792
3306
  yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
2793
3307
  VALUE argv[4];
2794
3308
 
2795
3309
  // value
3310
+ #line 148 "api_node.c.erb"
2796
3311
  argv[0] = rb_ary_pop(value_stack);
2797
3312
 
2798
3313
  // pattern
3314
+ #line 148 "api_node.c.erb"
2799
3315
  argv[1] = rb_ary_pop(value_stack);
2800
3316
 
2801
3317
  // operator_loc
3318
+ #line 173 "api_node.c.erb"
2802
3319
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2803
3320
 
2804
3321
  // location
@@ -2808,7 +3325,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2808
3325
  break;
2809
3326
  }
2810
3327
  #line 137 "api_node.c.erb"
2811
- case YP_NODE_MISSING_NODE: {
3328
+ case YP_MISSING_NODE: {
2812
3329
  VALUE argv[1];
2813
3330
 
2814
3331
  // location
@@ -2818,30 +3335,38 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2818
3335
  break;
2819
3336
  }
2820
3337
  #line 137 "api_node.c.erb"
2821
- case YP_NODE_MODULE_NODE: {
3338
+ case YP_MODULE_NODE: {
2822
3339
  yp_module_node_t *cast = (yp_module_node_t *) node;
2823
3340
  VALUE argv[7];
2824
3341
 
2825
3342
  // locals
3343
+ #line 166 "api_node.c.erb"
2826
3344
  argv[0] = rb_ary_new_capa(cast->locals.size);
2827
3345
  for (size_t index = 0; index < cast->locals.size; index++) {
3346
+ assert(cast->locals.ids[index] != 0);
2828
3347
  rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
2829
3348
  }
2830
3349
 
2831
3350
  // module_keyword_loc
3351
+ #line 173 "api_node.c.erb"
2832
3352
  argv[1] = yp_location_new(parser, cast->module_keyword_loc.start, cast->module_keyword_loc.end, source);
2833
3353
 
2834
3354
  // constant_path
3355
+ #line 148 "api_node.c.erb"
2835
3356
  argv[2] = rb_ary_pop(value_stack);
2836
3357
 
2837
3358
  // body
3359
+ #line 148 "api_node.c.erb"
2838
3360
  argv[3] = rb_ary_pop(value_stack);
2839
3361
 
2840
3362
  // end_keyword_loc
3363
+ #line 173 "api_node.c.erb"
2841
3364
  argv[4] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
2842
3365
 
2843
3366
  // name
2844
- argv[5] = yp_string_new(&cast->name, encoding);
3367
+ #line 160 "api_node.c.erb"
3368
+ assert(cast->name != 0);
3369
+ argv[5] = rb_id2sym(constants[cast->name - 1]);
2845
3370
 
2846
3371
  // location
2847
3372
  argv[6] = yp_location_new(parser, node->location.start, node->location.end, source);
@@ -2850,27 +3375,58 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2850
3375
  break;
2851
3376
  }
2852
3377
  #line 137 "api_node.c.erb"
2853
- case YP_NODE_MULTI_WRITE_NODE: {
2854
- yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
2855
- VALUE argv[6];
3378
+ case YP_MULTI_TARGET_NODE: {
3379
+ yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
3380
+ VALUE argv[4];
2856
3381
 
2857
3382
  // targets
3383
+ #line 151 "api_node.c.erb"
2858
3384
  argv[0] = rb_ary_new_capa(cast->targets.size);
2859
3385
  for (size_t index = 0; index < cast->targets.size; index++) {
2860
3386
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
2861
3387
  }
2862
3388
 
2863
- // operator_loc
2864
- argv[1] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3389
+ // lparen_loc
3390
+ #line 176 "api_node.c.erb"
3391
+ argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
2865
3392
 
2866
- // value
2867
- argv[2] = rb_ary_pop(value_stack);
3393
+ // rparen_loc
3394
+ #line 176 "api_node.c.erb"
3395
+ argv[2] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3396
+
3397
+ // location
3398
+ argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3399
+
3400
+ rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPMultiTargetNode));
3401
+ break;
3402
+ }
3403
+ #line 137 "api_node.c.erb"
3404
+ case YP_MULTI_WRITE_NODE: {
3405
+ yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
3406
+ VALUE argv[6];
3407
+
3408
+ // targets
3409
+ #line 151 "api_node.c.erb"
3410
+ argv[0] = rb_ary_new_capa(cast->targets.size);
3411
+ for (size_t index = 0; index < cast->targets.size; index++) {
3412
+ rb_ary_push(argv[0], rb_ary_pop(value_stack));
3413
+ }
2868
3414
 
2869
3415
  // lparen_loc
2870
- argv[3] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
3416
+ #line 176 "api_node.c.erb"
3417
+ argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
2871
3418
 
2872
3419
  // rparen_loc
2873
- argv[4] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3420
+ #line 176 "api_node.c.erb"
3421
+ argv[2] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3422
+
3423
+ // operator_loc
3424
+ #line 173 "api_node.c.erb"
3425
+ argv[3] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3426
+
3427
+ // value
3428
+ #line 148 "api_node.c.erb"
3429
+ argv[4] = rb_ary_pop(value_stack);
2874
3430
 
2875
3431
  // location
2876
3432
  argv[5] = yp_location_new(parser, node->location.start, node->location.end, source);
@@ -2879,14 +3435,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2879
3435
  break;
2880
3436
  }
2881
3437
  #line 137 "api_node.c.erb"
2882
- case YP_NODE_NEXT_NODE: {
3438
+ case YP_NEXT_NODE: {
2883
3439
  yp_next_node_t *cast = (yp_next_node_t *) node;
2884
3440
  VALUE argv[3];
2885
3441
 
2886
3442
  // arguments
3443
+ #line 148 "api_node.c.erb"
2887
3444
  argv[0] = rb_ary_pop(value_stack);
2888
3445
 
2889
3446
  // keyword_loc
3447
+ #line 173 "api_node.c.erb"
2890
3448
  argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
2891
3449
 
2892
3450
  // location
@@ -2896,7 +3454,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2896
3454
  break;
2897
3455
  }
2898
3456
  #line 137 "api_node.c.erb"
2899
- case YP_NODE_NIL_NODE: {
3457
+ case YP_NIL_NODE: {
2900
3458
  VALUE argv[1];
2901
3459
 
2902
3460
  // location
@@ -2906,14 +3464,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2906
3464
  break;
2907
3465
  }
2908
3466
  #line 137 "api_node.c.erb"
2909
- case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
3467
+ case YP_NO_KEYWORDS_PARAMETER_NODE: {
2910
3468
  yp_no_keywords_parameter_node_t *cast = (yp_no_keywords_parameter_node_t *) node;
2911
3469
  VALUE argv[3];
2912
3470
 
2913
3471
  // operator_loc
3472
+ #line 173 "api_node.c.erb"
2914
3473
  argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2915
3474
 
2916
3475
  // keyword_loc
3476
+ #line 173 "api_node.c.erb"
2917
3477
  argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
2918
3478
 
2919
3479
  // location
@@ -2923,11 +3483,12 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2923
3483
  break;
2924
3484
  }
2925
3485
  #line 137 "api_node.c.erb"
2926
- case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
3486
+ case YP_NUMBERED_REFERENCE_READ_NODE: {
2927
3487
  yp_numbered_reference_read_node_t *cast = (yp_numbered_reference_read_node_t *) node;
2928
3488
  VALUE argv[2];
2929
3489
 
2930
3490
  // number
3491
+ #line 179 "api_node.c.erb"
2931
3492
  argv[0] = ULONG2NUM(cast->number);
2932
3493
 
2933
3494
  // location
@@ -2937,20 +3498,25 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2937
3498
  break;
2938
3499
  }
2939
3500
  #line 137 "api_node.c.erb"
2940
- case YP_NODE_OPTIONAL_PARAMETER_NODE: {
3501
+ case YP_OPTIONAL_PARAMETER_NODE: {
2941
3502
  yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
2942
3503
  VALUE argv[5];
2943
3504
 
2944
3505
  // name
3506
+ #line 160 "api_node.c.erb"
3507
+ assert(cast->name != 0);
2945
3508
  argv[0] = rb_id2sym(constants[cast->name - 1]);
2946
3509
 
2947
3510
  // name_loc
3511
+ #line 173 "api_node.c.erb"
2948
3512
  argv[1] = yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
2949
3513
 
2950
3514
  // operator_loc
3515
+ #line 173 "api_node.c.erb"
2951
3516
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2952
3517
 
2953
3518
  // value
3519
+ #line 148 "api_node.c.erb"
2954
3520
  argv[3] = rb_ary_pop(value_stack);
2955
3521
 
2956
3522
  // location
@@ -2960,17 +3526,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2960
3526
  break;
2961
3527
  }
2962
3528
  #line 137 "api_node.c.erb"
2963
- case YP_NODE_OR_NODE: {
3529
+ case YP_OR_NODE: {
2964
3530
  yp_or_node_t *cast = (yp_or_node_t *) node;
2965
3531
  VALUE argv[4];
2966
3532
 
2967
3533
  // left
3534
+ #line 148 "api_node.c.erb"
2968
3535
  argv[0] = rb_ary_pop(value_stack);
2969
3536
 
2970
3537
  // right
3538
+ #line 148 "api_node.c.erb"
2971
3539
  argv[1] = rb_ary_pop(value_stack);
2972
3540
 
2973
3541
  // operator_loc
3542
+ #line 173 "api_node.c.erb"
2974
3543
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
2975
3544
 
2976
3545
  // location
@@ -2980,41 +3549,48 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
2980
3549
  break;
2981
3550
  }
2982
3551
  #line 137 "api_node.c.erb"
2983
- case YP_NODE_PARAMETERS_NODE: {
3552
+ case YP_PARAMETERS_NODE: {
2984
3553
  yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
2985
3554
  VALUE argv[8];
2986
3555
 
2987
3556
  // requireds
3557
+ #line 151 "api_node.c.erb"
2988
3558
  argv[0] = rb_ary_new_capa(cast->requireds.size);
2989
3559
  for (size_t index = 0; index < cast->requireds.size; index++) {
2990
3560
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
2991
3561
  }
2992
3562
 
2993
3563
  // optionals
3564
+ #line 151 "api_node.c.erb"
2994
3565
  argv[1] = rb_ary_new_capa(cast->optionals.size);
2995
3566
  for (size_t index = 0; index < cast->optionals.size; index++) {
2996
3567
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
2997
3568
  }
2998
3569
 
2999
3570
  // posts
3571
+ #line 151 "api_node.c.erb"
3000
3572
  argv[2] = rb_ary_new_capa(cast->posts.size);
3001
3573
  for (size_t index = 0; index < cast->posts.size; index++) {
3002
3574
  rb_ary_push(argv[2], rb_ary_pop(value_stack));
3003
3575
  }
3004
3576
 
3005
3577
  // rest
3578
+ #line 148 "api_node.c.erb"
3006
3579
  argv[3] = rb_ary_pop(value_stack);
3007
3580
 
3008
3581
  // keywords
3582
+ #line 151 "api_node.c.erb"
3009
3583
  argv[4] = rb_ary_new_capa(cast->keywords.size);
3010
3584
  for (size_t index = 0; index < cast->keywords.size; index++) {
3011
3585
  rb_ary_push(argv[4], rb_ary_pop(value_stack));
3012
3586
  }
3013
3587
 
3014
3588
  // keyword_rest
3589
+ #line 148 "api_node.c.erb"
3015
3590
  argv[5] = rb_ary_pop(value_stack);
3016
3591
 
3017
3592
  // block
3593
+ #line 148 "api_node.c.erb"
3018
3594
  argv[6] = rb_ary_pop(value_stack);
3019
3595
 
3020
3596
  // location
@@ -3024,17 +3600,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3024
3600
  break;
3025
3601
  }
3026
3602
  #line 137 "api_node.c.erb"
3027
- case YP_NODE_PARENTHESES_NODE: {
3603
+ case YP_PARENTHESES_NODE: {
3028
3604
  yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
3029
3605
  VALUE argv[4];
3030
3606
 
3031
3607
  // body
3608
+ #line 148 "api_node.c.erb"
3032
3609
  argv[0] = rb_ary_pop(value_stack);
3033
3610
 
3034
3611
  // opening_loc
3612
+ #line 173 "api_node.c.erb"
3035
3613
  argv[1] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3036
3614
 
3037
3615
  // closing_loc
3616
+ #line 173 "api_node.c.erb"
3038
3617
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3039
3618
 
3040
3619
  // location
@@ -3044,20 +3623,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3044
3623
  break;
3045
3624
  }
3046
3625
  #line 137 "api_node.c.erb"
3047
- case YP_NODE_PINNED_EXPRESSION_NODE: {
3626
+ case YP_PINNED_EXPRESSION_NODE: {
3048
3627
  yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
3049
3628
  VALUE argv[5];
3050
3629
 
3051
3630
  // expression
3631
+ #line 148 "api_node.c.erb"
3052
3632
  argv[0] = rb_ary_pop(value_stack);
3053
3633
 
3054
3634
  // operator_loc
3635
+ #line 173 "api_node.c.erb"
3055
3636
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3056
3637
 
3057
3638
  // lparen_loc
3639
+ #line 173 "api_node.c.erb"
3058
3640
  argv[2] = yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
3059
3641
 
3060
3642
  // rparen_loc
3643
+ #line 173 "api_node.c.erb"
3061
3644
  argv[3] = yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3062
3645
 
3063
3646
  // location
@@ -3067,14 +3650,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3067
3650
  break;
3068
3651
  }
3069
3652
  #line 137 "api_node.c.erb"
3070
- case YP_NODE_PINNED_VARIABLE_NODE: {
3653
+ case YP_PINNED_VARIABLE_NODE: {
3071
3654
  yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
3072
3655
  VALUE argv[3];
3073
3656
 
3074
3657
  // variable
3658
+ #line 148 "api_node.c.erb"
3075
3659
  argv[0] = rb_ary_pop(value_stack);
3076
3660
 
3077
3661
  // operator_loc
3662
+ #line 173 "api_node.c.erb"
3078
3663
  argv[1] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3079
3664
 
3080
3665
  // location
@@ -3084,20 +3669,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3084
3669
  break;
3085
3670
  }
3086
3671
  #line 137 "api_node.c.erb"
3087
- case YP_NODE_POST_EXECUTION_NODE: {
3672
+ case YP_POST_EXECUTION_NODE: {
3088
3673
  yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
3089
3674
  VALUE argv[5];
3090
3675
 
3091
3676
  // statements
3677
+ #line 148 "api_node.c.erb"
3092
3678
  argv[0] = rb_ary_pop(value_stack);
3093
3679
 
3094
3680
  // keyword_loc
3681
+ #line 173 "api_node.c.erb"
3095
3682
  argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3096
3683
 
3097
3684
  // opening_loc
3685
+ #line 173 "api_node.c.erb"
3098
3686
  argv[2] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3099
3687
 
3100
3688
  // closing_loc
3689
+ #line 173 "api_node.c.erb"
3101
3690
  argv[3] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3102
3691
 
3103
3692
  // location
@@ -3107,20 +3696,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3107
3696
  break;
3108
3697
  }
3109
3698
  #line 137 "api_node.c.erb"
3110
- case YP_NODE_PRE_EXECUTION_NODE: {
3699
+ case YP_PRE_EXECUTION_NODE: {
3111
3700
  yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
3112
3701
  VALUE argv[5];
3113
3702
 
3114
3703
  // statements
3704
+ #line 148 "api_node.c.erb"
3115
3705
  argv[0] = rb_ary_pop(value_stack);
3116
3706
 
3117
3707
  // keyword_loc
3708
+ #line 173 "api_node.c.erb"
3118
3709
  argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3119
3710
 
3120
3711
  // opening_loc
3712
+ #line 173 "api_node.c.erb"
3121
3713
  argv[2] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3122
3714
 
3123
3715
  // closing_loc
3716
+ #line 173 "api_node.c.erb"
3124
3717
  argv[3] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3125
3718
 
3126
3719
  // location
@@ -3130,17 +3723,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3130
3723
  break;
3131
3724
  }
3132
3725
  #line 137 "api_node.c.erb"
3133
- case YP_NODE_PROGRAM_NODE: {
3726
+ case YP_PROGRAM_NODE: {
3134
3727
  yp_program_node_t *cast = (yp_program_node_t *) node;
3135
3728
  VALUE argv[3];
3136
3729
 
3137
3730
  // locals
3731
+ #line 166 "api_node.c.erb"
3138
3732
  argv[0] = rb_ary_new_capa(cast->locals.size);
3139
3733
  for (size_t index = 0; index < cast->locals.size; index++) {
3734
+ assert(cast->locals.ids[index] != 0);
3140
3735
  rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
3141
3736
  }
3142
3737
 
3143
3738
  // statements
3739
+ #line 148 "api_node.c.erb"
3144
3740
  argv[1] = rb_ary_pop(value_stack);
3145
3741
 
3146
3742
  // location
@@ -3150,20 +3746,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3150
3746
  break;
3151
3747
  }
3152
3748
  #line 137 "api_node.c.erb"
3153
- case YP_NODE_RANGE_NODE: {
3749
+ case YP_RANGE_NODE: {
3154
3750
  yp_range_node_t *cast = (yp_range_node_t *) node;
3155
3751
  VALUE argv[5];
3156
3752
 
3157
3753
  // left
3754
+ #line 148 "api_node.c.erb"
3158
3755
  argv[0] = rb_ary_pop(value_stack);
3159
3756
 
3160
3757
  // right
3758
+ #line 148 "api_node.c.erb"
3161
3759
  argv[1] = rb_ary_pop(value_stack);
3162
3760
 
3163
3761
  // operator_loc
3762
+ #line 173 "api_node.c.erb"
3164
3763
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3165
3764
 
3166
3765
  // flags
3766
+ #line 182 "api_node.c.erb"
3167
3767
  argv[3] = ULONG2NUM(node->flags >> 1);
3168
3768
 
3169
3769
  // location
@@ -3173,10 +3773,11 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3173
3773
  break;
3174
3774
  }
3175
3775
  #line 137 "api_node.c.erb"
3176
- case YP_NODE_RATIONAL_NODE: {
3776
+ case YP_RATIONAL_NODE: {
3177
3777
  VALUE argv[2];
3178
3778
 
3179
3779
  // numeric
3780
+ #line 148 "api_node.c.erb"
3180
3781
  argv[0] = rb_ary_pop(value_stack);
3181
3782
 
3182
3783
  // location
@@ -3186,7 +3787,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3186
3787
  break;
3187
3788
  }
3188
3789
  #line 137 "api_node.c.erb"
3189
- case YP_NODE_REDO_NODE: {
3790
+ case YP_REDO_NODE: {
3190
3791
  VALUE argv[1];
3191
3792
 
3192
3793
  // location
@@ -3196,23 +3797,28 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3196
3797
  break;
3197
3798
  }
3198
3799
  #line 137 "api_node.c.erb"
3199
- case YP_NODE_REGULAR_EXPRESSION_NODE: {
3800
+ case YP_REGULAR_EXPRESSION_NODE: {
3200
3801
  yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
3201
3802
  VALUE argv[6];
3202
3803
 
3203
3804
  // opening_loc
3805
+ #line 173 "api_node.c.erb"
3204
3806
  argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3205
3807
 
3206
3808
  // content_loc
3809
+ #line 173 "api_node.c.erb"
3207
3810
  argv[1] = yp_location_new(parser, cast->content_loc.start, cast->content_loc.end, source);
3208
3811
 
3209
3812
  // closing_loc
3813
+ #line 173 "api_node.c.erb"
3210
3814
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3211
3815
 
3212
3816
  // unescaped
3817
+ #line 157 "api_node.c.erb"
3213
3818
  argv[3] = yp_string_new(&cast->unescaped, encoding);
3214
3819
 
3215
3820
  // flags
3821
+ #line 182 "api_node.c.erb"
3216
3822
  argv[4] = ULONG2NUM(node->flags >> 1);
3217
3823
 
3218
3824
  // location
@@ -3222,20 +3828,23 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3222
3828
  break;
3223
3829
  }
3224
3830
  #line 137 "api_node.c.erb"
3225
- case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
3831
+ case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
3226
3832
  yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
3227
3833
  VALUE argv[4];
3228
3834
 
3229
3835
  // parameters
3836
+ #line 151 "api_node.c.erb"
3230
3837
  argv[0] = rb_ary_new_capa(cast->parameters.size);
3231
3838
  for (size_t index = 0; index < cast->parameters.size; index++) {
3232
3839
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
3233
3840
  }
3234
3841
 
3235
3842
  // opening_loc
3843
+ #line 173 "api_node.c.erb"
3236
3844
  argv[1] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3237
3845
 
3238
3846
  // closing_loc
3847
+ #line 173 "api_node.c.erb"
3239
3848
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3240
3849
 
3241
3850
  // location
@@ -3245,11 +3854,13 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3245
3854
  break;
3246
3855
  }
3247
3856
  #line 137 "api_node.c.erb"
3248
- case YP_NODE_REQUIRED_PARAMETER_NODE: {
3857
+ case YP_REQUIRED_PARAMETER_NODE: {
3249
3858
  yp_required_parameter_node_t *cast = (yp_required_parameter_node_t *) node;
3250
3859
  VALUE argv[2];
3251
3860
 
3252
3861
  // name
3862
+ #line 160 "api_node.c.erb"
3863
+ assert(cast->name != 0);
3253
3864
  argv[0] = rb_id2sym(constants[cast->name - 1]);
3254
3865
 
3255
3866
  // location
@@ -3259,17 +3870,20 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3259
3870
  break;
3260
3871
  }
3261
3872
  #line 137 "api_node.c.erb"
3262
- case YP_NODE_RESCUE_MODIFIER_NODE: {
3873
+ case YP_RESCUE_MODIFIER_NODE: {
3263
3874
  yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
3264
3875
  VALUE argv[4];
3265
3876
 
3266
3877
  // expression
3878
+ #line 148 "api_node.c.erb"
3267
3879
  argv[0] = rb_ary_pop(value_stack);
3268
3880
 
3269
3881
  // keyword_loc
3882
+ #line 173 "api_node.c.erb"
3270
3883
  argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3271
3884
 
3272
3885
  // rescue_expression
3886
+ #line 148 "api_node.c.erb"
3273
3887
  argv[2] = rb_ary_pop(value_stack);
3274
3888
 
3275
3889
  // location
@@ -3279,29 +3893,35 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3279
3893
  break;
3280
3894
  }
3281
3895
  #line 137 "api_node.c.erb"
3282
- case YP_NODE_RESCUE_NODE: {
3896
+ case YP_RESCUE_NODE: {
3283
3897
  yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
3284
3898
  VALUE argv[7];
3285
3899
 
3286
3900
  // keyword_loc
3901
+ #line 173 "api_node.c.erb"
3287
3902
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3288
3903
 
3289
3904
  // exceptions
3905
+ #line 151 "api_node.c.erb"
3290
3906
  argv[1] = rb_ary_new_capa(cast->exceptions.size);
3291
3907
  for (size_t index = 0; index < cast->exceptions.size; index++) {
3292
3908
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
3293
3909
  }
3294
3910
 
3295
3911
  // operator_loc
3912
+ #line 176 "api_node.c.erb"
3296
3913
  argv[2] = cast->operator_loc.start == NULL ? Qnil : yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3297
3914
 
3298
3915
  // reference
3916
+ #line 148 "api_node.c.erb"
3299
3917
  argv[3] = rb_ary_pop(value_stack);
3300
3918
 
3301
3919
  // statements
3920
+ #line 148 "api_node.c.erb"
3302
3921
  argv[4] = rb_ary_pop(value_stack);
3303
3922
 
3304
3923
  // consequent
3924
+ #line 148 "api_node.c.erb"
3305
3925
  argv[5] = rb_ary_pop(value_stack);
3306
3926
 
3307
3927
  // location
@@ -3311,24 +3931,29 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3311
3931
  break;
3312
3932
  }
3313
3933
  #line 137 "api_node.c.erb"
3314
- case YP_NODE_REST_PARAMETER_NODE: {
3934
+ case YP_REST_PARAMETER_NODE: {
3315
3935
  yp_rest_parameter_node_t *cast = (yp_rest_parameter_node_t *) node;
3316
- VALUE argv[3];
3936
+ VALUE argv[4];
3317
3937
 
3318
- // operator_loc
3319
- argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3938
+ // name
3939
+ argv[0] = cast->name == 0 ? Qnil : rb_id2sym(constants[cast->name - 1]);
3320
3940
 
3321
3941
  // name_loc
3942
+ #line 176 "api_node.c.erb"
3322
3943
  argv[1] = cast->name_loc.start == NULL ? Qnil : yp_location_new(parser, cast->name_loc.start, cast->name_loc.end, source);
3323
3944
 
3945
+ // operator_loc
3946
+ #line 173 "api_node.c.erb"
3947
+ argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3948
+
3324
3949
  // location
3325
- argv[2] = yp_location_new(parser, node->location.start, node->location.end, source);
3950
+ argv[3] = yp_location_new(parser, node->location.start, node->location.end, source);
3326
3951
 
3327
- rb_ary_push(value_stack, rb_class_new_instance(3, argv, rb_cYARPRestParameterNode));
3952
+ rb_ary_push(value_stack, rb_class_new_instance(4, argv, rb_cYARPRestParameterNode));
3328
3953
  break;
3329
3954
  }
3330
3955
  #line 137 "api_node.c.erb"
3331
- case YP_NODE_RETRY_NODE: {
3956
+ case YP_RETRY_NODE: {
3332
3957
  VALUE argv[1];
3333
3958
 
3334
3959
  // location
@@ -3338,14 +3963,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3338
3963
  break;
3339
3964
  }
3340
3965
  #line 137 "api_node.c.erb"
3341
- case YP_NODE_RETURN_NODE: {
3966
+ case YP_RETURN_NODE: {
3342
3967
  yp_return_node_t *cast = (yp_return_node_t *) node;
3343
3968
  VALUE argv[3];
3344
3969
 
3345
3970
  // keyword_loc
3971
+ #line 173 "api_node.c.erb"
3346
3972
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3347
3973
 
3348
3974
  // arguments
3975
+ #line 148 "api_node.c.erb"
3349
3976
  argv[1] = rb_ary_pop(value_stack);
3350
3977
 
3351
3978
  // location
@@ -3355,7 +3982,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3355
3982
  break;
3356
3983
  }
3357
3984
  #line 137 "api_node.c.erb"
3358
- case YP_NODE_SELF_NODE: {
3985
+ case YP_SELF_NODE: {
3359
3986
  VALUE argv[1];
3360
3987
 
3361
3988
  // location
@@ -3365,29 +3992,36 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3365
3992
  break;
3366
3993
  }
3367
3994
  #line 137 "api_node.c.erb"
3368
- case YP_NODE_SINGLETON_CLASS_NODE: {
3995
+ case YP_SINGLETON_CLASS_NODE: {
3369
3996
  yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
3370
3997
  VALUE argv[7];
3371
3998
 
3372
3999
  // locals
4000
+ #line 166 "api_node.c.erb"
3373
4001
  argv[0] = rb_ary_new_capa(cast->locals.size);
3374
4002
  for (size_t index = 0; index < cast->locals.size; index++) {
4003
+ assert(cast->locals.ids[index] != 0);
3375
4004
  rb_ary_push(argv[0], rb_id2sym(constants[cast->locals.ids[index] - 1]));
3376
4005
  }
3377
4006
 
3378
4007
  // class_keyword_loc
4008
+ #line 173 "api_node.c.erb"
3379
4009
  argv[1] = yp_location_new(parser, cast->class_keyword_loc.start, cast->class_keyword_loc.end, source);
3380
4010
 
3381
4011
  // operator_loc
4012
+ #line 173 "api_node.c.erb"
3382
4013
  argv[2] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3383
4014
 
3384
4015
  // expression
4016
+ #line 148 "api_node.c.erb"
3385
4017
  argv[3] = rb_ary_pop(value_stack);
3386
4018
 
3387
4019
  // body
4020
+ #line 148 "api_node.c.erb"
3388
4021
  argv[4] = rb_ary_pop(value_stack);
3389
4022
 
3390
4023
  // end_keyword_loc
4024
+ #line 173 "api_node.c.erb"
3391
4025
  argv[5] = yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
3392
4026
 
3393
4027
  // location
@@ -3397,7 +4031,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3397
4031
  break;
3398
4032
  }
3399
4033
  #line 137 "api_node.c.erb"
3400
- case YP_NODE_SOURCE_ENCODING_NODE: {
4034
+ case YP_SOURCE_ENCODING_NODE: {
3401
4035
  VALUE argv[1];
3402
4036
 
3403
4037
  // location
@@ -3407,11 +4041,12 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3407
4041
  break;
3408
4042
  }
3409
4043
  #line 137 "api_node.c.erb"
3410
- case YP_NODE_SOURCE_FILE_NODE: {
4044
+ case YP_SOURCE_FILE_NODE: {
3411
4045
  yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
3412
4046
  VALUE argv[2];
3413
4047
 
3414
4048
  // filepath
4049
+ #line 157 "api_node.c.erb"
3415
4050
  argv[0] = yp_string_new(&cast->filepath, encoding);
3416
4051
 
3417
4052
  // location
@@ -3421,7 +4056,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3421
4056
  break;
3422
4057
  }
3423
4058
  #line 137 "api_node.c.erb"
3424
- case YP_NODE_SOURCE_LINE_NODE: {
4059
+ case YP_SOURCE_LINE_NODE: {
3425
4060
  VALUE argv[1];
3426
4061
 
3427
4062
  // location
@@ -3431,14 +4066,16 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3431
4066
  break;
3432
4067
  }
3433
4068
  #line 137 "api_node.c.erb"
3434
- case YP_NODE_SPLAT_NODE: {
4069
+ case YP_SPLAT_NODE: {
3435
4070
  yp_splat_node_t *cast = (yp_splat_node_t *) node;
3436
4071
  VALUE argv[3];
3437
4072
 
3438
4073
  // operator_loc
4074
+ #line 173 "api_node.c.erb"
3439
4075
  argv[0] = yp_location_new(parser, cast->operator_loc.start, cast->operator_loc.end, source);
3440
4076
 
3441
4077
  // expression
4078
+ #line 148 "api_node.c.erb"
3442
4079
  argv[1] = rb_ary_pop(value_stack);
3443
4080
 
3444
4081
  // location
@@ -3448,11 +4085,12 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3448
4085
  break;
3449
4086
  }
3450
4087
  #line 137 "api_node.c.erb"
3451
- case YP_NODE_STATEMENTS_NODE: {
4088
+ case YP_STATEMENTS_NODE: {
3452
4089
  yp_statements_node_t *cast = (yp_statements_node_t *) node;
3453
4090
  VALUE argv[2];
3454
4091
 
3455
4092
  // body
4093
+ #line 151 "api_node.c.erb"
3456
4094
  argv[0] = rb_ary_new_capa(cast->body.size);
3457
4095
  for (size_t index = 0; index < cast->body.size; index++) {
3458
4096
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
@@ -3465,13 +4103,15 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3465
4103
  break;
3466
4104
  }
3467
4105
  #line 137 "api_node.c.erb"
3468
- case YP_NODE_STRING_CONCAT_NODE: {
4106
+ case YP_STRING_CONCAT_NODE: {
3469
4107
  VALUE argv[3];
3470
4108
 
3471
4109
  // left
4110
+ #line 148 "api_node.c.erb"
3472
4111
  argv[0] = rb_ary_pop(value_stack);
3473
4112
 
3474
4113
  // right
4114
+ #line 148 "api_node.c.erb"
3475
4115
  argv[1] = rb_ary_pop(value_stack);
3476
4116
 
3477
4117
  // location
@@ -3481,20 +4121,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3481
4121
  break;
3482
4122
  }
3483
4123
  #line 137 "api_node.c.erb"
3484
- case YP_NODE_STRING_NODE: {
4124
+ case YP_STRING_NODE: {
3485
4125
  yp_string_node_t *cast = (yp_string_node_t *) node;
3486
4126
  VALUE argv[5];
3487
4127
 
3488
4128
  // opening_loc
4129
+ #line 176 "api_node.c.erb"
3489
4130
  argv[0] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3490
4131
 
3491
4132
  // content_loc
4133
+ #line 173 "api_node.c.erb"
3492
4134
  argv[1] = yp_location_new(parser, cast->content_loc.start, cast->content_loc.end, source);
3493
4135
 
3494
4136
  // closing_loc
4137
+ #line 176 "api_node.c.erb"
3495
4138
  argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3496
4139
 
3497
4140
  // unescaped
4141
+ #line 157 "api_node.c.erb"
3498
4142
  argv[3] = yp_string_new(&cast->unescaped, encoding);
3499
4143
 
3500
4144
  // location
@@ -3504,23 +4148,28 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3504
4148
  break;
3505
4149
  }
3506
4150
  #line 137 "api_node.c.erb"
3507
- case YP_NODE_SUPER_NODE: {
4151
+ case YP_SUPER_NODE: {
3508
4152
  yp_super_node_t *cast = (yp_super_node_t *) node;
3509
4153
  VALUE argv[6];
3510
4154
 
3511
4155
  // keyword_loc
4156
+ #line 173 "api_node.c.erb"
3512
4157
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3513
4158
 
3514
4159
  // lparen_loc
4160
+ #line 176 "api_node.c.erb"
3515
4161
  argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
3516
4162
 
3517
4163
  // arguments
4164
+ #line 148 "api_node.c.erb"
3518
4165
  argv[2] = rb_ary_pop(value_stack);
3519
4166
 
3520
4167
  // rparen_loc
4168
+ #line 176 "api_node.c.erb"
3521
4169
  argv[3] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3522
4170
 
3523
4171
  // block
4172
+ #line 148 "api_node.c.erb"
3524
4173
  argv[4] = rb_ary_pop(value_stack);
3525
4174
 
3526
4175
  // location
@@ -3530,20 +4179,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3530
4179
  break;
3531
4180
  }
3532
4181
  #line 137 "api_node.c.erb"
3533
- case YP_NODE_SYMBOL_NODE: {
4182
+ case YP_SYMBOL_NODE: {
3534
4183
  yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
3535
4184
  VALUE argv[5];
3536
4185
 
3537
4186
  // opening_loc
4187
+ #line 176 "api_node.c.erb"
3538
4188
  argv[0] = cast->opening_loc.start == NULL ? Qnil : yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3539
4189
 
3540
4190
  // value_loc
4191
+ #line 176 "api_node.c.erb"
3541
4192
  argv[1] = cast->value_loc.start == NULL ? Qnil : yp_location_new(parser, cast->value_loc.start, cast->value_loc.end, source);
3542
4193
 
3543
4194
  // closing_loc
4195
+ #line 176 "api_node.c.erb"
3544
4196
  argv[2] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3545
4197
 
3546
4198
  // unescaped
4199
+ #line 157 "api_node.c.erb"
3547
4200
  argv[3] = yp_string_new(&cast->unescaped, encoding);
3548
4201
 
3549
4202
  // location
@@ -3553,7 +4206,7 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3553
4206
  break;
3554
4207
  }
3555
4208
  #line 137 "api_node.c.erb"
3556
- case YP_NODE_TRUE_NODE: {
4209
+ case YP_TRUE_NODE: {
3557
4210
  VALUE argv[1];
3558
4211
 
3559
4212
  // location
@@ -3563,17 +4216,19 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3563
4216
  break;
3564
4217
  }
3565
4218
  #line 137 "api_node.c.erb"
3566
- case YP_NODE_UNDEF_NODE: {
4219
+ case YP_UNDEF_NODE: {
3567
4220
  yp_undef_node_t *cast = (yp_undef_node_t *) node;
3568
4221
  VALUE argv[3];
3569
4222
 
3570
4223
  // names
4224
+ #line 151 "api_node.c.erb"
3571
4225
  argv[0] = rb_ary_new_capa(cast->names.size);
3572
4226
  for (size_t index = 0; index < cast->names.size; index++) {
3573
4227
  rb_ary_push(argv[0], rb_ary_pop(value_stack));
3574
4228
  }
3575
4229
 
3576
4230
  // keyword_loc
4231
+ #line 173 "api_node.c.erb"
3577
4232
  argv[1] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3578
4233
 
3579
4234
  // location
@@ -3583,23 +4238,28 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3583
4238
  break;
3584
4239
  }
3585
4240
  #line 137 "api_node.c.erb"
3586
- case YP_NODE_UNLESS_NODE: {
4241
+ case YP_UNLESS_NODE: {
3587
4242
  yp_unless_node_t *cast = (yp_unless_node_t *) node;
3588
4243
  VALUE argv[6];
3589
4244
 
3590
4245
  // keyword_loc
4246
+ #line 173 "api_node.c.erb"
3591
4247
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3592
4248
 
3593
4249
  // predicate
4250
+ #line 148 "api_node.c.erb"
3594
4251
  argv[1] = rb_ary_pop(value_stack);
3595
4252
 
3596
4253
  // statements
4254
+ #line 148 "api_node.c.erb"
3597
4255
  argv[2] = rb_ary_pop(value_stack);
3598
4256
 
3599
4257
  // consequent
4258
+ #line 148 "api_node.c.erb"
3600
4259
  argv[3] = rb_ary_pop(value_stack);
3601
4260
 
3602
4261
  // end_keyword_loc
4262
+ #line 176 "api_node.c.erb"
3603
4263
  argv[4] = cast->end_keyword_loc.start == NULL ? Qnil : yp_location_new(parser, cast->end_keyword_loc.start, cast->end_keyword_loc.end, source);
3604
4264
 
3605
4265
  // location
@@ -3609,23 +4269,28 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3609
4269
  break;
3610
4270
  }
3611
4271
  #line 137 "api_node.c.erb"
3612
- case YP_NODE_UNTIL_NODE: {
4272
+ case YP_UNTIL_NODE: {
3613
4273
  yp_until_node_t *cast = (yp_until_node_t *) node;
3614
4274
  VALUE argv[6];
3615
4275
 
3616
4276
  // keyword_loc
4277
+ #line 173 "api_node.c.erb"
3617
4278
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3618
4279
 
3619
4280
  // closing_loc
4281
+ #line 176 "api_node.c.erb"
3620
4282
  argv[1] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3621
4283
 
3622
4284
  // predicate
4285
+ #line 148 "api_node.c.erb"
3623
4286
  argv[2] = rb_ary_pop(value_stack);
3624
4287
 
3625
4288
  // statements
4289
+ #line 148 "api_node.c.erb"
3626
4290
  argv[3] = rb_ary_pop(value_stack);
3627
4291
 
3628
4292
  // flags
4293
+ #line 182 "api_node.c.erb"
3629
4294
  argv[4] = ULONG2NUM(node->flags >> 1);
3630
4295
 
3631
4296
  // location
@@ -3635,20 +4300,23 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3635
4300
  break;
3636
4301
  }
3637
4302
  #line 137 "api_node.c.erb"
3638
- case YP_NODE_WHEN_NODE: {
4303
+ case YP_WHEN_NODE: {
3639
4304
  yp_when_node_t *cast = (yp_when_node_t *) node;
3640
4305
  VALUE argv[4];
3641
4306
 
3642
4307
  // keyword_loc
4308
+ #line 173 "api_node.c.erb"
3643
4309
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3644
4310
 
3645
4311
  // conditions
4312
+ #line 151 "api_node.c.erb"
3646
4313
  argv[1] = rb_ary_new_capa(cast->conditions.size);
3647
4314
  for (size_t index = 0; index < cast->conditions.size; index++) {
3648
4315
  rb_ary_push(argv[1], rb_ary_pop(value_stack));
3649
4316
  }
3650
4317
 
3651
4318
  // statements
4319
+ #line 148 "api_node.c.erb"
3652
4320
  argv[2] = rb_ary_pop(value_stack);
3653
4321
 
3654
4322
  // location
@@ -3658,23 +4326,28 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3658
4326
  break;
3659
4327
  }
3660
4328
  #line 137 "api_node.c.erb"
3661
- case YP_NODE_WHILE_NODE: {
4329
+ case YP_WHILE_NODE: {
3662
4330
  yp_while_node_t *cast = (yp_while_node_t *) node;
3663
4331
  VALUE argv[6];
3664
4332
 
3665
4333
  // keyword_loc
4334
+ #line 173 "api_node.c.erb"
3666
4335
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3667
4336
 
3668
4337
  // closing_loc
4338
+ #line 176 "api_node.c.erb"
3669
4339
  argv[1] = cast->closing_loc.start == NULL ? Qnil : yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3670
4340
 
3671
4341
  // predicate
4342
+ #line 148 "api_node.c.erb"
3672
4343
  argv[2] = rb_ary_pop(value_stack);
3673
4344
 
3674
4345
  // statements
4346
+ #line 148 "api_node.c.erb"
3675
4347
  argv[3] = rb_ary_pop(value_stack);
3676
4348
 
3677
4349
  // flags
4350
+ #line 182 "api_node.c.erb"
3678
4351
  argv[4] = ULONG2NUM(node->flags >> 1);
3679
4352
 
3680
4353
  // location
@@ -3684,20 +4357,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3684
4357
  break;
3685
4358
  }
3686
4359
  #line 137 "api_node.c.erb"
3687
- case YP_NODE_X_STRING_NODE: {
4360
+ case YP_X_STRING_NODE: {
3688
4361
  yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
3689
4362
  VALUE argv[5];
3690
4363
 
3691
4364
  // opening_loc
4365
+ #line 173 "api_node.c.erb"
3692
4366
  argv[0] = yp_location_new(parser, cast->opening_loc.start, cast->opening_loc.end, source);
3693
4367
 
3694
4368
  // content_loc
4369
+ #line 173 "api_node.c.erb"
3695
4370
  argv[1] = yp_location_new(parser, cast->content_loc.start, cast->content_loc.end, source);
3696
4371
 
3697
4372
  // closing_loc
4373
+ #line 173 "api_node.c.erb"
3698
4374
  argv[2] = yp_location_new(parser, cast->closing_loc.start, cast->closing_loc.end, source);
3699
4375
 
3700
4376
  // unescaped
4377
+ #line 157 "api_node.c.erb"
3701
4378
  argv[3] = yp_string_new(&cast->unescaped, encoding);
3702
4379
 
3703
4380
  // location
@@ -3707,20 +4384,24 @@ yp_ast_new(yp_parser_t *parser, yp_node_t *node, rb_encoding *encoding) {
3707
4384
  break;
3708
4385
  }
3709
4386
  #line 137 "api_node.c.erb"
3710
- case YP_NODE_YIELD_NODE: {
4387
+ case YP_YIELD_NODE: {
3711
4388
  yp_yield_node_t *cast = (yp_yield_node_t *) node;
3712
4389
  VALUE argv[5];
3713
4390
 
3714
4391
  // keyword_loc
4392
+ #line 173 "api_node.c.erb"
3715
4393
  argv[0] = yp_location_new(parser, cast->keyword_loc.start, cast->keyword_loc.end, source);
3716
4394
 
3717
4395
  // lparen_loc
4396
+ #line 176 "api_node.c.erb"
3718
4397
  argv[1] = cast->lparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->lparen_loc.start, cast->lparen_loc.end, source);
3719
4398
 
3720
4399
  // arguments
4400
+ #line 148 "api_node.c.erb"
3721
4401
  argv[2] = rb_ary_pop(value_stack);
3722
4402
 
3723
4403
  // rparen_loc
4404
+ #line 176 "api_node.c.erb"
3724
4405
  argv[3] = cast->rparen_loc.start == NULL ? Qnil : yp_location_new(parser, cast->rparen_loc.start, cast->rparen_loc.end, source);
3725
4406
 
3726
4407
  // location
@@ -3753,14 +4434,15 @@ Init_yarp_api_node(void) {
3753
4434
  rb_cYARPBackReferenceReadNode = rb_define_class_under(rb_cYARP, "BackReferenceReadNode", rb_cYARPNode);
3754
4435
  rb_cYARPBeginNode = rb_define_class_under(rb_cYARP, "BeginNode", rb_cYARPNode);
3755
4436
  rb_cYARPBlockArgumentNode = rb_define_class_under(rb_cYARP, "BlockArgumentNode", rb_cYARPNode);
4437
+ rb_cYARPBlockLocalVariableNode = rb_define_class_under(rb_cYARP, "BlockLocalVariableNode", rb_cYARPNode);
3756
4438
  rb_cYARPBlockNode = rb_define_class_under(rb_cYARP, "BlockNode", rb_cYARPNode);
3757
4439
  rb_cYARPBlockParameterNode = rb_define_class_under(rb_cYARP, "BlockParameterNode", rb_cYARPNode);
3758
4440
  rb_cYARPBlockParametersNode = rb_define_class_under(rb_cYARP, "BlockParametersNode", rb_cYARPNode);
3759
4441
  rb_cYARPBreakNode = rb_define_class_under(rb_cYARP, "BreakNode", rb_cYARPNode);
4442
+ rb_cYARPCallAndWriteNode = rb_define_class_under(rb_cYARP, "CallAndWriteNode", rb_cYARPNode);
3760
4443
  rb_cYARPCallNode = rb_define_class_under(rb_cYARP, "CallNode", rb_cYARPNode);
3761
- rb_cYARPCallOperatorAndWriteNode = rb_define_class_under(rb_cYARP, "CallOperatorAndWriteNode", rb_cYARPNode);
3762
- rb_cYARPCallOperatorOrWriteNode = rb_define_class_under(rb_cYARP, "CallOperatorOrWriteNode", rb_cYARPNode);
3763
4444
  rb_cYARPCallOperatorWriteNode = rb_define_class_under(rb_cYARP, "CallOperatorWriteNode", rb_cYARPNode);
4445
+ rb_cYARPCallOrWriteNode = rb_define_class_under(rb_cYARP, "CallOrWriteNode", rb_cYARPNode);
3764
4446
  rb_cYARPCapturePatternNode = rb_define_class_under(rb_cYARP, "CapturePatternNode", rb_cYARPNode);
3765
4447
  rb_cYARPCaseNode = rb_define_class_under(rb_cYARP, "CaseNode", rb_cYARPNode);
3766
4448
  rb_cYARPClassNode = rb_define_class_under(rb_cYARP, "ClassNode", rb_cYARPNode);
@@ -3832,6 +4514,7 @@ Init_yarp_api_node(void) {
3832
4514
  rb_cYARPMatchRequiredNode = rb_define_class_under(rb_cYARP, "MatchRequiredNode", rb_cYARPNode);
3833
4515
  rb_cYARPMissingNode = rb_define_class_under(rb_cYARP, "MissingNode", rb_cYARPNode);
3834
4516
  rb_cYARPModuleNode = rb_define_class_under(rb_cYARP, "ModuleNode", rb_cYARPNode);
4517
+ rb_cYARPMultiTargetNode = rb_define_class_under(rb_cYARP, "MultiTargetNode", rb_cYARPNode);
3835
4518
  rb_cYARPMultiWriteNode = rb_define_class_under(rb_cYARP, "MultiWriteNode", rb_cYARPNode);
3836
4519
  rb_cYARPNextNode = rb_define_class_under(rb_cYARP, "NextNode", rb_cYARPNode);
3837
4520
  rb_cYARPNilNode = rb_define_class_under(rb_cYARP, "NilNode", rb_cYARPNode);