yarp 0.8.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (33) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +34 -1
  3. data/README.md +4 -3
  4. data/config.yml +332 -52
  5. data/docs/configuration.md +1 -0
  6. data/docs/ruby_api.md +2 -0
  7. data/docs/serialization.md +1 -1
  8. data/docs/testing.md +2 -2
  9. data/ext/yarp/api_node.c +703 -136
  10. data/ext/yarp/extension.c +73 -24
  11. data/ext/yarp/extension.h +2 -2
  12. data/include/yarp/ast.h +331 -137
  13. data/include/yarp/node.h +10 -0
  14. data/include/yarp/unescape.h +4 -2
  15. data/include/yarp/util/yp_newline_list.h +3 -0
  16. data/include/yarp/version.h +2 -2
  17. data/include/yarp.h +10 -0
  18. data/lib/yarp/desugar_visitor.rb +267 -0
  19. data/lib/yarp/ffi.rb +27 -1
  20. data/lib/yarp/lex_compat.rb +93 -25
  21. data/lib/yarp/mutation_visitor.rb +683 -0
  22. data/lib/yarp/node.rb +3042 -508
  23. data/lib/yarp/serialize.rb +198 -126
  24. data/lib/yarp.rb +48 -2
  25. data/src/node.c +421 -185
  26. data/src/prettyprint.c +262 -80
  27. data/src/serialize.c +410 -270
  28. data/src/token_type.c +2 -2
  29. data/src/unescape.c +69 -51
  30. data/src/util/yp_newline_list.c +10 -0
  31. data/src/yarp.c +1208 -458
  32. data/yarp.gemspec +3 -1
  33. metadata +4 -2
data/src/node.c CHANGED
@@ -1,6 +1,6 @@
1
1
  /******************************************************************************/
2
- /* This file is generated by the bin/template script and should not be */
3
- /* modified manually. See */
2
+ /* This file is generated by the templates/template.rb script and should not */
3
+ /* be modified manually. See */
4
4
  /* templates/src/node.c.erb */
5
5
  /* if you are looking to modify the */
6
6
  /* template */
@@ -98,11 +98,6 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
98
98
  yp_node_destroy(parser, (yp_node_t *)((yp_and_node_t *)node)->left);
99
99
  yp_node_destroy(parser, (yp_node_t *)((yp_and_node_t *)node)->right);
100
100
  break;
101
- #line 81 "node.c.erb"
102
- case YP_NODE_AND_WRITE_NODE:
103
- yp_node_destroy(parser, (yp_node_t *)((yp_and_write_node_t *)node)->target);
104
- yp_node_destroy(parser, (yp_node_t *)((yp_and_write_node_t *)node)->value);
105
- break;
106
101
  #line 81 "node.c.erb"
107
102
  case YP_NODE_ARGUMENTS_NODE:
108
103
  yp_node_list_free(parser, &((yp_arguments_node_t *)node)->arguments);
@@ -238,16 +233,49 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
238
233
  if (((yp_class_node_t *)node)->body != NULL) {
239
234
  yp_node_destroy(parser, (yp_node_t *)((yp_class_node_t *)node)->body);
240
235
  }
236
+ yp_string_free(&((yp_class_node_t *)node)->name);
237
+ break;
238
+ #line 81 "node.c.erb"
239
+ case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE:
240
+ yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_and_write_node_t *)node)->value);
241
+ break;
242
+ #line 81 "node.c.erb"
243
+ case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
244
+ yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_operator_write_node_t *)node)->value);
245
+ break;
246
+ #line 81 "node.c.erb"
247
+ case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE:
248
+ yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_or_write_node_t *)node)->value);
241
249
  break;
242
250
  #line 81 "node.c.erb"
243
251
  case YP_NODE_CLASS_VARIABLE_READ_NODE:
244
252
  break;
253
+ #line 81 "node.c.erb"
254
+ case YP_NODE_CLASS_VARIABLE_TARGET_NODE:
255
+ break;
245
256
  #line 81 "node.c.erb"
246
257
  case YP_NODE_CLASS_VARIABLE_WRITE_NODE:
247
258
  if (((yp_class_variable_write_node_t *)node)->value != NULL) {
248
259
  yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_write_node_t *)node)->value);
249
260
  }
250
261
  break;
262
+ #line 81 "node.c.erb"
263
+ case YP_NODE_CONSTANT_AND_WRITE_NODE:
264
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_and_write_node_t *)node)->value);
265
+ break;
266
+ #line 81 "node.c.erb"
267
+ case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE:
268
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_operator_write_node_t *)node)->value);
269
+ break;
270
+ #line 81 "node.c.erb"
271
+ case YP_NODE_CONSTANT_OR_WRITE_NODE:
272
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_or_write_node_t *)node)->value);
273
+ break;
274
+ #line 81 "node.c.erb"
275
+ case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE:
276
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->target);
277
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->value);
278
+ break;
251
279
  #line 81 "node.c.erb"
252
280
  case YP_NODE_CONSTANT_PATH_NODE:
253
281
  if (((yp_constant_path_node_t *)node)->parent != NULL) {
@@ -255,21 +283,37 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
255
283
  }
256
284
  yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_node_t *)node)->child);
257
285
  break;
286
+ #line 81 "node.c.erb"
287
+ case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE:
288
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target);
289
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value);
290
+ break;
291
+ #line 81 "node.c.erb"
292
+ case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE:
293
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->target);
294
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->value);
295
+ break;
296
+ #line 81 "node.c.erb"
297
+ case YP_NODE_CONSTANT_PATH_TARGET_NODE:
298
+ if (((yp_constant_path_target_node_t *)node)->parent != NULL) {
299
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_target_node_t *)node)->parent);
300
+ }
301
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_target_node_t *)node)->child);
302
+ break;
258
303
  #line 81 "node.c.erb"
259
304
  case YP_NODE_CONSTANT_PATH_WRITE_NODE:
260
305
  yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->target);
261
- if (((yp_constant_path_write_node_t *)node)->value != NULL) {
262
- yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->value);
263
- }
306
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->value);
264
307
  break;
265
308
  #line 81 "node.c.erb"
266
309
  case YP_NODE_CONSTANT_READ_NODE:
267
310
  break;
311
+ #line 81 "node.c.erb"
312
+ case YP_NODE_CONSTANT_TARGET_NODE:
313
+ break;
268
314
  #line 81 "node.c.erb"
269
315
  case YP_NODE_CONSTANT_WRITE_NODE:
270
- if (((yp_constant_write_node_t *)node)->value != NULL) {
271
- yp_node_destroy(parser, (yp_node_t *)((yp_constant_write_node_t *)node)->value);
272
- }
316
+ yp_node_destroy(parser, (yp_node_t *)((yp_constant_write_node_t *)node)->value);
273
317
  break;
274
318
  #line 81 "node.c.erb"
275
319
  case YP_NODE_DEF_NODE:
@@ -354,14 +398,27 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
354
398
  yp_node_destroy(parser, (yp_node_t *)((yp_forwarding_super_node_t *)node)->block);
355
399
  }
356
400
  break;
401
+ #line 81 "node.c.erb"
402
+ case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE:
403
+ yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_and_write_node_t *)node)->value);
404
+ break;
405
+ #line 81 "node.c.erb"
406
+ case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
407
+ yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value);
408
+ break;
409
+ #line 81 "node.c.erb"
410
+ case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE:
411
+ yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_or_write_node_t *)node)->value);
412
+ break;
357
413
  #line 81 "node.c.erb"
358
414
  case YP_NODE_GLOBAL_VARIABLE_READ_NODE:
359
415
  break;
416
+ #line 81 "node.c.erb"
417
+ case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE:
418
+ break;
360
419
  #line 81 "node.c.erb"
361
420
  case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE:
362
- if (((yp_global_variable_write_node_t *)node)->value != NULL) {
363
- yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_write_node_t *)node)->value);
364
- }
421
+ yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_write_node_t *)node)->value);
365
422
  break;
366
423
  #line 81 "node.c.erb"
367
424
  case YP_NODE_HASH_NODE:
@@ -398,14 +455,27 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
398
455
  yp_node_destroy(parser, (yp_node_t *)((yp_in_node_t *)node)->statements);
399
456
  }
400
457
  break;
458
+ #line 81 "node.c.erb"
459
+ case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE:
460
+ yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_and_write_node_t *)node)->value);
461
+ break;
462
+ #line 81 "node.c.erb"
463
+ case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
464
+ yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_operator_write_node_t *)node)->value);
465
+ break;
466
+ #line 81 "node.c.erb"
467
+ case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE:
468
+ yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_or_write_node_t *)node)->value);
469
+ break;
401
470
  #line 81 "node.c.erb"
402
471
  case YP_NODE_INSTANCE_VARIABLE_READ_NODE:
403
472
  break;
473
+ #line 81 "node.c.erb"
474
+ case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE:
475
+ break;
404
476
  #line 81 "node.c.erb"
405
477
  case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE:
406
- if (((yp_instance_variable_write_node_t *)node)->value != NULL) {
407
- yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_write_node_t *)node)->value);
408
- }
478
+ yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_write_node_t *)node)->value);
409
479
  break;
410
480
  #line 81 "node.c.erb"
411
481
  case YP_NODE_INTEGER_NODE:
@@ -449,14 +519,27 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
449
519
  yp_node_destroy(parser, (yp_node_t *)((yp_lambda_node_t *)node)->body);
450
520
  }
451
521
  break;
522
+ #line 81 "node.c.erb"
523
+ case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE:
524
+ yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_and_write_node_t *)node)->value);
525
+ break;
526
+ #line 81 "node.c.erb"
527
+ case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
528
+ yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value);
529
+ break;
530
+ #line 81 "node.c.erb"
531
+ case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE:
532
+ yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_or_write_node_t *)node)->value);
533
+ break;
452
534
  #line 81 "node.c.erb"
453
535
  case YP_NODE_LOCAL_VARIABLE_READ_NODE:
454
536
  break;
537
+ #line 81 "node.c.erb"
538
+ case YP_NODE_LOCAL_VARIABLE_TARGET_NODE:
539
+ break;
455
540
  #line 81 "node.c.erb"
456
541
  case YP_NODE_LOCAL_VARIABLE_WRITE_NODE:
457
- if (((yp_local_variable_write_node_t *)node)->value != NULL) {
458
- yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_write_node_t *)node)->value);
459
- }
542
+ yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_write_node_t *)node)->value);
460
543
  break;
461
544
  #line 81 "node.c.erb"
462
545
  case YP_NODE_MATCH_PREDICATE_NODE:
@@ -478,6 +561,7 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
478
561
  if (((yp_module_node_t *)node)->body != NULL) {
479
562
  yp_node_destroy(parser, (yp_node_t *)((yp_module_node_t *)node)->body);
480
563
  }
564
+ yp_string_free(&((yp_module_node_t *)node)->name);
481
565
  break;
482
566
  #line 81 "node.c.erb"
483
567
  case YP_NODE_MULTI_WRITE_NODE:
@@ -501,11 +585,6 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
501
585
  #line 81 "node.c.erb"
502
586
  case YP_NODE_NUMBERED_REFERENCE_READ_NODE:
503
587
  break;
504
- #line 81 "node.c.erb"
505
- case YP_NODE_OPERATOR_WRITE_NODE:
506
- yp_node_destroy(parser, (yp_node_t *)((yp_operator_write_node_t *)node)->target);
507
- yp_node_destroy(parser, (yp_node_t *)((yp_operator_write_node_t *)node)->value);
508
- break;
509
588
  #line 81 "node.c.erb"
510
589
  case YP_NODE_OPTIONAL_PARAMETER_NODE:
511
590
  yp_node_destroy(parser, (yp_node_t *)((yp_optional_parameter_node_t *)node)->value);
@@ -515,11 +594,6 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
515
594
  yp_node_destroy(parser, (yp_node_t *)((yp_or_node_t *)node)->left);
516
595
  yp_node_destroy(parser, (yp_node_t *)((yp_or_node_t *)node)->right);
517
596
  break;
518
- #line 81 "node.c.erb"
519
- case YP_NODE_OR_WRITE_NODE:
520
- yp_node_destroy(parser, (yp_node_t *)((yp_or_write_node_t *)node)->target);
521
- yp_node_destroy(parser, (yp_node_t *)((yp_or_write_node_t *)node)->value);
522
- break;
523
597
  #line 81 "node.c.erb"
524
598
  case YP_NODE_PARAMETERS_NODE:
525
599
  yp_node_list_free(parser, &((yp_parameters_node_t *)node)->requireds);
@@ -738,47 +812,44 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
738
812
  memsize->node_count++;
739
813
 
740
814
  switch (YP_NODE_TYPE(node)) {
741
- #line 120 "node.c.erb"
815
+ // We do not calculate memsize of a ScopeNode
816
+ // as it should never be generated
817
+ case YP_NODE_SCOPE_NODE:
818
+ return;
819
+ #line 124 "node.c.erb"
742
820
  case YP_NODE_ALIAS_NODE: {
743
821
  memsize->memsize += sizeof(yp_alias_node_t);
744
822
  yp_node_memsize_node((yp_node_t *)((yp_alias_node_t *)node)->new_name, memsize);
745
823
  yp_node_memsize_node((yp_node_t *)((yp_alias_node_t *)node)->old_name, memsize);
746
824
  break;
747
825
  }
748
- #line 120 "node.c.erb"
826
+ #line 124 "node.c.erb"
749
827
  case YP_NODE_ALTERNATION_PATTERN_NODE: {
750
828
  memsize->memsize += sizeof(yp_alternation_pattern_node_t);
751
829
  yp_node_memsize_node((yp_node_t *)((yp_alternation_pattern_node_t *)node)->left, memsize);
752
830
  yp_node_memsize_node((yp_node_t *)((yp_alternation_pattern_node_t *)node)->right, memsize);
753
831
  break;
754
832
  }
755
- #line 120 "node.c.erb"
833
+ #line 124 "node.c.erb"
756
834
  case YP_NODE_AND_NODE: {
757
835
  memsize->memsize += sizeof(yp_and_node_t);
758
836
  yp_node_memsize_node((yp_node_t *)((yp_and_node_t *)node)->left, memsize);
759
837
  yp_node_memsize_node((yp_node_t *)((yp_and_node_t *)node)->right, memsize);
760
838
  break;
761
839
  }
762
- #line 120 "node.c.erb"
763
- case YP_NODE_AND_WRITE_NODE: {
764
- memsize->memsize += sizeof(yp_and_write_node_t);
765
- yp_node_memsize_node((yp_node_t *)((yp_and_write_node_t *)node)->target, memsize);
766
- yp_node_memsize_node((yp_node_t *)((yp_and_write_node_t *)node)->value, memsize);
767
- break;
768
- }
769
- #line 120 "node.c.erb"
840
+ #line 124 "node.c.erb"
770
841
  case YP_NODE_ARGUMENTS_NODE: {
771
842
  memsize->memsize += sizeof(yp_arguments_node_t);
772
843
  yp_node_list_memsize(&((yp_arguments_node_t *)node)->arguments, memsize);
773
844
  break;
774
845
  }
775
- #line 120 "node.c.erb"
846
+ #line 124 "node.c.erb"
776
847
  case YP_NODE_ARRAY_NODE: {
777
848
  memsize->memsize += sizeof(yp_array_node_t);
778
849
  yp_node_list_memsize(&((yp_array_node_t *)node)->elements, memsize);
779
850
  break;
780
851
  }
781
- #line 120 "node.c.erb"
852
+ #line 124 "node.c.erb"
782
853
  case YP_NODE_ARRAY_PATTERN_NODE: {
783
854
  memsize->memsize += sizeof(yp_array_pattern_node_t);
784
855
  if (((yp_array_pattern_node_t *)node)->constant != NULL) {
@@ -791,7 +862,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
791
862
  yp_node_list_memsize(&((yp_array_pattern_node_t *)node)->posts, memsize);
792
863
  break;
793
864
  }
794
- #line 120 "node.c.erb"
865
+ #line 124 "node.c.erb"
795
866
  case YP_NODE_ASSOC_NODE: {
796
867
  memsize->memsize += sizeof(yp_assoc_node_t);
797
868
  yp_node_memsize_node((yp_node_t *)((yp_assoc_node_t *)node)->key, memsize);
@@ -800,7 +871,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
800
871
  }
801
872
  break;
802
873
  }
803
- #line 120 "node.c.erb"
874
+ #line 124 "node.c.erb"
804
875
  case YP_NODE_ASSOC_SPLAT_NODE: {
805
876
  memsize->memsize += sizeof(yp_assoc_splat_node_t);
806
877
  if (((yp_assoc_splat_node_t *)node)->value != NULL) {
@@ -808,12 +879,12 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
808
879
  }
809
880
  break;
810
881
  }
811
- #line 120 "node.c.erb"
882
+ #line 124 "node.c.erb"
812
883
  case YP_NODE_BACK_REFERENCE_READ_NODE: {
813
884
  memsize->memsize += sizeof(yp_back_reference_read_node_t);
814
885
  break;
815
886
  }
816
- #line 120 "node.c.erb"
887
+ #line 124 "node.c.erb"
817
888
  case YP_NODE_BEGIN_NODE: {
818
889
  memsize->memsize += sizeof(yp_begin_node_t);
819
890
  if (((yp_begin_node_t *)node)->statements != NULL) {
@@ -830,7 +901,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
830
901
  }
831
902
  break;
832
903
  }
833
- #line 120 "node.c.erb"
904
+ #line 124 "node.c.erb"
834
905
  case YP_NODE_BLOCK_ARGUMENT_NODE: {
835
906
  memsize->memsize += sizeof(yp_block_argument_node_t);
836
907
  if (((yp_block_argument_node_t *)node)->expression != NULL) {
@@ -838,7 +909,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
838
909
  }
839
910
  break;
840
911
  }
841
- #line 120 "node.c.erb"
912
+ #line 124 "node.c.erb"
842
913
  case YP_NODE_BLOCK_NODE: {
843
914
  memsize->memsize += sizeof(yp_block_node_t);
844
915
  memsize->memsize += yp_constant_id_list_memsize(&((yp_block_node_t *)node)->locals);
@@ -850,12 +921,12 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
850
921
  }
851
922
  break;
852
923
  }
853
- #line 120 "node.c.erb"
924
+ #line 124 "node.c.erb"
854
925
  case YP_NODE_BLOCK_PARAMETER_NODE: {
855
926
  memsize->memsize += sizeof(yp_block_parameter_node_t);
856
927
  break;
857
928
  }
858
- #line 120 "node.c.erb"
929
+ #line 124 "node.c.erb"
859
930
  case YP_NODE_BLOCK_PARAMETERS_NODE: {
860
931
  memsize->memsize += sizeof(yp_block_parameters_node_t);
861
932
  if (((yp_block_parameters_node_t *)node)->parameters != NULL) {
@@ -864,7 +935,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
864
935
  memsize->memsize += yp_location_list_memsize(&((yp_block_parameters_node_t *)node)->locals);
865
936
  break;
866
937
  }
867
- #line 120 "node.c.erb"
938
+ #line 124 "node.c.erb"
868
939
  case YP_NODE_BREAK_NODE: {
869
940
  memsize->memsize += sizeof(yp_break_node_t);
870
941
  if (((yp_break_node_t *)node)->arguments != NULL) {
@@ -872,7 +943,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
872
943
  }
873
944
  break;
874
945
  }
875
- #line 120 "node.c.erb"
946
+ #line 124 "node.c.erb"
876
947
  case YP_NODE_CALL_NODE: {
877
948
  memsize->memsize += sizeof(yp_call_node_t);
878
949
  if (((yp_call_node_t *)node)->receiver != NULL) {
@@ -887,35 +958,35 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
887
958
  memsize->memsize += yp_string_memsize(&((yp_call_node_t *)node)->name);
888
959
  break;
889
960
  }
890
- #line 120 "node.c.erb"
961
+ #line 124 "node.c.erb"
891
962
  case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
892
963
  memsize->memsize += sizeof(yp_call_operator_and_write_node_t);
893
964
  yp_node_memsize_node((yp_node_t *)((yp_call_operator_and_write_node_t *)node)->target, memsize);
894
965
  yp_node_memsize_node((yp_node_t *)((yp_call_operator_and_write_node_t *)node)->value, memsize);
895
966
  break;
896
967
  }
897
- #line 120 "node.c.erb"
968
+ #line 124 "node.c.erb"
898
969
  case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
899
970
  memsize->memsize += sizeof(yp_call_operator_or_write_node_t);
900
971
  yp_node_memsize_node((yp_node_t *)((yp_call_operator_or_write_node_t *)node)->target, memsize);
901
972
  yp_node_memsize_node((yp_node_t *)((yp_call_operator_or_write_node_t *)node)->value, memsize);
902
973
  break;
903
974
  }
904
- #line 120 "node.c.erb"
975
+ #line 124 "node.c.erb"
905
976
  case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
906
977
  memsize->memsize += sizeof(yp_call_operator_write_node_t);
907
978
  yp_node_memsize_node((yp_node_t *)((yp_call_operator_write_node_t *)node)->target, memsize);
908
979
  yp_node_memsize_node((yp_node_t *)((yp_call_operator_write_node_t *)node)->value, memsize);
909
980
  break;
910
981
  }
911
- #line 120 "node.c.erb"
982
+ #line 124 "node.c.erb"
912
983
  case YP_NODE_CAPTURE_PATTERN_NODE: {
913
984
  memsize->memsize += sizeof(yp_capture_pattern_node_t);
914
985
  yp_node_memsize_node((yp_node_t *)((yp_capture_pattern_node_t *)node)->value, memsize);
915
986
  yp_node_memsize_node((yp_node_t *)((yp_capture_pattern_node_t *)node)->target, memsize);
916
987
  break;
917
988
  }
918
- #line 120 "node.c.erb"
989
+ #line 124 "node.c.erb"
919
990
  case YP_NODE_CASE_NODE: {
920
991
  memsize->memsize += sizeof(yp_case_node_t);
921
992
  if (((yp_case_node_t *)node)->predicate != NULL) {
@@ -927,7 +998,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
927
998
  }
928
999
  break;
929
1000
  }
930
- #line 120 "node.c.erb"
1001
+ #line 124 "node.c.erb"
931
1002
  case YP_NODE_CLASS_NODE: {
932
1003
  memsize->memsize += sizeof(yp_class_node_t);
933
1004
  memsize->memsize += yp_constant_id_list_memsize(&((yp_class_node_t *)node)->locals);
@@ -938,14 +1009,38 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
938
1009
  if (((yp_class_node_t *)node)->body != NULL) {
939
1010
  yp_node_memsize_node((yp_node_t *)((yp_class_node_t *)node)->body, memsize);
940
1011
  }
1012
+ memsize->memsize += yp_string_memsize(&((yp_class_node_t *)node)->name);
1013
+ break;
1014
+ }
1015
+ #line 124 "node.c.erb"
1016
+ case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
1017
+ memsize->memsize += sizeof(yp_class_variable_and_write_node_t);
1018
+ yp_node_memsize_node((yp_node_t *)((yp_class_variable_and_write_node_t *)node)->value, memsize);
1019
+ break;
1020
+ }
1021
+ #line 124 "node.c.erb"
1022
+ case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1023
+ memsize->memsize += sizeof(yp_class_variable_operator_write_node_t);
1024
+ yp_node_memsize_node((yp_node_t *)((yp_class_variable_operator_write_node_t *)node)->value, memsize);
1025
+ break;
1026
+ }
1027
+ #line 124 "node.c.erb"
1028
+ case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
1029
+ memsize->memsize += sizeof(yp_class_variable_or_write_node_t);
1030
+ yp_node_memsize_node((yp_node_t *)((yp_class_variable_or_write_node_t *)node)->value, memsize);
941
1031
  break;
942
1032
  }
943
- #line 120 "node.c.erb"
1033
+ #line 124 "node.c.erb"
944
1034
  case YP_NODE_CLASS_VARIABLE_READ_NODE: {
945
1035
  memsize->memsize += sizeof(yp_class_variable_read_node_t);
946
1036
  break;
947
1037
  }
948
- #line 120 "node.c.erb"
1038
+ #line 124 "node.c.erb"
1039
+ case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
1040
+ memsize->memsize += sizeof(yp_class_variable_target_node_t);
1041
+ break;
1042
+ }
1043
+ #line 124 "node.c.erb"
949
1044
  case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
950
1045
  memsize->memsize += sizeof(yp_class_variable_write_node_t);
951
1046
  if (((yp_class_variable_write_node_t *)node)->value != NULL) {
@@ -953,7 +1048,32 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
953
1048
  }
954
1049
  break;
955
1050
  }
956
- #line 120 "node.c.erb"
1051
+ #line 124 "node.c.erb"
1052
+ case YP_NODE_CONSTANT_AND_WRITE_NODE: {
1053
+ memsize->memsize += sizeof(yp_constant_and_write_node_t);
1054
+ yp_node_memsize_node((yp_node_t *)((yp_constant_and_write_node_t *)node)->value, memsize);
1055
+ break;
1056
+ }
1057
+ #line 124 "node.c.erb"
1058
+ case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
1059
+ memsize->memsize += sizeof(yp_constant_operator_write_node_t);
1060
+ yp_node_memsize_node((yp_node_t *)((yp_constant_operator_write_node_t *)node)->value, memsize);
1061
+ break;
1062
+ }
1063
+ #line 124 "node.c.erb"
1064
+ case YP_NODE_CONSTANT_OR_WRITE_NODE: {
1065
+ memsize->memsize += sizeof(yp_constant_or_write_node_t);
1066
+ yp_node_memsize_node((yp_node_t *)((yp_constant_or_write_node_t *)node)->value, memsize);
1067
+ break;
1068
+ }
1069
+ #line 124 "node.c.erb"
1070
+ case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
1071
+ memsize->memsize += sizeof(yp_constant_path_and_write_node_t);
1072
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_and_write_node_t *)node)->target, memsize);
1073
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_and_write_node_t *)node)->value, memsize);
1074
+ break;
1075
+ }
1076
+ #line 124 "node.c.erb"
957
1077
  case YP_NODE_CONSTANT_PATH_NODE: {
958
1078
  memsize->memsize += sizeof(yp_constant_path_node_t);
959
1079
  if (((yp_constant_path_node_t *)node)->parent != NULL) {
@@ -962,29 +1082,53 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
962
1082
  yp_node_memsize_node((yp_node_t *)((yp_constant_path_node_t *)node)->child, memsize);
963
1083
  break;
964
1084
  }
965
- #line 120 "node.c.erb"
1085
+ #line 124 "node.c.erb"
1086
+ case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1087
+ memsize->memsize += sizeof(yp_constant_path_operator_write_node_t);
1088
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target, memsize);
1089
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value, memsize);
1090
+ break;
1091
+ }
1092
+ #line 124 "node.c.erb"
1093
+ case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
1094
+ memsize->memsize += sizeof(yp_constant_path_or_write_node_t);
1095
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_or_write_node_t *)node)->target, memsize);
1096
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_or_write_node_t *)node)->value, memsize);
1097
+ break;
1098
+ }
1099
+ #line 124 "node.c.erb"
1100
+ case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
1101
+ memsize->memsize += sizeof(yp_constant_path_target_node_t);
1102
+ if (((yp_constant_path_target_node_t *)node)->parent != NULL) {
1103
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_target_node_t *)node)->parent, memsize);
1104
+ }
1105
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_target_node_t *)node)->child, memsize);
1106
+ break;
1107
+ }
1108
+ #line 124 "node.c.erb"
966
1109
  case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
967
1110
  memsize->memsize += sizeof(yp_constant_path_write_node_t);
968
1111
  yp_node_memsize_node((yp_node_t *)((yp_constant_path_write_node_t *)node)->target, memsize);
