prism 0.16.0 → 0.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (86) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +16 -1
  3. data/Makefile +6 -0
  4. data/README.md +1 -1
  5. data/config.yml +50 -35
  6. data/docs/fuzzing.md +1 -1
  7. data/docs/serialization.md +28 -29
  8. data/ext/prism/api_node.c +802 -770
  9. data/ext/prism/api_pack.c +20 -9
  10. data/ext/prism/extension.c +464 -162
  11. data/ext/prism/extension.h +1 -1
  12. data/include/prism/ast.h +3173 -763
  13. data/include/prism/defines.h +32 -9
  14. data/include/prism/diagnostic.h +36 -3
  15. data/include/prism/enc/pm_encoding.h +118 -28
  16. data/include/prism/node.h +38 -13
  17. data/include/prism/options.h +204 -0
  18. data/include/prism/pack.h +44 -33
  19. data/include/prism/parser.h +445 -200
  20. data/include/prism/prettyprint.h +12 -1
  21. data/include/prism/regexp.h +16 -2
  22. data/include/prism/util/pm_buffer.h +94 -16
  23. data/include/prism/util/pm_char.h +162 -48
  24. data/include/prism/util/pm_constant_pool.h +126 -32
  25. data/include/prism/util/pm_list.h +68 -38
  26. data/include/prism/util/pm_memchr.h +18 -3
  27. data/include/prism/util/pm_newline_list.h +70 -27
  28. data/include/prism/util/pm_state_stack.h +25 -7
  29. data/include/prism/util/pm_string.h +115 -27
  30. data/include/prism/util/pm_string_list.h +25 -6
  31. data/include/prism/util/pm_strncasecmp.h +32 -0
  32. data/include/prism/util/pm_strpbrk.h +31 -17
  33. data/include/prism/version.h +27 -2
  34. data/include/prism.h +224 -31
  35. data/lib/prism/compiler.rb +6 -3
  36. data/lib/prism/debug.rb +23 -7
  37. data/lib/prism/dispatcher.rb +33 -18
  38. data/lib/prism/dsl.rb +10 -5
  39. data/lib/prism/ffi.rb +132 -80
  40. data/lib/prism/lex_compat.rb +25 -15
  41. data/lib/prism/mutation_compiler.rb +10 -5
  42. data/lib/prism/node.rb +370 -135
  43. data/lib/prism/node_ext.rb +1 -1
  44. data/lib/prism/node_inspector.rb +1 -1
  45. data/lib/prism/pack.rb +79 -40
  46. data/lib/prism/parse_result/comments.rb +7 -2
  47. data/lib/prism/parse_result/newlines.rb +4 -0
  48. data/lib/prism/parse_result.rb +150 -30
  49. data/lib/prism/pattern.rb +11 -0
  50. data/lib/prism/ripper_compat.rb +28 -10
  51. data/lib/prism/serialize.rb +86 -54
  52. data/lib/prism/visitor.rb +10 -3
  53. data/lib/prism.rb +20 -2
  54. data/prism.gemspec +4 -2
  55. data/rbi/prism.rbi +104 -60
  56. data/rbi/prism_static.rbi +16 -2
  57. data/sig/prism.rbs +72 -43
  58. data/sig/prism_static.rbs +14 -1
  59. data/src/diagnostic.c +56 -53
  60. data/src/enc/pm_big5.c +1 -0
  61. data/src/enc/pm_euc_jp.c +1 -0
  62. data/src/enc/pm_gbk.c +1 -0
  63. data/src/enc/pm_shift_jis.c +1 -0
  64. data/src/enc/pm_tables.c +316 -80
  65. data/src/enc/pm_unicode.c +53 -8
  66. data/src/enc/pm_windows_31j.c +1 -0
  67. data/src/node.c +334 -321
  68. data/src/options.c +170 -0
  69. data/src/prettyprint.c +74 -47
  70. data/src/prism.c +1642 -856
  71. data/src/regexp.c +151 -95
  72. data/src/serialize.c +44 -20
  73. data/src/token_type.c +3 -1
  74. data/src/util/pm_buffer.c +45 -15
  75. data/src/util/pm_char.c +103 -57
  76. data/src/util/pm_constant_pool.c +51 -21
  77. data/src/util/pm_list.c +12 -4
  78. data/src/util/pm_memchr.c +5 -3
  79. data/src/util/pm_newline_list.c +20 -12
  80. data/src/util/pm_state_stack.c +9 -3
  81. data/src/util/pm_string.c +95 -85
  82. data/src/util/pm_string_list.c +14 -15
  83. data/src/util/pm_strncasecmp.c +10 -3
  84. data/src/util/pm_strpbrk.c +25 -19
  85. metadata +5 -3
  86. 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,45 +486,45 @@ 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) {
@@ -535,7 +536,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
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,7 +775,7 @@ 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
781
  pm_node_list_free(parser, &cast->lefts);
@@ -792,7 +785,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
792
785
  pm_node_list_free(parser, &cast->rights);
793
786
  break;
794
787
  }
795
- #line 57 "node.c.erb"
788
+ #line 58 "node.c.erb"
796
789
  case PM_MULTI_WRITE_NODE: {
797
790
  pm_multi_write_node_t *cast = (pm_multi_write_node_t *) node;
798
791
  pm_node_list_free(parser, &cast->lefts);
@@ -803,7 +796,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
803
796
  pm_node_destroy(parser, (pm_node_t *)cast->value);
804
797
  break;
805
798
  }
806
- #line 57 "node.c.erb"
799
+ #line 58 "node.c.erb"
807
800
  case PM_NEXT_NODE: {
808
801
  pm_next_node_t *cast = (pm_next_node_t *) node;
809
802
  if (cast->arguments != NULL) {
@@ -811,32 +804,38 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
811
804
  }
812
805
  break;
813
806
  }
814
- #line 57 "node.c.erb"
807
+ #line 58 "node.c.erb"
815
808
  case PM_NIL_NODE: {
816
809
  break;
817
810
  }
818
- #line 57 "node.c.erb"
811
+ #line 58 "node.c.erb"
819
812
  case PM_NO_KEYWORDS_PARAMETER_NODE: {
820
813
  break;
821
814
  }
822
- #line 57 "node.c.erb"
815
+ #line 58 "node.c.erb"
823
816
  case PM_NUMBERED_REFERENCE_READ_NODE: {
824
817
  break;
825
818
  }
826
- #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"
827
826
  case PM_OPTIONAL_PARAMETER_NODE: {
828
827
  pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
829
828
  pm_node_destroy(parser, (pm_node_t *)cast->value);
830
829
  break;
831
830
  }
832
- #line 57 "node.c.erb"
831
+ #line 58 "node.c.erb"
833
832
  case PM_OR_NODE: {
834
833
  pm_or_node_t *cast = (pm_or_node_t *) node;
835
834
  pm_node_destroy(parser, (pm_node_t *)cast->left);
836
835
  pm_node_destroy(parser, (pm_node_t *)cast->right);
837
836
  break;
838
837
  }
839
- #line 57 "node.c.erb"
838
+ #line 58 "node.c.erb"
840
839
  case PM_PARAMETERS_NODE: {
841
840
  pm_parameters_node_t *cast = (pm_parameters_node_t *) node;
842
841
  pm_node_list_free(parser, &cast->requireds);
@@ -854,7 +853,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
854
853
  }
855
854
  break;
856
855
  }
857
- #line 57 "node.c.erb"
856
+ #line 58 "node.c.erb"
858
857
  case PM_PARENTHESES_NODE: {
859
858
  pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
860
859
  if (cast->body != NULL) {
@@ -862,19 +861,19 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
862
861
  }
863
862
  break;
864
863
  }
865
- #line 57 "node.c.erb"
864
+ #line 58 "node.c.erb"
866
865
  case PM_PINNED_EXPRESSION_NODE: {
867
866
  pm_pinned_expression_node_t *cast = (pm_pinned_expression_node_t *) node;
868
867
  pm_node_destroy(parser, (pm_node_t *)cast->expression);
869
868
  break;
870
869
  }
871
- #line 57 "node.c.erb"
870
+ #line 58 "node.c.erb"
872
871
  case PM_PINNED_VARIABLE_NODE: {
873
872
  pm_pinned_variable_node_t *cast = (pm_pinned_variable_node_t *) node;
874
873
  pm_node_destroy(parser, (pm_node_t *)cast->variable);
875
874
  break;
876
875
  }
877
- #line 57 "node.c.erb"
876
+ #line 58 "node.c.erb"
878
877
  case PM_POST_EXECUTION_NODE: {
879
878
  pm_post_execution_node_t *cast = (pm_post_execution_node_t *) node;
880
879
  if (cast->statements != NULL) {
@@ -882,7 +881,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
882
881
  }
883
882
  break;
884
883
  }
885
- #line 57 "node.c.erb"
884
+ #line 58 "node.c.erb"
886
885
  case PM_PRE_EXECUTION_NODE: {
887
886
  pm_pre_execution_node_t *cast = (pm_pre_execution_node_t *) node;
888
887
  if (cast->statements != NULL) {
@@ -890,14 +889,14 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
890
889
  }
891
890
  break;
892
891
  }
893
- #line 57 "node.c.erb"
892
+ #line 58 "node.c.erb"
894
893
  case PM_PROGRAM_NODE: {
895
894
  pm_program_node_t *cast = (pm_program_node_t *) node;
896
895
  pm_constant_id_list_free(&cast->locals);
897
896
  pm_node_destroy(parser, (pm_node_t *)cast->statements);
898
897
  break;
899
898
  }
900
- #line 57 "node.c.erb"
899
+ #line 58 "node.c.erb"
901
900
  case PM_RANGE_NODE: {
902
901
  pm_range_node_t *cast = (pm_range_node_t *) node;
903
902
  if (cast->left != NULL) {
@@ -908,34 +907,38 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
908
907
  }
909
908
  break;
910
909
  }
911
- #line 57 "node.c.erb"
910
+ #line 58 "node.c.erb"
912
911
  case PM_RATIONAL_NODE: {
913
912
  pm_rational_node_t *cast = (pm_rational_node_t *) node;
914
913
  pm_node_destroy(parser, (pm_node_t *)cast->numeric);
915
914
  break;
916
915
  }
917
- #line 57 "node.c.erb"
916
+ #line 58 "node.c.erb"
918
917
  case PM_REDO_NODE: {
919
918
  break;
920
919
  }
921
- #line 57 "node.c.erb"
920
+ #line 58 "node.c.erb"
922
921
  case PM_REGULAR_EXPRESSION_NODE: {
923
922
  pm_regular_expression_node_t *cast = (pm_regular_expression_node_t *) node;
924
923
  pm_string_free(&cast->unescaped);
925
924
  break;
926
925
  }
927
- #line 57 "node.c.erb"
926
+ #line 58 "node.c.erb"
927
+ case PM_REQUIRED_KEYWORD_PARAMETER_NODE: {
928
+ break;
929
+ }
930
+ #line 58 "node.c.erb"
928
931
  case PM_REQUIRED_PARAMETER_NODE: {
929
932
  break;
930
933
  }
931
- #line 57 "node.c.erb"
934
+ #line 58 "node.c.erb"
932
935
  case PM_RESCUE_MODIFIER_NODE: {
933
936
  pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
934
937
  pm_node_destroy(parser, (pm_node_t *)cast->expression);
935
938
  pm_node_destroy(parser, (pm_node_t *)cast->rescue_expression);
936
939
  break;
937
940
  }
938
- #line 57 "node.c.erb"
941
+ #line 58 "node.c.erb"
939
942
  case PM_RESCUE_NODE: {
940
943
  pm_rescue_node_t *cast = (pm_rescue_node_t *) node;
941
944
  pm_node_list_free(parser, &cast->exceptions);
@@ -950,15 +953,15 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
950
953
  }
951
954
  break;
952
955
  }
953
- #line 57 "node.c.erb"
956
+ #line 58 "node.c.erb"
954
957
  case PM_REST_PARAMETER_NODE: {
955
958
  break;
956
959
  }
957
- #line 57 "node.c.erb"
960
+ #line 58 "node.c.erb"
958
961
  case PM_RETRY_NODE: {
959
962
  break;
960
963
  }
961
- #line 57 "node.c.erb"
964
+ #line 58 "node.c.erb"
962
965
  case PM_RETURN_NODE: {
963
966
  pm_return_node_t *cast = (pm_return_node_t *) node;
964
967
  if (cast->arguments != NULL) {
@@ -966,11 +969,11 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
966
969
  }
967
970
  break;
968
971
  }
969
- #line 57 "node.c.erb"
972
+ #line 58 "node.c.erb"
970
973
  case PM_SELF_NODE: {
971
974
  break;
972
975
  }
973
- #line 57 "node.c.erb"
976
+ #line 58 "node.c.erb"
974
977
  case PM_SINGLETON_CLASS_NODE: {
975
978
  pm_singleton_class_node_t *cast = (pm_singleton_class_node_t *) node;
976
979
  pm_constant_id_list_free(&cast->locals);
@@ -980,21 +983,21 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
980
983
  }
981
984
  break;
982
985
  }
983
- #line 57 "node.c.erb"
986
+ #line 58 "node.c.erb"
984
987
  case PM_SOURCE_ENCODING_NODE: {
985
988
  break;
986
989
  }
987
- #line 57 "node.c.erb"
990
+ #line 58 "node.c.erb"
988
991
  case PM_SOURCE_FILE_NODE: {
989
992
  pm_source_file_node_t *cast = (pm_source_file_node_t *) node;
990
993
  pm_string_free(&cast->filepath);
991
994
  break;
992
995
  }
993
- #line 57 "node.c.erb"
996
+ #line 58 "node.c.erb"
994
997
  case PM_SOURCE_LINE_NODE: {
995
998
  break;
996
999
  }
997
- #line 57 "node.c.erb"
1000
+ #line 58 "node.c.erb"
998
1001
  case PM_SPLAT_NODE: {
999
1002
  pm_splat_node_t *cast = (pm_splat_node_t *) node;
1000
1003
  if (cast->expression != NULL) {
@@ -1002,26 +1005,26 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1002
1005
  }
1003
1006
  break;
1004
1007
  }
1005
- #line 57 "node.c.erb"
1008
+ #line 58 "node.c.erb"
1006
1009
  case PM_STATEMENTS_NODE: {
1007
1010
  pm_statements_node_t *cast = (pm_statements_node_t *) node;
1008
1011
  pm_node_list_free(parser, &cast->body);
1009
1012
  break;
1010
1013
  }
1011
- #line 57 "node.c.erb"
1014
+ #line 58 "node.c.erb"
1012
1015
  case PM_STRING_CONCAT_NODE: {
1013
1016
  pm_string_concat_node_t *cast = (pm_string_concat_node_t *) node;
1014
1017
  pm_node_destroy(parser, (pm_node_t *)cast->left);
1015
1018
  pm_node_destroy(parser, (pm_node_t *)cast->right);
1016
1019
  break;
1017
1020
  }
1018
- #line 57 "node.c.erb"
1021
+ #line 58 "node.c.erb"
1019
1022
  case PM_STRING_NODE: {
1020
1023
  pm_string_node_t *cast = (pm_string_node_t *) node;
1021
1024
  pm_string_free(&cast->unescaped);
1022
1025
  break;
1023
1026
  }
1024
- #line 57 "node.c.erb"
1027
+ #line 58 "node.c.erb"
1025
1028
  case PM_SUPER_NODE: {
1026
1029
  pm_super_node_t *cast = (pm_super_node_t *) node;
1027
1030
  if (cast->arguments != NULL) {
@@ -1032,23 +1035,23 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1032
1035
  }
1033
1036
  break;
1034
1037
  }
1035
- #line 57 "node.c.erb"
1038
+ #line 58 "node.c.erb"
1036
1039
  case PM_SYMBOL_NODE: {
1037
1040
  pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
1038
1041
  pm_string_free(&cast->unescaped);
1039
1042
  break;
1040
1043
  }
1041
- #line 57 "node.c.erb"
1044
+ #line 58 "node.c.erb"
1042
1045
  case PM_TRUE_NODE: {
1043
1046
  break;
1044
1047
  }
1045
- #line 57 "node.c.erb"
1048
+ #line 58 "node.c.erb"
1046
1049
  case PM_UNDEF_NODE: {
1047
1050
  pm_undef_node_t *cast = (pm_undef_node_t *) node;
1048
1051
  pm_node_list_free(parser, &cast->names);
1049
1052
  break;
1050
1053
  }
1051
- #line 57 "node.c.erb"
1054
+ #line 58 "node.c.erb"
1052
1055
  case PM_UNLESS_NODE: {
1053
1056
  pm_unless_node_t *cast = (pm_unless_node_t *) node;
1054
1057
  pm_node_destroy(parser, (pm_node_t *)cast->predicate);
@@ -1060,7 +1063,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1060
1063
  }
1061
1064
  break;
1062
1065
  }
1063
- #line 57 "node.c.erb"
1066
+ #line 58 "node.c.erb"
1064
1067
  case PM_UNTIL_NODE: {
1065
1068
  pm_until_node_t *cast = (pm_until_node_t *) node;
1066
1069
  pm_node_destroy(parser, (pm_node_t *)cast->predicate);
@@ -1069,7 +1072,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1069
1072
  }
1070
1073
  break;
1071
1074
  }
1072
- #line 57 "node.c.erb"
1075
+ #line 58 "node.c.erb"
1073
1076
  case PM_WHEN_NODE: {
1074
1077
  pm_when_node_t *cast = (pm_when_node_t *) node;
1075
1078
  pm_node_list_free(parser, &cast->conditions);
@@ -1078,7 +1081,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1078
1081
  }
1079
1082
  break;
1080
1083
  }
1081
- #line 57 "node.c.erb"
1084
+ #line 58 "node.c.erb"
1082
1085
  case PM_WHILE_NODE: {
1083
1086
  pm_while_node_t *cast = (pm_while_node_t *) node;
1084
1087
  pm_node_destroy(parser, (pm_node_t *)cast->predicate);
@@ -1087,13 +1090,13 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1087
1090
  }
1088
1091
  break;
1089
1092
  }
1090
- #line 57 "node.c.erb"
1093
+ #line 58 "node.c.erb"
1091
1094
  case PM_X_STRING_NODE: {
1092
1095
  pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
1093
1096
  pm_string_free(&cast->unescaped);
1094
1097
  break;
1095
1098
  }
1096
- #line 57 "node.c.erb"
1099
+ #line 58 "node.c.erb"
1097
1100
  case PM_YIELD_NODE: {
1098
1101
  pm_yield_node_t *cast = (pm_yield_node_t *) node;
1099
1102
  if (cast->arguments != NULL) {
@@ -1101,7 +1104,7 @@ pm_node_destroy(pm_parser_t *parser, pm_node_t *node) {
1101
1104
  }
1102
1105
  break;
1103
1106
  }
1104
- #line 84 "node.c.erb"
1107
+ #line 85 "node.c.erb"
1105
1108
  default:
1106
1109
  assert(false && "unreachable");
1107
1110
  break;
@@ -1118,7 +1121,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1118
1121
  // as it should never be generated
1119
1122
  case PM_SCOPE_NODE:
1120
1123
  return;
1121
- #line 102 "node.c.erb"
1124
+ #line 103 "node.c.erb"
1122
1125
  case PM_ALIAS_GLOBAL_VARIABLE_NODE: {
1123
1126
  pm_alias_global_variable_node_t *cast = (pm_alias_global_variable_node_t *) node;
1124
1127
  memsize->memsize += sizeof(*cast);
@@ -1126,7 +1129,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1126
1129
  pm_node_memsize_node((pm_node_t *)cast->old_name, memsize);
1127
1130
  break;
1128
1131
  }
1129
- #line 102 "node.c.erb"
1132
+ #line 103 "node.c.erb"
1130
1133
  case PM_ALIAS_METHOD_NODE: {
1131
1134
  pm_alias_method_node_t *cast = (pm_alias_method_node_t *) node;
1132
1135
  memsize->memsize += sizeof(*cast);
@@ -1134,7 +1137,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1134
1137
  pm_node_memsize_node((pm_node_t *)cast->old_name, memsize);
1135
1138
  break;
1136
1139
  }
1137
- #line 102 "node.c.erb"
1140
+ #line 103 "node.c.erb"
1138
1141
  case PM_ALTERNATION_PATTERN_NODE: {
1139
1142
  pm_alternation_pattern_node_t *cast = (pm_alternation_pattern_node_t *) node;
1140
1143
  memsize->memsize += sizeof(*cast);
@@ -1142,7 +1145,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1142
1145
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1143
1146
  break;
1144
1147
  }
1145
- #line 102 "node.c.erb"
1148
+ #line 103 "node.c.erb"
1146
1149
  case PM_AND_NODE: {
1147
1150
  pm_and_node_t *cast = (pm_and_node_t *) node;
1148
1151
  memsize->memsize += sizeof(*cast);
@@ -1150,7 +1153,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1150
1153
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1151
1154
  break;
1152
1155
  }
1153
- #line 102 "node.c.erb"
1156
+ #line 103 "node.c.erb"
1154
1157
  case PM_ARGUMENTS_NODE: {
1155
1158
  pm_arguments_node_t *cast = (pm_arguments_node_t *) node;
1156
1159
  memsize->memsize += sizeof(*cast);
@@ -1159,7 +1162,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1159
1162
  memsize->memsize += pm_node_list_memsize(&cast->arguments, memsize);
1160
1163
  break;
1161
1164
  }
1162
- #line 102 "node.c.erb"
1165
+ #line 103 "node.c.erb"
1163
1166
  case PM_ARRAY_NODE: {
1164
1167
  pm_array_node_t *cast = (pm_array_node_t *) node;
1165
1168
  memsize->memsize += sizeof(*cast);
@@ -1168,7 +1171,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1168
1171
  memsize->memsize += pm_node_list_memsize(&cast->elements, memsize);
1169
1172
  break;
1170
1173
  }
1171
- #line 102 "node.c.erb"
1174
+ #line 103 "node.c.erb"
1172
1175
  case PM_ARRAY_PATTERN_NODE: {
1173
1176
  pm_array_pattern_node_t *cast = (pm_array_pattern_node_t *) node;
1174
1177
  memsize->memsize += sizeof(*cast);
@@ -1184,7 +1187,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1184
1187
  memsize->memsize += pm_node_list_memsize(&cast->posts, memsize);
1185
1188
  break;
1186
1189
  }
1187
- #line 102 "node.c.erb"
1190
+ #line 103 "node.c.erb"
1188
1191
  case PM_ASSOC_NODE: {
1189
1192
  pm_assoc_node_t *cast = (pm_assoc_node_t *) node;
1190
1193
  memsize->memsize += sizeof(*cast);
@@ -1194,7 +1197,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1194
1197
  }
1195
1198
  break;
1196
1199
  }
1197
- #line 102 "node.c.erb"
1200
+ #line 103 "node.c.erb"
1198
1201
  case PM_ASSOC_SPLAT_NODE: {
1199
1202
  pm_assoc_splat_node_t *cast = (pm_assoc_splat_node_t *) node;
1200
1203
  memsize->memsize += sizeof(*cast);
@@ -1203,13 +1206,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1203
1206
  }
1204
1207
  break;
1205
1208
  }
1206
- #line 102 "node.c.erb"
1209
+ #line 103 "node.c.erb"
1207
1210
  case PM_BACK_REFERENCE_READ_NODE: {
1208
1211
  pm_back_reference_read_node_t *cast = (pm_back_reference_read_node_t *) node;
1209
1212
  memsize->memsize += sizeof(*cast);
1210
1213
  break;
1211
1214
  }
1212
- #line 102 "node.c.erb"
1215
+ #line 103 "node.c.erb"
1213
1216
  case PM_BEGIN_NODE: {
1214
1217
  pm_begin_node_t *cast = (pm_begin_node_t *) node;
1215
1218
  memsize->memsize += sizeof(*cast);
@@ -1227,7 +1230,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1227
1230
  }
1228
1231
  break;
1229
1232
  }
1230
- #line 102 "node.c.erb"
1233
+ #line 103 "node.c.erb"
1231
1234
  case PM_BLOCK_ARGUMENT_NODE: {
1232
1235
  pm_block_argument_node_t *cast = (pm_block_argument_node_t *) node;
1233
1236
  memsize->memsize += sizeof(*cast);
@@ -1236,13 +1239,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1236
1239
  }
1237
1240
  break;
1238
1241
  }
1239
- #line 102 "node.c.erb"
1242
+ #line 103 "node.c.erb"
1240
1243
  case PM_BLOCK_LOCAL_VARIABLE_NODE: {
1241
1244
  pm_block_local_variable_node_t *cast = (pm_block_local_variable_node_t *) node;
1242
1245
  memsize->memsize += sizeof(*cast);
1243
1246
  break;
1244
1247
  }
1245
- #line 102 "node.c.erb"
1248
+ #line 103 "node.c.erb"
1246
1249
  case PM_BLOCK_NODE: {
1247
1250
  pm_block_node_t *cast = (pm_block_node_t *) node;
1248
1251
  memsize->memsize += sizeof(*cast);
@@ -1257,13 +1260,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1257
1260
  }
1258
1261
  break;
1259
1262
  }
1260
- #line 102 "node.c.erb"
1263
+ #line 103 "node.c.erb"
1261
1264
  case PM_BLOCK_PARAMETER_NODE: {
1262
1265
  pm_block_parameter_node_t *cast = (pm_block_parameter_node_t *) node;
1263
1266
  memsize->memsize += sizeof(*cast);
1264
1267
  break;
1265
1268
  }
1266
- #line 102 "node.c.erb"
1269
+ #line 103 "node.c.erb"
1267
1270
  case PM_BLOCK_PARAMETERS_NODE: {
1268
1271
  pm_block_parameters_node_t *cast = (pm_block_parameters_node_t *) node;
1269
1272
  memsize->memsize += sizeof(*cast);
@@ -1275,7 +1278,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1275
1278
  memsize->memsize += pm_node_list_memsize(&cast->locals, memsize);
1276
1279
  break;
1277
1280
  }
1278
- #line 102 "node.c.erb"
1281
+ #line 103 "node.c.erb"
1279
1282
  case PM_BREAK_NODE: {
1280
1283
  pm_break_node_t *cast = (pm_break_node_t *) node;
1281
1284
  memsize->memsize += sizeof(*cast);
@@ -1284,7 +1287,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1284
1287
  }
1285
1288
  break;
1286
1289
  }
1287
- #line 102 "node.c.erb"
1290
+ #line 103 "node.c.erb"
1288
1291
  case PM_CALL_AND_WRITE_NODE: {
1289
1292
  pm_call_and_write_node_t *cast = (pm_call_and_write_node_t *) node;
1290
1293
  memsize->memsize += sizeof(*cast);
@@ -1294,7 +1297,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1294
1297
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1295
1298
  break;
1296
1299
  }
1297
- #line 102 "node.c.erb"
1300
+ #line 103 "node.c.erb"
1298
1301
  case PM_CALL_NODE: {
1299
1302
  pm_call_node_t *cast = (pm_call_node_t *) node;
1300
1303
  memsize->memsize += sizeof(*cast);
@@ -1309,7 +1312,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1309
1312
  }
1310
1313
  break;
1311
1314
  }
1312
- #line 102 "node.c.erb"
1315
+ #line 103 "node.c.erb"
1313
1316
  case PM_CALL_OPERATOR_WRITE_NODE: {
1314
1317
  pm_call_operator_write_node_t *cast = (pm_call_operator_write_node_t *) node;
1315
1318
  memsize->memsize += sizeof(*cast);
@@ -1319,7 +1322,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1319
1322
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1320
1323
  break;
1321
1324
  }
1322
- #line 102 "node.c.erb"
1325
+ #line 103 "node.c.erb"
1323
1326
  case PM_CALL_OR_WRITE_NODE: {
1324
1327
  pm_call_or_write_node_t *cast = (pm_call_or_write_node_t *) node;
1325
1328
  memsize->memsize += sizeof(*cast);
@@ -1329,7 +1332,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1329
1332
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1330
1333
  break;
1331
1334
  }
1332
- #line 102 "node.c.erb"
1335
+ #line 103 "node.c.erb"
1333
1336
  case PM_CAPTURE_PATTERN_NODE: {
1334
1337
  pm_capture_pattern_node_t *cast = (pm_capture_pattern_node_t *) node;
1335
1338
  memsize->memsize += sizeof(*cast);
@@ -1337,7 +1340,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1337
1340
  pm_node_memsize_node((pm_node_t *)cast->target, memsize);
1338
1341
  break;
1339
1342
  }
1340
- #line 102 "node.c.erb"
1343
+ #line 103 "node.c.erb"
1341
1344
  case PM_CASE_NODE: {
1342
1345
  pm_case_node_t *cast = (pm_case_node_t *) node;
1343
1346
  memsize->memsize += sizeof(*cast);
@@ -1352,7 +1355,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1352
1355
  }
1353
1356
  break;
1354
1357
  }
1355
- #line 102 "node.c.erb"
1358
+ #line 103 "node.c.erb"
1356
1359
  case PM_CLASS_NODE: {
1357
1360
  pm_class_node_t *cast = (pm_class_node_t *) node;
1358
1361
  memsize->memsize += sizeof(*cast);
@@ -1368,68 +1371,68 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1368
1371
  }
1369
1372
  break;
1370
1373
  }
1371
- #line 102 "node.c.erb"
1374
+ #line 103 "node.c.erb"
1372
1375
  case PM_CLASS_VARIABLE_AND_WRITE_NODE: {
1373
1376
  pm_class_variable_and_write_node_t *cast = (pm_class_variable_and_write_node_t *) node;
1374
1377
  memsize->memsize += sizeof(*cast);
1375
1378
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1376
1379
  break;
1377
1380
  }
1378
- #line 102 "node.c.erb"
1381
+ #line 103 "node.c.erb"
1379
1382
  case PM_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1380
1383
  pm_class_variable_operator_write_node_t *cast = (pm_class_variable_operator_write_node_t *) node;
1381
1384
  memsize->memsize += sizeof(*cast);
1382
1385
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1383
1386
  break;
1384
1387
  }
1385
- #line 102 "node.c.erb"
1388
+ #line 103 "node.c.erb"
1386
1389
  case PM_CLASS_VARIABLE_OR_WRITE_NODE: {
1387
1390
  pm_class_variable_or_write_node_t *cast = (pm_class_variable_or_write_node_t *) node;
1388
1391
  memsize->memsize += sizeof(*cast);
1389
1392
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1390
1393
  break;
1391
1394
  }
1392
- #line 102 "node.c.erb"
1395
+ #line 103 "node.c.erb"
1393
1396
  case PM_CLASS_VARIABLE_READ_NODE: {
1394
1397
  pm_class_variable_read_node_t *cast = (pm_class_variable_read_node_t *) node;
1395
1398
  memsize->memsize += sizeof(*cast);
1396
1399
  break;
1397
1400
  }
1398
- #line 102 "node.c.erb"
1401
+ #line 103 "node.c.erb"
1399
1402
  case PM_CLASS_VARIABLE_TARGET_NODE: {
1400
1403
  pm_class_variable_target_node_t *cast = (pm_class_variable_target_node_t *) node;
1401
1404
  memsize->memsize += sizeof(*cast);
1402
1405
  break;
1403
1406
  }
1404
- #line 102 "node.c.erb"
1407
+ #line 103 "node.c.erb"
1405
1408
  case PM_CLASS_VARIABLE_WRITE_NODE: {
1406
1409
  pm_class_variable_write_node_t *cast = (pm_class_variable_write_node_t *) node;
1407
1410
  memsize->memsize += sizeof(*cast);
1408
1411
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1409
1412
  break;
1410
1413
  }
1411
- #line 102 "node.c.erb"
1414
+ #line 103 "node.c.erb"
1412
1415
  case PM_CONSTANT_AND_WRITE_NODE: {
1413
1416
  pm_constant_and_write_node_t *cast = (pm_constant_and_write_node_t *) node;
1414
1417
  memsize->memsize += sizeof(*cast);
1415
1418
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1416
1419
  break;
1417
1420
  }
1418
- #line 102 "node.c.erb"
1421
+ #line 103 "node.c.erb"
1419
1422
  case PM_CONSTANT_OPERATOR_WRITE_NODE: {
1420
1423
  pm_constant_operator_write_node_t *cast = (pm_constant_operator_write_node_t *) node;
1421
1424
  memsize->memsize += sizeof(*cast);
1422
1425
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1423
1426
  break;
1424
1427
  }
1425
- #line 102 "node.c.erb"
1428
+ #line 103 "node.c.erb"
1426
1429
  case PM_CONSTANT_OR_WRITE_NODE: {
1427
1430
  pm_constant_or_write_node_t *cast = (pm_constant_or_write_node_t *) node;
1428
1431
  memsize->memsize += sizeof(*cast);
1429
1432
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1430
1433
  break;
1431
1434
  }
1432
- #line 102 "node.c.erb"
1435
+ #line 103 "node.c.erb"
1433
1436
  case PM_CONSTANT_PATH_AND_WRITE_NODE: {
1434
1437
  pm_constant_path_and_write_node_t *cast = (pm_constant_path_and_write_node_t *) node;
1435
1438
  memsize->memsize += sizeof(*cast);
@@ -1437,7 +1440,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1437
1440
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1438
1441
  break;
1439
1442
  }
1440
- #line 102 "node.c.erb"
1443
+ #line 103 "node.c.erb"
1441
1444
  case PM_CONSTANT_PATH_NODE: {
1442
1445
  pm_constant_path_node_t *cast = (pm_constant_path_node_t *) node;
1443
1446
  memsize->memsize += sizeof(*cast);
@@ -1447,7 +1450,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1447
1450
  pm_node_memsize_node((pm_node_t *)cast->child, memsize);
1448
1451
  break;
1449
1452
  }
1450
- #line 102 "node.c.erb"
1453
+ #line 103 "node.c.erb"
1451
1454
  case PM_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1452
1455
  pm_constant_path_operator_write_node_t *cast = (pm_constant_path_operator_write_node_t *) node;
1453
1456
  memsize->memsize += sizeof(*cast);
@@ -1455,7 +1458,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1455
1458
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1456
1459
  break;
1457
1460
  }
1458
- #line 102 "node.c.erb"
1461
+ #line 103 "node.c.erb"
1459
1462
  case PM_CONSTANT_PATH_OR_WRITE_NODE: {
1460
1463
  pm_constant_path_or_write_node_t *cast = (pm_constant_path_or_write_node_t *) node;
1461
1464
  memsize->memsize += sizeof(*cast);
@@ -1463,7 +1466,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1463
1466
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1464
1467
  break;
1465
1468
  }
1466
- #line 102 "node.c.erb"
1469
+ #line 103 "node.c.erb"
1467
1470
  case PM_CONSTANT_PATH_TARGET_NODE: {
1468
1471
  pm_constant_path_target_node_t *cast = (pm_constant_path_target_node_t *) node;
1469
1472
  memsize->memsize += sizeof(*cast);
@@ -1473,7 +1476,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1473
1476
  pm_node_memsize_node((pm_node_t *)cast->child, memsize);
1474
1477
  break;
1475
1478
  }
1476
- #line 102 "node.c.erb"
1479
+ #line 103 "node.c.erb"
1477
1480
  case PM_CONSTANT_PATH_WRITE_NODE: {
1478
1481
  pm_constant_path_write_node_t *cast = (pm_constant_path_write_node_t *) node;
1479
1482
  memsize->memsize += sizeof(*cast);
@@ -1481,26 +1484,26 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1481
1484
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1482
1485
  break;
1483
1486
  }
1484
- #line 102 "node.c.erb"
1487
+ #line 103 "node.c.erb"
1485
1488
  case PM_CONSTANT_READ_NODE: {
1486
1489
  pm_constant_read_node_t *cast = (pm_constant_read_node_t *) node;
1487
1490
  memsize->memsize += sizeof(*cast);
1488
1491
  break;
1489
1492
  }
1490
- #line 102 "node.c.erb"
1493
+ #line 103 "node.c.erb"
1491
1494
  case PM_CONSTANT_TARGET_NODE: {
1492
1495
  pm_constant_target_node_t *cast = (pm_constant_target_node_t *) node;
1493
1496
  memsize->memsize += sizeof(*cast);
1494
1497
  break;
1495
1498
  }
1496
- #line 102 "node.c.erb"
1499
+ #line 103 "node.c.erb"
1497
1500
  case PM_CONSTANT_WRITE_NODE: {
1498
1501
  pm_constant_write_node_t *cast = (pm_constant_write_node_t *) node;
1499
1502
  memsize->memsize += sizeof(*cast);
1500
1503
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1501
1504
  break;
1502
1505
  }
1503
- #line 102 "node.c.erb"
1506
+ #line 103 "node.c.erb"
1504
1507
  case PM_DEF_NODE: {
1505
1508
  pm_def_node_t *cast = (pm_def_node_t *) node;
1506
1509
  memsize->memsize += sizeof(*cast);
@@ -1518,14 +1521,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1518
1521
  memsize->memsize += pm_constant_id_list_memsize(&cast->locals);
1519
1522
  break;
1520
1523
  }
1521
- #line 102 "node.c.erb"
1524
+ #line 103 "node.c.erb"
1522
1525
  case PM_DEFINED_NODE: {
1523
1526
  pm_defined_node_t *cast = (pm_defined_node_t *) node;
1524
1527
  memsize->memsize += sizeof(*cast);
1525
1528
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1526
1529
  break;
1527
1530
  }
1528
- #line 102 "node.c.erb"
1531
+ #line 103 "node.c.erb"
1529
1532
  case PM_ELSE_NODE: {
1530
1533
  pm_else_node_t *cast = (pm_else_node_t *) node;
1531
1534
  memsize->memsize += sizeof(*cast);
@@ -1534,7 +1537,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1534
1537
  }
1535
1538
  break;
1536
1539
  }
1537
- #line 102 "node.c.erb"
1540
+ #line 103 "node.c.erb"
1538
1541
  case PM_EMBEDDED_STATEMENTS_NODE: {
1539
1542
  pm_embedded_statements_node_t *cast = (pm_embedded_statements_node_t *) node;
1540
1543
  memsize->memsize += sizeof(*cast);
@@ -1543,14 +1546,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1543
1546
  }
1544
1547
  break;
1545
1548
  }
1546
- #line 102 "node.c.erb"
1549
+ #line 103 "node.c.erb"
1547
1550
  case PM_EMBEDDED_VARIABLE_NODE: {
1548
1551
  pm_embedded_variable_node_t *cast = (pm_embedded_variable_node_t *) node;
1549
1552
  memsize->memsize += sizeof(*cast);
1550
1553
  pm_node_memsize_node((pm_node_t *)cast->variable, memsize);
1551
1554
  break;
1552
1555
  }
1553
- #line 102 "node.c.erb"
1556
+ #line 103 "node.c.erb"
1554
1557
  case PM_ENSURE_NODE: {
1555
1558
  pm_ensure_node_t *cast = (pm_ensure_node_t *) node;
1556
1559
  memsize->memsize += sizeof(*cast);
@@ -1559,13 +1562,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1559
1562
  }
1560
1563
  break;
1561
1564
  }
1562
- #line 102 "node.c.erb"
1565
+ #line 103 "node.c.erb"
1563
1566
  case PM_FALSE_NODE: {
1564
1567
  pm_false_node_t *cast = (pm_false_node_t *) node;
1565
1568
  memsize->memsize += sizeof(*cast);
1566
1569
  break;
1567
1570
  }
1568
- #line 102 "node.c.erb"
1571
+ #line 103 "node.c.erb"
1569
1572
  case PM_FIND_PATTERN_NODE: {
1570
1573
  pm_find_pattern_node_t *cast = (pm_find_pattern_node_t *) node;
1571
1574
  memsize->memsize += sizeof(*cast);
@@ -1579,7 +1582,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1579
1582
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
1580
1583
  break;
1581
1584
  }
1582
- #line 102 "node.c.erb"
1585
+ #line 103 "node.c.erb"
1583
1586
  case PM_FLIP_FLOP_NODE: {
1584
1587
  pm_flip_flop_node_t *cast = (pm_flip_flop_node_t *) node;
1585
1588
  memsize->memsize += sizeof(*cast);
@@ -1591,13 +1594,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1591
1594
  }
1592
1595
  break;
1593
1596
  }
1594
- #line 102 "node.c.erb"
1597
+ #line 103 "node.c.erb"
1595
1598
  case PM_FLOAT_NODE: {
1596
1599
  pm_float_node_t *cast = (pm_float_node_t *) node;
1597
1600
  memsize->memsize += sizeof(*cast);
1598
1601
  break;
1599
1602
  }
1600
- #line 102 "node.c.erb"
1603
+ #line 103 "node.c.erb"
1601
1604
  case PM_FOR_NODE: {
1602
1605
  pm_for_node_t *cast = (pm_for_node_t *) node;
1603
1606
  memsize->memsize += sizeof(*cast);
@@ -1608,19 +1611,19 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1608
1611
  }
1609
1612
  break;
1610
1613
  }
1611
- #line 102 "node.c.erb"
1614
+ #line 103 "node.c.erb"
1612
1615
  case PM_FORWARDING_ARGUMENTS_NODE: {
1613
1616
  pm_forwarding_arguments_node_t *cast = (pm_forwarding_arguments_node_t *) node;
1614
1617
  memsize->memsize += sizeof(*cast);
1615
1618
  break;
1616
1619
  }
1617
- #line 102 "node.c.erb"
1620
+ #line 103 "node.c.erb"
1618
1621
  case PM_FORWARDING_PARAMETER_NODE: {
1619
1622
  pm_forwarding_parameter_node_t *cast = (pm_forwarding_parameter_node_t *) node;
1620
1623
  memsize->memsize += sizeof(*cast);
1621
1624
  break;
1622
1625
  }
1623
- #line 102 "node.c.erb"
1626
+ #line 103 "node.c.erb"
1624
1627
  case PM_FORWARDING_SUPER_NODE: {
1625
1628
  pm_forwarding_super_node_t *cast = (pm_forwarding_super_node_t *) node;
1626
1629
  memsize->memsize += sizeof(*cast);
@@ -1629,47 +1632,47 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1629
1632
  }
1630
1633
  break;
1631
1634
  }
1632
- #line 102 "node.c.erb"
1635
+ #line 103 "node.c.erb"
1633
1636
  case PM_GLOBAL_VARIABLE_AND_WRITE_NODE: {
1634
1637
  pm_global_variable_and_write_node_t *cast = (pm_global_variable_and_write_node_t *) node;
1635
1638
  memsize->memsize += sizeof(*cast);
1636
1639
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1637
1640
  break;
1638
1641
  }
1639
- #line 102 "node.c.erb"
1642
+ #line 103 "node.c.erb"
1640
1643
  case PM_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
1641
1644
  pm_global_variable_operator_write_node_t *cast = (pm_global_variable_operator_write_node_t *) node;
1642
1645
  memsize->memsize += sizeof(*cast);
1643
1646
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1644
1647
  break;
1645
1648
  }
1646
- #line 102 "node.c.erb"
1649
+ #line 103 "node.c.erb"
1647
1650
  case PM_GLOBAL_VARIABLE_OR_WRITE_NODE: {
1648
1651
  pm_global_variable_or_write_node_t *cast = (pm_global_variable_or_write_node_t *) node;
1649
1652
  memsize->memsize += sizeof(*cast);
1650
1653
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1651
1654
  break;
1652
1655
  }
1653
- #line 102 "node.c.erb"
1656
+ #line 103 "node.c.erb"
1654
1657
  case PM_GLOBAL_VARIABLE_READ_NODE: {
1655
1658
  pm_global_variable_read_node_t *cast = (pm_global_variable_read_node_t *) node;
1656
1659
  memsize->memsize += sizeof(*cast);
1657
1660
  break;
1658
1661
  }
1659
- #line 102 "node.c.erb"
1662
+ #line 103 "node.c.erb"
1660
1663
  case PM_GLOBAL_VARIABLE_TARGET_NODE: {
1661
1664
  pm_global_variable_target_node_t *cast = (pm_global_variable_target_node_t *) node;
1662
1665
  memsize->memsize += sizeof(*cast);
1663
1666
  break;
1664
1667
  }
1665
- #line 102 "node.c.erb"
1668
+ #line 103 "node.c.erb"
1666
1669
  case PM_GLOBAL_VARIABLE_WRITE_NODE: {
1667
1670
  pm_global_variable_write_node_t *cast = (pm_global_variable_write_node_t *) node;
1668
1671
  memsize->memsize += sizeof(*cast);
1669
1672
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1670
1673
  break;
1671
1674
  }
1672
- #line 102 "node.c.erb"
1675
+ #line 103 "node.c.erb"
1673
1676
  case PM_HASH_NODE: {
1674
1677
  pm_hash_node_t *cast = (pm_hash_node_t *) node;
1675
1678
  memsize->memsize += sizeof(*cast);
@@ -1678,7 +1681,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1678
1681
  memsize->memsize += pm_node_list_memsize(&cast->elements, memsize);
1679
1682
  break;
1680
1683
  }
1681
- #line 102 "node.c.erb"
1684
+ #line 103 "node.c.erb"
1682
1685
  case PM_HASH_PATTERN_NODE: {
1683
1686
  pm_hash_pattern_node_t *cast = (pm_hash_pattern_node_t *) node;
1684
1687
  memsize->memsize += sizeof(*cast);
@@ -1693,7 +1696,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1693
1696
  }
1694
1697
  break;
1695
1698
  }
1696
- #line 102 "node.c.erb"
1699
+ #line 103 "node.c.erb"
1697
1700
  case PM_IF_NODE: {
1698
1701
  pm_if_node_t *cast = (pm_if_node_t *) node;
1699
1702
  memsize->memsize += sizeof(*cast);
@@ -1706,21 +1709,21 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1706
1709
  }
1707
1710
  break;
1708
1711
  }
1709
- #line 102 "node.c.erb"
1712
+ #line 103 "node.c.erb"
1710
1713
  case PM_IMAGINARY_NODE: {
1711
1714
  pm_imaginary_node_t *cast = (pm_imaginary_node_t *) node;
1712
1715
  memsize->memsize += sizeof(*cast);
1713
1716
  pm_node_memsize_node((pm_node_t *)cast->numeric, memsize);
1714
1717
  break;
1715
1718
  }
1716
- #line 102 "node.c.erb"
1719
+ #line 103 "node.c.erb"
1717
1720
  case PM_IMPLICIT_NODE: {
1718
1721
  pm_implicit_node_t *cast = (pm_implicit_node_t *) node;
1719
1722
  memsize->memsize += sizeof(*cast);
1720
1723
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1721
1724
  break;
1722
1725
  }
1723
- #line 102 "node.c.erb"
1726
+ #line 103 "node.c.erb"
1724
1727
  case PM_IN_NODE: {
1725
1728
  pm_in_node_t *cast = (pm_in_node_t *) node;
1726
1729
  memsize->memsize += sizeof(*cast);
@@ -1730,7 +1733,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1730
1733
  }
1731
1734
  break;
1732
1735
  }
1733
- #line 102 "node.c.erb"
1736
+ #line 103 "node.c.erb"
1734
1737
  case PM_INDEX_AND_WRITE_NODE: {
1735
1738
  pm_index_and_write_node_t *cast = (pm_index_and_write_node_t *) node;
1736
1739
  memsize->memsize += sizeof(*cast);
@@ -1746,7 +1749,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1746
1749
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1747
1750
  break;
1748
1751
  }
1749
- #line 102 "node.c.erb"
1752
+ #line 103 "node.c.erb"
1750
1753
  case PM_INDEX_OPERATOR_WRITE_NODE: {
1751
1754
  pm_index_operator_write_node_t *cast = (pm_index_operator_write_node_t *) node;
1752
1755
  memsize->memsize += sizeof(*cast);
@@ -1762,7 +1765,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1762
1765
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1763
1766
  break;
1764
1767
  }
1765
- #line 102 "node.c.erb"
1768
+ #line 103 "node.c.erb"
1766
1769
  case PM_INDEX_OR_WRITE_NODE: {
1767
1770
  pm_index_or_write_node_t *cast = (pm_index_or_write_node_t *) node;
1768
1771
  memsize->memsize += sizeof(*cast);
@@ -1778,53 +1781,53 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1778
1781
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1779
1782
  break;
1780
1783
  }
1781
- #line 102 "node.c.erb"
1784
+ #line 103 "node.c.erb"
1782
1785
  case PM_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1783
1786
  pm_instance_variable_and_write_node_t *cast = (pm_instance_variable_and_write_node_t *) node;
1784
1787
  memsize->memsize += sizeof(*cast);
1785
1788
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1786
1789
  break;
1787
1790
  }
1788
- #line 102 "node.c.erb"
1791
+ #line 103 "node.c.erb"
1789
1792
  case PM_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1790
1793
  pm_instance_variable_operator_write_node_t *cast = (pm_instance_variable_operator_write_node_t *) node;
1791
1794
  memsize->memsize += sizeof(*cast);
1792
1795
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1793
1796
  break;
1794
1797
  }
1795
- #line 102 "node.c.erb"
1798
+ #line 103 "node.c.erb"
1796
1799
  case PM_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1797
1800
  pm_instance_variable_or_write_node_t *cast = (pm_instance_variable_or_write_node_t *) node;
1798
1801
  memsize->memsize += sizeof(*cast);
1799
1802
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1800
1803
  break;
1801
1804
  }
1802
- #line 102 "node.c.erb"
1805
+ #line 103 "node.c.erb"
1803
1806
  case PM_INSTANCE_VARIABLE_READ_NODE: {
1804
1807
  pm_instance_variable_read_node_t *cast = (pm_instance_variable_read_node_t *) node;
1805
1808
  memsize->memsize += sizeof(*cast);
1806
1809
  break;
1807
1810
  }
1808
- #line 102 "node.c.erb"
1811
+ #line 103 "node.c.erb"
1809
1812
  case PM_INSTANCE_VARIABLE_TARGET_NODE: {
1810
1813
  pm_instance_variable_target_node_t *cast = (pm_instance_variable_target_node_t *) node;
1811
1814
  memsize->memsize += sizeof(*cast);
1812
1815
  break;
1813
1816
  }
1814
- #line 102 "node.c.erb"
1817
+ #line 103 "node.c.erb"
1815
1818
  case PM_INSTANCE_VARIABLE_WRITE_NODE: {
1816
1819
  pm_instance_variable_write_node_t *cast = (pm_instance_variable_write_node_t *) node;
1817
1820
  memsize->memsize += sizeof(*cast);
1818
1821
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1819
1822
  break;
1820
1823
  }
1821
- #line 102 "node.c.erb"
1824
+ #line 103 "node.c.erb"
1822
1825
  case PM_INTEGER_NODE: {
1823
1826
  pm_integer_node_t *cast = (pm_integer_node_t *) node;
1824
1827
  memsize->memsize += sizeof(*cast);
1825
1828
  break;
1826
1829
  }
1827
- #line 102 "node.c.erb"
1830
+ #line 103 "node.c.erb"
1828
1831
  case PM_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1829
1832
  pm_interpolated_match_last_line_node_t *cast = (pm_interpolated_match_last_line_node_t *) node;
1830
1833
  memsize->memsize += sizeof(*cast);
@@ -1833,7 +1836,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1833
1836
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1834
1837
  break;
1835
1838
  }
1836
- #line 102 "node.c.erb"
1839
+ #line 103 "node.c.erb"
1837
1840
  case PM_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1838
1841
  pm_interpolated_regular_expression_node_t *cast = (pm_interpolated_regular_expression_node_t *) node;
1839
1842
  memsize->memsize += sizeof(*cast);
@@ -1842,7 +1845,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1842
1845
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1843
1846
  break;
1844
1847
  }
1845
- #line 102 "node.c.erb"
1848
+ #line 103 "node.c.erb"
1846
1849
  case PM_INTERPOLATED_STRING_NODE: {
1847
1850
  pm_interpolated_string_node_t *cast = (pm_interpolated_string_node_t *) node;
1848
1851
  memsize->memsize += sizeof(*cast);
@@ -1851,7 +1854,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1851
1854
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1852
1855
  break;
1853
1856
  }
1854
- #line 102 "node.c.erb"
1857
+ #line 103 "node.c.erb"
1855
1858
  case PM_INTERPOLATED_SYMBOL_NODE: {
1856
1859
  pm_interpolated_symbol_node_t *cast = (pm_interpolated_symbol_node_t *) node;
1857
1860
  memsize->memsize += sizeof(*cast);
@@ -1860,7 +1863,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1860
1863
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1861
1864
  break;
1862
1865
  }
1863
- #line 102 "node.c.erb"
1866
+ #line 103 "node.c.erb"
1864
1867
  case PM_INTERPOLATED_X_STRING_NODE: {
1865
1868
  pm_interpolated_x_string_node_t *cast = (pm_interpolated_x_string_node_t *) node;
1866
1869
  memsize->memsize += sizeof(*cast);
@@ -1869,7 +1872,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1869
1872
  memsize->memsize += pm_node_list_memsize(&cast->parts, memsize);
1870
1873
  break;
1871
1874
  }
1872
- #line 102 "node.c.erb"
1875
+ #line 103 "node.c.erb"
1873
1876
  case PM_KEYWORD_HASH_NODE: {
1874
1877
  pm_keyword_hash_node_t *cast = (pm_keyword_hash_node_t *) node;
1875
1878
  memsize->memsize += sizeof(*cast);
@@ -1878,22 +1881,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1878
1881
  memsize->memsize += pm_node_list_memsize(&cast->elements, memsize);
1879
1882
  break;
1880
1883
  }
1881
- #line 102 "node.c.erb"
1882
- case PM_KEYWORD_PARAMETER_NODE: {
1883
- pm_keyword_parameter_node_t *cast = (pm_keyword_parameter_node_t *) node;
1884
- memsize->memsize += sizeof(*cast);
1885
- if (cast->value != NULL) {
1886
- pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1887
- }
1888
- break;
1889
- }
1890
- #line 102 "node.c.erb"
1884
+ #line 103 "node.c.erb"
1891
1885
  case PM_KEYWORD_REST_PARAMETER_NODE: {
1892
1886
  pm_keyword_rest_parameter_node_t *cast = (pm_keyword_rest_parameter_node_t *) node;
1893
1887
  memsize->memsize += sizeof(*cast);
1894
1888
  break;
1895
1889
  }
1896
- #line 102 "node.c.erb"
1890
+ #line 103 "node.c.erb"
1897
1891
  case PM_LAMBDA_NODE: {
1898
1892
  pm_lambda_node_t *cast = (pm_lambda_node_t *) node;
1899
1893
  memsize->memsize += sizeof(*cast);
@@ -1908,54 +1902,54 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1908
1902
  }
1909
1903
  break;
1910
1904
  }
1911
- #line 102 "node.c.erb"
1905
+ #line 103 "node.c.erb"
1912
1906
  case PM_LOCAL_VARIABLE_AND_WRITE_NODE: {
1913
1907
  pm_local_variable_and_write_node_t *cast = (pm_local_variable_and_write_node_t *) node;
1914
1908
  memsize->memsize += sizeof(*cast);
1915
1909
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1916
1910
  break;
1917
1911
  }
1918
- #line 102 "node.c.erb"
1912
+ #line 103 "node.c.erb"
1919
1913
  case PM_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1920
1914
  pm_local_variable_operator_write_node_t *cast = (pm_local_variable_operator_write_node_t *) node;
1921
1915
  memsize->memsize += sizeof(*cast);
1922
1916
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1923
1917
  break;
1924
1918
  }
1925
- #line 102 "node.c.erb"
1919
+ #line 103 "node.c.erb"
1926
1920
  case PM_LOCAL_VARIABLE_OR_WRITE_NODE: {
1927
1921
  pm_local_variable_or_write_node_t *cast = (pm_local_variable_or_write_node_t *) node;
1928
1922
  memsize->memsize += sizeof(*cast);
1929
1923
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1930
1924
  break;
1931
1925
  }
1932
- #line 102 "node.c.erb"
1926
+ #line 103 "node.c.erb"
1933
1927
  case PM_LOCAL_VARIABLE_READ_NODE: {
1934
1928
  pm_local_variable_read_node_t *cast = (pm_local_variable_read_node_t *) node;
1935
1929
  memsize->memsize += sizeof(*cast);
1936
1930
  break;
1937
1931
  }
1938
- #line 102 "node.c.erb"
1932
+ #line 103 "node.c.erb"
1939
1933
  case PM_LOCAL_VARIABLE_TARGET_NODE: {
1940
1934
  pm_local_variable_target_node_t *cast = (pm_local_variable_target_node_t *) node;
1941
1935
  memsize->memsize += sizeof(*cast);
1942
1936
  break;
1943
1937
  }
1944
- #line 102 "node.c.erb"
1938
+ #line 103 "node.c.erb"
1945
1939
  case PM_LOCAL_VARIABLE_WRITE_NODE: {
1946
1940
  pm_local_variable_write_node_t *cast = (pm_local_variable_write_node_t *) node;
1947
1941
  memsize->memsize += sizeof(*cast);
1948
1942
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
1949
1943
  break;
1950
1944
  }
1951
- #line 102 "node.c.erb"
1945
+ #line 103 "node.c.erb"
1952
1946
  case PM_MATCH_LAST_LINE_NODE: {
1953
1947
  pm_match_last_line_node_t *cast = (pm_match_last_line_node_t *) node;
1954
1948
  memsize->memsize += sizeof(*cast);
1955
1949
  memsize->memsize += pm_string_memsize(&cast->unescaped);
1956
1950
  break;
1957
1951
  }
1958
- #line 102 "node.c.erb"
1952
+ #line 103 "node.c.erb"
1959
1953
  case PM_MATCH_PREDICATE_NODE: {
1960
1954
  pm_match_predicate_node_t *cast = (pm_match_predicate_node_t *) node;
1961
1955
  memsize->memsize += sizeof(*cast);
@@ -1963,7 +1957,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1963
1957
  pm_node_memsize_node((pm_node_t *)cast->pattern, memsize);
1964
1958
  break;
1965
1959
  }
1966
- #line 102 "node.c.erb"
1960
+ #line 103 "node.c.erb"
1967
1961
  case PM_MATCH_REQUIRED_NODE: {
1968
1962
  pm_match_required_node_t *cast = (pm_match_required_node_t *) node;
1969
1963
  memsize->memsize += sizeof(*cast);
@@ -1971,7 +1965,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1971
1965
  pm_node_memsize_node((pm_node_t *)cast->pattern, memsize);
1972
1966
  break;
1973
1967
  }
1974
- #line 102 "node.c.erb"
1968
+ #line 103 "node.c.erb"
1975
1969
  case PM_MATCH_WRITE_NODE: {
1976
1970
  pm_match_write_node_t *cast = (pm_match_write_node_t *) node;
1977
1971
  memsize->memsize += sizeof(*cast);
@@ -1981,13 +1975,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
1981
1975
  memsize->memsize += pm_constant_id_list_memsize(&cast->locals);
1982
1976
  break;
1983
1977
  }
1984
- #line 102 "node.c.erb"
1978
+ #line 103 "node.c.erb"
1985
1979
  case PM_MISSING_NODE: {
1986
1980
  pm_missing_node_t *cast = (pm_missing_node_t *) node;
1987
1981
  memsize->memsize += sizeof(*cast);
1988
1982
  break;
1989
1983
  }
1990
- #line 102 "node.c.erb"
1984
+ #line 103 "node.c.erb"
1991
1985
  case PM_MODULE_NODE: {
1992
1986
  pm_module_node_t *cast = (pm_module_node_t *) node;
1993
1987
  memsize->memsize += sizeof(*cast);
@@ -2000,7 +1994,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2000
1994
  }
2001
1995
  break;
2002
1996
  }
2003
- #line 102 "node.c.erb"
1997
+ #line 103 "node.c.erb"
2004
1998
  case PM_MULTI_TARGET_NODE: {
2005
1999
  pm_multi_target_node_t *cast = (pm_multi_target_node_t *) node;
2006
2000
  memsize->memsize += sizeof(*cast);
@@ -2013,7 +2007,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2013
2007
  memsize->memsize += pm_node_list_memsize(&cast->rights, memsize);
2014
2008
  break;
2015
2009
  }
2016
- #line 102 "node.c.erb"
2010
+ #line 103 "node.c.erb"
2017
2011
  case PM_MULTI_WRITE_NODE: {
2018
2012
  pm_multi_write_node_t *cast = (pm_multi_write_node_t *) node;
2019
2013
  memsize->memsize += sizeof(*cast);
@@ -2027,7 +2021,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2027
2021
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
2028
2022
  break;
2029
2023
  }
2030
- #line 102 "node.c.erb"
2024
+ #line 103 "node.c.erb"
2031
2025
  case PM_NEXT_NODE: {
2032
2026
  pm_next_node_t *cast = (pm_next_node_t *) node;
2033
2027
  memsize->memsize += sizeof(*cast);
@@ -2036,32 +2030,39 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2036
2030
  }
2037
2031
  break;
2038
2032
  }
2039
- #line 102 "node.c.erb"
2033
+ #line 103 "node.c.erb"
2040
2034
  case PM_NIL_NODE: {
2041
2035
  pm_nil_node_t *cast = (pm_nil_node_t *) node;
2042
2036
  memsize->memsize += sizeof(*cast);
2043
2037
  break;
2044
2038
  }
2045
- #line 102 "node.c.erb"
2039
+ #line 103 "node.c.erb"
2046
2040
  case PM_NO_KEYWORDS_PARAMETER_NODE: {
2047
2041
  pm_no_keywords_parameter_node_t *cast = (pm_no_keywords_parameter_node_t *) node;
2048
2042
  memsize->memsize += sizeof(*cast);
2049
2043
  break;
2050
2044
  }
2051
- #line 102 "node.c.erb"
2045
+ #line 103 "node.c.erb"
2052
2046
  case PM_NUMBERED_REFERENCE_READ_NODE: {
2053
2047
  pm_numbered_reference_read_node_t *cast = (pm_numbered_reference_read_node_t *) node;
2054
2048
  memsize->memsize += sizeof(*cast);
2055
2049
  break;
2056
2050
  }
2057
- #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"
2058
2059
  case PM_OPTIONAL_PARAMETER_NODE: {
2059
2060
  pm_optional_parameter_node_t *cast = (pm_optional_parameter_node_t *) node;
2060
2061
  memsize->memsize += sizeof(*cast);
2061
2062
  pm_node_memsize_node((pm_node_t *)cast->value, memsize);
2062
2063
  break;
2063
2064
  }
2064
- #line 102 "node.c.erb"
2065
+ #line 103 "node.c.erb"
2065
2066
  case PM_OR_NODE: {
2066
2067
  pm_or_node_t *cast = (pm_or_node_t *) node;
2067
2068
  memsize->memsize += sizeof(*cast);
@@ -2069,7 +2070,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2069
2070
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
2070
2071
  break;
2071
2072
  }
2072
- #line 102 "node.c.erb"
2073
+ #line 103 "node.c.erb"
2073
2074
  case PM_PARAMETERS_NODE: {
2074
2075
  pm_parameters_node_t *cast = (pm_parameters_node_t *) node;
2075
2076
  memsize->memsize += sizeof(*cast);
@@ -2090,7 +2091,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2090
2091
  }
2091
2092
  break;
2092
2093
  }
2093
- #line 102 "node.c.erb"
2094
+ #line 103 "node.c.erb"
2094
2095
  case PM_PARENTHESES_NODE: {
2095
2096
  pm_parentheses_node_t *cast = (pm_parentheses_node_t *) node;
2096
2097
  memsize->memsize += sizeof(*cast);
@@ -2099,21 +2100,21 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2099
2100
  }
2100
2101
  break;
2101
2102
  }
2102
- #line 102 "node.c.erb"
2103
+ #line 103 "node.c.erb"
2103
2104
  case PM_PINNED_EXPRESSION_NODE: {
2104
2105
  pm_pinned_expression_node_t *cast = (pm_pinned_expression_node_t *) node;
2105
2106
  memsize->memsize += sizeof(*cast);
2106
2107
  pm_node_memsize_node((pm_node_t *)cast->expression, memsize);
2107
2108
  break;
2108
2109
  }
2109
- #line 102 "node.c.erb"
2110
+ #line 103 "node.c.erb"
2110
2111
  case PM_PINNED_VARIABLE_NODE: {
2111
2112
  pm_pinned_variable_node_t *cast = (pm_pinned_variable_node_t *) node;
2112
2113
  memsize->memsize += sizeof(*cast);
2113
2114
  pm_node_memsize_node((pm_node_t *)cast->variable, memsize);
2114
2115
  break;
2115
2116
  }
2116
- #line 102 "node.c.erb"
2117
+ #line 103 "node.c.erb"
2117
2118
  case PM_POST_EXECUTION_NODE: {
2118
2119
  pm_post_execution_node_t *cast = (pm_post_execution_node_t *) node;
2119
2120
  memsize->memsize += sizeof(*cast);
@@ -2122,7 +2123,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2122
2123
  }
2123
2124
  break;
2124
2125
  }
2125
- #line 102 "node.c.erb"
2126
+ #line 103 "node.c.erb"
2126
2127
  case PM_PRE_EXECUTION_NODE: {
2127
2128
  pm_pre_execution_node_t *cast = (pm_pre_execution_node_t *) node;
2128
2129
  memsize->memsize += sizeof(*cast);
@@ -2131,7 +2132,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2131
2132
  }
2132
2133
  break;
2133
2134
  }
2134
- #line 102 "node.c.erb"
2135
+ #line 103 "node.c.erb"
2135
2136
  case PM_PROGRAM_NODE: {
2136
2137
  pm_program_node_t *cast = (pm_program_node_t *) node;
2137
2138
  memsize->memsize += sizeof(*cast);
@@ -2141,7 +2142,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2141
2142
  pm_node_memsize_node((pm_node_t *)cast->statements, memsize);
2142
2143
  break;
2143
2144
  }
2144
- #line 102 "node.c.erb"
2145
+ #line 103 "node.c.erb"
2145
2146
  case PM_RANGE_NODE: {
2146
2147
  pm_range_node_t *cast = (pm_range_node_t *) node;
2147
2148
  memsize->memsize += sizeof(*cast);
@@ -2153,33 +2154,39 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2153
2154
  }
2154
2155
  break;
2155
2156
  }
2156
- #line 102 "node.c.erb"
2157
+ #line 103 "node.c.erb"
2157
2158
  case PM_RATIONAL_NODE: {
2158
2159
  pm_rational_node_t *cast = (pm_rational_node_t *) node;
2159
2160
  memsize->memsize += sizeof(*cast);
2160
2161
  pm_node_memsize_node((pm_node_t *)cast->numeric, memsize);
2161
2162
  break;
2162
2163
  }
2163
- #line 102 "node.c.erb"
2164
+ #line 103 "node.c.erb"
2164
2165
  case PM_REDO_NODE: {
2165
2166
  pm_redo_node_t *cast = (pm_redo_node_t *) node;
2166
2167
  memsize->memsize += sizeof(*cast);
2167
2168
  break;
2168
2169
  }
2169
- #line 102 "node.c.erb"
2170
+ #line 103 "node.c.erb"
2170
2171
  case PM_REGULAR_EXPRESSION_NODE: {
2171
2172
  pm_regular_expression_node_t *cast = (pm_regular_expression_node_t *) node;
2172
2173
  memsize->memsize += sizeof(*cast);
2173
2174
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2174
2175
  break;
2175
2176
  }
2176
- #line 102 "node.c.erb"
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;
2180
+ memsize->memsize += sizeof(*cast);
2181
+ break;
2182
+ }
2183
+ #line 103 "node.c.erb"
2177
2184
  case PM_REQUIRED_PARAMETER_NODE: {
2178
2185
  pm_required_parameter_node_t *cast = (pm_required_parameter_node_t *) node;
2179
2186
  memsize->memsize += sizeof(*cast);
2180
2187
  break;
2181
2188
  }
2182
- #line 102 "node.c.erb"
2189
+ #line 103 "node.c.erb"
2183
2190
  case PM_RESCUE_MODIFIER_NODE: {
2184
2191
  pm_rescue_modifier_node_t *cast = (pm_rescue_modifier_node_t *) node;
2185
2192
  memsize->memsize += sizeof(*cast);
@@ -2187,7 +2194,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2187
2194
  pm_node_memsize_node((pm_node_t *)cast->rescue_expression, memsize);
2188
2195
  break;
2189
2196
  }
2190
- #line 102 "node.c.erb"
2197
+ #line 103 "node.c.erb"
2191
2198
  case PM_RESCUE_NODE: {
2192
2199
  pm_rescue_node_t *cast = (pm_rescue_node_t *) node;
2193
2200
  memsize->memsize += sizeof(*cast);
@@ -2205,19 +2212,19 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2205
2212
  }
2206
2213
  break;
2207
2214
  }
2208
- #line 102 "node.c.erb"
2215
+ #line 103 "node.c.erb"
2209
2216
  case PM_REST_PARAMETER_NODE: {
2210
2217
  pm_rest_parameter_node_t *cast = (pm_rest_parameter_node_t *) node;
2211
2218
  memsize->memsize += sizeof(*cast);
2212
2219
  break;
2213
2220
  }
2214
- #line 102 "node.c.erb"
2221
+ #line 103 "node.c.erb"
2215
2222
  case PM_RETRY_NODE: {
2216
2223
  pm_retry_node_t *cast = (pm_retry_node_t *) node;
2217
2224
  memsize->memsize += sizeof(*cast);
2218
2225
  break;
2219
2226
  }
2220
- #line 102 "node.c.erb"
2227
+ #line 103 "node.c.erb"
2221
2228
  case PM_RETURN_NODE: {
2222
2229
  pm_return_node_t *cast = (pm_return_node_t *) node;
2223
2230
  memsize->memsize += sizeof(*cast);
@@ -2226,13 +2233,13 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2226
2233
  }
2227
2234
  break;
2228
2235
  }
2229
- #line 102 "node.c.erb"
2236
+ #line 103 "node.c.erb"
2230
2237
  case PM_SELF_NODE: {
2231
2238
  pm_self_node_t *cast = (pm_self_node_t *) node;
2232
2239
  memsize->memsize += sizeof(*cast);
2233
2240
  break;
2234
2241
  }
2235
- #line 102 "node.c.erb"
2242
+ #line 103 "node.c.erb"
2236
2243
  case PM_SINGLETON_CLASS_NODE: {
2237
2244
  pm_singleton_class_node_t *cast = (pm_singleton_class_node_t *) node;
2238
2245
  memsize->memsize += sizeof(*cast);
@@ -2245,26 +2252,26 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2245
2252
  }
2246
2253
  break;
2247
2254
  }
2248
- #line 102 "node.c.erb"
2255
+ #line 103 "node.c.erb"
2249
2256
  case PM_SOURCE_ENCODING_NODE: {
2250
2257
  pm_source_encoding_node_t *cast = (pm_source_encoding_node_t *) node;
2251
2258
  memsize->memsize += sizeof(*cast);
2252
2259
  break;
2253
2260
  }
2254
- #line 102 "node.c.erb"
2261
+ #line 103 "node.c.erb"
2255
2262
  case PM_SOURCE_FILE_NODE: {
2256
2263
  pm_source_file_node_t *cast = (pm_source_file_node_t *) node;
2257
2264
  memsize->memsize += sizeof(*cast);
2258
2265
  memsize->memsize += pm_string_memsize(&cast->filepath);
2259
2266
  break;
2260
2267
  }
2261
- #line 102 "node.c.erb"
2268
+ #line 103 "node.c.erb"
2262
2269
  case PM_SOURCE_LINE_NODE: {
2263
2270
  pm_source_line_node_t *cast = (pm_source_line_node_t *) node;
2264
2271
  memsize->memsize += sizeof(*cast);
2265
2272
  break;
2266
2273
  }
2267
- #line 102 "node.c.erb"
2274
+ #line 103 "node.c.erb"
2268
2275
  case PM_SPLAT_NODE: {
2269
2276
  pm_splat_node_t *cast = (pm_splat_node_t *) node;
2270
2277
  memsize->memsize += sizeof(*cast);
@@ -2273,7 +2280,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2273
2280
  }
2274
2281
  break;
2275
2282
  }
2276
- #line 102 "node.c.erb"
2283
+ #line 103 "node.c.erb"
2277
2284
  case PM_STATEMENTS_NODE: {
2278
2285
  pm_statements_node_t *cast = (pm_statements_node_t *) node;
2279
2286
  memsize->memsize += sizeof(*cast);
@@ -2282,7 +2289,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2282
2289
  memsize->memsize += pm_node_list_memsize(&cast->body, memsize);
2283
2290
  break;
2284
2291
  }
2285
- #line 102 "node.c.erb"
2292
+ #line 103 "node.c.erb"
2286
2293
  case PM_STRING_CONCAT_NODE: {
2287
2294
  pm_string_concat_node_t *cast = (pm_string_concat_node_t *) node;
2288
2295
  memsize->memsize += sizeof(*cast);
@@ -2290,14 +2297,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2290
2297
  pm_node_memsize_node((pm_node_t *)cast->right, memsize);
2291
2298
  break;
2292
2299
  }
2293
- #line 102 "node.c.erb"
2300
+ #line 103 "node.c.erb"
2294
2301
  case PM_STRING_NODE: {
2295
2302
  pm_string_node_t *cast = (pm_string_node_t *) node;
2296
2303
  memsize->memsize += sizeof(*cast);
2297
2304
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2298
2305
  break;
2299
2306
  }
2300
- #line 102 "node.c.erb"
2307
+ #line 103 "node.c.erb"
2301
2308
  case PM_SUPER_NODE: {
2302
2309
  pm_super_node_t *cast = (pm_super_node_t *) node;
2303
2310
  memsize->memsize += sizeof(*cast);
@@ -2309,20 +2316,20 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2309
2316
  }
2310
2317
  break;
2311
2318
  }
2312
- #line 102 "node.c.erb"
2319
+ #line 103 "node.c.erb"
2313
2320
  case PM_SYMBOL_NODE: {
2314
2321
  pm_symbol_node_t *cast = (pm_symbol_node_t *) node;
2315
2322
  memsize->memsize += sizeof(*cast);
2316
2323
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2317
2324
  break;
2318
2325
  }
2319
- #line 102 "node.c.erb"
2326
+ #line 103 "node.c.erb"
2320
2327
  case PM_TRUE_NODE: {
2321
2328
  pm_true_node_t *cast = (pm_true_node_t *) node;
2322
2329
  memsize->memsize += sizeof(*cast);
2323
2330
  break;
2324
2331
  }
2325
- #line 102 "node.c.erb"
2332
+ #line 103 "node.c.erb"
2326
2333
  case PM_UNDEF_NODE: {
2327
2334
  pm_undef_node_t *cast = (pm_undef_node_t *) node;
2328
2335
  memsize->memsize += sizeof(*cast);
@@ -2331,7 +2338,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2331
2338
  memsize->memsize += pm_node_list_memsize(&cast->names, memsize);
2332
2339
  break;
2333
2340
  }
2334
- #line 102 "node.c.erb"
2341
+ #line 103 "node.c.erb"
2335
2342
  case PM_UNLESS_NODE: {
2336
2343
  pm_unless_node_t *cast = (pm_unless_node_t *) node;
2337
2344
  memsize->memsize += sizeof(*cast);
@@ -2344,7 +2351,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2344
2351
  }
2345
2352
  break;
2346
2353
  }
2347
- #line 102 "node.c.erb"
2354
+ #line 103 "node.c.erb"
2348
2355
  case PM_UNTIL_NODE: {
2349
2356
  pm_until_node_t *cast = (pm_until_node_t *) node;
2350
2357
  memsize->memsize += sizeof(*cast);
@@ -2354,7 +2361,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2354
2361
  }
2355
2362
  break;
2356
2363
  }
2357
- #line 102 "node.c.erb"
2364
+ #line 103 "node.c.erb"
2358
2365
  case PM_WHEN_NODE: {
2359
2366
  pm_when_node_t *cast = (pm_when_node_t *) node;
2360
2367
  memsize->memsize += sizeof(*cast);
@@ -2366,7 +2373,7 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2366
2373
  }
2367
2374
  break;
2368
2375
  }
2369
- #line 102 "node.c.erb"
2376
+ #line 103 "node.c.erb"
2370
2377
  case PM_WHILE_NODE: {
2371
2378
  pm_while_node_t *cast = (pm_while_node_t *) node;
2372
2379
  memsize->memsize += sizeof(*cast);
@@ -2376,14 +2383,14 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2376
2383
  }
2377
2384
  break;
2378
2385
  }
2379
- #line 102 "node.c.erb"
2386
+ #line 103 "node.c.erb"
2380
2387
  case PM_X_STRING_NODE: {
2381
2388
  pm_x_string_node_t *cast = (pm_x_string_node_t *) node;
2382
2389
  memsize->memsize += sizeof(*cast);
2383
2390
  memsize->memsize += pm_string_memsize(&cast->unescaped);
2384
2391
  break;
2385
2392
  }
2386
- #line 102 "node.c.erb"
2393
+ #line 103 "node.c.erb"
2387
2394
  case PM_YIELD_NODE: {
2388
2395
  pm_yield_node_t *cast = (pm_yield_node_t *) node;
2389
2396
  memsize->memsize += sizeof(*cast);
@@ -2392,18 +2399,22 @@ pm_node_memsize_node(pm_node_t *node, pm_memsize_t *memsize) {
2392
2399
  }
2393
2400
  break;
2394
2401
  }
2395
- #line 136 "node.c.erb"
2402
+ #line 137 "node.c.erb"
2396
2403
  }
2397
2404
  }
2398
2405
 
2399
- // Calculates the memory footprint of a given node.
2406
+ /**
2407
+ * Calculates the memory footprint of a given node.
2408
+ */
2400
2409
  PRISM_EXPORTED_FUNCTION void
2401
2410
  pm_node_memsize(pm_node_t *node, pm_memsize_t *memsize) {
2402
2411
  *memsize = (pm_memsize_t) { .memsize = 0, .node_count = 0 };
2403
2412
  pm_node_memsize_node(node, memsize);
2404
2413
  }
2405
2414
 
2406
- // Returns a string representation of the given node type.
2415
+ /**
2416
+ * Returns a string representation of the given node type.
2417
+ */
2407
2418
  PRISM_EXPORTED_FUNCTION const char *
2408
2419
  pm_node_type_to_str(pm_node_type_t node_type)
2409
2420
  {
@@ -2576,8 +2587,6 @@ pm_node_type_to_str(pm_node_type_t node_type)
2576
2587
  return "PM_INTERPOLATED_X_STRING_NODE";
2577
2588
  case PM_KEYWORD_HASH_NODE:
2578
2589
  return "PM_KEYWORD_HASH_NODE";
2579
- case PM_KEYWORD_PARAMETER_NODE:
2580
- return "PM_KEYWORD_PARAMETER_NODE";
2581
2590
  case PM_KEYWORD_REST_PARAMETER_NODE:
2582
2591
  return "PM_KEYWORD_REST_PARAMETER_NODE";
2583
2592
  case PM_LAMBDA_NODE:
@@ -2618,6 +2627,8 @@ pm_node_type_to_str(pm_node_type_t node_type)
2618
2627
  return "PM_NO_KEYWORDS_PARAMETER_NODE";
2619
2628
  case PM_NUMBERED_REFERENCE_READ_NODE:
2620
2629
  return "PM_NUMBERED_REFERENCE_READ_NODE";
2630
+ case PM_OPTIONAL_KEYWORD_PARAMETER_NODE:
2631
+ return "PM_OPTIONAL_KEYWORD_PARAMETER_NODE";
2621
2632
  case PM_OPTIONAL_PARAMETER_NODE:
2622
2633
  return "PM_OPTIONAL_PARAMETER_NODE";
2623
2634
  case PM_OR_NODE:
@@ -2644,6 +2655,8 @@ pm_node_type_to_str(pm_node_type_t node_type)
2644
2655
  return "PM_REDO_NODE";
2645
2656
  case PM_REGULAR_EXPRESSION_NODE:
2646
2657
  return "PM_REGULAR_EXPRESSION_NODE";
2658
+ case PM_REQUIRED_KEYWORD_PARAMETER_NODE:
2659
+ return "PM_REQUIRED_KEYWORD_PARAMETER_NODE";
2647
2660
  case PM_REQUIRED_PARAMETER_NODE:
2648
2661
  return "PM_REQUIRED_PARAMETER_NODE";
2649
2662
  case PM_RESCUE_MODIFIER_NODE: