prism 0.15.1 → 0.17.0

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