969
- if (((yp_constant_path_write_node_t *)node)->value != NULL) {
970
- yp_node_memsize_node((yp_node_t *)((yp_constant_path_write_node_t *)node)->value, memsize);
971
- }
1112
+ yp_node_memsize_node((yp_node_t *)((yp_constant_path_write_node_t *)node)->value, memsize);
972
1113
  break;
973
1114
  }
974
- #line 120 "node.c.erb"
1115
+ #line 124 "node.c.erb"
975
1116
  case YP_NODE_CONSTANT_READ_NODE: {
976
1117
  memsize->memsize += sizeof(yp_constant_read_node_t);
977
1118
  break;
978
1119
  }
979
- #line 120 "node.c.erb"
1120
+ #line 124 "node.c.erb"
1121
+ case YP_NODE_CONSTANT_TARGET_NODE: {
1122
+ memsize->memsize += sizeof(yp_constant_target_node_t);
1123
+ break;
1124
+ }
1125
+ #line 124 "node.c.erb"
980
1126
  case YP_NODE_CONSTANT_WRITE_NODE: {
981
1127
  memsize->memsize += sizeof(yp_constant_write_node_t);
982
- if (((yp_constant_write_node_t *)node)->value != NULL) {
983
- yp_node_memsize_node((yp_node_t *)((yp_constant_write_node_t *)node)->value, memsize);
984
- }
1128
+ yp_node_memsize_node((yp_node_t *)((yp_constant_write_node_t *)node)->value, memsize);
985
1129
  break;
986
1130
  }
987
- #line 120 "node.c.erb"
1131
+ #line 124 "node.c.erb"
988
1132
  case YP_NODE_DEF_NODE: {
989
1133
  memsize->memsize += sizeof(yp_def_node_t);
990
1134
  if (((yp_def_node_t *)node)->receiver != NULL) {
@@ -999,13 +1143,13 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
999
1143
  memsize->memsize += yp_constant_id_list_memsize(&((yp_def_node_t *)node)->locals);
1000
1144
  break;
1001
1145
  }
1002
- #line 120 "node.c.erb"
1146
+ #line 124 "node.c.erb"
1003
1147
  case YP_NODE_DEFINED_NODE: {
1004
1148
  memsize->memsize += sizeof(yp_defined_node_t);
1005
1149
  yp_node_memsize_node((yp_node_t *)((yp_defined_node_t *)node)->value, memsize);
1006
1150
  break;
1007
1151
  }
1008
- #line 120 "node.c.erb"
1152
+ #line 124 "node.c.erb"
1009
1153
  case YP_NODE_ELSE_NODE: {
1010
1154
  memsize->memsize += sizeof(yp_else_node_t);
1011
1155
  if (((yp_else_node_t *)node)->statements != NULL) {
@@ -1013,7 +1157,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1013
1157
  }
1014
1158
  break;
1015
1159
  }
1016
- #line 120 "node.c.erb"
1160
+ #line 124 "node.c.erb"
1017
1161
  case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
1018
1162
  memsize->memsize += sizeof(yp_embedded_statements_node_t);
1019
1163
  if (((yp_embedded_statements_node_t *)node)->statements != NULL) {
@@ -1021,13 +1165,13 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1021
1165
  }
1022
1166
  break;
1023
1167
  }
1024
- #line 120 "node.c.erb"
1168
+ #line 124 "node.c.erb"
1025
1169
  case YP_NODE_EMBEDDED_VARIABLE_NODE: {
1026
1170
  memsize->memsize += sizeof(yp_embedded_variable_node_t);
1027
1171
  yp_node_memsize_node((yp_node_t *)((yp_embedded_variable_node_t *)node)->variable, memsize);
1028
1172
  break;
1029
1173
  }
1030
- #line 120 "node.c.erb"
1174
+ #line 124 "node.c.erb"
1031
1175
  case YP_NODE_ENSURE_NODE: {
1032
1176
  memsize->memsize += sizeof(yp_ensure_node_t);
1033
1177
  if (((yp_ensure_node_t *)node)->statements != NULL) {
@@ -1035,12 +1179,12 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1035
1179
  }
1036
1180
  break;
1037
1181
  }
1038
- #line 120 "node.c.erb"
1182
+ #line 124 "node.c.erb"
1039
1183
  case YP_NODE_FALSE_NODE: {
1040
1184
  memsize->memsize += sizeof(yp_false_node_t);
1041
1185
  break;
1042
1186
  }
1043
- #line 120 "node.c.erb"
1187
+ #line 124 "node.c.erb"
1044
1188
  case YP_NODE_FIND_PATTERN_NODE: {
1045
1189
  memsize->memsize += sizeof(yp_find_pattern_node_t);
1046
1190
  if (((yp_find_pattern_node_t *)node)->constant != NULL) {
@@ -1051,7 +1195,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1051
1195
  yp_node_memsize_node((yp_node_t *)((yp_find_pattern_node_t *)node)->right, memsize);
1052
1196
  break;
1053
1197
  }
1054
- #line 120 "node.c.erb"
1198
+ #line 124 "node.c.erb"
1055
1199
  case YP_NODE_FLIP_FLOP_NODE: {
1056
1200
  memsize->memsize += sizeof(yp_flip_flop_node_t);
1057
1201
  if (((yp_flip_flop_node_t *)node)->left != NULL) {
@@ -1062,12 +1206,12 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1062
1206
  }
1063
1207
  break;
1064
1208
  }
1065
- #line 120 "node.c.erb"
1209
+ #line 124 "node.c.erb"
1066
1210
  case YP_NODE_FLOAT_NODE: {
1067
1211
  memsize->memsize += sizeof(yp_float_node_t);
1068
1212
  break;
1069
1213
  }
1070
- #line 120 "node.c.erb"
1214
+ #line 124 "node.c.erb"
1071
1215
  case YP_NODE_FOR_NODE: {
1072
1216
  memsize->memsize += sizeof(yp_for_node_t);
1073
1217
  yp_node_memsize_node((yp_node_t *)((yp_for_node_t *)node)->index, memsize);
@@ -1077,17 +1221,17 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1077
1221
  }
1078
1222
  break;
1079
1223
  }
1080
- #line 120 "node.c.erb"
1224
+ #line 124 "node.c.erb"
1081
1225
  case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
1082
1226
  memsize->memsize += sizeof(yp_forwarding_arguments_node_t);
1083
1227
  break;
1084
1228
  }
1085
- #line 120 "node.c.erb"
1229
+ #line 124 "node.c.erb"
1086
1230
  case YP_NODE_FORWARDING_PARAMETER_NODE: {
1087
1231
  memsize->memsize += sizeof(yp_forwarding_parameter_node_t);
1088
1232
  break;
1089
1233
  }
1090
- #line 120 "node.c.erb"
1234
+ #line 124 "node.c.erb"
1091
1235
  case YP_NODE_FORWARDING_SUPER_NODE: {
1092
1236
  memsize->memsize += sizeof(yp_forwarding_super_node_t);
1093
1237
  if (((yp_forwarding_super_node_t *)node)->block != NULL) {
@@ -1095,26 +1239,47 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1095
1239
  }
1096
1240
  break;
1097
1241
  }
1098
- #line 120 "node.c.erb"
1242
+ #line 124 "node.c.erb"
1243
+ case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
1244
+ memsize->memsize += sizeof(yp_global_variable_and_write_node_t);
1245
+ yp_node_memsize_node((yp_node_t *)((yp_global_variable_and_write_node_t *)node)->value, memsize);
1246
+ break;
1247
+ }
1248
+ #line 124 "node.c.erb"
1249
+ case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
1250
+ memsize->memsize += sizeof(yp_global_variable_operator_write_node_t);
1251
+ yp_node_memsize_node((yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value, memsize);
1252
+ break;
1253
+ }
1254
+ #line 124 "node.c.erb"
1255
+ case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
1256
+ memsize->memsize += sizeof(yp_global_variable_or_write_node_t);
1257
+ yp_node_memsize_node((yp_node_t *)((yp_global_variable_or_write_node_t *)node)->value, memsize);
1258
+ break;
1259
+ }
1260
+ #line 124 "node.c.erb"
1099
1261
  case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
1100
1262
  memsize->memsize += sizeof(yp_global_variable_read_node_t);
1101
1263
  break;
1102
1264
  }
1103
- #line 120 "node.c.erb"
1265
+ #line 124 "node.c.erb"
1266
+ case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
1267
+ memsize->memsize += sizeof(yp_global_variable_target_node_t);
1268
+ break;
1269
+ }
1270
+ #line 124 "node.c.erb"
1104
1271
  case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
1105
1272
  memsize->memsize += sizeof(yp_global_variable_write_node_t);
1106
- if (((yp_global_variable_write_node_t *)node)->value != NULL) {
1107
- yp_node_memsize_node((yp_node_t *)((yp_global_variable_write_node_t *)node)->value, memsize);
1108
- }
1273
+ yp_node_memsize_node((yp_node_t *)((yp_global_variable_write_node_t *)node)->value, memsize);
1109
1274
  break;
1110
1275
  }
1111
- #line 120 "node.c.erb"
1276
+ #line 124 "node.c.erb"
1112
1277
  case YP_NODE_HASH_NODE: {
1113
1278
  memsize->memsize += sizeof(yp_hash_node_t);
1114
1279
  yp_node_list_memsize(&((yp_hash_node_t *)node)->elements, memsize);
1115
1280
  break;
1116
1281
  }
1117
- #line 120 "node.c.erb"
1282
+ #line 124 "node.c.erb"
1118
1283
  case YP_NODE_HASH_PATTERN_NODE: {
1119
1284
  memsize->memsize += sizeof(yp_hash_pattern_node_t);
1120
1285
  if (((yp_hash_pattern_node_t *)node)->constant != NULL) {
@@ -1126,7 +1291,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1126
1291
  }
1127
1292
  break;
1128
1293
  }
1129
- #line 120 "node.c.erb"
1294
+ #line 124 "node.c.erb"
1130
1295
  case YP_NODE_IF_NODE: {
1131
1296
  memsize->memsize += sizeof(yp_if_node_t);
1132
1297
  yp_node_memsize_node((yp_node_t *)((yp_if_node_t *)node)->predicate, memsize);
@@ -1138,13 +1303,13 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1138
1303
  }
1139
1304
  break;
1140
1305
  }
1141
- #line 120 "node.c.erb"
1306
+ #line 124 "node.c.erb"
1142
1307
  case YP_NODE_IMAGINARY_NODE: {
1143
1308
  memsize->memsize += sizeof(yp_imaginary_node_t);
1144
1309
  yp_node_memsize_node((yp_node_t *)((yp_imaginary_node_t *)node)->numeric, memsize);
1145
1310
  break;
1146
1311
  }
1147
- #line 120 "node.c.erb"
1312
+ #line 124 "node.c.erb"
1148
1313
  case YP_NODE_IN_NODE: {
1149
1314
  memsize->memsize += sizeof(yp_in_node_t);
1150
1315
  yp_node_memsize_node((yp_node_t *)((yp_in_node_t *)node)->pattern, memsize);
@@ -1153,55 +1318,76 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1153
1318
  }
1154
1319
  break;
1155
1320
  }
1156
- #line 120 "node.c.erb"
1321
+ #line 124 "node.c.erb"
1322
+ case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1323
+ memsize->memsize += sizeof(yp_instance_variable_and_write_node_t);
1324
+ yp_node_memsize_node((yp_node_t *)((yp_instance_variable_and_write_node_t *)node)->value, memsize);
1325
+ break;
1326
+ }
1327
+ #line 124 "node.c.erb"
1328
+ case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1329
+ memsize->memsize += sizeof(yp_instance_variable_operator_write_node_t);
1330
+ yp_node_memsize_node((yp_node_t *)((yp_instance_variable_operator_write_node_t *)node)->value, memsize);
1331
+ break;
1332
+ }
1333
+ #line 124 "node.c.erb"
1334
+ case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1335
+ memsize->memsize += sizeof(yp_instance_variable_or_write_node_t);
1336
+ yp_node_memsize_node((yp_node_t *)((yp_instance_variable_or_write_node_t *)node)->value, memsize);
1337
+ break;
1338
+ }
1339
+ #line 124 "node.c.erb"
1157
1340
  case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
1158
1341
  memsize->memsize += sizeof(yp_instance_variable_read_node_t);
1159
1342
  break;
1160
1343
  }
1161
- #line 120 "node.c.erb"
1344
+ #line 124 "node.c.erb"
1345
+ case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
1346
+ memsize->memsize += sizeof(yp_instance_variable_target_node_t);
1347
+ break;
1348
+ }
1349
+ #line 124 "node.c.erb"
1162
1350
  case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
1163
1351
  memsize->memsize += sizeof(yp_instance_variable_write_node_t);
1164
- if (((yp_instance_variable_write_node_t *)node)->value != NULL) {
1165
- yp_node_memsize_node((yp_node_t *)((yp_instance_variable_write_node_t *)node)->value, memsize);
1166
- }
1352
+ yp_node_memsize_node((yp_node_t *)((yp_instance_variable_write_node_t *)node)->value, memsize);
1167
1353
  break;
1168
1354
  }
1169
- #line 120 "node.c.erb"
1355
+ #line 124 "node.c.erb"
1170
1356
  case YP_NODE_INTEGER_NODE: {
1171
1357
  memsize->memsize += sizeof(yp_integer_node_t);
1172
1358
  break;
1173
1359
  }
1174
- #line 120 "node.c.erb"
1360
+ #line 124 "node.c.erb"
1175
1361
  case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1176
1362
  memsize->memsize += sizeof(yp_interpolated_regular_expression_node_t);
1177
1363
  yp_node_list_memsize(&((yp_interpolated_regular_expression_node_t *)node)->parts, memsize);
1178
1364
  break;
1179
1365
  }
1180
- #line 120 "node.c.erb"
1366
+ #line 124 "node.c.erb"
1181
1367
  case YP_NODE_INTERPOLATED_STRING_NODE: {
1182
1368
  memsize->memsize += sizeof(yp_interpolated_string_node_t);
1183
1369
  yp_node_list_memsize(&((yp_interpolated_string_node_t *)node)->parts, memsize);
1184
1370
  break;
1185
1371
  }
1186
- #line 120 "node.c.erb"
1372
+ #line 124 "node.c.erb"
1187
1373
  case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
1188
1374
  memsize->memsize += sizeof(yp_interpolated_symbol_node_t);
1189
1375
  yp_node_list_memsize(&((yp_interpolated_symbol_node_t *)node)->parts, memsize);
1190
1376
  break;
1191
1377
  }
1192
- #line 120 "node.c.erb"
1378
+ #line 124 "node.c.erb"
1193
1379
  case YP_NODE_INTERPOLATED_X_STRING_NODE: {
1194
1380
  memsize->memsize += sizeof(yp_interpolated_x_string_node_t);
1195
1381
  yp_node_list_memsize(&((yp_interpolated_x_string_node_t *)node)->parts, memsize);
1196
1382
  break;
1197
1383
  }
1198
- #line 120 "node.c.erb"
1384
+ #line 124 "node.c.erb"
1199
1385
  case YP_NODE_KEYWORD_HASH_NODE: {
1200
1386
  memsize->memsize += sizeof(yp_keyword_hash_node_t);
1201
1387
  yp_node_list_memsize(&((yp_keyword_hash_node_t *)node)->elements, memsize);
1202
1388
  break;
1203
1389
  }
1204
- #line 120 "node.c.erb"
1390
+ #line 124 "node.c.erb"
1205
1391
  case YP_NODE_KEYWORD_PARAMETER_NODE: {
1206
1392
  memsize->memsize += sizeof(yp_keyword_parameter_node_t);
1207
1393
  if (((yp_keyword_parameter_node_t *)node)->value != NULL) {
@@ -1209,12 +1395,12 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1209
1395
  }
1210
1396
  break;
1211
1397
  }
1212
- #line 120 "node.c.erb"
1398
+ #line 124 "node.c.erb"
1213
1399
  case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
1214
1400
  memsize->memsize += sizeof(yp_keyword_rest_parameter_node_t);
1215
1401
  break;
1216
1402
  }
1217
- #line 120 "node.c.erb"
1403
+ #line 124 "node.c.erb"
1218
1404
  case YP_NODE_LAMBDA_NODE: {
1219
1405
  memsize->memsize += sizeof(yp_lambda_node_t);
1220
1406
  memsize->memsize += yp_constant_id_list_memsize(&((yp_lambda_node_t *)node)->locals);
@@ -1226,39 +1412,60 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1226
1412
  }
1227
1413
  break;
1228
1414
  }
1229
- #line 120 "node.c.erb"
1415
+ #line 124 "node.c.erb"
1416
+ case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
1417
+ memsize->memsize += sizeof(yp_local_variable_and_write_node_t);
1418
+ yp_node_memsize_node((yp_node_t *)((yp_local_variable_and_write_node_t *)node)->value, memsize);
1419
+ break;
1420
+ }
1421
+ #line 124 "node.c.erb"
1422
+ case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1423
+ memsize->memsize += sizeof(yp_local_variable_operator_write_node_t);
1424
+ yp_node_memsize_node((yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value, memsize);
1425
+ break;
1426
+ }
1427
+ #line 124 "node.c.erb"
1428
+ case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
1429
+ memsize->memsize += sizeof(yp_local_variable_or_write_node_t);
1430
+ yp_node_memsize_node((yp_node_t *)((yp_local_variable_or_write_node_t *)node)->value, memsize);
1431
+ break;
1432
+ }
1433
+ #line 124 "node.c.erb"
1230
1434
  case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
1231
1435
  memsize->memsize += sizeof(yp_local_variable_read_node_t);
1232
1436
  break;
1233
1437
  }
1234
- #line 120 "node.c.erb"
1438
+ #line 124 "node.c.erb"
1439
+ case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
1440
+ memsize->memsize += sizeof(yp_local_variable_target_node_t);
1441
+ break;
1442
+ }
1443
+ #line 124 "node.c.erb"
1235
1444
  case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
1236
1445
  memsize->memsize += sizeof(yp_local_variable_write_node_t);
1237
- if (((yp_local_variable_write_node_t *)node)->value != NULL) {
1238
- yp_node_memsize_node((yp_node_t *)((yp_local_variable_write_node_t *)node)->value, memsize);
1239
- }
1446
+ yp_node_memsize_node((yp_node_t *)((yp_local_variable_write_node_t *)node)->value, memsize);
1240
1447
  break;
1241
1448
  }
1242
- #line 120 "node.c.erb"
1449
+ #line 124 "node.c.erb"
1243
1450
  case YP_NODE_MATCH_PREDICATE_NODE: {
1244
1451
  memsize->memsize += sizeof(yp_match_predicate_node_t);
1245
1452
  yp_node_memsize_node((yp_node_t *)((yp_match_predicate_node_t *)node)->value, memsize);
1246
1453
  yp_node_memsize_node((yp_node_t *)((yp_match_predicate_node_t *)node)->pattern, memsize);
1247
1454
  break;
1248
1455
  }
1249
- #line 120 "node.c.erb"
1456
+ #line 124 "node.c.erb"
1250
1457
  case YP_NODE_MATCH_REQUIRED_NODE: {
1251
1458
  memsize->memsize += sizeof(yp_match_required_node_t);
1252
1459
  yp_node_memsize_node((yp_node_t *)((yp_match_required_node_t *)node)->value, memsize);
1253
1460
  yp_node_memsize_node((yp_node_t *)((yp_match_required_node_t *)node)->pattern, memsize);
1254
1461
  break;
1255
1462
  }
1256
- #line 120 "node.c.erb"
1463
+ #line 124 "node.c.erb"
1257
1464
  case YP_NODE_MISSING_NODE: {
1258
1465
  memsize->memsize += sizeof(yp_missing_node_t);
1259
1466
  break;
1260
1467
  }
1261
- #line 120 "node.c.erb"
1468
+ #line 124 "node.c.erb"
1262
1469
  case YP_NODE_MODULE_NODE: {
1263
1470
  memsize->memsize += sizeof(yp_module_node_t);
1264
1471
  memsize->memsize += yp_constant_id_list_memsize(&((yp_module_node_t *)node)->locals);
@@ -1266,9 +1473,10 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1266
1473
  if (((yp_module_node_t *)node)->body != NULL) {
1267
1474
  yp_node_memsize_node((yp_node_t *)((yp_module_node_t *)node)->body, memsize);
1268
1475
  }
1476
+ memsize->memsize += yp_string_memsize(&((yp_module_node_t *)node)->name);
1269
1477
  break;
1270
1478
  }
1271
- #line 120 "node.c.erb"
1479
+ #line 124 "node.c.erb"
1272
1480
  case YP_NODE_MULTI_WRITE_NODE: {
1273
1481
  memsize->memsize += sizeof(yp_multi_write_node_t);
1274
1482
  yp_node_list_memsize(&((yp_multi_write_node_t *)node)->targets, memsize);
@@ -1277,7 +1485,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1277
1485
  }
1278
1486
  break;
1279
1487
  }
1280
- #line 120 "node.c.erb"
1488
+ #line 124 "node.c.erb"
1281
1489
  case YP_NODE_NEXT_NODE: {
1282
1490
  memsize->memsize += sizeof(yp_next_node_t);
1283
1491
  if (((yp_next_node_t *)node)->arguments != NULL) {
@@ -1285,49 +1493,35 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1285
1493
  }
1286
1494
  break;
1287
1495
  }
1288
- #line 120 "node.c.erb"
1496
+ #line 124 "node.c.erb"
1289
1497
  case YP_NODE_NIL_NODE: {
1290
1498
  memsize->memsize += sizeof(yp_nil_node_t);
1291
1499
  break;
1292
1500
  }
1293
- #line 120 "node.c.erb"
1501
+ #line 124 "node.c.erb"
1294
1502
  case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
1295
1503
  memsize->memsize += sizeof(yp_no_keywords_parameter_node_t);
1296
1504
  break;
1297
1505
  }
1298
- #line 120 "node.c.erb"
1506
+ #line 124 "node.c.erb"
1299
1507
  case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
1300
1508
  memsize->memsize += sizeof(yp_numbered_reference_read_node_t);
1301
1509
  break;
1302
1510
  }
1303
- #line 120 "node.c.erb"
1304
- case YP_NODE_OPERATOR_WRITE_NODE: {
1305
- memsize->memsize += sizeof(yp_operator_write_node_t);
1306
- yp_node_memsize_node((yp_node_t *)((yp_operator_write_node_t *)node)->target, memsize);
1307
- yp_node_memsize_node((yp_node_t *)((yp_operator_write_node_t *)node)->value, memsize);
1308
- break;
1309
- }
1310
- #line 120 "node.c.erb"
1511
+ #line 124 "node.c.erb"
1311
1512
  case YP_NODE_OPTIONAL_PARAMETER_NODE: {
1312
1513
  memsize->memsize += sizeof(yp_optional_parameter_node_t);
1313
1514
  yp_node_memsize_node((yp_node_t *)((yp_optional_parameter_node_t *)node)->value, memsize);
1314
1515
  break;
1315
1516
  }
1316
- #line 120 "node.c.erb"
1517
+ #line 124 "node.c.erb"
1317
1518
  case YP_NODE_OR_NODE: {
1318
1519
  memsize->memsize += sizeof(yp_or_node_t);
1319
1520
  yp_node_memsize_node((yp_node_t *)((yp_or_node_t *)node)->left, memsize);
1320
1521
  yp_node_memsize_node((yp_node_t *)((yp_or_node_t *)node)->right, memsize);
1321
1522
  break;
1322
1523
  }
1323
- #line 120 "node.c.erb"
1324
- case YP_NODE_OR_WRITE_NODE: {
1325
- memsize->memsize += sizeof(yp_or_write_node_t);
1326
- yp_node_memsize_node((yp_node_t *)((yp_or_write_node_t *)node)->target, memsize);
1327
- yp_node_memsize_node((yp_node_t *)((yp_or_write_node_t *)node)->value, memsize);
1328
- break;
1329
- }
1330
- #line 120 "node.c.erb"
1524
+ #line 124 "node.c.erb"
1331
1525
  case YP_NODE_PARAMETERS_NODE: {
1332
1526
  memsize->memsize += sizeof(yp_parameters_node_t);
1333
1527
  yp_node_list_memsize(&((yp_parameters_node_t *)node)->requireds, memsize);
@@ -1345,7 +1539,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1345
1539
  }
1346
1540
  break;
1347
1541
  }
1348
- #line 120 "node.c.erb"
1542
+ #line 124 "node.c.erb"
1349
1543
  case YP_NODE_PARENTHESES_NODE: {
1350
1544
  memsize->memsize += sizeof(yp_parentheses_node_t);
1351
1545
  if (((yp_parentheses_node_t *)node)->body != NULL) {
@@ -1353,19 +1547,19 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1353
1547
  }
1354
1548
  break;
1355
1549
  }
1356
- #line 120 "node.c.erb"
1550
+ #line 124 "node.c.erb"
1357
1551
  case YP_NODE_PINNED_EXPRESSION_NODE: {
1358
1552
  memsize->memsize += sizeof(yp_pinned_expression_node_t);
1359
1553
  yp_node_memsize_node((yp_node_t *)((yp_pinned_expression_node_t *)node)->expression, memsize);
1360
1554
  break;
1361
1555
  }
1362
- #line 120 "node.c.erb"
1556
+ #line 124 "node.c.erb"
1363
1557
  case YP_NODE_PINNED_VARIABLE_NODE: {
1364
1558
  memsize->memsize += sizeof(yp_pinned_variable_node_t);
1365
1559
  yp_node_memsize_node((yp_node_t *)((yp_pinned_variable_node_t *)node)->variable, memsize);
1366
1560
  break;
1367
1561
  }
1368
- #line 120 "node.c.erb"
1562
+ #line 124 "node.c.erb"
1369
1563
  case YP_NODE_POST_EXECUTION_NODE: {
1370
1564
  memsize->memsize += sizeof(yp_post_execution_node_t);
1371
1565
  if (((yp_post_execution_node_t *)node)->statements != NULL) {
@@ -1373,7 +1567,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1373
1567
  }
1374
1568
  break;
1375
1569
  }
1376
- #line 120 "node.c.erb"
1570
+ #line 124 "node.c.erb"
1377
1571
  case YP_NODE_PRE_EXECUTION_NODE: {
1378
1572
  memsize->memsize += sizeof(yp_pre_execution_node_t);
1379
1573
  if (((yp_pre_execution_node_t *)node)->statements != NULL) {
@@ -1381,14 +1575,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1381
1575
  }
1382
1576
  break;
1383
1577
  }
1384
- #line 120 "node.c.erb"
1578
+ #line 124 "node.c.erb"
1385
1579
  case YP_NODE_PROGRAM_NODE: {
1386
1580
  memsize->memsize += sizeof(yp_program_node_t);
1387
1581
  memsize->memsize += yp_constant_id_list_memsize(&((yp_program_node_t *)node)->locals);
1388
1582
  yp_node_memsize_node((yp_node_t *)((yp_program_node_t *)node)->statements, memsize);
1389
1583
  break;
1390
1584
  }
1391
- #line 120 "node.c.erb"
1585
+ #line 124 "node.c.erb"
1392
1586
  case YP_NODE_RANGE_NODE: {
1393
1587
  memsize->memsize += sizeof(yp_range_node_t);
1394
1588
  if (((yp_range_node_t *)node)->left != NULL) {
@@ -1399,42 +1593,42 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1399
1593
  }
1400
1594
  break;
1401
1595
  }
1402
- #line 120 "node.c.erb"
1596
+ #line 124 "node.c.erb"
1403
1597
  case YP_NODE_RATIONAL_NODE: {
1404
1598
  memsize->memsize += sizeof(yp_rational_node_t);
1405
1599
  yp_node_memsize_node((yp_node_t *)((yp_rational_node_t *)node)->numeric, memsize);
1406
1600
  break;
1407
1601
  }
1408
- #line 120 "node.c.erb"
1602
+ #line 124 "node.c.erb"
1409
1603
  case YP_NODE_REDO_NODE: {
1410
1604
  memsize->memsize += sizeof(yp_redo_node_t);
1411
1605
  break;
1412
1606
  }
1413
- #line 120 "node.c.erb"
1607
+ #line 124 "node.c.erb"
1414
1608
  case YP_NODE_REGULAR_EXPRESSION_NODE: {
1415
1609
  memsize->memsize += sizeof(yp_regular_expression_node_t);
1416
1610
  memsize->memsize += yp_string_memsize(&((yp_regular_expression_node_t *)node)->unescaped);
1417
1611
  break;
1418
1612
  }
1419
- #line 120 "node.c.erb"
1613
+ #line 124 "node.c.erb"
1420
1614
  case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
1421
1615
  memsize->memsize += sizeof(yp_required_destructured_parameter_node_t);
1422
1616
  yp_node_list_memsize(&((yp_required_destructured_parameter_node_t *)node)->parameters, memsize);
1423
1617
  break;
1424
1618
  }
1425
- #line 120 "node.c.erb"
1619
+ #line 124 "node.c.erb"
1426
1620
  case YP_NODE_REQUIRED_PARAMETER_NODE: {
1427
1621
  memsize->memsize += sizeof(yp_required_parameter_node_t);
1428
1622
  break;
1429
1623
  }
1430
- #line 120 "node.c.erb"
1624
+ #line 124 "node.c.erb"
1431
1625
  case YP_NODE_RESCUE_MODIFIER_NODE: {
1432
1626
  memsize->memsize += sizeof(yp_rescue_modifier_node_t);
1433
1627
  yp_node_memsize_node((yp_node_t *)((yp_rescue_modifier_node_t *)node)->expression, memsize);
1434
1628
  yp_node_memsize_node((yp_node_t *)((yp_rescue_modifier_node_t *)node)->rescue_expression, memsize);
1435
1629
  break;
1436
1630
  }
1437
- #line 120 "node.c.erb"
1631
+ #line 124 "node.c.erb"
1438
1632
  case YP_NODE_RESCUE_NODE: {
1439
1633
  memsize->memsize += sizeof(yp_rescue_node_t);
1440
1634
  yp_node_list_memsize(&((yp_rescue_node_t *)node)->exceptions, memsize);
@@ -1449,17 +1643,17 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1449
1643
  }
1450
1644
  break;
1451
1645
  }
1452
- #line 120 "node.c.erb"
1646
+ #line 124 "node.c.erb"
1453
1647
  case YP_NODE_REST_PARAMETER_NODE: {
1454
1648
  memsize->memsize += sizeof(yp_rest_parameter_node_t);
1455
1649
  break;
1456
1650
  }
1457
- #line 120 "node.c.erb"
1651
+ #line 124 "node.c.erb"
1458
1652
  case YP_NODE_RETRY_NODE: {
1459
1653
  memsize->memsize += sizeof(yp_retry_node_t);
1460
1654
  break;
1461
1655
  }
1462
- #line 120 "node.c.erb"
1656
+ #line 124 "node.c.erb"
1463
1657
  case YP_NODE_RETURN_NODE: {
1464
1658
  memsize->memsize += sizeof(yp_return_node_t);
1465
1659
  if (((yp_return_node_t *)node)->arguments != NULL) {
@@ -1467,12 +1661,12 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1467
1661
  }
1468
1662
  break;
1469
1663
  }
1470
- #line 120 "node.c.erb"
1664
+ #line 124 "node.c.erb"
1471
1665
  case YP_NODE_SELF_NODE: {
1472
1666
  memsize->memsize += sizeof(yp_self_node_t);
1473
1667
  break;
1474
1668
  }
1475
- #line 120 "node.c.erb"
1669
+ #line 124 "node.c.erb"
1476
1670
  case YP_NODE_SINGLETON_CLASS_NODE: {
1477
1671
  memsize->memsize += sizeof(yp_singleton_class_node_t);
1478
1672
  memsize->memsize += yp_constant_id_list_memsize(&((yp_singleton_class_node_t *)node)->locals);
@@ -1482,23 +1676,23 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1482
1676
  }
1483
1677
  break;
1484
1678
  }
1485
- #line 120 "node.c.erb"
1679
+ #line 124 "node.c.erb"
1486
1680
  case YP_NODE_SOURCE_ENCODING_NODE: {
1487
1681
  memsize->memsize += sizeof(yp_source_encoding_node_t);
1488
1682
  break;
1489
1683
  }
1490
- #line 120 "node.c.erb"
1684
+ #line 124 "node.c.erb"
1491
1685
  case YP_NODE_SOURCE_FILE_NODE: {
1492
1686
  memsize->memsize += sizeof(yp_source_file_node_t);
1493
1687
  memsize->memsize += yp_string_memsize(&((yp_source_file_node_t *)node)->filepath);
1494
1688
  break;
1495
1689
  }
1496
- #line 120 "node.c.erb"
1690
+ #line 124 "node.c.erb"
1497
1691
  case YP_NODE_SOURCE_LINE_NODE: {
1498
1692
  memsize->memsize += sizeof(yp_source_line_node_t);
1499
1693
  break;
1500
1694
  }
1501
- #line 120 "node.c.erb"
1695
+ #line 124 "node.c.erb"
1502
1696
  case YP_NODE_SPLAT_NODE: {
1503
1697
  memsize->memsize += sizeof(yp_splat_node_t);
1504
1698
  if (((yp_splat_node_t *)node)->expression != NULL) {
@@ -1506,26 +1700,26 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1506
1700
  }
1507
1701
  break;
1508
1702
  }
1509
- #line 120 "node.c.erb"
1703
+ #line 124 "node.c.erb"
1510
1704
  case YP_NODE_STATEMENTS_NODE: {
1511
1705
  memsize->memsize += sizeof(yp_statements_node_t);
1512
1706
  yp_node_list_memsize(&((yp_statements_node_t *)node)->body, memsize);
1513
1707
  break;
1514
1708
  }
1515
- #line 120 "node.c.erb"
1709
+ #line 124 "node.c.erb"
1516
1710
  case YP_NODE_STRING_CONCAT_NODE: {
1517
1711
  memsize->memsize += sizeof(yp_string_concat_node_t);
1518
1712
  yp_node_memsize_node((yp_node_t *)((yp_string_concat_node_t *)node)->left, memsize);
1519
1713
  yp_node_memsize_node((yp_node_t *)((yp_string_concat_node_t *)node)->right, memsize);
1520
1714
  break;
1521
1715
  }
1522
- #line 120 "node.c.erb"
1716
+ #line 124 "node.c.erb"
1523
1717
  case YP_NODE_STRING_NODE: {
1524
1718
  memsize->memsize += sizeof(yp_string_node_t);
1525
1719
  memsize->memsize += yp_string_memsize(&((yp_string_node_t *)node)->unescaped);
1526
1720
  break;
1527
1721
  }
1528
- #line 120 "node.c.erb"
1722
+ #line 124 "node.c.erb"
1529
1723
  case YP_NODE_SUPER_NODE: {
1530
1724
  memsize->memsize += sizeof(yp_super_node_t);
1531
1725
  if (((yp_super_node_t *)node)->arguments != NULL) {
@@ -1536,24 +1730,24 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1536
1730
  }
1537
1731
  break;
1538
1732
  }
1539
- #line 120 "node.c.erb"
1733
+ #line 124 "node.c.erb"
1540
1734
  case YP_NODE_SYMBOL_NODE: {
1541
1735
  memsize->memsize += sizeof(yp_symbol_node_t);
1542
1736
  memsize->memsize += yp_string_memsize(&((yp_symbol_node_t *)node)->unescaped);
1543
1737
  break;
1544
1738
  }
1545
- #line 120 "node.c.erb"
1739
+ #line 124 "node.c.erb"
1546
1740
  case YP_NODE_TRUE_NODE: {
1547
1741
  memsize->memsize += sizeof(yp_true_node_t);
1548
1742
  break;
1549
1743
  }
1550
- #line 120 "node.c.erb"
1744
+ #line 124 "node.c.erb"
1551
1745
  case YP_NODE_UNDEF_NODE: {
1552
1746
  memsize->memsize += sizeof(yp_undef_node_t);
1553
1747
  yp_node_list_memsize(&((yp_undef_node_t *)node)->names, memsize);
1554
1748
  break;
1555
1749
  }
1556
- #line 120 "node.c.erb"
1750
+ #line 124 "node.c.erb"
1557
1751
  case YP_NODE_UNLESS_NODE: {
1558
1752
  memsize->memsize += sizeof(yp_unless_node_t);
1559
1753
  yp_node_memsize_node((yp_node_t *)((yp_unless_node_t *)node)->predicate, memsize);
@@ -1565,7 +1759,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1565
1759
  }
1566
1760
  break;
1567
1761
  }
1568
- #line 120 "node.c.erb"
1762
+ #line 124 "node.c.erb"
1569
1763
  case YP_NODE_UNTIL_NODE: {
1570
1764
  memsize->memsize += sizeof(yp_until_node_t);
1571
1765
  yp_node_memsize_node((yp_node_t *)((yp_until_node_t *)node)->predicate, memsize);
@@ -1574,7 +1768,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1574
1768
  }
1575
1769
  break;
1576
1770
  }
1577
- #line 120 "node.c.erb"
1771
+ #line 124 "node.c.erb"
1578
1772
  case YP_NODE_WHEN_NODE: {
1579
1773
  memsize->memsize += sizeof(yp_when_node_t);
1580
1774
  yp_node_list_memsize(&((yp_when_node_t *)node)->conditions, memsize);
@@ -1583,7 +1777,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1583
1777
  }
1584
1778
  break;
1585
1779
  }
1586
- #line 120 "node.c.erb"
1780
+ #line 124 "node.c.erb"
1587
1781
  case YP_NODE_WHILE_NODE: {
1588
1782
  memsize->memsize += sizeof(yp_while_node_t);
1589
1783
  yp_node_memsize_node((yp_node_t *)((yp_while_node_t *)node)->predicate, memsize);
@@ -1592,13 +1786,13 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1592
1786
  }
1593
1787
  break;
1594
1788
  }
1595
- #line 120 "node.c.erb"
1789
+ #line 124 "node.c.erb"
1596
1790
  case YP_NODE_X_STRING_NODE: {
1597
1791
  memsize->memsize += sizeof(yp_x_string_node_t);
1598
1792
  memsize->memsize += yp_string_memsize(&((yp_x_string_node_t *)node)->unescaped);
1599
1793
  break;
1600
1794
  }
1601
- #line 120 "node.c.erb"
1795
+ #line 124 "node.c.erb"
1602
1796
  case YP_NODE_YIELD_NODE: {
1603
1797
  memsize->memsize += sizeof(yp_yield_node_t);
1604
1798
  if (((yp_yield_node_t *)node)->arguments != NULL) {
@@ -1606,7 +1800,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1606
1800
  }
1607
1801
  break;
1608
1802
  }
1609
- #line 147 "node.c.erb"
1803
+ #line 151 "node.c.erb"
1610
1804
  }
1611
1805
  }
1612
1806
 
@@ -1628,8 +1822,6 @@ yp_node_type_to_str(yp_node_type_t node_type)
1628
1822
  return "YP_NODE_ALTERNATION_PATTERN_NODE";
1629
1823
  case YP_NODE_AND_NODE:
1630
1824
  return "YP_NODE_AND_NODE";
1631
- case YP_NODE_AND_WRITE_NODE:
1632
- return "YP_NODE_AND_WRITE_NODE";
1633
1825
  case YP_NODE_ARGUMENTS_NODE:
1634
1826
  return "YP_NODE_ARGUMENTS_NODE";
1635
1827
  case YP_NODE_ARRAY_NODE:
@@ -1668,16 +1860,40 @@ yp_node_type_to_str(yp_node_type_t node_type)
1668
1860
  return "YP_NODE_CASE_NODE";
1669
1861
  case YP_NODE_CLASS_NODE:
1670
1862
  return "YP_NODE_CLASS_NODE";
1863
+ case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE:
1864
+ return "YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE";
1865
+ case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
1866
+ return "YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE";
1867
+ case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE:
1868
+ return "YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE";
1671
1869
  case YP_NODE_CLASS_VARIABLE_READ_NODE:
1672
1870
  return "YP_NODE_CLASS_VARIABLE_READ_NODE";
1871
+ case YP_NODE_CLASS_VARIABLE_TARGET_NODE:
1872
+ return "YP_NODE_CLASS_VARIABLE_TARGET_NODE";
1673
1873
  case YP_NODE_CLASS_VARIABLE_WRITE_NODE:
1674
1874
  return "YP_NODE_CLASS_VARIABLE_WRITE_NODE";
1875
+ case YP_NODE_CONSTANT_AND_WRITE_NODE:
1876
+ return "YP_NODE_CONSTANT_AND_WRITE_NODE";
1877
+ case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE:
1878
+ return "YP_NODE_CONSTANT_OPERATOR_WRITE_NODE";
1879
+ case YP_NODE_CONSTANT_OR_WRITE_NODE:
1880
+ return "YP_NODE_CONSTANT_OR_WRITE_NODE";
1881
+ case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE:
1882
+ return "YP_NODE_CONSTANT_PATH_AND_WRITE_NODE";
1675
1883
  case YP_NODE_CONSTANT_PATH_NODE:
1676
1884
  return "YP_NODE_CONSTANT_PATH_NODE";
1885
+ case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE:
1886
+ return "YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE";
1887
+ case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE:
1888
+ return "YP_NODE_CONSTANT_PATH_OR_WRITE_NODE";
1889
+ case YP_NODE_CONSTANT_PATH_TARGET_NODE:
1890
+ return "YP_NODE_CONSTANT_PATH_TARGET_NODE";
1677
1891
  case YP_NODE_CONSTANT_PATH_WRITE_NODE:
1678
1892
  return "YP_NODE_CONSTANT_PATH_WRITE_NODE";
1679
1893
  case YP_NODE_CONSTANT_READ_NODE:
1680
1894
  return "YP_NODE_CONSTANT_READ_NODE";
1895
+ case YP_NODE_CONSTANT_TARGET_NODE:
1896
+ return "YP_NODE_CONSTANT_TARGET_NODE";
1681
1897
  case YP_NODE_CONSTANT_WRITE_NODE:
1682
1898
  return "YP_NODE_CONSTANT_WRITE_NODE";
1683
1899
  case YP_NODE_DEF_NODE:
@@ -1708,8 +1924,16 @@ yp_node_type_to_str(yp_node_type_t node_type)
1708
1924
  return "YP_NODE_FORWARDING_PARAMETER_NODE";
1709
1925
  case YP_NODE_FORWARDING_SUPER_NODE:
1710
1926
  return "YP_NODE_FORWARDING_SUPER_NODE";
1927
+ case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE:
1928
+ return "YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE";
1929
+ case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
1930
+ return "YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE";
1931
+ case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE:
1932
+ return "YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE";
1711
1933
  case YP_NODE_GLOBAL_VARIABLE_READ_NODE:
1712
1934
  return "YP_NODE_GLOBAL_VARIABLE_READ_NODE";
1935
+ case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE:
1936
+ return "YP_NODE_GLOBAL_VARIABLE_TARGET_NODE";
1713
1937
  case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE:
1714
1938
  return "YP_NODE_GLOBAL_VARIABLE_WRITE_NODE";
1715
1939
  case YP_NODE_HASH_NODE:
@@ -1722,8 +1946,16 @@ yp_node_type_to_str(yp_node_type_t node_type)
1722
1946
  return "YP_NODE_IMAGINARY_NODE";
1723
1947
  case YP_NODE_IN_NODE:
1724
1948
  return "YP_NODE_IN_NODE";
1949
+ case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE:
1950
+ return "YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE";
1951
+ case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
1952
+ return "YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE";
1953
+ case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE:
1954
+ return "YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE";
1725
1955
  case YP_NODE_INSTANCE_VARIABLE_READ_NODE:
1726
1956
  return "YP_NODE_INSTANCE_VARIABLE_READ_NODE";
1957
+ case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE:
1958
+ return "YP_NODE_INSTANCE_VARIABLE_TARGET_NODE";
1727
1959
  case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE:
1728
1960
  return "YP_NODE_INSTANCE_VARIABLE_WRITE_NODE";
1729
1961
  case YP_NODE_INTEGER_NODE:
@@ -1744,8 +1976,16 @@ yp_node_type_to_str(yp_node_type_t node_type)
1744
1976
  return "YP_NODE_KEYWORD_REST_PARAMETER_NODE";
1745
1977
  case YP_NODE_LAMBDA_NODE:
1746
1978
  return "YP_NODE_LAMBDA_NODE";
1979
+ case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE:
1980
+ return "YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE";
1981
+ case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
1982
+ return "YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE";
1983
+ case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE:
1984
+ return "YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE";
1747
1985
  case YP_NODE_LOCAL_VARIABLE_READ_NODE:
1748
1986
  return "YP_NODE_LOCAL_VARIABLE_READ_NODE";
1987
+ case YP_NODE_LOCAL_VARIABLE_TARGET_NODE:
1988
+ return "YP_NODE_LOCAL_VARIABLE_TARGET_NODE";
1749
1989
  case YP_NODE_LOCAL_VARIABLE_WRITE_NODE:
1750
1990
  return "YP_NODE_LOCAL_VARIABLE_WRITE_NODE";
1751
1991
  case YP_NODE_MATCH_PREDICATE_NODE:
@@ -1766,14 +2006,10 @@ yp_node_type_to_str(yp_node_type_t node_type)
1766
2006
  return "YP_NODE_NO_KEYWORDS_PARAMETER_NODE";
1767
2007
  case YP_NODE_NUMBERED_REFERENCE_READ_NODE:
1768
2008
  return "YP_NODE_NUMBERED_REFERENCE_READ_NODE";
1769
- case YP_NODE_OPERATOR_WRITE_NODE:
1770
- return "YP_NODE_OPERATOR_WRITE_NODE";
1771
2009
  case YP_NODE_OPTIONAL_PARAMETER_NODE:
1772
2010
  return "YP_NODE_OPTIONAL_PARAMETER_NODE";
1773
2011
  case YP_NODE_OR_NODE:
1774
2012
  return "YP_NODE_OR_NODE";
1775
- case YP_NODE_OR_WRITE_NODE:
1776
- return "YP_NODE_OR_WRITE_NODE";
1777
2013
  case YP_NODE_PARAMETERS_NODE:
1778
2014
  return "YP_NODE_PARAMETERS_NODE";
1779
2015
  case YP_NODE_PARENTHESES_NODE: