prism 0.15.1 → 0.17.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 (91) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +35 -1
  3. data/Makefile +12 -0
  4. data/README.md +3 -1
  5. data/config.yml +66 -50
  6. data/docs/configuration.md +2 -0
  7. data/docs/fuzzing.md +1 -1
  8. data/docs/javascript.md +90 -0
  9. data/docs/releasing.md +27 -0
  10. data/docs/ruby_api.md +2 -0
  11. data/docs/serialization.md +28 -29
  12. data/ext/prism/api_node.c +856 -826
  13. data/ext/prism/api_pack.c +20 -9
  14. data/ext/prism/extension.c +494 -119
  15. data/ext/prism/extension.h +1 -1
  16. data/include/prism/ast.h +3157 -747
  17. data/include/prism/defines.h +40 -8
  18. data/include/prism/diagnostic.h +36 -3
  19. data/include/prism/enc/pm_encoding.h +119 -28
  20. data/include/prism/node.h +38 -30
  21. data/include/prism/options.h +204 -0
  22. data/include/prism/pack.h +44 -33
  23. data/include/prism/parser.h +445 -199
  24. data/include/prism/prettyprint.h +26 -0
  25. data/include/prism/regexp.h +16 -2
  26. data/include/prism/util/pm_buffer.h +102 -18
  27. data/include/prism/util/pm_char.h +162 -48
  28. data/include/prism/util/pm_constant_pool.h +128 -34
  29. data/include/prism/util/pm_list.h +68 -38
  30. data/include/prism/util/pm_memchr.h +18 -3
  31. data/include/prism/util/pm_newline_list.h +71 -28
  32. data/include/prism/util/pm_state_stack.h +25 -7
  33. data/include/prism/util/pm_string.h +115 -27
  34. data/include/prism/util/pm_string_list.h +25 -6
  35. data/include/prism/util/pm_strncasecmp.h +32 -0
  36. data/include/prism/util/pm_strpbrk.h +31 -17
  37. data/include/prism/version.h +28 -3
  38. data/include/prism.h +229 -36
  39. data/lib/prism/compiler.rb +5 -5
  40. data/lib/prism/debug.rb +43 -13
  41. data/lib/prism/desugar_compiler.rb +1 -1
  42. data/lib/prism/dispatcher.rb +27 -26
  43. data/lib/prism/dsl.rb +16 -16
  44. data/lib/prism/ffi.rb +138 -61
  45. data/lib/prism/lex_compat.rb +26 -16
  46. data/lib/prism/mutation_compiler.rb +11 -11
  47. data/lib/prism/node.rb +426 -227
  48. data/lib/prism/node_ext.rb +23 -16
  49. data/lib/prism/node_inspector.rb +1 -1
  50. data/lib/prism/pack.rb +79 -40
  51. data/lib/prism/parse_result/comments.rb +7 -2
  52. data/lib/prism/parse_result/newlines.rb +4 -0
  53. data/lib/prism/parse_result.rb +157 -21
  54. data/lib/prism/pattern.rb +14 -3
  55. data/lib/prism/ripper_compat.rb +28 -10
  56. data/lib/prism/serialize.rb +935 -307
  57. data/lib/prism/visitor.rb +9 -5
  58. data/lib/prism.rb +20 -2
  59. data/prism.gemspec +11 -2
  60. data/rbi/prism.rbi +7305 -0
  61. data/rbi/prism_static.rbi +196 -0
  62. data/sig/prism.rbs +4468 -0
  63. data/sig/prism_static.rbs +123 -0
  64. data/src/diagnostic.c +56 -53
  65. data/src/enc/pm_big5.c +1 -0
  66. data/src/enc/pm_euc_jp.c +1 -0
  67. data/src/enc/pm_gbk.c +1 -0
  68. data/src/enc/pm_shift_jis.c +1 -0
  69. data/src/enc/pm_tables.c +316 -80
  70. data/src/enc/pm_unicode.c +54 -9
  71. data/src/enc/pm_windows_31j.c +1 -0
  72. data/src/node.c +357 -345
  73. data/src/options.c +170 -0
  74. data/src/prettyprint.c +7697 -1643
  75. data/src/prism.c +1964 -1125
  76. data/src/regexp.c +153 -95
  77. data/src/serialize.c +432 -397
  78. data/src/token_type.c +3 -1
  79. data/src/util/pm_buffer.c +88 -23
  80. data/src/util/pm_char.c +103 -57
  81. data/src/util/pm_constant_pool.c +52 -22
  82. data/src/util/pm_list.c +12 -4
  83. data/src/util/pm_memchr.c +5 -3
  84. data/src/util/pm_newline_list.c +25 -63
  85. data/src/util/pm_state_stack.c +9 -3
  86. data/src/util/pm_string.c +95 -85
  87. data/src/util/pm_string_list.c +14 -15
  88. data/src/util/pm_strncasecmp.c +10 -3
  89. data/src/util/pm_strpbrk.c +25 -19
  90. metadata +12 -3
  91. data/docs/prism.png +0 -0
data/src/node.c CHANGED
@@ -8,17 +8,12 @@
8
8
  #line 2 "node.c.erb"
9
9
  #include "prism/node.h"
10
10
 
11
- // Clear the node but preserves the location.
12
- void pm_node_clear(pm_node_t *node) {
13
- pm_location_t location = node->location;
14
- memset(node, 0, sizeof(pm_node_t));
15
- node->location = location;
16
- }
17
-
18
11
  static void
19
12
  pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize);
20
13
 
21
- // Calculate the size of the node list in bytes.
14
+ /**
15
+ * Calculate the size of the node list in bytes.
16
+ */
22
17
  static size_t
23
18
  pm_node_list_memsize(pm_node_list_t *node_list, pm_memsize_t *memsize) {
24
19
  size_t size = sizeof(pm_node_list_t) + (node_list->capacity * sizeof(pm_node_t *));
@@ -28,7 +23,9 @@ pm_node_list_memsize(pm_node_list_t *node_list, pm_memsize_t *memsize) {
28
23
  return size;
29
24
  }
30
25
 
31
- // Append a new node onto the end of the node list.
26
+ /**
27
+ * Append a new node onto the end of the node list.
28
+ */
32
29
  void
33
30
  pm_node_list_append(pm_node_list_t *list, pm_node_t *node) {
34
31
  if (list->size == list->capacity) {
@@ -41,8 +38,10 @@ pm_node_list_append(pm_node_list_t *list, pm_node_t *node) {
41
38
  PRISM_EXPORTED_FUNCTION void
42
39
  pm_node_destroy(pm_parser_t *parser, pm_node_t *node);
43
40
 
44
- // Deallocate the inner memory of a list of nodes. The parser argument is not
45
- // used, but is here for the future possibility of pre-allocating memory pools.
41
+ /**
42
+ * Deallocate the inner memory of a list of nodes. The parser argument is not
43
+ * used, but is here for the future possibility of pre-allocating memory pools.
44
+ */
46
45
  static void
47
46
  pm_node_list_free(pm_parser_t *parser, pm_node_list_t *list) {
48
47
  if (list->capacity > 0) {
@@ -53,53 +52,55 @@ pm_node_list_free(pm_parser_t *parser, pm_node_list_t *list) {
53
52
  }
54
53
  }
55
54
 
56
- // Deallocate the space for a pm_node_t. Similarly to pm_node_alloc, we're not
57
- // using the parser argument, but it's there to allow for the future possibility
58
- // of pre-allocating larger memory pools.
55
+ /**
56
+ * Deallocate the space for a pm_node_t. Similarly to pm_node_alloc, we're not
57
+ * using the parser argument, but it's there to allow for the future possibility
58
+ * of pre-allocating larger memory pools.
59
+ */
59
60
  PRISM_EXPORTED_FUNCTION void
60
61
  pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
61
62
  switch (PM_NODE_TYPE(node)) {
62
- #line 57 "node.c.erb"
63
+ #line 58 "node.c.erb"
63
64
  case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
64
65
  pm_alias_global_variable_node_t *cast = (pm_alias_global_variable_node_t *) node;
65
66
  pm_node_destroy(parser, (pm_node_t *)cast->new_name);
66
67
  pm_node_destroy(parser, (pm_node_t *)cast->old_name);
67
68
  break;
68
69
  }
69
- #line 57 "node.c.erb"
70
+ #line 58 "node.c.erb"
70
71
  case PM_ALIAS_METHOD_NODE: {
71
72
  pm_alias_method_node_t *cast = (pm_alias_method_node_t *) node;
72
73
  pm_node_destroy(parser, (pm_node_t *)cast->new_name);
73
74
  pm_node_destroy(parser, (pm_node_t *)cast->old_name);
74
75
  break;
75
76
  }
76
- #line 57 "node.c.erb"
77
+ #line 58 "node.c.erb"
77
78
  case PM_ALTERNATION_PATTERN_NODE: {
78
79
  pm_alternation_pattern_node_t *cast = (pm_alternation_pattern_node_t *) node;
79
80
  pm_node_destroy(parser, (pm_node_t *)cast->left);
80
81
  pm_node_destroy(parser, (pm_node_t *)cast->right);
81
82
  break;
82
83
  }
83
- #line 57 "node.c.erb"
84
+ #line 58 "node.c.erb"
84
85
  case PM_AND_NODE: {
85
86
  pm_and_node_t *cast = (pm_and_node_t *) node;
86
87
  pm_node_destroy(parser, (pm_node_t *)cast->left);
87
88
  pm_node_destroy(parser, (pm_node_t *)cast->right);
88
89
  break;
89
90
  }
90
- #line 57 "node.c.erb"
91
+ #line 58 "node.c.erb"
91
92
  case PM_ARGUMENTS_NODE: {
92
93
  pm_arguments_node_t *cast = (pm_arguments_node_t *) node;
93
94
  pm_node_list_free(parser, &cast->arguments);
94
95
  break;
95
96
  }
96
- #line 57 "node.c.erb"
97
+ #line 58 "node.c.erb"
97
98
  case PM_ARRAY_NODE: {
98
99
  pm_array_node_t *cast = (pm_array_node_t *) node;
99
100
  pm_node_list_free(parser, &cast->elements);
100
101
  break;
101
102
  }
102
- #line 57 "node.c.erb"
103
+ #line 58 "node.c.erb"
103
104
  case PM_ARRAY_PATTERN_NODE: {
104
105
  pm_array_pattern_node_t *cast = (pm_array_pattern_node_t *) node;
105
106
  if (cast->constant != NULL) {
@@ -112,7 +113,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
112
113
  pm_node_list_free(parser, &cast->posts);
113
114
  break;
114
115
  }
115
- #line 57 "node.c.erb"
116
+ #line 58 "node.c.erb"
116
117
  case PM_ASSOC_NODE: {
117
118
  pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
118
119
  pm_node_destroy(parser, (pm_node_t *)cast->key);
@@ -121,7 +122,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
121
122
  }
122
123
  break;
123
124
  }
124
- #line 57 "node.c.erb"
125
+ #line 58 "node.c.erb"
125
126
  case PM_ASSOC_SPLAT_NODE: {
126
127
  pm_assoc_splat_node_t *cast = (pm_assoc_splat_node_t *) node;
127
128
  if (cast->value != NULL) {
@@ -129,11 +130,11 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
129
130
  }
130
131
  break;
131
132
  }
132
- #line 57 "node.c.erb"
133
+ #line 58 "node.c.erb"
133
134
  case PM_BACK_REFERENCE_READ_NODE: {
134
135
  break;
135
136
  }
136
- #line 57 "node.c.erb"
137
+ #line 58 "node.c.erb"
137
138
  case PM_BEGIN_NODE: {
138
139
  pm_begin_node_t *cast = (pm_begin_node_t *) node;
139
140
  if (cast->statements != NULL) {
@@ -150,7 +151,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
150
151
  }
151
152
  break;
152
153
  }
153
- #line 57 "node.c.erb"
154
+ #line 58 "node.c.erb"
154
155
  case PM_BLOCK_ARGUMENT_NODE: {
155
156
  pm_block_argument_node_t *cast = (pm_block_argument_node_t *) node;
156
157
  if (cast->expression != NULL) {
@@ -158,11 +159,11 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
158
159
  }
159
160
  break;
160
161
  }
161
- #line 57 "node.c.erb"
162
+ #line 58 "node.c.erb"
162
163
  case PM_BLOCK_LOCAL_VARIABLE_NODE: {
163
164
  break;
164
165
  }
165
- #line 57 "node.c.erb"
166
+ #line 58 "node.c.erb"
166
167
  case PM_BLOCK_NODE: {
167
168
  pm_block_node_t *cast = (pm_block_node_t *) node;
168
169
  pm_constant_id_list_free(&cast->locals);
@@ -174,11 +175,11 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
174
175
  }
175
176
  break;
176
177
  }
177
- #line 57 "node.c.erb"
178
+ #line 58 "node.c.erb"
178
179
  case PM_BLOCK_PARAMETER_NODE: {
179
180
  break;
180
181
  }
181
- #line 57 "node.c.erb"
182
+ #line 58 "node.c.erb"
182
183
  case PM_BLOCK_PARAMETERS_NODE: {
183
184
  pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) node;
184
185
  if (cast->parameters != NULL) {
@@ -187,7 +188,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
187
188
  pm_node_list_free(parser, &cast->locals);
188
189
  break;
189
190
  }
190
- #line 57 "node.c.erb"
191
+ #line 58 "node.c.erb"
191
192
  case PM_BREAK_NODE: {
192
193
  pm_break_node_t *cast = (pm_break_node_t *) node;
193
194
  if (cast->arguments != NULL) {
@@ -195,7 +196,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
195
196
  }
196
197
  break;
197
198
  }
198
- #line 57 "node.c.erb"
199
+ #line 58 "node.c.erb"
199
200
  case PM_CALL_AND_WRITE_NODE: {
200
201
  pm_call_and_write_node_t *cast = (pm_call_and_write_node_t *) node;
201
202
  if (cast->receiver != NULL) {
@@ -204,7 +205,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
204
205
  pm_node_destroy(parser, (pm_node_t *)cast->value);
205
206
  break;
206
207
  }
207
- #line 57 "node.c.erb"
208
+ #line 58 "node.c.erb"
208
209
  case PM_CALL_NODE: {
209
210
  pm_call_node_t *cast = (pm_call_node_t *) node;
210
211
  if (cast->receiver != NULL) {
@@ -218,7 +219,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
218
219
  }
219
220
  break;
220
221
  }
221
- #line 57 "node.c.erb"
222
+ #line 58 "node.c.erb"
222
223
  case PM_CALL_OPERATOR_WRITE_NODE: {
223
224
  pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
224
225
  if (cast->receiver != NULL) {
@@ -227,7 +228,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
227
228
  pm_node_destroy(parser, (pm_node_t *)cast->value);
228
229
  break;
229
230
  }
230
- #line 57 "node.c.erb"
231
+ #line 58 "node.c.erb"
231
232
  case PM_CALL_OR_WRITE_NODE: {
232
233
  pm_call_or_write_node_t *cast = (pm_call_or_write_node_t *) node;
233
234
  if (cast->receiver != NULL) {
@@ -236,14 +237,14 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
236
237
  pm_node_destroy(parser, (pm_node_t *)cast->value);
237
238
  break;
238
239
  }
239
- #line 57 "node.c.erb"
240
+ #line 58 "node.c.erb"
240
241
  case PM_CAPTURE_PATTERN_NODE: {
241
242
  pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
242
243
  pm_node_destroy(parser, (pm_node_t *)cast->value);
243
244
  pm_node_destroy(parser, (pm_node_t *)cast->target);
244
245
  break;
245
246
  }
246
- #line 57 "node.c.erb"
247
+ #line 58 "node.c.erb"
247
248
  case PM_CASE_NODE: {
248
249
  pm_case_node_t *cast = (pm_case_node_t *) node;
249
250
  if (cast->predicate != NULL) {
@@ -255,7 +256,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
255
256
  }
256
257
  break;
257
258
  }
258
- #line 57 "node.c.erb"
259
+ #line 58 "node.c.erb"
259
260
  case PM_CLASS_NODE: {
260
261
  pm_class_node_t *cast = (pm_class_node_t *) node;
261
262
  pm_constant_id_list_free(&cast->locals);
@@ -268,64 +269,64 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
268
269
  }
269
270
  break;
270
271
  }
271
- #line 57 "node.c.erb"
272
+ #line 58 "node.c.erb"
272
273
  case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
273
274
  pm_class_variable_and_write_node_t *cast = (pm_class_variable_and_write_node_t *) node;
274
275
  pm_node_destroy(parser, (pm_node_t *)cast->value);
275
276
  break;
276
277
  }
277
- #line 57 "node.c.erb"
278
+ #line 58 "node.c.erb"
278
279
  case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
279
280
  pm_class_variable_operator_write_node_t *cast = (pm_class_variable_operator_write_node_t *) node;
280
281
  pm_node_destroy(parser, (pm_node_t *)cast->value);
281
282
  break;
282
283
  }
283
- #line 57 "node.c.erb"
284
+ #line 58 "node.c.erb"
284
285
  case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
285
286
  pm_class_variable_or_write_node_t *cast = (pm_class_variable_or_write_node_t *) node;
286
287
  pm_node_destroy(parser, (pm_node_t *)cast->value);
287
288
  break;
288
289
  }
289
- #line 57 "node.c.erb"
290
+ #line 58 "node.c.erb"
290
291
  case PM_CLASS_VARIABLE_READ_NODE: {
291
292
  break;
292
293
  }
293
- #line 57 "node.c.erb"
294
+ #line 58 "node.c.erb"
294
295
  case PM_CLASS_VARIABLE_TARGET_NODE: {
295
296
  break;
296
297
  }
297
- #line 57 "node.c.erb"
298
+ #line 58 "node.c.erb"
298
299
  case PM_CLASS_VARIABLE_WRITE_NODE: {
299
300
  pm_class_variable_write_node_t *cast = (pm_class_variable_write_node_t *) node;
300
301
  pm_node_destroy(parser, (pm_node_t *)cast->value);
301
302
  break;
302
303
  }
303
- #line 57 "node.c.erb"
304
+ #line 58 "node.c.erb"
304
305
  case PM_CONSTANT_AND_WRITE_NODE: {
305
306
  pm_constant_and_write_node_t *cast = (pm_constant_and_write_node_t *) node;
306
307
  pm_node_destroy(parser, (pm_node_t *)cast->value);
307
308
  break;
308
309
  }
309
- #line 57 "node.c.erb"
310
+ #line 58 "node.c.erb"
310
311
  case PM_CONSTANT_OPERATOR_WRITE_NODE: {
311
312
  pm_constant_operator_write_node_t *cast = (pm_constant_operator_write_node_t *) node;
312
313
  pm_node_destroy(parser, (pm_node_t *)cast->value);
313
314
  break;
314
315
  }
315
- #line 57 "node.c.erb"
316
+ #line 58 "node.c.erb"
316
317
  case PM_CONSTANT_OR_WRITE_NODE: {
317
318
  pm_constant_or_write_node_t *cast = (pm_constant_or_write_node_t *) node;
318
319
  pm_node_destroy(parser, (pm_node_t *)cast->value);
319
320
  break;
320
321
  }
321
- #line 57 "node.c.erb"
322
+ #line 58 "node.c.erb"
322
323
  case PM_CONSTANT_PATH_AND_WRITE_NODE: {
323
324
  pm_constant_path_and_write_node_t *cast = (pm_constant_path_and_write_node_t *) node;
324
325
  pm_node_destroy(parser, (pm_node_t *)cast->target);
325
326
  pm_node_destroy(parser, (pm_node_t *)cast->value);
326
327
  break;
327
328
  }
328
- #line 57 "node.c.erb"
329
+ #line 58 "node.c.erb"
329
330
  case PM_CONSTANT_PATH_NODE: {
330
331
  pm_constant_path_node_t *cast = (pm_constant_path_node_t *) node;
331
332
  if (cast->parent != NULL) {
@@ -334,21 +335,21 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
334
335
  pm_node_destroy(parser, (pm_node_t *)cast->child);
335
336
  break;
336
337
  }
337
- #line 57 "node.c.erb"
338
+ #line 58 "node.c.erb"
338
339
  case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
339
340
  pm_constant_path_operator_write_node_t *cast = (pm_constant_path_operator_write_node_t *) node;
340
341
  pm_node_destroy(parser, (pm_node_t *)cast->target);
341
342
  pm_node_destroy(parser, (pm_node_t *)cast->value);
342
343
  break;
343
344
  }
344
- #line 57 "node.c.erb"
345
+ #line 58 "node.c.erb"
345
346
  case PM_CONSTANT_PATH_OR_WRITE_NODE: {
346
347
  pm_constant_path_or_write_node_t *cast = (pm_constant_path_or_write_node_t *) node;
347
348
  pm_node_destroy(parser, (pm_node_t *)cast->target);
348
349
  pm_node_destroy(parser, (pm_node_t *)cast->value);
349
350
  break;
350
351
  }
351
- #line 57 "node.c.erb"
352
+ #line 58 "node.c.erb"
352
353
  case PM_CONSTANT_PATH_TARGET_NODE: {
353
354
  pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *) node;
354
355
  if (cast->parent != NULL) {
@@ -357,28 +358,28 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
357
358
  pm_node_destroy(parser, (pm_node_t *)cast->child);
358
359
  break;
359
360
  }
360
- #line 57 "node.c.erb"
361
+ #line 58 "node.c.erb"
361
362
  case PM_CONSTANT_PATH_WRITE_NODE: {
362
363
  pm_constant_path_write_node_t *cast = (pm_constant_path_write_node_t *) node;
363
364
  pm_node_destroy(parser, (pm_node_t *)cast->target);
364
365
  pm_node_destroy(parser, (pm_node_t *)cast->value);
365
366
  break;
366
367
  }
367
- #line 57 "node.c.erb"
368
+ #line 58 "node.c.erb"
368
369
  case PM_CONSTANT_READ_NODE: {
369
370
  break;
370
371
  }
371
- #line 57 "node.c.erb"
372
+ #line 58 "node.c.erb"
372
373
  case PM_CONSTANT_TARGET_NODE: {
373
374
  break;
374
375
  }
375
- #line 57 "node.c.erb"
376
+ #line 58 "node.c.erb"
376
377
  case PM_CONSTANT_WRITE_NODE: {
377
378
  pm_constant_write_node_t *cast = (pm_constant_write_node_t *) node;
378
379
  pm_node_destroy(parser, (pm_node_t *)cast->value);
379
380
  break;
380
381
  }
381
- #line 57 "node.c.erb"
382
+ #line 58 "node.c.erb"
382
383
  case PM_DEF_NODE: {
383
384
  pm_def_node_t *cast = (pm_def_node_t *) node;
384
385
  if (cast->receiver != NULL) {
@@ -393,13 +394,13 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
393
394
  pm_constant_id_list_free(&cast->locals);
394
395
  break;
395
396
  }
396
- #line 57 "node.c.erb"
397
+ #line 58 "node.c.erb"
397
398
  case PM_DEFINED_NODE: {
398
399
  pm_defined_node_t *cast = (pm_defined_node_t *) node;
399
400
  pm_node_destroy(parser, (pm_node_t *)cast->value);
400
401
  break;
401
402
  }
402
- #line 57 "node.c.erb"
403
+ #line 58 "node.c.erb"
403
404
  case PM_ELSE_NODE: {
404
405
  pm_else_node_t *cast = (pm_else_node_t *) node;
405
406
  if (cast->statements != NULL) {
@@ -407,7 +408,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
407
408
  }
408
409
  break;
409
410
  }
410
- #line 57 "node.c.erb"
411
+ #line 58 "node.c.erb"
411
412
  case PM_EMBEDDED_STATEMENTS_NODE: {
412
413
  pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) node;
413
414
  if (cast->statements != NULL) {
@@ -415,13 +416,13 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
415
416
  }
416
417
  break;
417
418
  }
418
- #line 57 "node.c.erb"
419
+ #line 58 "node.c.erb"
419
420
  case PM_EMBEDDED_VARIABLE_NODE: {
420
421
  pm_embedded_variable_node_t *cast = (pm_embedded_variable_node_t *) node;
421
422
  pm_node_destroy(parser, (pm_node_t *)cast->variable);
422
423
  break;
423
424
  }
424
- #line 57 "node.c.erb"
425
+ #line 58 "node.c.erb"
425
426
  case PM_ENSURE_NODE: {
426
427
  pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
427
428
  if (cast->statements != NULL) {
@@ -429,11 +430,11 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
429
430
  }
430
431
  break;
431
432
  }
432
- #line 57 "node.c.erb"
433
+ #line 58 "node.c.erb"
433
434
  case PM_FALSE_NODE: {
434
435
  break;
435
436
  }
436
- #line 57 "node.c.erb"
437
+ #line 58 "node.c.erb"
437
438
  case PM_FIND_PATTERN_NODE: {
438
439
  pm_find_pattern_node_t *cast = (pm_find_pattern_node_t *) node;
439
440
  if (cast->constant != NULL) {
@@ -444,7 +445,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
444
445
  pm_node_destroy(parser, (pm_node_t *)cast->right);
445
446
  break;
446
447
  }
447
- #line 57 "node.c.erb"
448
+ #line 58 "node.c.erb"
448
449
  case PM_FLIP_FLOP_NODE: {
449
450
  pm_flip_flop_node_t *cast = (pm_flip_flop_node_t *) node;
450
451
  if (cast->left != NULL) {
@@ -455,11 +456,11 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
455
456
  }
456
457
  break;
457
458
  }
458
- #line 57 "node.c.erb"
459
+ #line 58 "node.c.erb"
459
460
  case PM_FLOAT_NODE: {
460
461
  break;
461
462
  }
462
- #line 57 "node.c.erb"
463
+ #line 58 "node.c.erb"
463
464
  case PM_FOR_NODE: {
464
465
  pm_for_node_t *cast = (pm_for_node_t *) node;
465
466
  pm_node_destroy(parser, (pm_node_t *)cast->index);
@@ -469,15 +470,15 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
469
470
  }
470
471
  break;
471
472
  }
472
- #line 57 "node.c.erb"
473
+ #line 58 "node.c.erb"
473
474
  case PM_FORWARDING_ARGUMENTS_NODE: {
474
475
  break;
475
476
  }
476
- #line 57 "node.c.erb"
477
+ #line 58 "node.c.erb"
477
478
  case PM_FORWARDING_PARAMETER_NODE: {
478
479
  break;
479
480
  }
480
- #line 57 "node.c.erb"
481
+ #line 58 "node.c.erb"
481
482
  case PM_FORWARDING_SUPER_NODE: {
482
483
  pm_forwarding_super_node_t *cast = (pm_forwarding_super_node_t *) node;
483
484
  if (cast->block != NULL) {
@@ -485,57 +486,57 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
485
486
  }
486
487
  break;
487
488
  }
488
- #line 57 "node.c.erb"
489
+ #line 58 "node.c.erb"
489
490
  case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
490
491
  pm_global_variable_and_write_node_t *cast = (pm_global_variable_and_write_node_t *) node;
491
492
  pm_node_destroy(parser, (pm_node_t *)cast->value);
492
493
  break;
493
494
  }
494
- #line 57 "node.c.erb"
495
+ #line 58 "node.c.erb"
495
496
  case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
496
497
  pm_global_variable_operator_write_node_t *cast = (pm_global_variable_operator_write_node_t *) node;
497
498
  pm_node_destroy(parser, (pm_node_t *)cast->value);
498
499
  break;
499
500
  }
500
- #line 57 "node.c.erb"
501
+ #line 58 "node.c.erb"
501
502
  case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
502
503
  pm_global_variable_or_write_node_t *cast = (pm_global_variable_or_write_node_t *) node;
503
504
  pm_node_destroy(parser, (pm_node_t *)cast->value);
504
505
  break;
505
506
  }
506
- #line 57 "node.c.erb"
507
+ #line 58 "node.c.erb"
507
508
  case PM_GLOBAL_VARIABLE_READ_NODE: {
508
509
  break;
509
510
  }
510
- #line 57 "node.c.erb"
511
+ #line 58 "node.c.erb"
511
512
  case PM_GLOBAL_VARIABLE_TARGET_NODE: {
512
513
  break;
513
514
  }
514
- #line 57 "node.c.erb"
515
+ #line 58 "node.c.erb"
515
516
  case PM_GLOBAL_VARIABLE_WRITE_NODE: {
516
517
  pm_global_variable_write_node_t *cast = (pm_global_variable_write_node_t *) node;
517
518
  pm_node_destroy(parser, (pm_node_t *)cast->value);
518
519
  break;
519
520
  }
520
- #line 57 "node.c.erb"
521
+ #line 58 "node.c.erb"
521
522
  case PM_HASH_NODE: {
522
523
  pm_hash_node_t *cast = (pm_hash_node_t *) node;
523
524
  pm_node_list_free(parser, &cast->elements);
524
525
  break;
525
526
  }
526
- #line 57 "node.c.erb"
527
+ #line 58 "node.c.erb"
527
528
  case PM_HASH_PATTERN_NODE: {
528
529
  pm_hash_pattern_node_t *cast = (pm_hash_pattern_node_t *) node;
529
530
  if (cast->constant != NULL) {
530
531
  pm_node_destroy(parser, (pm_node_t *)cast->constant);
531
532
  }
532
- pm_node_list_free(parser, &cast->assocs);
533
- if (cast->kwrest != NULL) {
534
- pm_node_destroy(parser, (pm_node_t *)cast->kwrest);
533
+ pm_node_list_free(parser, &cast->elements);
534
+ if (cast->rest != NULL) {
535
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
535
536
  }
536
537
  break;
537
538
  }
538
- #line 57 "node.c.erb"
539
+ #line 58 "node.c.erb"
539
540
  case PM_IF_NODE: {
540
541
  pm_if_node_t *cast = (pm_if_node_t *) node;
541
542
  pm_node_destroy(parser, (pm_node_t *)cast->predicate);
@@ -547,19 +548,19 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
547
548
  }
548
549
  break;
549
550
  }
550
- #line 57 "node.c.erb"
551
+ #line 58 "node.c.erb"
551
552
  case PM_IMAGINARY_NODE: {
552
553
  pm_imaginary_node_t *cast = (pm_imaginary_node_t *) node;
553
554
  pm_node_destroy(parser, (pm_node_t *)cast->numeric);
554
555
  break;
555
556
  }
556
- #line 57 "node.c.erb"
557
+ #line 58 "node.c.erb"
557
558
  case PM_IMPLICIT_NODE: {
558
559
  pm_implicit_node_t *cast = (pm_implicit_node_t *) node;
559
560
  pm_node_destroy(parser, (pm_node_t *)cast->value);
560
561
  break;
561
562
  }
562
- #line 57 "node.c.erb"
563
+ #line 58 "node.c.erb"
563
564
  case PM_IN_NODE: {
564
565
  pm_in_node_t *cast = (pm_in_node_t *) node;
565
566
  pm_node_destroy(parser, (pm_node_t *)cast->pattern);
@@ -568,7 +569,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
568
569
  }
569
570
  break;
570
571
  }
571
- #line 57 "node.c.erb"
572
+ #line 58 "node.c.erb"
572
573
  case PM_INDEX_AND_WRITE_NODE: {
573
574
  pm_index_and_write_node_t *cast = (pm_index_and_write_node_t *) node;
574
575
  if (cast->receiver != NULL) {
@@ -583,7 +584,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
583
584
  pm_node_destroy(parser, (pm_node_t *)cast->value);
584
585
  break;
585
586
  }
586
- #line 57 "node.c.erb"
587
+ #line 58 "node.c.erb"
587
588
  case PM_INDEX_OPERATOR_WRITE_NODE: {
588
589
  pm_index_operator_write_node_t *cast = (pm_index_operator_write_node_t *) node;
589
590
  if (cast->receiver != NULL) {
@@ -598,7 +599,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
598
599
  pm_node_destroy(parser, (pm_node_t *)cast->value);
599
600
  break;
600
601
  }
601
- #line 57 "node.c.erb"
602
+ #line 58 "node.c.erb"
602
603
  case PM_INDEX_OR_WRITE_NODE: {
603
604
  pm_index_or_write_node_t *cast = (pm_index_or_write_node_t *) node;
604
605
  if (cast->receiver != NULL) {
@@ -613,91 +614,83 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
613
614
  pm_node_destroy(parser, (pm_node_t *)cast->value);
614
615
  break;
615
616
  }
616
- #line 57 "node.c.erb"
617
+ #line 58 "node.c.erb"
617
618
  case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
618
619
  pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
619
620
  pm_node_destroy(parser, (pm_node_t *)cast->value);
620
621
  break;
621
622
  }
622
- #line 57 "node.c.erb"
623
+ #line 58 "node.c.erb"
623
624
  case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
624
625
  pm_instance_variable_operator_write_node_t *cast = (pm_instance_variable_operator_write_node_t *) node;
625
626
  pm_node_destroy(parser, (pm_node_t *)cast->value);
626
627
  break;
627
628
  }
628
- #line 57 "node.c.erb"
629
+ #line 58 "node.c.erb"
629
630
  case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
630
631
  pm_instance_variable_or_write_node_t *cast = (pm_instance_variable_or_write_node_t *) node;
631
632
  pm_node_destroy(parser, (pm_node_t *)cast->value);
632
633
  break;
633
634
  }
634
- #line 57 "node.c.erb"
635
+ #line 58 "node.c.erb"
635
636
  case PM_INSTANCE_VARIABLE_READ_NODE: {
636
637
  break;
637
638
  }
638
- #line 57 "node.c.erb"
639
+ #line 58 "node.c.erb"
639
640
  case PM_INSTANCE_VARIABLE_TARGET_NODE: {
640
641
  break;
641
642
  }
642
- #line 57 "node.c.erb"
643
+ #line 58 "node.c.erb"
643
644
  case PM_INSTANCE_VARIABLE_WRITE_NODE: {
644
645
  pm_instance_variable_write_node_t *cast = (pm_instance_variable_write_node_t *) node;
645
646
  pm_node_destroy(parser, (pm_node_t *)cast->value);
646
647
  break;
647
648
  }
648
- #line 57 "node.c.erb"
649
+ #line 58 "node.c.erb"
649
650
  case PM_INTEGER_NODE: {
650
651
  break;
651
652
  }
652
- #line 57 "node.c.erb"
653
+ #line 58 "node.c.erb"
653
654
  case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
654
655
  pm_interpolated_match_last_line_node_t *cast = (pm_interpolated_match_last_line_node_t *) node;
655
656
  pm_node_list_free(parser, &cast->parts);
656
657
  break;
657
658
  }
658
- #line 57 "node.c.erb"
659
+ #line 58 "node.c.erb"
659
660
  case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
660
661
  pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
661
662
  pm_node_list_free(parser, &cast->parts);
662
663
  break;
663
664
  }
664
- #line 57 "node.c.erb"
665
+ #line 58 "node.c.erb"
665
666
  case PM_INTERPOLATED_STRING_NODE: {
666
667
  pm_interpolated_string_node_t *cast = (pm_interpolated_string_node_t *) node;
667
668
  pm_node_list_free(parser, &cast->parts);
668
669
  break;
669
670
  }
670
- #line 57 "node.c.erb"
671
+ #line 58 "node.c.erb"
671
672
  case PM_INTERPOLATED_SYMBOL_NODE: {
672
673
  pm_interpolated_symbol_node_t *cast = (pm_interpolated_symbol_node_t *) node;
673
674
  pm_node_list_free(parser, &cast->parts);
674
675
  break;
675
676
  }
676
- #line 57 "node.c.erb"
677
+ #line 58 "node.c.erb"
677
678
  case PM_INTERPOLATED_X_STRING_NODE: {
678
679
  pm_interpolated_x_string_node_t *cast = (pm_interpolated_x_string_node_t *) node;
679
680
  pm_node_list_free(parser, &cast->parts);
680
681
  break;
681
682
  }
682
- #line 57 "node.c.erb"
683
+ #line 58 "node.c.erb"
683
684
  case PM_KEYWORD_HASH_NODE: {
684
685
  pm_keyword_hash_node_t *cast = (pm_keyword_hash_node_t *) node;
685
686
  pm_node_list_free(parser, &cast->elements);
686
687
  break;
687
688
  }
688
- #line 57 "node.c.erb"
689
- case PM_KEYWORD_PARAMETER_NODE: {
690
- pm_keyword_parameter_node_t *cast = (pm_keyword_parameter_node_t *) node;
691
- if (cast->value != NULL) {
692
- pm_node_destroy(parser, (pm_node_t *)cast->value);
693
- }
694
- break;
695
- }
696
- #line 57 "node.c.erb"
689
+ #line 58 "node.c.erb"
697
690
  case PM_KEYWORD_REST_PARAMETER_NODE: {
698
691
  break;
699
692
  }
700
- #line 57 "node.c.erb"
693
+ #line 58 "node.c.erb"
701
694
  case PM_LAMBDA_NODE: {
702
695
  pm_lambda_node_t *cast = (pm_lambda_node_t *) node;
703
696
  pm_constant_id_list_free(&cast->locals);
@@ -709,70 +702,70 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
709
702
  }
710
703
  break;
711
704
  }
712
- #line 57 "node.c.erb"
705
+ #line 58 "node.c.erb"
713
706
  case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
714
707
  pm_local_variable_and_write_node_t *cast = (pm_local_variable_and_write_node_t *) node;
715
708
  pm_node_destroy(parser, (pm_node_t *)cast->value);
716
709
  break;
717
710
  }
718
- #line 57 "node.c.erb"
711
+ #line 58 "node.c.erb"
719
712
  case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
720
713
  pm_local_variable_operator_write_node_t *cast = (pm_local_variable_operator_write_node_t *) node;
721
714
  pm_node_destroy(parser, (pm_node_t *)cast->value);
722
715
  break;
723
716
  }
724
- #line 57 "node.c.erb"
717
+ #line 58 "node.c.erb"
725
718
  case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
726
719
  pm_local_variable_or_write_node_t *cast = (pm_local_variable_or_write_node_t *) node;
727
720
  pm_node_destroy(parser, (pm_node_t *)cast->value);
728
721
  break;
729
722
  }
730
- #line 57 "node.c.erb"
723
+ #line 58 "node.c.erb"
731
724
  case PM_LOCAL_VARIABLE_READ_NODE: {
732
725
  break;
733
726
  }
734
- #line 57 "node.c.erb"
727
+ #line 58 "node.c.erb"
735
728
  case PM_LOCAL_VARIABLE_TARGET_NODE: {
736
729
  break;
737
730
  }
738
- #line 57 "node.c.erb"
731
+ #line 58 "node.c.erb"
739
732
  case PM_LOCAL_VARIABLE_WRITE_NODE: {
740
733
  pm_local_variable_write_node_t *cast = (pm_local_variable_write_node_t *) node;
741
734
  pm_node_destroy(parser, (pm_node_t *)cast->value);
742
735
  break;
743
736
  }
744
- #line 57 "node.c.erb"
737
+ #line 58 "node.c.erb"
745
738
  case PM_MATCH_LAST_LINE_NODE: {
746
739
  pm_match_last_line_node_t *cast = (pm_match_last_line_node_t *) node;
747
740
  pm_string_free(&cast->unescaped);
748
741
  break;
749
742
  }
750
- #line 57 "node.c.erb"
743
+ #line 58 "node.c.erb"
751
744
  case PM_MATCH_PREDICATE_NODE: {
752
745
  pm_match_predicate_node_t *cast = (pm_match_predicate_node_t *) node;
753
746
  pm_node_destroy(parser, (pm_node_t *)cast->value);
754
747
  pm_node_destroy(parser, (pm_node_t *)cast->pattern);
755
748
  break;
756
749
  }
757
- #line 57 "node.c.erb"
750
+ #line 58 "node.c.erb"
758
751
  case PM_MATCH_REQUIRED_NODE: {
759
752
  pm_match_required_node_t *cast = (pm_match_required_node_t *) node;
760
753
  pm_node_destroy(parser, (pm_node_t *)cast->value);
761
754
  pm_node_destroy(parser, (pm_node_t *)cast->pattern);
762
755
  break;
763
756
  }
764
- #line 57 "node.c.erb"
757
+ #line 58 "node.c.erb"
765
758
  case PM_MATCH_WRITE_NODE: {
766
759
  pm_match_write_node_t *cast = (pm_match_write_node_t *) node;
767
760
  pm_node_destroy(parser, (pm_node_t *)cast->call);
768
761
  pm_constant_id_list_free(&cast->locals);
769
762
  break;
770
763
  }
771
- #line 57 "node.c.erb"
764
+ #line 58 "node.c.erb"
772
765
  case PM_MISSING_NODE: {
773
766
  break;
774
767
  }
775
- #line 57 "node.c.erb"
768
+ #line 58 "node.c.erb"
776
769
  case PM_MODULE_NODE: {
777
770
  pm_module_node_t *cast = (pm_module_node_t *) node;
778
771
  pm_constant_id_list_free(&cast->locals);
@@ -782,20 +775,28 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
782
775
  }
783
776
  break;
784
777
  }
785
- #line 57 "node.c.erb"
778
+ #line 58 "node.c.erb"
786
779
  case PM_MULTI_TARGET_NODE: {
787
780
  pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
788
- pm_node_list_free(parser, &cast->targets);
781
+ pm_node_list_free(parser, &cast->lefts);
782
+ if (cast->rest != NULL) {
783
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
784
+ }
785
+ pm_node_list_free(parser, &cast->rights);
789
786
  break;
790
787
  }
791
- #line 57 "node.c.erb"
788
+ #line 58 "node.c.erb"
792
789
  case PM_MULTI_WRITE_NODE: {
793
790
  pm_multi_write_node_t *cast = (pm_multi_write_node_t *) node;
794
- pm_node_list_free(parser, &cast->targets);
791
+ pm_node_list_free(parser, &cast->lefts);
792
+ if (cast->rest != NULL) {
793
+ pm_node_destroy(parser, (pm_node_t *)cast->rest);
794
+ }
795
+ pm_node_list_free(parser, &cast->rights);
795
796
  pm_node_destroy(parser, (pm_node_t *)cast->value);
796
797
  break;
797
798
  }
798
- #line 57 "node.c.erb"
799
+ #line 58 "node.c.erb"
799
800
  case PM_NEXT_NODE: {
800
801
  pm_next_node_t *cast = (pm_next_node_t *) node;
801
802
  if (cast->arguments != NULL) {
@@ -803,32 +804,38 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
803
804
  }
804
805
  break;
805
806
  }
806
- #line 57 "node.c.erb"
807
+ #line 58 "node.c.erb"
807
808
  case PM_NIL_NODE: {
808
809
  break;
809
810
  }
810
- #line 57 "node.c.erb"
811
+ #line 58 "node.c.erb"
811
812
  case PM_NO_KEYWORDS_PARAMETER_NODE: {
812
813
  break;
813
814
  }
814
- #line 57 "node.c.erb"
815
+ #line 58 "node.c.erb"
815
816
  case PM_NUMBERED_REFERENCE_READ_NODE: {
816
817
  break;
817
818
  }
818
- #line 57 "node.c.erb"
819
+ #line 58 "node.c.erb"
820
+ case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
821
+ pm_optional_keyword_parameter_node_t *cast = (pm_optional_keyword_parameter_node_t *) node;
822
+ pm_node_destroy(parser, (pm_node_t *)cast->value);
823
+ break;
824
+ }
825
+ #line 58 "node.c.erb"
819
826
  case PM_OPTIONAL_PARAMETER_NODE: {
820
827
  pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
821
828
  pm_node_destroy(parser, (pm_node_t *)cast->value);
822
829
  break;
823
830
  }
824
- #line 57 "node.c.erb"
831
+ #line 58 "node.c.erb"
825
832
  case PM_OR_NODE: {
826
833
  pm_or_node_t *cast = (pm_or_node_t *) node;
827
834
  pm_node_destroy(parser, (pm_node_t *)cast->left);
828
835
  pm_node_destroy(parser, (pm_node_t *)cast->right);
829
836
  break;
830
837
  }
831
- #line 57 "node.c.erb"
838
+ #line 58 "node.c.erb"
832
839
  case PM_PARAMETERS_NODE: {
833
840
  pm_parameters_node_t *cast = (pm_parameters_node_t *) node;
834
841
  pm_node_list_free(parser, &cast->requireds);
@@ -846,7 +853,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
846
853
  }
847
854
  break;
848
855
  }
849
- #line 57 "node.c.erb"
856
+ #line 58 "node.c.erb"
850
857
  case PM_PARENTHESES_NODE: {
851
858
  pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
852
859
  if (cast->body != NULL) {
@@ -854,19 +861,19 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
854
861
  }
855
862
  break;
856
863
  }
857
- #line 57 "node.c.erb"
864
+ #line 58 "node.c.erb"
858
865
  case PM_PINNED_EXPRESSION_NODE: {
859
866
  pm_pinned_expression_node_t *cast = (pm_pinned_expression_node_t *) node;
860
867
  pm_node_destroy(parser, (pm_node_t *)cast->expression);
861
868
  break;
862
869
  }
863
- #line 57 "node.c.erb"
870
+ #line 58 "node.c.erb"
864
871
  case PM_PINNED_VARIABLE_NODE: {
865
872
  pm_pinned_variable_node_t *cast = (pm_pinned_variable_node_t *) node;
866
873
  pm_node_destroy(parser, (pm_node_t *)cast->variable);
867
874
  break;
868
875
  }
869
- #line 57 "node.c.erb"
876
+ #line 58 "node.c.erb"
870
877
  case PM_POST_EXECUTION_NODE: {
871
878
  pm_post_execution_node_t *cast = (pm_post_execution_node_t *) node;
872
879
  if (cast->statements != NULL) {
@@ -874,7 +881,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
874
881
  }
875
882
  break;
876
883
  }
877
- #line 57 "node.c.erb"
884
+ #line 58 "node.c.erb"
878
885
  case PM_PRE_EXECUTION_NODE: {
879
886
  pm_pre_execution_node_t *cast = (pm_pre_execution_node_t *) node;
880
887
  if (cast->statements != NULL) {
@@ -882,14 +889,14 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
882
889
  }
883
890
  break;
884
891
  }
885
- #line 57 "node.c.erb"
892
+ #line 58 "node.c.erb"
886
893
  case PM_PROGRAM_NODE: {
887
894
  pm_program_node_t *cast = (pm_program_node_t *) node;
888
895
  pm_constant_id_list_free(&cast->locals);
889
896
  pm_node_destroy(parser, (pm_node_t *)cast->statements);
890
897
  break;
891
898
  }
892
- #line 57 "node.c.erb"
899
+ #line 58 "node.c.erb"
893
900
  case PM_RANGE_NODE: {
894
901
  pm_range_node_t *cast = (pm_range_node_t *) node;
895
902
  if (cast->left != NULL) {
@@ -900,40 +907,38 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
900
907
  }
901
908
  break;
902
909
  }
903
- #line 57 "node.c.erb"
910
+ #line 58 "node.c.erb"
904
911
  case PM_RATIONAL_NODE: {
905
912
  pm_rational_node_t *cast = (pm_rational_node_t *) node;
906
913
  pm_node_destroy(parser, (pm_node_t *)cast->numeric);
907
914
  break;
908
915
  }
909
- #line 57 "node.c.erb"
916
+ #line 58 "node.c.erb"
910
917
  case PM_REDO_NODE: {
911
918
  break;
912
919
  }
913
- #line 57 "node.c.erb"
920
+ #line 58 "node.c.erb"
914
921
  case PM_REGULAR_EXPRESSION_NODE: {
915
922
  pm_regular_expression_node_t *cast = (pm_regular_expression_node_t *) node;
916
923
  pm_string_free(&cast->unescaped);
917
924
  break;
918
925
  }
919
- #line 57 "node.c.erb"
920
- case PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
921
- pm_required_destructured_parameter_node_t *cast = (pm_required_destructured_parameter_node_t *) node;
922
- pm_node_list_free(parser, &cast->parameters);
926
+ #line 58 "node.c.erb"
927
+ case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
923
928
  break;
924
929
  }
925
- #line 57 "node.c.erb"
930
+ #line 58 "node.c.erb"
926
931
  case PM_REQUIRED_PARAMETER_NODE: {
927
932
  break;
928
933
  }
929
- #line 57 "node.c.erb"
934
+ #line 58 "node.c.erb"
930
935
  case PM_RESCUE_MODIFIER_NODE: {
931
936
  pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
932
937
  pm_node_destroy(parser, (pm_node_t *)cast->expression);
933
938
  pm_node_destroy(parser, (pm_node_t *)cast->rescue_expression);
934
939
  break;
935
940
  }
936
- #line 57 "node.c.erb"
941
+ #line 58 "node.c.erb"
937
942
  case PM_RESCUE_NODE: {
938
943
  pm_rescue_node_t *cast = (pm_rescue_node_t *) node;
939
944
  pm_node_list_free(parser, &cast->exceptions);
@@ -948,15 +953,15 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
948
953
  }
949
954
  break;
950
955
  }
951
- #line 57 "node.c.erb"
956
+ #line 58 "node.c.erb"
952
957
  case PM_REST_PARAMETER_NODE: {
953
958
  break;
954
959
  }
955
- #line 57 "node.c.erb"
960
+ #line 58 "node.c.erb"
956
961
  case PM_RETRY_NODE: {
957
962
  break;
958
963
  }
959
- #line 57 "node.c.erb"
964
+ #line 58 "node.c.erb"
960
965
  case PM_RETURN_NODE: {
961
966
  pm_return_node_t *cast = (pm_return_node_t *) node;
962
967
  if (cast->arguments != NULL) {
@@ -964,11 +969,11 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
964
969
  }
965
970
  break;
966
971
  }
967
- #line 57 "node.c.erb"
972
+ #line 58 "node.c.erb"
968
973
  case PM_SELF_NODE: {
969
974
  break;
970
975
  }
971
- #line 57 "node.c.erb"
976
+ #line 58 "node.c.erb"
972
977
  case PM_SINGLETON_CLASS_NODE: {
973
978
  pm_singleton_class_node_t *cast = (pm_singleton_class_node_t *) node;
974
979
  pm_constant_id_list_free(&cast->locals);
@@ -978,21 +983,21 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
978
983
  }
979
984
  break;
980
985
  }
981
- #line 57 "node.c.erb"
986
+ #line 58 "node.c.erb"
982
987
  case PM_SOURCE_ENCODING_NODE: {
983
988
  break;
984
989
  }
985
- #line 57 "node.c.erb"
990
+ #line 58 "node.c.erb"
986
991
  case PM_SOURCE_FILE_NODE: {
987
992
  pm_source_file_node_t *cast = (pm_source_file_node_t *) node;
988
993
  pm_string_free(&cast->filepath);
989
994
  break;
990
995
  }
991
- #line 57 "node.c.erb"
996
+ #line 58 "node.c.erb"
992
997
  case PM_SOURCE_LINE_NODE: {
993
998
  break;
994
999
  }
995
- #line 57 "node.c.erb"
1000
+ #line 58 "node.c.erb"
996
1001
  case PM_SPLAT_NODE: {
997
1002
  pm_splat_node_t *cast = (pm_splat_node_t *) node;
998
1003
  if (cast->expression != NULL) {
@@ -1000,26 +1005,26 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1000
1005
  }
1001
1006
  break;
1002
1007
  }
1003
- #line 57 "node.c.erb"
1008
+ #line 58 "node.c.erb"
1004
1009
  case PM_STATEMENTS_NODE: {
1005
1010
  pm_statements_node_t *cast = (pm_statements_node_t *) node;
1006
1011
  pm_node_list_free(parser, &cast->body);
1007
1012
  break;
1008
1013
  }
1009
- #line 57 "node.c.erb"
1014
+ #line 58 "node.c.erb"
1010
1015
  case PM_STRING_CONCAT_NODE: {
1011
1016
  pm_string_concat_node_t *cast = (pm_string_concat_node_t *) node;
1012
1017
  pm_node_destroy(parser, (pm_node_t *)cast->left);
1013
1018
  pm_node_destroy(parser, (pm_node_t *)cast->right);
1014
1019
  break;
1015
1020
  }
1016
- #line 57 "node.c.erb"
1021
+ #line 58 "node.c.erb"
1017
1022
  case PM_STRING_NODE: {
1018
1023
  pm_string_node_t *cast = (pm_string_node_t *) node;
1019
1024
  pm_string_free(&cast->unescaped);
1020
1025
  break;
1021
1026
  }
1022
- #line 57 "node.c.erb"
1027
+ #line 58 "node.c.erb"
1023
1028
  case PM_SUPER_NODE: {
1024
1029
  pm_super_node_t *cast = (pm_super_node_t *) node;
1025
1030
  if (cast->arguments != NULL) {
@@ -1030,23 +1035,23 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1030
1035
  }
1031
1036
  break;
1032
1037
  }
1033
- #line 57 "node.c.erb"
1038
+ #line 58 "node.c.erb"
1034
1039
  case PM_SYMBOL_NODE: {
1035
1040
  pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
1036
1041
  pm_string_free(&cast->unescaped);
1037
1042
  break;
1038
1043
  }
1039
- #line 57 "node.c.erb"
1044
+ #line 58 "node.c.erb"
1040
1045
  case PM_TRUE_NODE: {
1041
1046
  break;
1042
1047
  }
1043
- #line 57 "node.c.erb"
1048
+ #line 58 "node.c.erb"
1044
1049
  case PM_UNDEF_NODE: {
1045
1050
  pm_undef_node_t *cast = (pm_undef_node_t *) node;
1046
1051
  pm_node_list_free(parser, &cast->names);
1047
1052
  break;
1048
1053
  }
1049
- #line 57 "node.c.erb"
1054
+ #line 58 "node.c.erb"
1050
1055
  case PM_UNLESS_NODE: {
1051
1056
  pm_unless_node_t *cast = (pm_unless_node_t *) node;
1052
1057
  pm_node_destroy(parser, (pm_node_t *)cast->predicate);
@@ -1058,7 +1063,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1058
1063
  }
1059
1064
  break;
1060
1065
  }
1061
- #line 57 "node.c.erb"
1066
+ #line 58 "node.c.erb"
1062
1067
  case PM_UNTIL_NODE: {
1063
1068
  pm_until_node_t *cast = (pm_until_node_t *) node;
1064
1069
  pm_node_destroy(parser, (pm_node_t *)cast->predicate);
@@ -1067,7 +1072,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1067
1072
  }
1068
1073
  break;
1069
1074
  }
1070
- #line 57 "node.c.erb"
1075
+ #line 58 "node.c.erb"
1071
1076
  case PM_WHEN_NODE: {
1072
1077
  pm_when_node_t *cast = (pm_when_node_t *) node;
1073
1078
  pm_node_list_free(parser, &cast->conditions);
@@ -1076,7 +1081,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1076
1081
  }
1077
1082
  break;
1078
1083
  }
1079
- #line 57 "node.c.erb"
1084
+ #line 58 "node.c.erb"
1080
1085
  case PM_WHILE_NODE: {
1081
1086
  pm_while_node_t *cast = (pm_while_node_t *) node;
1082
1087
  pm_node_destroy(parser, (pm_node_t *)cast->predicate);
@@ -1085,13 +1090,13 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1085
1090
  }
1086
1091
  break;
1087
1092
  }
1088
- #line 57 "node.c.erb"
1093
+ #line 58 "node.c.erb"
1089
1094
  case PM_X_STRING_NODE: {
1090
1095
  pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
1091
1096
  pm_string_free(&cast->unescaped);
1092
1097
  break;
1093
1098
  }
1094
- #line 57 "node.c.erb"
1099
+ #line 58 "node.c.erb"
1095
1100
  case PM_YIELD_NODE: {
1096
1101
  pm_yield_node_t *cast = (pm_yield_node_t *) node;
1097
1102
  if (cast->arguments != NULL) {
@@ -1099,7 +1104,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1099
1104
  }
1100
1105
  break;
1101
1106
  }
1102
- #line 84 "node.c.erb"
1107
+ #line 85 "node.c.erb"
1103
1108
  default:
1104
1109
  assert(false && "unreachable");
1105
1110
  break;
@@ -1116,7 +1121,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1116
1121
  // as it should never be generated
1117
1122
  case PM_SCOPE_NODE:
1118
1123
  return;
1119
- #line 102 "node.c.erb"
1124
+ #line 103 "node.c.erb"
1120
1125
  case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
1121
1126
  pm_alias_global_variable_node_t *cast = (pm_alias_global_variable_node_t *) node;
1122
1127
  memsize->memsize += sizeof(*cast);
@@ -1124,7 +1129,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1124
1129
  pm_node_memsize_node((pm_node_t *)cast->old_name, memsize);
1125
1130
  break;
1126
1131
  }
1127
- #line 102 "node.c.erb"
1132
+ #line 103 "node.c.erb"
1128
1133
  case PM_ALIAS_METHOD_NODE: {
1129
1134
  pm_alias_method_node_t *cast = (pm_alias_method_node_t *) node;
1130
1135
  memsize->memsize += sizeof(*cast);
@@ -1132,7 +1137,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1132
1137
  pm_node_memsize_node((pm_node_t *)cast->old_name, memsize);
1133
1138
  break;
1134
1139
  }
1135
- #line 102 "node.c.erb"
1140
+ #line 103 "node.c.erb"
1136
1141
  case PM_ALTERNATION_PATTERN_NODE: {
1137
1142
  pm_alternation_pattern_node_t *cast = (pm_alternation_pattern_node_t *) node;
1138
1143
  memsize->memsize += sizeof(*cast);
@@ -1140,7 +1145,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1140
1145
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1141
1146
  break;
1142
1147
  }
1143
- #line 102 "node.c.erb"
1148
+ #line 103 "node.c.erb"
1144
1149
  case PM_AND_NODE: {
1145
1150
  pm_and_node_t *cast = (pm_and_node_t *) node;
1146
1151
  memsize->memsize += sizeof(*cast);
@@ -1148,7 +1153,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1148
1153
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1149
1154
  break;
1150
1155
  }
1151
- #line 102 "node.c.erb"
1156
+ #line 103 "node.c.erb"
1152
1157
  case PM_ARGUMENTS_NODE: {
1153
1158
  pm_arguments_node_t *cast = (pm_arguments_node_t *) node;
1154
1159
  memsize->memsize += sizeof(*cast);
@@ -1157,7 +1162,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1157
1162
  memsize->memsize += pm_node_list_memsize(&cast->arguments, memsize);
1158
1163
  break;
1159
1164
  }
1160
- #line 102 "node.c.erb"
1165
+ #line 103 "node.c.erb"
1161
1166
  case PM_ARRAY_NODE: {
1162
1167
  pm_array_node_t *cast = (pm_array_node_t *) node;
1163
1168
  memsize->memsize += sizeof(*cast);
@@ -1166,7 +1171,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1166
1171
  memsize->memsize += pm_node_list_memsize(&cast->elements, memsize);
1167
1172
  break;
1168
1173
  }
1169
- #line 102 "node.c.erb"
1174
+ #line 103 "node.c.erb"
1170
1175
  case PM_ARRAY_PATTERN_NODE: {
1171
1176
  pm_array_pattern_node_t *cast = (pm_array_pattern_node_t *) node;
1172
1177
  memsize->memsize += sizeof(*cast);
@@ -1182,7 +1187,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1182
1187
  memsize->memsize += pm_node_list_memsize(&cast->posts, memsize);
1183
1188
  break;
1184
1189
  }
1185
- #line 102 "node.c.erb"
1190
+ #line 103 "node.c.erb"
1186
1191
  case PM_ASSOC_NODE: {
1187
1192
  pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
1188
1193
  memsize->memsize += sizeof(*cast);
@@ -1192,7 +1197,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1192
1197
  }
1193
1198
  break;
1194
1199
  }
1195
- #line 102 "node.c.erb"
1200
+ #line 103 "node.c.erb"
1196
1201
  case PM_ASSOC_SPLAT_NODE: {
1197
1202
  pm_assoc_splat_node_t *cast = (pm_assoc_splat_node_t *) node;
1198
1203
  memsize->memsize += sizeof(*cast);
@@ -1201,13 +1206,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1201
1206
  }
1202
1207
  break;
1203
1208
  }
1204
- #line 102 "node.c.erb"
1209
+ #line 103 "node.c.erb"
1205
1210
  case PM_BACK_REFERENCE_READ_NODE: {
1206
1211
  pm_back_reference_read_node_t *cast = (pm_back_reference_read_node_t *) node;
1207
1212
  memsize->memsize += sizeof(*cast);
1208
1213
  break;
1209
1214
  }
1210
- #line 102 "node.c.erb"
1215
+ #line 103 "node.c.erb"
1211
1216
  case PM_BEGIN_NODE: {
1212
1217
  pm_begin_node_t *cast = (pm_begin_node_t *) node;
1213
1218
  memsize->memsize += sizeof(*cast);
@@ -1225,7 +1230,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1225
1230
  }
1226
1231
  break;
1227
1232
  }
1228
- #line 102 "node.c.erb"
1233
+ #line 103 "node.c.erb"
1229
1234
  case PM_BLOCK_ARGUMENT_NODE: {
1230
1235
  pm_block_argument_node_t *cast = (pm_block_argument_node_t *) node;
1231
1236
  memsize->memsize += sizeof(*cast);
@@ -1234,13 +1239,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1234
1239
  }
1235
1240
  break;
1236
1241
  }
1237
- #line 102 "node.c.erb"
1242
+ #line 103 "node.c.erb"
1238
1243
  case PM_BLOCK_LOCAL_VARIABLE_NODE: {
1239
1244
  pm_block_local_variable_node_t *cast = (pm_block_local_variable_node_t *) node;
1240
1245
  memsize->memsize += sizeof(*cast);
1241
1246
  break;
1242
1247
  }
1243
- #line 102 "node.c.erb"
1248
+ #line 103 "node.c.erb"
1244
1249
  case PM_BLOCK_NODE: {
1245
1250
  pm_block_node_t *cast = (pm_block_node_t *) node;
1246
1251
  memsize->memsize += sizeof(*cast);
@@ -1255,13 +1260,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1255
1260
  }
1256
1261
  break;
1257
1262
  }
1258
- #line 102 "node.c.erb"
1263
+ #line 103 "node.c.erb"
1259
1264
  case PM_BLOCK_PARAMETER_NODE: {
1260
1265
  pm_block_parameter_node_t *cast = (pm_block_parameter_node_t *) node;
1261
1266
  memsize->memsize += sizeof(*cast);
1262
1267
  break;
1263
1268
  }
1264
- #line 102 "node.c.erb"
1269
+ #line 103 "node.c.erb"
1265
1270
  case PM_BLOCK_PARAMETERS_NODE: {
1266
1271
  pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) node;
1267
1272
  memsize->memsize += sizeof(*cast);
@@ -1273,7 +1278,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1273
1278
  memsize->memsize += pm_node_list_memsize(&cast->locals, memsize);
1274
1279
  break;
1275
1280
  }
1276
- #line 102 "node.c.erb"
1281
+ #line 103 "node.c.erb"
1277
1282
  case PM_BREAK_NODE: {
1278
1283
  pm_break_node_t *cast = (pm_break_node_t *) node;
1279
1284
  memsize->memsize += sizeof(*cast);
@@ -1282,7 +1287,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1282
1287
  }
1283
1288
  break;
1284
1289
  }
1285
- #line 102 "node.c.erb"
1290
+ #line 103 "node.c.erb"
1286
1291
  case PM_CALL_AND_WRITE_NODE: {
1287
1292
  pm_call_and_write_node_t *cast = (pm_call_and_write_node_t *) node;
1288
1293
  memsize->memsize += sizeof(*cast);
@@ -1292,7 +1297,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1292
1297
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1293
1298
  break;
1294
1299
  }
1295
- #line 102 "node.c.erb"
1300
+ #line 103 "node.c.erb"
1296
1301
  case PM_CALL_NODE: {
1297
1302
  pm_call_node_t *cast = (pm_call_node_t *) node;
1298
1303
  memsize->memsize += sizeof(*cast);
@@ -1307,7 +1312,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1307
1312
  }
1308
1313
  break;
1309
1314
  }
1310
- #line 102 "node.c.erb"
1315
+ #line 103 "node.c.erb"
1311
1316
  case PM_CALL_OPERATOR_WRITE_NODE: {
1312
1317
  pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
1313
1318
  memsize->memsize += sizeof(*cast);
@@ -1317,7 +1322,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1317
1322
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1318
1323
  break;
1319
1324
  }
1320
- #line 102 "node.c.erb"
1325
+ #line 103 "node.c.erb"
1321
1326
  case PM_CALL_OR_WRITE_NODE: {
1322
1327
  pm_call_or_write_node_t *cast = (pm_call_or_write_node_t *) node;
1323
1328
  memsize->memsize += sizeof(*cast);
@@ -1327,7 +1332,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1327
1332
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1328
1333
  break;
1329
1334
  }
1330
- #line 102 "node.c.erb"
1335
+ #line 103 "node.c.erb"
1331
1336
  case PM_CAPTURE_PATTERN_NODE: {
1332
1337
  pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
1333
1338
  memsize->memsize += sizeof(*cast);
@@ -1335,7 +1340,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1335
1340
  pm_node_memsize_node((pm_node_t *)cast->target, memsize);
1336
1341
  break;
1337
1342
  }
1338
- #line 102 "node.c.erb"
1343
+ #line 103 "node.c.erb"
1339
1344
  case PM_CASE_NODE: {
1340
1345
  pm_case_node_t *cast = (pm_case_node_t *) node;
1341
1346
  memsize->memsize += sizeof(*cast);
@@ -1350,7 +1355,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1350
1355
  }
1351
1356
  break;
1352
1357
  }
1353
- #line 102 "node.c.erb"
1358
+ #line 103 "node.c.erb"
1354
1359
  case PM_CLASS_NODE: {
1355
1360
  pm_class_node_t *cast = (pm_class_node_t *) node;
1356
1361
  memsize->memsize += sizeof(*cast);
@@ -1366,68 +1371,68 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1366
1371
  }
1367
1372
  break;
1368
1373
  }
1369
- #line 102 "node.c.erb"
1374
+ #line 103 "node.c.erb"
1370
1375
  case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
1371
1376
  pm_class_variable_and_write_node_t *cast = (pm_class_variable_and_write_node_t *) node;
1372
1377
  memsize->memsize += sizeof(*cast);
1373
1378
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1374
1379
  break;
1375
1380
  }
1376
- #line 102 "node.c.erb"
1381
+ #line 103 "node.c.erb"
1377
1382
  case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1378
1383
  pm_class_variable_operator_write_node_t *cast = (pm_class_variable_operator_write_node_t *) node;
1379
1384
  memsize->memsize += sizeof(*cast);
1380
1385
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1381
1386
  break;
1382
1387
  }
1383
- #line 102 "node.c.erb"
1388
+ #line 103 "node.c.erb"
1384
1389
  case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
1385
1390
  pm_class_variable_or_write_node_t *cast = (pm_class_variable_or_write_node_t *) node;
1386
1391
  memsize->memsize += sizeof(*cast);
1387
1392
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1388
1393
  break;
1389
1394
  }
1390
- #line 102 "node.c.erb"
1395
+ #line 103 "node.c.erb"
1391
1396
  case PM_CLASS_VARIABLE_READ_NODE: {
1392
1397
  pm_class_variable_read_node_t *cast = (pm_class_variable_read_node_t *) node;
1393
1398
  memsize->memsize += sizeof(*cast);
1394
1399
  break;
1395
1400
  }
1396
- #line 102 "node.c.erb"
1401
+ #line 103 "node.c.erb"
1397
1402
  case PM_CLASS_VARIABLE_TARGET_NODE: {
1398
1403
  pm_class_variable_target_node_t *cast = (pm_class_variable_target_node_t *) node;
1399
1404
  memsize->memsize += sizeof(*cast);
1400
1405
  break;
1401
1406
  }
1402
- #line 102 "node.c.erb"
1407
+ #line 103 "node.c.erb"
1403
1408
  case PM_CLASS_VARIABLE_WRITE_NODE: {
1404
1409
  pm_class_variable_write_node_t *cast = (pm_class_variable_write_node_t *) node;
1405
1410
  memsize->memsize += sizeof(*cast);
1406
1411
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1407
1412
  break;
1408
1413
  }
1409
- #line 102 "node.c.erb"
1414
+ #line 103 "node.c.erb"
1410
1415
  case PM_CONSTANT_AND_WRITE_NODE: {
1411
1416
  pm_constant_and_write_node_t *cast = (pm_constant_and_write_node_t *) node;
1412
1417
  memsize->memsize += sizeof(*cast);
1413
1418
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1414
1419
  break;
1415
1420
  }
1416
- #line 102 "node.c.erb"
1421
+ #line 103 "node.c.erb"
1417
1422
  case PM_CONSTANT_OPERATOR_WRITE_NODE: {
1418
1423
  pm_constant_operator_write_node_t *cast = (pm_constant_operator_write_node_t *) node;
1419
1424
  memsize->memsize += sizeof(*cast);
1420
1425
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1421
1426
  break;
1422
1427
  }
1423
- #line 102 "node.c.erb"
1428
+ #line 103 "node.c.erb"
1424
1429
  case PM_CONSTANT_OR_WRITE_NODE: {
1425
1430
  pm_constant_or_write_node_t *cast = (pm_constant_or_write_node_t *) node;
1426
1431
  memsize->memsize += sizeof(*cast);
1427
1432
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1428
1433
  break;
1429
1434
  }
1430
- #line 102 "node.c.erb"
1435
+ #line 103 "node.c.erb"
1431
1436
  case PM_CONSTANT_PATH_AND_WRITE_NODE: {
1432
1437
  pm_constant_path_and_write_node_t *cast = (pm_constant_path_and_write_node_t *) node;
1433
1438
  memsize->memsize += sizeof(*cast);
@@ -1435,7 +1440,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1435
1440
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1436
1441
  break;
1437
1442
  }
1438
- #line 102 "node.c.erb"
1443
+ #line 103 "node.c.erb"
1439
1444
  case PM_CONSTANT_PATH_NODE: {
1440
1445
  pm_constant_path_node_t *cast = (pm_constant_path_node_t *) node;
1441
1446
  memsize->memsize += sizeof(*cast);
@@ -1445,7 +1450,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1445
1450
  pm_node_memsize_node((pm_node_t *)cast->child, memsize);
1446
1451
  break;
1447
1452
  }
1448
- #line 102 "node.c.erb"
1453
+ #line 103 "node.c.erb"
1449
1454
  case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1450
1455
  pm_constant_path_operator_write_node_t *cast = (pm_constant_path_operator_write_node_t *) node;
1451
1456
  memsize->memsize += sizeof(*cast);
@@ -1453,7 +1458,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1453
1458
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1454
1459
  break;
1455
1460
  }
1456
- #line 102 "node.c.erb"
1461
+ #line 103 "node.c.erb"
1457
1462
  case PM_CONSTANT_PATH_OR_WRITE_NODE: {
1458
1463
  pm_constant_path_or_write_node_t *cast = (pm_constant_path_or_write_node_t *) node;
1459
1464
  memsize->memsize += sizeof(*cast);
@@ -1461,7 +1466,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1461
1466
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1462
1467
  break;
1463
1468
  }
1464
- #line 102 "node.c.erb"
1469
+ #line 103 "node.c.erb"
1465
1470
  case PM_CONSTANT_PATH_TARGET_NODE: {
1466
1471
  pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *) node;
1467
1472
  memsize->memsize += sizeof(*cast);
@@ -1471,7 +1476,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1471
1476
  pm_node_memsize_node((pm_node_t *)cast->child, memsize);
1472
1477
  break;
1473
1478
  }
1474
- #line 102 "node.c.erb"
1479
+ #line 103 "node.c.erb"
1475
1480
  case PM_CONSTANT_PATH_WRITE_NODE: {
1476
1481
  pm_constant_path_write_node_t *cast = (pm_constant_path_write_node_t *) node;
1477
1482
  memsize->memsize += sizeof(*cast);
@@ -1479,26 +1484,26 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1479
1484
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1480
1485
  break;
1481
1486
  }
1482
- #line 102 "node.c.erb"
1487
+ #line 103 "node.c.erb"
1483
1488
  case PM_CONSTANT_READ_NODE: {
1484
1489
  pm_constant_read_node_t *cast = (pm_constant_read_node_t *) node;
1485
1490
  memsize->memsize += sizeof(*cast);
1486
1491
  break;
1487
1492
  }
1488
- #line 102 "node.c.erb"
1493
+ #line 103 "node.c.erb"
1489
1494
  case PM_CONSTANT_TARGET_NODE: {
1490
1495
  pm_constant_target_node_t *cast = (pm_constant_target_node_t *) node;
1491
1496
  memsize->memsize += sizeof(*cast);
1492
1497
  break;
1493
1498
  }
1494
- #line 102 "node.c.erb"
1499
+ #line 103 "node.c.erb"
1495
1500
  case PM_CONSTANT_WRITE_NODE: {
1496
1501
  pm_constant_write_node_t *cast = (pm_constant_write_node_t *) node;
1497
1502
  memsize->memsize += sizeof(*cast);
1498
1503
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1499
1504
  break;
1500
1505
  }
1501
- #line 102 "node.c.erb"
1506
+ #line 103 "node.c.erb"
1502
1507
  case PM_DEF_NODE: {
1503
1508
  pm_def_node_t *cast = (pm_def_node_t *) node;
1504
1509
  memsize->memsize += sizeof(*cast);
@@ -1516,14 +1521,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1516
1521
  memsize->memsize += pm_constant_id_list_memsize(&cast->locals);
1517
1522
  break;
1518
1523
  }
1519
- #line 102 "node.c.erb"
1524
+ #line 103 "node.c.erb"
1520
1525
  case PM_DEFINED_NODE: {
1521
1526
  pm_defined_node_t *cast = (pm_defined_node_t *) node;
1522
1527
  memsize->memsize += sizeof(*cast);
1523
1528
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1524
1529
  break;
1525
1530
  }
1526
- #line 102 "node.c.erb"
1531
+ #line 103 "node.c.erb"
1527
1532
  case PM_ELSE_NODE: {
1528
1533
  pm_else_node_t *cast = (pm_else_node_t *) node;
1529
1534
  memsize->memsize += sizeof(*cast);
@@ -1532,7 +1537,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1532
1537
  }
1533
1538
  break;
1534
1539
  }
1535
- #line 102 "node.c.erb"
1540
+ #line 103 "node.c.erb"
1536
1541
  case PM_EMBEDDED_STATEMENTS_NODE: {
1537
1542
  pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) node;
1538
1543
  memsize->memsize += sizeof(*cast);
@@ -1541,14 +1546,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1541
1546
  }
1542
1547
  break;
1543
1548
  }
1544
- #line 102 "node.c.erb"
1549
+ #line 103 "node.c.erb"
1545
1550
  case PM_EMBEDDED_VARIABLE_NODE: {
1546
1551
  pm_embedded_variable_node_t *cast = (pm_embedded_variable_node_t *) node;
1547
1552
  memsize->memsize += sizeof(*cast);
1548
1553
  pm_node_memsize_node((pm_node_t *)cast->variable, memsize);
1549
1554
  break;
1550
1555
  }
1551
- #line 102 "node.c.erb"
1556
+ #line 103 "node.c.erb"
1552
1557
  case PM_ENSURE_NODE: {
1553
1558
  pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
1554
1559
  memsize->memsize += sizeof(*cast);
@@ -1557,13 +1562,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1557
1562
  }
1558
1563
  break;
1559
1564
  }
1560
- #line 102 "node.c.erb"
1565
+ #line 103 "node.c.erb"
1561
1566
  case PM_FALSE_NODE: {
1562
1567
  pm_false_node_t *cast = (pm_false_node_t *) node;
1563
1568
  memsize->memsize += sizeof(*cast);
1564
1569
  break;
1565
1570
  }
1566
- #line 102 "node.c.erb"
1571
+ #line 103 "node.c.erb"
1567
1572
  case PM_FIND_PATTERN_NODE: {
1568
1573
  pm_find_pattern_node_t *cast = (pm_find_pattern_node_t *) node;
1569
1574
  memsize->memsize += sizeof(*cast);
@@ -1577,7 +1582,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1577
1582
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1578
1583
  break;
1579
1584
  }
1580
- #line 102 "node.c.erb"
1585
+ #line 103 "node.c.erb"
1581
1586
  case PM_FLIP_FLOP_NODE: {
1582
1587
  pm_flip_flop_node_t *cast = (pm_flip_flop_node_t *) node;
1583
1588
  memsize->memsize += sizeof(*cast);
@@ -1589,13 +1594,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1589
1594
  }
1590
1595
  break;
1591
1596
  }
1592
- #line 102 "node.c.erb"
1597
+ #line 103 "node.c.erb"
1593
1598
  case PM_FLOAT_NODE: {
1594
1599
  pm_float_node_t *cast = (pm_float_node_t *) node;
1595
1600
  memsize->memsize += sizeof(*cast);
1596
1601
  break;
1597
1602
  }
1598
- #line 102 "node.c.erb"
1603
+ #line 103 "node.c.erb"
1599
1604
  case PM_FOR_NODE: {
1600
1605
  pm_for_node_t *cast = (pm_for_node_t *) node;
1601
1606
  memsize->memsize += sizeof(*cast);
@@ -1606,19 +1611,19 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1606
1611
  }
1607
1612
  break;
1608
1613
  }
1609
- #line 102 "node.c.erb"
1614
+ #line 103 "node.c.erb"
1610
1615
  case PM_FORWARDING_ARGUMENTS_NODE: {
1611
1616
  pm_forwarding_arguments_node_t *cast = (pm_forwarding_arguments_node_t *) node;
1612
1617
  memsize->memsize += sizeof(*cast);
1613
1618
  break;
1614
1619
  }
1615
- #line 102 "node.c.erb"
1620
+ #line 103 "node.c.erb"
1616
1621
  case PM_FORWARDING_PARAMETER_NODE: {
1617
1622
  pm_forwarding_parameter_node_t *cast = (pm_forwarding_parameter_node_t *) node;
1618
1623
  memsize->memsize += sizeof(*cast);
1619
1624
  break;
1620
1625
  }
1621
- #line 102 "node.c.erb"
1626
+ #line 103 "node.c.erb"
1622
1627
  case PM_FORWARDING_SUPER_NODE: {
1623
1628
  pm_forwarding_super_node_t *cast = (pm_forwarding_super_node_t *) node;
1624
1629
  memsize->memsize += sizeof(*cast);
@@ -1627,47 +1632,47 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1627
1632
  }
1628
1633
  break;
1629
1634
  }
1630
- #line 102 "node.c.erb"
1635
+ #line 103 "node.c.erb"
1631
1636
  case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
1632
1637
  pm_global_variable_and_write_node_t *cast = (pm_global_variable_and_write_node_t *) node;
1633
1638
  memsize->memsize += sizeof(*cast);
1634
1639
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1635
1640
  break;
1636
1641
  }
1637
- #line 102 "node.c.erb"
1642
+ #line 103 "node.c.erb"
1638
1643
  case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
1639
1644
  pm_global_variable_operator_write_node_t *cast = (pm_global_variable_operator_write_node_t *) node;
1640
1645
  memsize->memsize += sizeof(*cast);
1641
1646
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1642
1647
  break;
1643
1648
  }
1644
- #line 102 "node.c.erb"
1649
+ #line 103 "node.c.erb"
1645
1650
  case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
1646
1651
  pm_global_variable_or_write_node_t *cast = (pm_global_variable_or_write_node_t *) node;
1647
1652
  memsize->memsize += sizeof(*cast);
1648
1653
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1649
1654
  break;
1650
1655
  }
1651
- #line 102 "node.c.erb"
1656
+ #line 103 "node.c.erb"
1652
1657
  case PM_GLOBAL_VARIABLE_READ_NODE: {
1653
1658
  pm_global_variable_read_node_t *cast = (pm_global_variable_read_node_t *) node;
1654
1659
  memsize->memsize += sizeof(*cast);
1655
1660
  break;
1656
1661
  }
1657
- #line 102 "node.c.erb"
1662
+ #line 103 "node.c.erb"
1658
1663
  case PM_GLOBAL_VARIABLE_TARGET_NODE: {
1659
1664
  pm_global_variable_target_node_t *cast = (pm_global_variable_target_node_t *) node;
1660
1665
  memsize->memsize += sizeof(*cast);
1661
1666
  break;
1662
1667
  }
1663
- #line 102 "node.c.erb"
1668
+ #line 103 "node.c.erb"
1664
1669
  case PM_GLOBAL_VARIABLE_WRITE_NODE: {
1665
1670
  pm_global_variable_write_node_t *cast = (pm_global_variable_write_node_t *) node;
1666
1671
  memsize->memsize += sizeof(*cast);
1667
1672
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1668
1673
  break;
1669
1674
  }
1670
- #line 102 "node.c.erb"
1675
+ #line 103 "node.c.erb"
1671
1676
  case PM_HASH_NODE: {
1672
1677
  pm_hash_node_t *cast = (pm_hash_node_t *) node;
1673
1678
  memsize->memsize += sizeof(*cast);
@@ -1676,7 +1681,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1676
1681
  memsize->memsize += pm_node_list_memsize(&cast->elements, memsize);
1677
1682
  break;
1678
1683
  }
1679
- #line 102 "node.c.erb"
1684
+ #line 103 "node.c.erb"
1680
1685
  case PM_HASH_PATTERN_NODE: {
1681
1686
  pm_hash_pattern_node_t *cast = (pm_hash_pattern_node_t *) node;
1682
1687
  memsize->memsize += sizeof(*cast);
@@ -1685,13 +1690,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1685
1690
  if (cast->constant != NULL) {
1686
1691
  pm_node_memsize_node((pm_node_t *)cast->constant, memsize);
1687
1692
  }
1688
- memsize->memsize += pm_node_list_memsize(&cast->assocs, memsize);
1689
- if (cast->kwrest != NULL) {
1690
- pm_node_memsize_node((pm_node_t *)cast->kwrest, memsize);
1693
+ memsize->memsize += pm_node_list_memsize(&cast->elements, memsize);
1694
+ if (cast->rest != NULL) {
1695
+ pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
1691
1696
  }
1692
1697
  break;
1693
1698
  }
1694
- #line 102 "node.c.erb"
1699
+ #line 103 "node.c.erb"
1695
1700
  case PM_IF_NODE: {
1696
1701
  pm_if_node_t *cast = (pm_if_node_t *) node;
1697
1702
  memsize->memsize += sizeof(*cast);
@@ -1704,21 +1709,21 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1704
1709
  }
1705
1710
  break;
1706
1711
  }
1707
- #line 102 "node.c.erb"
1712
+ #line 103 "node.c.erb"
1708
1713
  case PM_IMAGINARY_NODE: {
1709
1714
  pm_imaginary_node_t *cast = (pm_imaginary_node_t *) node;
1710
1715
  memsize->memsize += sizeof(*cast);
1711
1716
  pm_node_memsize_node((pm_node_t *)cast->numeric, memsize);
1712
1717
  break;
1713
1718
  }
1714
- #line 102 "node.c.erb"
1719
+ #line 103 "node.c.erb"
1715
1720
  case PM_IMPLICIT_NODE: {
1716
1721
  pm_implicit_node_t *cast = (pm_implicit_node_t *) node;
1717
1722
  memsize->memsize += sizeof(*cast);
1718
1723
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1719
1724
  break;
1720
1725
  }
1721
- #line 102 "node.c.erb"
1726
+ #line 103 "node.c.erb"
1722
1727
  case PM_IN_NODE: {
1723
1728
  pm_in_node_t *cast = (pm_in_node_t *) node;
1724
1729
  memsize->memsize += sizeof(*cast);
@@ -1728,7 +1733,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1728
1733
  }
1729
1734
  break;
1730
1735
  }
1731
- #line 102 "node.c.erb"
1736
+ #line 103 "node.c.erb"
1732
1737
  case PM_INDEX_AND_WRITE_NODE: {
1733
1738
  pm_index_and_write_node_t *cast = (pm_index_and_write_node_t *) node;
1734
1739
  memsize->memsize += sizeof(*cast);
@@ -1744,7 +1749,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1744
1749
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1745
1750
  break;
1746
1751
  }
1747
- #line 102 "node.c.erb"
1752
+ #line 103 "node.c.erb"
1748
1753
  case PM_INDEX_OPERATOR_WRITE_NODE: {
1749
1754
  pm_index_operator_write_node_t *cast = (pm_index_operator_write_node_t *) node;
1750
1755
  memsize->memsize += sizeof(*cast);
@@ -1760,7 +1765,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1760
1765
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1761
1766
  break;
1762
1767
  }
1763
- #line 102 "node.c.erb"
1768
+ #line 103 "node.c.erb"
1764
1769
  case PM_INDEX_OR_WRITE_NODE: {
1765
1770
  pm_index_or_write_node_t *cast = (pm_index_or_write_node_t *) node;
1766
1771
  memsize->memsize += sizeof(*cast);
@@ -1776,53 +1781,53 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1776
1781
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1777
1782
  break;
1778
1783
  }
1779
- #line 102 "node.c.erb"
1784
+ #line 103 "node.c.erb"
1780
1785
  case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1781
1786
  pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
1782
1787
  memsize->memsize += sizeof(*cast);
1783
1788
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1784
1789
  break;
1785
1790
  }
1786
- #line 102 "node.c.erb"
1791
+ #line 103 "node.c.erb"
1787
1792
  case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1788
1793
  pm_instance_variable_operator_write_node_t *cast = (pm_instance_variable_operator_write_node_t *) node;
1789
1794
  memsize->memsize += sizeof(*cast);
1790
1795
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1791
1796
  break;
1792
1797
  }
1793
- #line 102 "node.c.erb"
1798
+ #line 103 "node.c.erb"
1794
1799
  case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1795
1800
  pm_instance_variable_or_write_node_t *cast = (pm_instance_variable_or_write_node_t *) node;
1796
1801
  memsize->memsize += sizeof(*cast);
1797
1802
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1798
1803
  break;
1799
1804
  }
1800
- #line 102 "node.c.erb"
1805
+ #line 103 "node.c.erb"
1801
1806
  case PM_INSTANCE_VARIABLE_READ_NODE: {
1802
1807
  pm_instance_variable_read_node_t *cast = (pm_instance_variable_read_node_t *) node;
1803
1808
  memsize->memsize += sizeof(*cast);
1804
1809
  break;
1805
1810
  }
1806
- #line 102 "node.c.erb"
1811
+ #line 103 "node.c.erb"
1807
1812
  case PM_INSTANCE_VARIABLE_TARGET_NODE: {
1808
1813
  pm_instance_variable_target_node_t *cast = (pm_instance_variable_target_node_t *) node;
1809
1814
  memsize->memsize += sizeof(*cast);
1810
1815
  break;
1811
1816
  }
1812
- #line 102 "node.c.erb"
1817
+ #line 103 "node.c.erb"
1813
1818
  case PM_INSTANCE_VARIABLE_WRITE_NODE: {
1814
1819
  pm_instance_variable_write_node_t *cast = (pm_instance_variable_write_node_t *) node;
1815
1820
  memsize->memsize += sizeof(*cast);
1816
1821
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1817
1822
  break;
1818
1823
  }
1819
- #line 102 "node.c.erb"
1824
+ #line 103 "node.c.erb"
1820
1825
  case PM_INTEGER_NODE: {
1821
1826
  pm_integer_node_t *cast = (pm_integer_node_t *) node;
1822
1827
  memsize->memsize += sizeof(*cast);
1823
1828
  break;
1824
1829
  }
1825
- #line 102 "node.c.erb"
1830
+ #line 103 "node.c.erb"
1826
1831
  case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1827
1832
  pm_interpolated_match_last_line_node_t *cast = (pm_interpolated_match_last_line_node_t *) node;
1828
1833
  memsize->memsize += sizeof(*cast);
@@ -1831,7 +1836,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1831
1836
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1832
1837
  break;
1833
1838
  }
1834
- #line 102 "node.c.erb"
1839
+ #line 103 "node.c.erb"
1835
1840
  case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1836
1841
  pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
1837
1842
  memsize->memsize += sizeof(*cast);
@@ -1840,7 +1845,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1840
1845
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1841
1846
  break;
1842
1847
  }
1843
- #line 102 "node.c.erb"
1848
+ #line 103 "node.c.erb"
1844
1849
  case PM_INTERPOLATED_STRING_NODE: {
1845
1850
  pm_interpolated_string_node_t *cast = (pm_interpolated_string_node_t *) node;
1846
1851
  memsize->memsize += sizeof(*cast);
@@ -1849,7 +1854,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1849
1854
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1850
1855
  break;
1851
1856
  }
1852
- #line 102 "node.c.erb"
1857
+ #line 103 "node.c.erb"
1853
1858
  case PM_INTERPOLATED_SYMBOL_NODE: {
1854
1859
  pm_interpolated_symbol_node_t *cast = (pm_interpolated_symbol_node_t *) node;
1855
1860
  memsize->memsize += sizeof(*cast);
@@ -1858,7 +1863,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1858
1863
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1859
1864
  break;
1860
1865
  }
1861
- #line 102 "node.c.erb"
1866
+ #line 103 "node.c.erb"
1862
1867
  case PM_INTERPOLATED_X_STRING_NODE: {
1863
1868
  pm_interpolated_x_string_node_t *cast = (pm_interpolated_x_string_node_t *) node;
1864
1869
  memsize->memsize += sizeof(*cast);
@@ -1867,7 +1872,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1867
1872
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1868
1873
  break;
1869
1874
  }
1870
- #line 102 "node.c.erb"
1875
+ #line 103 "node.c.erb"
1871
1876
  case PM_KEYWORD_HASH_NODE: {
1872
1877
  pm_keyword_hash_node_t *cast = (pm_keyword_hash_node_t *) node;
1873
1878
  memsize->memsize += sizeof(*cast);
@@ -1876,22 +1881,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1876
1881
  memsize->memsize += pm_node_list_memsize(&cast->elements, memsize);
1877
1882
  break;
1878
1883
  }
1879
- #line 102 "node.c.erb"
1880
- case PM_KEYWORD_PARAMETER_NODE: {
1881
- pm_keyword_parameter_node_t *cast = (pm_keyword_parameter_node_t *) node;
1882
- memsize->memsize += sizeof(*cast);
1883
- if (cast->value != NULL) {
1884
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1885
- }
1886
- break;
1887
- }
1888
- #line 102 "node.c.erb"
1884
+ #line 103 "node.c.erb"
1889
1885
  case PM_KEYWORD_REST_PARAMETER_NODE: {
1890
1886
  pm_keyword_rest_parameter_node_t *cast = (pm_keyword_rest_parameter_node_t *) node;
1891
1887
  memsize->memsize += sizeof(*cast);
1892
1888
  break;
1893
1889
  }
1894
- #line 102 "node.c.erb"
1890
+ #line 103 "node.c.erb"
1895
1891
  case PM_LAMBDA_NODE: {
1896
1892
  pm_lambda_node_t *cast = (pm_lambda_node_t *) node;
1897
1893
  memsize->memsize += sizeof(*cast);
@@ -1906,54 +1902,54 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1906
1902
  }
1907
1903
  break;
1908
1904
  }
1909
- #line 102 "node.c.erb"
1905
+ #line 103 "node.c.erb"
1910
1906
  case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
1911
1907
  pm_local_variable_and_write_node_t *cast = (pm_local_variable_and_write_node_t *) node;
1912
1908
  memsize->memsize += sizeof(*cast);
1913
1909
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1914
1910
  break;
1915
1911
  }
1916
- #line 102 "node.c.erb"
1912
+ #line 103 "node.c.erb"
1917
1913
  case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1918
1914
  pm_local_variable_operator_write_node_t *cast = (pm_local_variable_operator_write_node_t *) node;
1919
1915
  memsize->memsize += sizeof(*cast);
1920
1916
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1921
1917
  break;
1922
1918
  }
1923
- #line 102 "node.c.erb"
1919
+ #line 103 "node.c.erb"
1924
1920
  case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
1925
1921
  pm_local_variable_or_write_node_t *cast = (pm_local_variable_or_write_node_t *) node;
1926
1922
  memsize->memsize += sizeof(*cast);
1927
1923
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1928
1924
  break;
1929
1925
  }
1930
- #line 102 "node.c.erb"
1926
+ #line 103 "node.c.erb"
1931
1927
  case PM_LOCAL_VARIABLE_READ_NODE: {
1932
1928
  pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
1933
1929
  memsize->memsize += sizeof(*cast);
1934
1930
  break;
1935
1931
  }
1936
- #line 102 "node.c.erb"
1932
+ #line 103 "node.c.erb"
1937
1933
  case PM_LOCAL_VARIABLE_TARGET_NODE: {
1938
1934
  pm_local_variable_target_node_t *cast = (pm_local_variable_target_node_t *) node;
1939
1935
  memsize->memsize += sizeof(*cast);
1940
1936
  break;
1941
1937
  }
1942
- #line 102 "node.c.erb"
1938
+ #line 103 "node.c.erb"
1943
1939
  case PM_LOCAL_VARIABLE_WRITE_NODE: {
1944
1940
  pm_local_variable_write_node_t *cast = (pm_local_variable_write_node_t *) node;
1945
1941
  memsize->memsize += sizeof(*cast);
1946
1942
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1947
1943
  break;
1948
1944
  }
1949
- #line 102 "node.c.erb"
1945
+ #line 103 "node.c.erb"
1950
1946
  case PM_MATCH_LAST_LINE_NODE: {
1951
1947
  pm_match_last_line_node_t *cast = (pm_match_last_line_node_t *) node;
1952
1948
  memsize->memsize += sizeof(*cast);
1953
1949
  memsize->memsize += pm_string_memsize(&cast->unescaped);
1954
1950
  break;
1955
1951
  }
1956
- #line 102 "node.c.erb"
1952
+ #line 103 "node.c.erb"
1957
1953
  case PM_MATCH_PREDICATE_NODE: {
1958
1954
  pm_match_predicate_node_t *cast = (pm_match_predicate_node_t *) node;
1959
1955
  memsize->memsize += sizeof(*cast);
@@ -1961,7 +1957,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1961
1957
  pm_node_memsize_node((pm_node_t *)cast->pattern, memsize);
1962
1958
  break;
1963
1959
  }
1964
- #line 102 "node.c.erb"
1960
+ #line 103 "node.c.erb"
1965
1961
  case PM_MATCH_REQUIRED_NODE: {
1966
1962
  pm_match_required_node_t *cast = (pm_match_required_node_t *) node;
1967
1963
  memsize->memsize += sizeof(*cast);
@@ -1969,7 +1965,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1969
1965
  pm_node_memsize_node((pm_node_t *)cast->pattern, memsize);
1970
1966
  break;
1971
1967
  }
1972
- #line 102 "node.c.erb"
1968
+ #line 103 "node.c.erb"
1973
1969
  case PM_MATCH_WRITE_NODE: {
1974
1970
  pm_match_write_node_t *cast = (pm_match_write_node_t *) node;
1975
1971
  memsize->memsize += sizeof(*cast);
@@ -1979,13 +1975,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1979
1975
  memsize->memsize += pm_constant_id_list_memsize(&cast->locals);
1980
1976
  break;
1981
1977
  }
1982
- #line 102 "node.c.erb"
1978
+ #line 103 "node.c.erb"
1983
1979
  case PM_MISSING_NODE: {
1984
1980
  pm_missing_node_t *cast = (pm_missing_node_t *) node;
1985
1981
  memsize->memsize += sizeof(*cast);
1986
1982
  break;
1987
1983
  }
1988
- #line 102 "node.c.erb"
1984
+ #line 103 "node.c.erb"
1989
1985
  case PM_MODULE_NODE: {
1990
1986
  pm_module_node_t *cast = (pm_module_node_t *) node;
1991
1987
  memsize->memsize += sizeof(*cast);
@@ -1998,26 +1994,34 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1998
1994
  }
1999
1995
  break;
2000
1996
  }
2001
- #line 102 "node.c.erb"
1997
+ #line 103 "node.c.erb"
2002
1998
  case PM_MULTI_TARGET_NODE: {
2003
1999
  pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
2004
2000
  memsize->memsize += sizeof(*cast);
2005
2001
  // Node lists will add in their own sizes below.
2006
- memsize->memsize -= sizeof(pm_node_list_t) * 1;
2007
- memsize->memsize += pm_node_list_memsize(&cast->targets, memsize);
2002
+ memsize->memsize -= sizeof(pm_node_list_t) * 2;
2003
+ memsize->memsize += pm_node_list_memsize(&cast->lefts, memsize);
2004
+ if (cast->rest != NULL) {
2005
+ pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
2006
+ }
2007
+ memsize->memsize += pm_node_list_memsize(&cast->rights, memsize);
2008
2008
  break;
2009
2009
  }
2010
- #line 102 "node.c.erb"
2010
+ #line 103 "node.c.erb"
2011
2011
  case PM_MULTI_WRITE_NODE: {
2012
2012
  pm_multi_write_node_t *cast = (pm_multi_write_node_t *) node;
2013
2013
  memsize->memsize += sizeof(*cast);
2014
2014
  // Node lists will add in their own sizes below.
2015
- memsize->memsize -= sizeof(pm_node_list_t) * 1;
2016
- memsize->memsize += pm_node_list_memsize(&cast->targets, memsize);
2015
+ memsize->memsize -= sizeof(pm_node_list_t) * 2;
2016
+ memsize->memsize += pm_node_list_memsize(&cast->lefts, memsize);
2017
+ if (cast->rest != NULL) {
2018
+ pm_node_memsize_node((pm_node_t *)cast->rest, memsize);
2019
+ }
2020
+ memsize->memsize += pm_node_list_memsize(&cast->rights, memsize);
2017
2021
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
2018
2022
  break;
2019
2023
  }
2020
- #line 102 "node.c.erb"
2024
+ #line 103 "node.c.erb"
2021
2025
  case PM_NEXT_NODE: {
2022
2026
  pm_next_node_t *cast = (pm_next_node_t *) node;
2023
2027
  memsize->memsize += sizeof(*cast);
@@ -2026,32 +2030,39 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2026
2030
  }
2027
2031
  break;
2028
2032
  }
2029
- #line 102 "node.c.erb"
2033
+ #line 103 "node.c.erb"
2030
2034
  case PM_NIL_NODE: {
2031
2035
  pm_nil_node_t *cast = (pm_nil_node_t *) node;
2032
2036
  memsize->memsize += sizeof(*cast);
2033
2037
  break;
2034
2038
  }
2035
- #line 102 "node.c.erb"
2039
+ #line 103 "node.c.erb"
2036
2040
  case PM_NO_KEYWORDS_PARAMETER_NODE: {
2037
2041
  pm_no_keywords_parameter_node_t *cast = (pm_no_keywords_parameter_node_t *) node;
2038
2042
  memsize->memsize += sizeof(*cast);
2039
2043
  break;
2040
2044
  }
2041
- #line 102 "node.c.erb"
2045
+ #line 103 "node.c.erb"
2042
2046
  case PM_NUMBERED_REFERENCE_READ_NODE: {
2043
2047
  pm_numbered_reference_read_node_t *cast = (pm_numbered_reference_read_node_t *) node;
2044
2048
  memsize->memsize += sizeof(*cast);
2045
2049
  break;
2046
2050
  }
2047
- #line 102 "node.c.erb"
2051
+ #line 103 "node.c.erb"
2052
+ case PM_OPTIONAL_KEYWORD_PARAMETER_NODE: {
2053
+ pm_optional_keyword_parameter_node_t *cast = (pm_optional_keyword_parameter_node_t *) node;
2054
+ memsize->memsize += sizeof(*cast);
2055
+ pm_node_memsize_node((pm_node_t *)cast->value, memsize);
2056
+ break;
2057
+ }
2058
+ #line 103 "node.c.erb"
2048
2059
  case PM_OPTIONAL_PARAMETER_NODE: {
2049
2060
  pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
2050
2061
  memsize->memsize += sizeof(*cast);
2051
2062
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
2052
2063
  break;
2053
2064
  }
2054
- #line 102 "node.c.erb"
2065
+ #line 103 "node.c.erb"
2055
2066
  case PM_OR_NODE: {
2056
2067
  pm_or_node_t *cast = (pm_or_node_t *) node;
2057
2068
  memsize->memsize += sizeof(*cast);
@@ -2059,7 +2070,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2059
2070
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
2060
2071
  break;
2061
2072
  }
2062
- #line 102 "node.c.erb"
2073
+ #line 103 "node.c.erb"
2063
2074
  case PM_PARAMETERS_NODE: {
2064
2075
  pm_parameters_node_t *cast = (pm_parameters_node_t *) node;
2065
2076
  memsize->memsize += sizeof(*cast);
@@ -2080,7 +2091,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2080
2091
  }
2081
2092
  break;
2082
2093
  }
2083
- #line 102 "node.c.erb"
2094
+ #line 103 "node.c.erb"
2084
2095
  case PM_PARENTHESES_NODE: {
2085
2096
  pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
2086
2097
  memsize->memsize += sizeof(*cast);
@@ -2089,21 +2100,21 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2089
2100
  }
2090
2101
  break;
2091
2102
  }
2092
- #line 102 "node.c.erb"
2103
+ #line 103 "node.c.erb"
2093
2104
  case PM_PINNED_EXPRESSION_NODE: {
2094
2105
  pm_pinned_expression_node_t *cast = (pm_pinned_expression_node_t *) node;
2095
2106
  memsize->memsize += sizeof(*cast);
2096
2107
  pm_node_memsize_node((pm_node_t *)cast->expression, memsize);
2097
2108
  break;
2098
2109
  }
2099
- #line 102 "node.c.erb"
2110
+ #line 103 "node.c.erb"
2100
2111
  case PM_PINNED_VARIABLE_NODE: {
2101
2112
  pm_pinned_variable_node_t *cast = (pm_pinned_variable_node_t *) node;
2102
2113
  memsize->memsize += sizeof(*cast);
2103
2114
  pm_node_memsize_node((pm_node_t *)cast->variable, memsize);
2104
2115
  break;
2105
2116
  }
2106
- #line 102 "node.c.erb"
2117
+ #line 103 "node.c.erb"
2107
2118
  case PM_POST_EXECUTION_NODE: {
2108
2119
  pm_post_execution_node_t *cast = (pm_post_execution_node_t *) node;
2109
2120
  memsize->memsize += sizeof(*cast);
@@ -2112,7 +2123,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2112
2123
  }
2113
2124
  break;
2114
2125
  }
2115
- #line 102 "node.c.erb"
2126
+ #line 103 "node.c.erb"
2116
2127
  case PM_PRE_EXECUTION_NODE: {
2117
2128
  pm_pre_execution_node_t *cast = (pm_pre_execution_node_t *) node;
2118
2129
  memsize->memsize += sizeof(*cast);
@@ -2121,7 +2132,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2121
2132
  }
2122
2133
  break;
2123
2134
  }
2124
- #line 102 "node.c.erb"
2135
+ #line 103 "node.c.erb"
2125
2136
  case PM_PROGRAM_NODE: {
2126
2137
  pm_program_node_t *cast = (pm_program_node_t *) node;
2127
2138
  memsize->memsize += sizeof(*cast);
@@ -2131,7 +2142,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2131
2142
  pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
2132
2143
  break;
2133
2144
  }
2134
- #line 102 "node.c.erb"
2145
+ #line 103 "node.c.erb"
2135
2146
  case PM_RANGE_NODE: {
2136
2147
  pm_range_node_t *cast = (pm_range_node_t *) node;
2137
2148
  memsize->memsize += sizeof(*cast);
@@ -2143,42 +2154,39 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2143
2154
  }
2144
2155
  break;
2145
2156
  }
2146
- #line 102 "node.c.erb"
2157
+ #line 103 "node.c.erb"
2147
2158
  case PM_RATIONAL_NODE: {
2148
2159
  pm_rational_node_t *cast = (pm_rational_node_t *) node;
2149
2160
  memsize->memsize += sizeof(*cast);
2150
2161
  pm_node_memsize_node((pm_node_t *)cast->numeric, memsize);
2151
2162
  break;
2152
2163
  }
2153
- #line 102 "node.c.erb"
2164
+ #line 103 "node.c.erb"
2154
2165
  case PM_REDO_NODE: {
2155
2166
  pm_redo_node_t *cast = (pm_redo_node_t *) node;
2156
2167
  memsize->memsize += sizeof(*cast);
2157
2168
  break;
2158
2169
  }
2159
- #line 102 "node.c.erb"
2170
+ #line 103 "node.c.erb"
2160
2171
  case PM_REGULAR_EXPRESSION_NODE: {
2161
2172
  pm_regular_expression_node_t *cast = (pm_regular_expression_node_t *) node;
2162
2173
  memsize->memsize += sizeof(*cast);
2163
2174
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2164
2175
  break;
2165
2176
  }
2166
- #line 102 "node.c.erb"
2167
- case PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
2168
- pm_required_destructured_parameter_node_t *cast = (pm_required_destructured_parameter_node_t *) node;
2177
+ #line 103 "node.c.erb"
2178
+ case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
2179
+ pm_required_keyword_parameter_node_t *cast = (pm_required_keyword_parameter_node_t *) node;
2169
2180
  memsize->memsize += sizeof(*cast);
2170
- // Node lists will add in their own sizes below.
2171
- memsize->memsize -= sizeof(pm_node_list_t) * 1;
2172
- memsize->memsize += pm_node_list_memsize(&cast->parameters, memsize);
2173
2181
  break;
2174
2182
  }
2175
- #line 102 "node.c.erb"
2183
+ #line 103 "node.c.erb"
2176
2184
  case PM_REQUIRED_PARAMETER_NODE: {
2177
2185
  pm_required_parameter_node_t *cast = (pm_required_parameter_node_t *) node;
2178
2186
  memsize->memsize += sizeof(*cast);
2179
2187
  break;
2180
2188
  }
2181
- #line 102 "node.c.erb"
2189
+ #line 103 "node.c.erb"
2182
2190
  case PM_RESCUE_MODIFIER_NODE: {
2183
2191
  pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
2184
2192
  memsize->memsize += sizeof(*cast);
@@ -2186,7 +2194,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2186
2194
  pm_node_memsize_node((pm_node_t *)cast->rescue_expression, memsize);
2187
2195
  break;
2188
2196
  }
2189
- #line 102 "node.c.erb"
2197
+ #line 103 "node.c.erb"
2190
2198
  case PM_RESCUE_NODE: {
2191
2199
  pm_rescue_node_t *cast = (pm_rescue_node_t *) node;
2192
2200
  memsize->memsize += sizeof(*cast);
@@ -2204,19 +2212,19 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2204
2212
  }
2205
2213
  break;
2206
2214
  }
2207
- #line 102 "node.c.erb"
2215
+ #line 103 "node.c.erb"
2208
2216
  case PM_REST_PARAMETER_NODE: {
2209
2217
  pm_rest_parameter_node_t *cast = (pm_rest_parameter_node_t *) node;
2210
2218
  memsize->memsize += sizeof(*cast);
2211
2219
  break;
2212
2220
  }
2213
- #line 102 "node.c.erb"
2221
+ #line 103 "node.c.erb"
2214
2222
  case PM_RETRY_NODE: {
2215
2223
  pm_retry_node_t *cast = (pm_retry_node_t *) node;
2216
2224
  memsize->memsize += sizeof(*cast);
2217
2225
  break;
2218
2226
  }
2219
- #line 102 "node.c.erb"
2227
+ #line 103 "node.c.erb"
2220
2228
  case PM_RETURN_NODE: {
2221
2229
  pm_return_node_t *cast = (pm_return_node_t *) node;
2222
2230
  memsize->memsize += sizeof(*cast);
@@ -2225,13 +2233,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2225
2233
  }
2226
2234
  break;
2227
2235
  }
2228
- #line 102 "node.c.erb"
2236
+ #line 103 "node.c.erb"
2229
2237
  case PM_SELF_NODE: {
2230
2238
  pm_self_node_t *cast = (pm_self_node_t *) node;
2231
2239
  memsize->memsize += sizeof(*cast);
2232
2240
  break;
2233
2241
  }
2234
- #line 102 "node.c.erb"
2242
+ #line 103 "node.c.erb"
2235
2243
  case PM_SINGLETON_CLASS_NODE: {
2236
2244
  pm_singleton_class_node_t *cast = (pm_singleton_class_node_t *) node;
2237
2245
  memsize->memsize += sizeof(*cast);
@@ -2244,26 +2252,26 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2244
2252
  }
2245
2253
  break;
2246
2254
  }
2247
- #line 102 "node.c.erb"
2255
+ #line 103 "node.c.erb"
2248
2256
  case PM_SOURCE_ENCODING_NODE: {
2249
2257
  pm_source_encoding_node_t *cast = (pm_source_encoding_node_t *) node;
2250
2258
  memsize->memsize += sizeof(*cast);
2251
2259
  break;
2252
2260
  }
2253
- #line 102 "node.c.erb"
2261
+ #line 103 "node.c.erb"
2254
2262
  case PM_SOURCE_FILE_NODE: {
2255
2263
  pm_source_file_node_t *cast = (pm_source_file_node_t *) node;
2256
2264
  memsize->memsize += sizeof(*cast);
2257
2265
  memsize->memsize += pm_string_memsize(&cast->filepath);
2258
2266
  break;
2259
2267
  }
2260
- #line 102 "node.c.erb"
2268
+ #line 103 "node.c.erb"
2261
2269
  case PM_SOURCE_LINE_NODE: {
2262
2270
  pm_source_line_node_t *cast = (pm_source_line_node_t *) node;
2263
2271
  memsize->memsize += sizeof(*cast);
2264
2272
  break;
2265
2273
  }
2266
- #line 102 "node.c.erb"
2274
+ #line 103 "node.c.erb"
2267
2275
  case PM_SPLAT_NODE: {
2268
2276
  pm_splat_node_t *cast = (pm_splat_node_t *) node;
2269
2277
  memsize->memsize += sizeof(*cast);
@@ -2272,7 +2280,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2272
2280
  }
2273
2281
  break;
2274
2282
  }
2275
- #line 102 "node.c.erb"
2283
+ #line 103 "node.c.erb"
2276
2284
  case PM_STATEMENTS_NODE: {
2277
2285
  pm_statements_node_t *cast = (pm_statements_node_t *) node;
2278
2286
  memsize->memsize += sizeof(*cast);
@@ -2281,7 +2289,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2281
2289
  memsize->memsize += pm_node_list_memsize(&cast->body, memsize);
2282
2290
  break;
2283
2291
  }
2284
- #line 102 "node.c.erb"
2292
+ #line 103 "node.c.erb"
2285
2293
  case PM_STRING_CONCAT_NODE: {
2286
2294
  pm_string_concat_node_t *cast = (pm_string_concat_node_t *) node;
2287
2295
  memsize->memsize += sizeof(*cast);
@@ -2289,14 +2297,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2289
2297
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
2290
2298
  break;
2291
2299
  }
2292
- #line 102 "node.c.erb"
2300
+ #line 103 "node.c.erb"
2293
2301
  case PM_STRING_NODE: {
2294
2302
  pm_string_node_t *cast = (pm_string_node_t *) node;
2295
2303
  memsize->memsize += sizeof(*cast);
2296
2304
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2297
2305
  break;
2298
2306
  }
2299
- #line 102 "node.c.erb"
2307
+ #line 103 "node.c.erb"
2300
2308
  case PM_SUPER_NODE: {
2301
2309
  pm_super_node_t *cast = (pm_super_node_t *) node;
2302
2310
  memsize->memsize += sizeof(*cast);
@@ -2308,20 +2316,20 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2308
2316
  }
2309
2317
  break;
2310
2318
  }
2311
- #line 102 "node.c.erb"
2319
+ #line 103 "node.c.erb"
2312
2320
  case PM_SYMBOL_NODE: {
2313
2321
  pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
2314
2322
  memsize->memsize += sizeof(*cast);
2315
2323
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2316
2324
  break;
2317
2325
  }
2318
- #line 102 "node.c.erb"
2326
+ #line 103 "node.c.erb"
2319
2327
  case PM_TRUE_NODE: {
2320
2328
  pm_true_node_t *cast = (pm_true_node_t *) node;
2321
2329
  memsize->memsize += sizeof(*cast);
2322
2330
  break;
2323
2331
  }
2324
- #line 102 "node.c.erb"
2332
+ #line 103 "node.c.erb"
2325
2333
  case PM_UNDEF_NODE: {
2326
2334
  pm_undef_node_t *cast = (pm_undef_node_t *) node;
2327
2335
  memsize->memsize += sizeof(*cast);
@@ -2330,7 +2338,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2330
2338
  memsize->memsize += pm_node_list_memsize(&cast->names, memsize);
2331
2339
  break;
2332
2340
  }
2333
- #line 102 "node.c.erb"
2341
+ #line 103 "node.c.erb"
2334
2342
  case PM_UNLESS_NODE: {
2335
2343
  pm_unless_node_t *cast = (pm_unless_node_t *) node;
2336
2344
  memsize->memsize += sizeof(*cast);
@@ -2343,7 +2351,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2343
2351
  }
2344
2352
  break;
2345
2353
  }
2346
- #line 102 "node.c.erb"
2354
+ #line 103 "node.c.erb"
2347
2355
  case PM_UNTIL_NODE: {
2348
2356
  pm_until_node_t *cast = (pm_until_node_t *) node;
2349
2357
  memsize->memsize += sizeof(*cast);
@@ -2353,7 +2361,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2353
2361
  }
2354
2362
  break;
2355
2363
  }
2356
- #line 102 "node.c.erb"
2364
+ #line 103 "node.c.erb"
2357
2365
  case PM_WHEN_NODE: {
2358
2366
  pm_when_node_t *cast = (pm_when_node_t *) node;
2359
2367
  memsize->memsize += sizeof(*cast);
@@ -2365,7 +2373,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2365
2373
  }
2366
2374
  break;
2367
2375
  }
2368
- #line 102 "node.c.erb"
2376
+ #line 103 "node.c.erb"
2369
2377
  case PM_WHILE_NODE: {
2370
2378
  pm_while_node_t *cast = (pm_while_node_t *) node;
2371
2379
  memsize->memsize += sizeof(*cast);
@@ -2375,14 +2383,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2375
2383
  }
2376
2384
  break;
2377
2385
  }
2378
- #line 102 "node.c.erb"
2386
+ #line 103 "node.c.erb"
2379
2387
  case PM_X_STRING_NODE: {
2380
2388
  pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
2381
2389
  memsize->memsize += sizeof(*cast);
2382
2390
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2383
2391
  break;
2384
2392
  }
2385
- #line 102 "node.c.erb"
2393
+ #line 103 "node.c.erb"
2386
2394
  case PM_YIELD_NODE: {
2387
2395
  pm_yield_node_t *cast = (pm_yield_node_t *) node;
2388
2396
  memsize->memsize += sizeof(*cast);
@@ -2391,18 +2399,22 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2391
2399
  }
2392
2400
  break;
2393
2401
  }
2394
- #line 136 "node.c.erb"
2402
+ #line 137 "node.c.erb"
2395
2403
  }
2396
2404
  }
2397
2405
 
2398
- // Calculates the memory footprint of a given node.
2406
+ /**
2407
+ * Calculates the memory footprint of a given node.
2408
+ */
2399
2409
  PRISM_EXPORTED_FUNCTION void
2400
2410
  pm_node_memsize(pm_node_t *node, pm_memsize_t *memsize) {
2401
2411
  *memsize = (pm_memsize_t) { .memsize = 0, .node_count = 0 };
2402
2412
  pm_node_memsize_node(node, memsize);
2403
2413
  }
2404
2414
 
2405
- // Returns a string representation of the given node type.
2415
+ /**
2416
+ * Returns a string representation of the given node type.
2417
+ */
2406
2418
  PRISM_EXPORTED_FUNCTION const char *
2407
2419
  pm_node_type_to_str(pm_node_type_t node_type)
2408
2420
  {
@@ -2575,8 +2587,6 @@ pm_node_type_to_str(pm_node_type_t node_type)
2575
2587
  return "PM_INTERPOLATED_X_STRING_NODE";
2576
2588
  case PM_KEYWORD_HASH_NODE:
2577
2589
  return "PM_KEYWORD_HASH_NODE";
2578
- case PM_KEYWORD_PARAMETER_NODE:
2579
- return "PM_KEYWORD_PARAMETER_NODE";
2580
2590
  case PM_KEYWORD_REST_PARAMETER_NODE:
2581
2591
  return "PM_KEYWORD_REST_PARAMETER_NODE";
2582
2592
  case PM_LAMBDA_NODE:
@@ -2617,6 +2627,8 @@ pm_node_type_to_str(pm_node_type_t node_type)
2617
2627
  return "PM_NO_KEYWORDS_PARAMETER_NODE";
2618
2628
  case PM_NUMBERED_REFERENCE_READ_NODE:
2619
2629
  return "PM_NUMBERED_REFERENCE_READ_NODE";
2630
+ case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
2631
+ return "PM_OPTIONAL_KEYWORD_PARAMETER_NODE";
2620
2632
  case PM_OPTIONAL_PARAMETER_NODE:
2621
2633
  return "PM_OPTIONAL_PARAMETER_NODE";
2622
2634
  case PM_OR_NODE:
@@ -2643,8 +2655,8 @@ pm_node_type_to_str(pm_node_type_t node_type)
2643
2655
  return "PM_REDO_NODE";
2644
2656
  case PM_REGULAR_EXPRESSION_NODE:
2645
2657
  return "PM_REGULAR_EXPRESSION_NODE";
2646
- case PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE:
2647
- return "PM_REQUIRED_DESTRUCTURED_PARAMETER_NODE";
2658
+ case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
2659
+ return "PM_REQUIRED_KEYWORD_PARAMETER_NODE";
2648
2660
  case PM_REQUIRED_PARAMETER_NODE:
2649
2661
  return "PM_REQUIRED_PARAMETER_NODE";
2650
2662
  case PM_RESCUE_MODIFIER_NODE: