yarp 0.8.0 → 0.9.0

Sign up to get free protection for your applications and to get access to all the features.
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: