prism 0.16.0 → 0.17.0

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