yarp 0.10.0 → 0.12.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (39) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +50 -1
  3. data/CONTRIBUTING.md +7 -0
  4. data/config.yml +259 -49
  5. data/docs/configuration.md +0 -1
  6. data/docs/mapping.md +91 -91
  7. data/docs/serialization.md +23 -20
  8. data/ext/yarp/api_node.c +1268 -419
  9. data/ext/yarp/extension.c +9 -2
  10. data/ext/yarp/extension.h +2 -2
  11. data/include/yarp/ast.h +471 -318
  12. data/include/yarp/diagnostic.h +203 -1
  13. data/include/yarp/enc/yp_encoding.h +1 -1
  14. data/include/yarp/node.h +0 -4
  15. data/include/yarp/parser.h +44 -16
  16. data/include/yarp/util/yp_char.h +22 -6
  17. data/include/yarp/util/yp_constant_pool.h +11 -4
  18. data/include/yarp/version.h +2 -2
  19. data/lib/yarp/desugar_visitor.rb +19 -19
  20. data/lib/yarp/mutation_visitor.rb +50 -15
  21. data/lib/yarp/node.rb +6455 -443
  22. data/lib/yarp/parse_result/comments.rb +172 -0
  23. data/lib/yarp/parse_result/newlines.rb +60 -0
  24. data/lib/yarp/pattern.rb +239 -0
  25. data/lib/yarp/serialize.rb +173 -140
  26. data/lib/yarp.rb +151 -76
  27. data/src/diagnostic.c +259 -2
  28. data/src/enc/yp_unicode.c +5 -5
  29. data/src/node.c +984 -872
  30. data/src/prettyprint.c +461 -203
  31. data/src/serialize.c +380 -185
  32. data/src/unescape.c +20 -20
  33. data/src/util/yp_char.c +59 -16
  34. data/src/util/yp_constant_pool.c +97 -13
  35. data/src/util/yp_newline_list.c +5 -1
  36. data/src/util/yp_string_list.c +4 -1
  37. data/src/yarp.c +2313 -1675
  38. data/yarp.gemspec +4 -1
  39. metadata +5 -2
data/src/node.c CHANGED
@@ -15,30 +15,6 @@ void yp_node_clear(yp_node_t *node) {
15
15
  node->location = location;
16
16
  }
17
17
 
18
- // Calculate the size of the token list in bytes.
19
- static size_t
20
- yp_location_list_memsize(yp_location_list_t *list) {
21
- return sizeof(yp_location_list_t) + (list->capacity * sizeof(yp_location_t));
22
- }
23
-
24
- // Append a token to the given list.
25
- void
26
- yp_location_list_append(yp_location_list_t *list, const yp_token_t *token) {
27
- if (list->size == list->capacity) {
28
- list->capacity = list->capacity == 0 ? 2 : list->capacity * 2;
29
- list->locations = (yp_location_t *) realloc(list->locations, sizeof(yp_location_t) * list->capacity);
30
- }
31
- list->locations[list->size++] = (yp_location_t) { .start = token->start, .end = token->end };
32
- }
33
-
34
- // Free the memory associated with the token list.
35
- static void
36
- yp_location_list_free(yp_location_list_t *list) {
37
- if (list->locations != NULL) {
38
- free(list->locations);
39
- }
40
- }
41
-
42
18
  static void
43
19
  yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize);
44
20
 
@@ -83,41 +59,48 @@ yp_node_list_free(yp_parser_t *parser, yp_node_list_t *list) {
83
59
  YP_EXPORTED_FUNCTION void
84
60
  yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
85
61
  switch (YP_NODE_TYPE(node)) {
86
- #line 81 "node.c.erb"
87
- case YP_NODE_ALIAS_NODE: {
88
- yp_alias_node_t *cast = (yp_alias_node_t *) node;
62
+ #line 57 "node.c.erb"
63
+ case YP_ALIAS_GLOBAL_VARIABLE_NODE: {
64
+ yp_alias_global_variable_node_t *cast = (yp_alias_global_variable_node_t *) node;
89
65
  yp_node_destroy(parser, (yp_node_t *)cast->new_name);
90
66
  yp_node_destroy(parser, (yp_node_t *)cast->old_name);
91
67
  break;
92
68
  }
93
- #line 81 "node.c.erb"
94
- case YP_NODE_ALTERNATION_PATTERN_NODE: {
69
+ #line 57 "node.c.erb"
70
+ case YP_ALIAS_METHOD_NODE: {
71
+ yp_alias_method_node_t *cast = (yp_alias_method_node_t *) node;
72
+ yp_node_destroy(parser, (yp_node_t *)cast->new_name);
73
+ yp_node_destroy(parser, (yp_node_t *)cast->old_name);
74
+ break;
75
+ }
76
+ #line 57 "node.c.erb"
77
+ case YP_ALTERNATION_PATTERN_NODE: {
95
78
  yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
96
79
  yp_node_destroy(parser, (yp_node_t *)cast->left);
97
80
  yp_node_destroy(parser, (yp_node_t *)cast->right);
98
81
  break;
99
82
  }
100
- #line 81 "node.c.erb"
101
- case YP_NODE_AND_NODE: {
83
+ #line 57 "node.c.erb"
84
+ case YP_AND_NODE: {
102
85
  yp_and_node_t *cast = (yp_and_node_t *) node;
103
86
  yp_node_destroy(parser, (yp_node_t *)cast->left);
104
87
  yp_node_destroy(parser, (yp_node_t *)cast->right);
105
88
  break;
106
89
  }
107
- #line 81 "node.c.erb"
108
- case YP_NODE_ARGUMENTS_NODE: {
90
+ #line 57 "node.c.erb"
91
+ case YP_ARGUMENTS_NODE: {
109
92
  yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
110
93
  yp_node_list_free(parser, &cast->arguments);
111
94
  break;
112
95
  }
113
- #line 81 "node.c.erb"
114
- case YP_NODE_ARRAY_NODE: {
96
+ #line 57 "node.c.erb"
97
+ case YP_ARRAY_NODE: {
115
98
  yp_array_node_t *cast = (yp_array_node_t *) node;
116
99
  yp_node_list_free(parser, &cast->elements);
117
100
  break;
118
101
  }
119
- #line 81 "node.c.erb"
120
- case YP_NODE_ARRAY_PATTERN_NODE: {
102
+ #line 57 "node.c.erb"
103
+ case YP_ARRAY_PATTERN_NODE: {
121
104
  yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
122
105
  if (cast->constant != NULL) {
123
106
  yp_node_destroy(parser, (yp_node_t *)cast->constant);
@@ -129,8 +112,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
129
112
  yp_node_list_free(parser, &cast->posts);
130
113
  break;
131
114
  }
132
- #line 81 "node.c.erb"
133
- case YP_NODE_ASSOC_NODE: {
115
+ #line 57 "node.c.erb"
116
+ case YP_ASSOC_NODE: {
134
117
  yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
135
118
  yp_node_destroy(parser, (yp_node_t *)cast->key);
136
119
  if (cast->value != NULL) {
@@ -138,20 +121,20 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
138
121
  }
139
122
  break;
140
123
  }
141
- #line 81 "node.c.erb"
142
- case YP_NODE_ASSOC_SPLAT_NODE: {
124
+ #line 57 "node.c.erb"
125
+ case YP_ASSOC_SPLAT_NODE: {
143
126
  yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
144
127
  if (cast->value != NULL) {
145
128
  yp_node_destroy(parser, (yp_node_t *)cast->value);
146
129
  }
147
130
  break;
148
131
  }
149
- #line 81 "node.c.erb"
150
- case YP_NODE_BACK_REFERENCE_READ_NODE: {
132
+ #line 57 "node.c.erb"
133
+ case YP_BACK_REFERENCE_READ_NODE: {
151
134
  break;
152
135
  }
153
- #line 81 "node.c.erb"
154
- case YP_NODE_BEGIN_NODE: {
136
+ #line 57 "node.c.erb"
137
+ case YP_BEGIN_NODE: {
155
138
  yp_begin_node_t *cast = (yp_begin_node_t *) node;
156
139
  if (cast->statements != NULL) {
157
140
  yp_node_destroy(parser, (yp_node_t *)cast->statements);
@@ -167,16 +150,20 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
167
150
  }
168
151
  break;
169
152
  }
170
- #line 81 "node.c.erb"
171
- case YP_NODE_BLOCK_ARGUMENT_NODE: {
153
+ #line 57 "node.c.erb"
154
+ case YP_BLOCK_ARGUMENT_NODE: {
172
155
  yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
173
156
  if (cast->expression != NULL) {
174
157
  yp_node_destroy(parser, (yp_node_t *)cast->expression);
175
158
  }
176
159
  break;
177
160
  }
178
- #line 81 "node.c.erb"
179
- case YP_NODE_BLOCK_NODE: {
161
+ #line 57 "node.c.erb"
162
+ case YP_BLOCK_LOCAL_VARIABLE_NODE: {
163
+ break;
164
+ }
165
+ #line 57 "node.c.erb"
166
+ case YP_BLOCK_NODE: {
180
167
  yp_block_node_t *cast = (yp_block_node_t *) node;
181
168
  yp_constant_id_list_free(&cast->locals);
182
169
  if (cast->parameters != NULL) {
@@ -187,29 +174,43 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
187
174
  }
188
175
  break;
189
176
  }
190
- #line 81 "node.c.erb"
191
- case YP_NODE_BLOCK_PARAMETER_NODE: {
177
+ #line 57 "node.c.erb"
178
+ case YP_BLOCK_PARAMETER_NODE: {
192
179
  break;
193
180
  }
194
- #line 81 "node.c.erb"
195
- case YP_NODE_BLOCK_PARAMETERS_NODE: {
181
+ #line 57 "node.c.erb"
182
+ case YP_BLOCK_PARAMETERS_NODE: {
196
183
  yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
197
184
  if (cast->parameters != NULL) {
198
185
  yp_node_destroy(parser, (yp_node_t *)cast->parameters);
199
186
  }
200
- yp_location_list_free(&cast->locals);
187
+ yp_node_list_free(parser, &cast->locals);
201
188
  break;
202
189
  }
203
- #line 81 "node.c.erb"
204
- case YP_NODE_BREAK_NODE: {
190
+ #line 57 "node.c.erb"
191
+ case YP_BREAK_NODE: {
205
192
  yp_break_node_t *cast = (yp_break_node_t *) node;
206
193
  if (cast->arguments != NULL) {
207
194
  yp_node_destroy(parser, (yp_node_t *)cast->arguments);
208
195
  }
209
196
  break;
210
197
  }
211
- #line 81 "node.c.erb"
212
- case YP_NODE_CALL_NODE: {
198
+ #line 57 "node.c.erb"
199
+ case YP_CALL_AND_WRITE_NODE: {
200
+ yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
201
+ if (cast->receiver != NULL) {
202
+ yp_node_destroy(parser, (yp_node_t *)cast->receiver);
203
+ }
204
+ if (cast->arguments != NULL) {
205
+ yp_node_destroy(parser, (yp_node_t *)cast->arguments);
206
+ }
207
+ yp_string_free(&cast->read_name);
208
+ yp_string_free(&cast->write_name);
209
+ yp_node_destroy(parser, (yp_node_t *)cast->value);
210
+ break;
211
+ }
212
+ #line 57 "node.c.erb"
213
+ case YP_CALL_NODE: {
213
214
  yp_call_node_t *cast = (yp_call_node_t *) node;
214
215
  if (cast->receiver != NULL) {
215
216
  yp_node_destroy(parser, (yp_node_t *)cast->receiver);
@@ -223,36 +224,43 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
223
224
  yp_string_free(&cast->name);
224
225
  break;
225
226
  }
226
- #line 81 "node.c.erb"
227
- case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
228
- yp_call_operator_and_write_node_t *cast = (yp_call_operator_and_write_node_t *) node;
229
- yp_node_destroy(parser, (yp_node_t *)cast->target);
230
- yp_node_destroy(parser, (yp_node_t *)cast->value);
231
- break;
232
- }
233
- #line 81 "node.c.erb"
234
- case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
235
- yp_call_operator_or_write_node_t *cast = (yp_call_operator_or_write_node_t *) node;
236
- yp_node_destroy(parser, (yp_node_t *)cast->target);
227
+ #line 57 "node.c.erb"
228
+ case YP_CALL_OPERATOR_WRITE_NODE: {
229
+ yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
230
+ if (cast->receiver != NULL) {
231
+ yp_node_destroy(parser, (yp_node_t *)cast->receiver);
232
+ }
233
+ if (cast->arguments != NULL) {
234
+ yp_node_destroy(parser, (yp_node_t *)cast->arguments);
235
+ }
236
+ yp_string_free(&cast->read_name);
237
+ yp_string_free(&cast->write_name);
237
238
  yp_node_destroy(parser, (yp_node_t *)cast->value);
238
239
  break;
239
240
  }
240
- #line 81 "node.c.erb"
241
- case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
242
- yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
243
- yp_node_destroy(parser, (yp_node_t *)cast->target);
241
+ #line 57 "node.c.erb"
242
+ case YP_CALL_OR_WRITE_NODE: {
243
+ yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
244
+ if (cast->receiver != NULL) {
245
+ yp_node_destroy(parser, (yp_node_t *)cast->receiver);
246
+ }
247
+ if (cast->arguments != NULL) {
248
+ yp_node_destroy(parser, (yp_node_t *)cast->arguments);
249
+ }
250
+ yp_string_free(&cast->read_name);
251
+ yp_string_free(&cast->write_name);
244
252
  yp_node_destroy(parser, (yp_node_t *)cast->value);
245
253
  break;
246
254
  }
247
- #line 81 "node.c.erb"
248
- case YP_NODE_CAPTURE_PATTERN_NODE: {
255
+ #line 57 "node.c.erb"
256
+ case YP_CAPTURE_PATTERN_NODE: {
249
257
  yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
250
258
  yp_node_destroy(parser, (yp_node_t *)cast->value);
251
259
  yp_node_destroy(parser, (yp_node_t *)cast->target);
252
260
  break;
253
261
  }
254
- #line 81 "node.c.erb"
255
- case YP_NODE_CASE_NODE: {
262
+ #line 57 "node.c.erb"
263
+ case YP_CASE_NODE: {
256
264
  yp_case_node_t *cast = (yp_case_node_t *) node;
257
265
  if (cast->predicate != NULL) {
258
266
  yp_node_destroy(parser, (yp_node_t *)cast->predicate);
@@ -263,8 +271,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
263
271
  }
264
272
  break;
265
273
  }
266
- #line 81 "node.c.erb"
267
- case YP_NODE_CLASS_NODE: {
274
+ #line 57 "node.c.erb"
275
+ case YP_CLASS_NODE: {
268
276
  yp_class_node_t *cast = (yp_class_node_t *) node;
269
277
  yp_constant_id_list_free(&cast->locals);
270
278
  yp_node_destroy(parser, (yp_node_t *)cast->constant_path);
@@ -274,70 +282,67 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
274
282
  if (cast->body != NULL) {
275
283
  yp_node_destroy(parser, (yp_node_t *)cast->body);
276
284
  }
277
- yp_string_free(&cast->name);
278
285
  break;
279
286
  }
280
- #line 81 "node.c.erb"
281
- case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
287
+ #line 57 "node.c.erb"
288
+ case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
282
289
  yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
283
290
  yp_node_destroy(parser, (yp_node_t *)cast->value);
284
291
  break;
285
292
  }
286
- #line 81 "node.c.erb"
287
- case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
293
+ #line 57 "node.c.erb"
294
+ case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
288
295
  yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
289
296
  yp_node_destroy(parser, (yp_node_t *)cast->value);
290
297
  break;
291
298
  }
292
- #line 81 "node.c.erb"
293
- case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
299
+ #line 57 "node.c.erb"
300
+ case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
294
301
  yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
295
302
  yp_node_destroy(parser, (yp_node_t *)cast->value);
296
303
  break;
297
304
  }
298
- #line 81 "node.c.erb"
299
- case YP_NODE_CLASS_VARIABLE_READ_NODE: {
305
+ #line 57 "node.c.erb"
306
+ case YP_CLASS_VARIABLE_READ_NODE: {
300
307
  break;
301
308
  }
302
- #line 81 "node.c.erb"
303
- case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
309
+ #line 57 "node.c.erb"
310
+ case YP_CLASS_VARIABLE_TARGET_NODE: {
304
311
  break;
305
312
  }
306
- #line 81 "node.c.erb"
307
- case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
313
+ #line 57 "node.c.erb"
314
+ case YP_CLASS_VARIABLE_WRITE_NODE: {
308
315
  yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
309
- if (cast->value != NULL) {
310
- yp_node_destroy(parser, (yp_node_t *)cast->value);
311
- }
316
+ yp_node_destroy(parser, (yp_node_t *)cast->value);
312
317
  break;
313
318
  }
314
- #line 81 "node.c.erb"
315
- case YP_NODE_CONSTANT_AND_WRITE_NODE: {
319
+ #line 57 "node.c.erb"
320
+ case YP_CONSTANT_AND_WRITE_NODE: {
316
321
  yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
317
322
  yp_node_destroy(parser, (yp_node_t *)cast->value);
318
323
  break;
319
324
  }
320
- #line 81 "node.c.erb"
321
- case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
325
+ #line 57 "node.c.erb"
326
+ case YP_CONSTANT_OPERATOR_WRITE_NODE: {
322
327
  yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
323
328
  yp_node_destroy(parser, (yp_node_t *)cast->value);
324
329
  break;
325
330
  }
326
- #line 81 "node.c.erb"
327
- case YP_NODE_CONSTANT_OR_WRITE_NODE: {
331
+ #line 57 "node.c.erb"
332
+ case YP_CONSTANT_OR_WRITE_NODE: {
328
333
  yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
329
334
  yp_node_destroy(parser, (yp_node_t *)cast->value);
330
335
  break;
331
336
  }
332
- #line 81 "node.c.erb"
333
- case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
337
+ #line 57 "node.c.erb"
338
+ case YP_CONSTANT_PATH_AND_WRITE_NODE: {
334
339
  yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
335
340
  yp_node_destroy(parser, (yp_node_t *)cast->target);
336
341
  yp_node_destroy(parser, (yp_node_t *)cast->value);
337
342
  break;
338
343
  }
339
- #line 81 "node.c.erb"
340
- case YP_NODE_CONSTANT_PATH_NODE: {
344
+ #line 57 "node.c.erb"
345
+ case YP_CONSTANT_PATH_NODE: {
341
346
  yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
342
347
  if (cast->parent != NULL) {
343
348
  yp_node_destroy(parser, (yp_node_t *)cast->parent);
@@ -345,22 +350,22 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
345
350
  yp_node_destroy(parser, (yp_node_t *)cast->child);
346
351
  break;
347
352
  }
348
- #line 81 "node.c.erb"
349
- case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
353
+ #line 57 "node.c.erb"
354
+ case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
350
355
  yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
351
356
  yp_node_destroy(parser, (yp_node_t *)cast->target);
352
357
  yp_node_destroy(parser, (yp_node_t *)cast->value);
353
358
  break;
354
359
  }
355
- #line 81 "node.c.erb"
356
- case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
360
+ #line 57 "node.c.erb"
361
+ case YP_CONSTANT_PATH_OR_WRITE_NODE: {
357
362
  yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
358
363
  yp_node_destroy(parser, (yp_node_t *)cast->target);
359
364
  yp_node_destroy(parser, (yp_node_t *)cast->value);
360
365
  break;
361
366
  }
362
- #line 81 "node.c.erb"
363
- case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
367
+ #line 57 "node.c.erb"
368
+ case YP_CONSTANT_PATH_TARGET_NODE: {
364
369
  yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
365
370
  if (cast->parent != NULL) {
366
371
  yp_node_destroy(parser, (yp_node_t *)cast->parent);
@@ -368,29 +373,29 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
368
373
  yp_node_destroy(parser, (yp_node_t *)cast->child);
369
374
  break;
370
375
  }
371
- #line 81 "node.c.erb"
372
- case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
376
+ #line 57 "node.c.erb"
377
+ case YP_CONSTANT_PATH_WRITE_NODE: {
373
378
  yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
374
379
  yp_node_destroy(parser, (yp_node_t *)cast->target);
375
380
  yp_node_destroy(parser, (yp_node_t *)cast->value);
376
381
  break;
377
382
  }
378
- #line 81 "node.c.erb"
379
- case YP_NODE_CONSTANT_READ_NODE: {
383
+ #line 57 "node.c.erb"
384
+ case YP_CONSTANT_READ_NODE: {
380
385
  break;
381
386
  }
382
- #line 81 "node.c.erb"
383
- case YP_NODE_CONSTANT_TARGET_NODE: {
387
+ #line 57 "node.c.erb"
388
+ case YP_CONSTANT_TARGET_NODE: {
384
389
  break;
385
390
  }
386
- #line 81 "node.c.erb"
387
- case YP_NODE_CONSTANT_WRITE_NODE: {
391
+ #line 57 "node.c.erb"
392
+ case YP_CONSTANT_WRITE_NODE: {
388
393
  yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
389
394
  yp_node_destroy(parser, (yp_node_t *)cast->value);
390
395
  break;
391
396
  }
392
- #line 81 "node.c.erb"
393
- case YP_NODE_DEF_NODE: {
397
+ #line 57 "node.c.erb"
398
+ case YP_DEF_NODE: {
394
399
  yp_def_node_t *cast = (yp_def_node_t *) node;
395
400
  if (cast->receiver != NULL) {
396
401
  yp_node_destroy(parser, (yp_node_t *)cast->receiver);
@@ -404,48 +409,48 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
404
409
  yp_constant_id_list_free(&cast->locals);
405
410
  break;
406
411
  }
407
- #line 81 "node.c.erb"
408
- case YP_NODE_DEFINED_NODE: {
412
+ #line 57 "node.c.erb"
413
+ case YP_DEFINED_NODE: {
409
414
  yp_defined_node_t *cast = (yp_defined_node_t *) node;
410
415
  yp_node_destroy(parser, (yp_node_t *)cast->value);
411
416
  break;
412
417
  }
413
- #line 81 "node.c.erb"
414
- case YP_NODE_ELSE_NODE: {
418
+ #line 57 "node.c.erb"
419
+ case YP_ELSE_NODE: {
415
420
  yp_else_node_t *cast = (yp_else_node_t *) node;
416
421
  if (cast->statements != NULL) {
417
422
  yp_node_destroy(parser, (yp_node_t *)cast->statements);
418
423
  }
419
424
  break;
420
425
  }
421
- #line 81 "node.c.erb"
422
- case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
426
+ #line 57 "node.c.erb"
427
+ case YP_EMBEDDED_STATEMENTS_NODE: {
423
428
  yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
424
429
  if (cast->statements != NULL) {
425
430
  yp_node_destroy(parser, (yp_node_t *)cast->statements);
426
431
  }
427
432
  break;
428
433
  }
429
- #line 81 "node.c.erb"
430
- case YP_NODE_EMBEDDED_VARIABLE_NODE: {
434
+ #line 57 "node.c.erb"
435
+ case YP_EMBEDDED_VARIABLE_NODE: {
431
436
  yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
432
437
  yp_node_destroy(parser, (yp_node_t *)cast->variable);
433
438
  break;
434
439
  }
435
- #line 81 "node.c.erb"
436
- case YP_NODE_ENSURE_NODE: {
440
+ #line 57 "node.c.erb"
441
+ case YP_ENSURE_NODE: {
437
442
  yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
438
443
  if (cast->statements != NULL) {
439
444
  yp_node_destroy(parser, (yp_node_t *)cast->statements);
440
445
  }
441
446
  break;
442
447
  }
443
- #line 81 "node.c.erb"
444
- case YP_NODE_FALSE_NODE: {
448
+ #line 57 "node.c.erb"
449
+ case YP_FALSE_NODE: {
445
450
  break;
446
451
  }
447
- #line 81 "node.c.erb"
448
- case YP_NODE_FIND_PATTERN_NODE: {
452
+ #line 57 "node.c.erb"
453
+ case YP_FIND_PATTERN_NODE: {
449
454
  yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
450
455
  if (cast->constant != NULL) {
451
456
  yp_node_destroy(parser, (yp_node_t *)cast->constant);
@@ -455,8 +460,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
455
460
  yp_node_destroy(parser, (yp_node_t *)cast->right);
456
461
  break;
457
462
  }
458
- #line 81 "node.c.erb"
459
- case YP_NODE_FLIP_FLOP_NODE: {
463
+ #line 57 "node.c.erb"
464
+ case YP_FLIP_FLOP_NODE: {
460
465
  yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
461
466
  if (cast->left != NULL) {
462
467
  yp_node_destroy(parser, (yp_node_t *)cast->left);
@@ -466,12 +471,12 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
466
471
  }
467
472
  break;
468
473
  }
469
- #line 81 "node.c.erb"
470
- case YP_NODE_FLOAT_NODE: {
474
+ #line 57 "node.c.erb"
475
+ case YP_FLOAT_NODE: {
471
476
  break;
472
477
  }
473
- #line 81 "node.c.erb"
474
- case YP_NODE_FOR_NODE: {
478
+ #line 57 "node.c.erb"
479
+ case YP_FOR_NODE: {
475
480
  yp_for_node_t *cast = (yp_for_node_t *) node;
476
481
  yp_node_destroy(parser, (yp_node_t *)cast->index);
477
482
  yp_node_destroy(parser, (yp_node_t *)cast->collection);
@@ -480,62 +485,62 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
480
485
  }
481
486
  break;
482
487
  }
483
- #line 81 "node.c.erb"
484
- case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
488
+ #line 57 "node.c.erb"
489
+ case YP_FORWARDING_ARGUMENTS_NODE: {
485
490
  break;
486
491
  }
487
- #line 81 "node.c.erb"
488
- case YP_NODE_FORWARDING_PARAMETER_NODE: {
492
+ #line 57 "node.c.erb"
493
+ case YP_FORWARDING_PARAMETER_NODE: {
489
494
  break;
490
495
  }
491
- #line 81 "node.c.erb"
492
- case YP_NODE_FORWARDING_SUPER_NODE: {
496
+ #line 57 "node.c.erb"
497
+ case YP_FORWARDING_SUPER_NODE: {
493
498
  yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
494
499
  if (cast->block != NULL) {
495
500
  yp_node_destroy(parser, (yp_node_t *)cast->block);
496
501
  }
497
502
  break;
498
503
  }
499
- #line 81 "node.c.erb"
500
- case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
504
+ #line 57 "node.c.erb"
505
+ case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
501
506
  yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
502
507
  yp_node_destroy(parser, (yp_node_t *)cast->value);
503
508
  break;
504
509
  }
505
- #line 81 "node.c.erb"
506
- case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
510
+ #line 57 "node.c.erb"
511
+ case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
507
512
  yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
508
513
  yp_node_destroy(parser, (yp_node_t *)cast->value);
509
514
  break;
510
515
  }
511
- #line 81 "node.c.erb"
512
- case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
516
+ #line 57 "node.c.erb"
517
+ case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
513
518
  yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
514
519
  yp_node_destroy(parser, (yp_node_t *)cast->value);
515
520
  break;
516
521
  }
517
- #line 81 "node.c.erb"
518
- case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
522
+ #line 57 "node.c.erb"
523
+ case YP_GLOBAL_VARIABLE_READ_NODE: {
519
524
  break;
520
525
  }
521
- #line 81 "node.c.erb"
522
- case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
526
+ #line 57 "node.c.erb"
527
+ case YP_GLOBAL_VARIABLE_TARGET_NODE: {
523
528
  break;
524
529
  }
525
- #line 81 "node.c.erb"
526
- case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
530
+ #line 57 "node.c.erb"
531
+ case YP_GLOBAL_VARIABLE_WRITE_NODE: {
527
532
  yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
528
533
  yp_node_destroy(parser, (yp_node_t *)cast->value);
529
534
  break;
530
535
  }
531
- #line 81 "node.c.erb"
532
- case YP_NODE_HASH_NODE: {
536
+ #line 57 "node.c.erb"
537
+ case YP_HASH_NODE: {
533
538
  yp_hash_node_t *cast = (yp_hash_node_t *) node;
534
539
  yp_node_list_free(parser, &cast->elements);
535
540
  break;
536
541
  }
537
- #line 81 "node.c.erb"
538
- case YP_NODE_HASH_PATTERN_NODE: {
542
+ #line 57 "node.c.erb"
543
+ case YP_HASH_PATTERN_NODE: {
539
544
  yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
540
545
  if (cast->constant != NULL) {
541
546
  yp_node_destroy(parser, (yp_node_t *)cast->constant);
@@ -546,8 +551,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
546
551
  }
547
552
  break;
548
553
  }
549
- #line 81 "node.c.erb"
550
- case YP_NODE_IF_NODE: {
554
+ #line 57 "node.c.erb"
555
+ case YP_IF_NODE: {
551
556
  yp_if_node_t *cast = (yp_if_node_t *) node;
552
557
  yp_node_destroy(parser, (yp_node_t *)cast->predicate);
553
558
  if (cast->statements != NULL) {
@@ -558,14 +563,20 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
558
563
  }
559
564
  break;
560
565
  }
561
- #line 81 "node.c.erb"
562
- case YP_NODE_IMAGINARY_NODE: {
566
+ #line 57 "node.c.erb"
567
+ case YP_IMAGINARY_NODE: {
563
568
  yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
564
569
  yp_node_destroy(parser, (yp_node_t *)cast->numeric);
565
570
  break;
566
571
  }
567
- #line 81 "node.c.erb"
568
- case YP_NODE_IN_NODE: {
572
+ #line 57 "node.c.erb"
573
+ case YP_IMPLICIT_NODE: {
574
+ yp_implicit_node_t *cast = (yp_implicit_node_t *) node;
575
+ yp_node_destroy(parser, (yp_node_t *)cast->value);
576
+ break;
577
+ }
578
+ #line 57 "node.c.erb"
579
+ case YP_IN_NODE: {
569
580
  yp_in_node_t *cast = (yp_in_node_t *) node;
570
581
  yp_node_destroy(parser, (yp_node_t *)cast->pattern);
571
582
  if (cast->statements != NULL) {
@@ -573,86 +584,92 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
573
584
  }
574
585
  break;
575
586
  }
576
- #line 81 "node.c.erb"
577
- case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
587
+ #line 57 "node.c.erb"
588
+ case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
578
589
  yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
579
590
  yp_node_destroy(parser, (yp_node_t *)cast->value);
580
591
  break;
581
592
  }
582
- #line 81 "node.c.erb"
583
- case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
593
+ #line 57 "node.c.erb"
594
+ case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
584
595
  yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
585
596
  yp_node_destroy(parser, (yp_node_t *)cast->value);
586
597
  break;
587
598
  }
588
- #line 81 "node.c.erb"
589
- case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
599
+ #line 57 "node.c.erb"
600
+ case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
590
601
  yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
591
602
  yp_node_destroy(parser, (yp_node_t *)cast->value);
592
603
  break;
593
604
  }
594
- #line 81 "node.c.erb"
595
- case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
605
+ #line 57 "node.c.erb"
606
+ case YP_INSTANCE_VARIABLE_READ_NODE: {
596
607
  break;
597
608
  }
598
- #line 81 "node.c.erb"
599
- case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
609
+ #line 57 "node.c.erb"
610
+ case YP_INSTANCE_VARIABLE_TARGET_NODE: {
600
611
  break;
601
612
  }
602
- #line 81 "node.c.erb"
603
- case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
613
+ #line 57 "node.c.erb"
614
+ case YP_INSTANCE_VARIABLE_WRITE_NODE: {
604
615
  yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
605
616
  yp_node_destroy(parser, (yp_node_t *)cast->value);
606
617
  break;
607
618
  }
608
- #line 81 "node.c.erb"
609
- case YP_NODE_INTEGER_NODE: {
619
+ #line 57 "node.c.erb"
620
+ case YP_INTEGER_NODE: {
621
+ break;
622
+ }
623
+ #line 57 "node.c.erb"
624
+ case YP_INTERPOLATED_MATCH_LAST_LINE_NODE: {
625
+ yp_interpolated_match_last_line_node_t *cast = (yp_interpolated_match_last_line_node_t *) node;
626
+ yp_node_list_free(parser, &cast->parts);
610
627
  break;
611
628
  }
612
- #line 81 "node.c.erb"
613
- case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
629
+ #line 57 "node.c.erb"
630
+ case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
614
631
  yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
615
632
  yp_node_list_free(parser, &cast->parts);
616
633
  break;
617
634
  }
618
- #line 81 "node.c.erb"
619
- case YP_NODE_INTERPOLATED_STRING_NODE: {
635
+ #line 57 "node.c.erb"
636
+ case YP_INTERPOLATED_STRING_NODE: {
620
637
  yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
621
638
  yp_node_list_free(parser, &cast->parts);
622
639
  break;
623
640
  }
624
- #line 81 "node.c.erb"
625
- case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
641
+ #line 57 "node.c.erb"
642
+ case YP_INTERPOLATED_SYMBOL_NODE: {
626
643
  yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
627
644
  yp_node_list_free(parser, &cast->parts);
628
645
  break;
629
646
  }
630
- #line 81 "node.c.erb"
631
- case YP_NODE_INTERPOLATED_X_STRING_NODE: {
647
+ #line 57 "node.c.erb"
648
+ case YP_INTERPOLATED_X_STRING_NODE: {
632
649
  yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
633
650
  yp_node_list_free(parser, &cast->parts);
634
651
  break;
635
652
  }
636
- #line 81 "node.c.erb"
637
- case YP_NODE_KEYWORD_HASH_NODE: {
653
+ #line 57 "node.c.erb"
654
+ case YP_KEYWORD_HASH_NODE: {
638
655
  yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
639
656
  yp_node_list_free(parser, &cast->elements);
640
657
  break;
641
658
  }
642
- #line 81 "node.c.erb"
643
- case YP_NODE_KEYWORD_PARAMETER_NODE: {
659
+ #line 57 "node.c.erb"
660
+ case YP_KEYWORD_PARAMETER_NODE: {
644
661
  yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
645
662
  if (cast->value != NULL) {
646
663
  yp_node_destroy(parser, (yp_node_t *)cast->value);
647
664
  }
648
665
  break;
649
666
  }
650
- #line 81 "node.c.erb"
651
- case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
667
+ #line 57 "node.c.erb"
668
+ case YP_KEYWORD_REST_PARAMETER_NODE: {
652
669
  break;
653
670
  }
654
- #line 81 "node.c.erb"
655
- case YP_NODE_LAMBDA_NODE: {
671
+ #line 57 "node.c.erb"
672
+ case YP_LAMBDA_NODE: {
656
673
  yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
657
674
  yp_constant_id_list_free(&cast->locals);
658
675
  if (cast->parameters != NULL) {
@@ -663,118 +680,134 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
663
680
  }
664
681
  break;
665
682
  }
666
- #line 81 "node.c.erb"
667
- case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
683
+ #line 57 "node.c.erb"
684
+ case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
668
685
  yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
669
686
  yp_node_destroy(parser, (yp_node_t *)cast->value);
670
687
  break;
671
688
  }
672
- #line 81 "node.c.erb"
673
- case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
689
+ #line 57 "node.c.erb"
690
+ case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
674
691
  yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
675
692
  yp_node_destroy(parser, (yp_node_t *)cast->value);
676
693
  break;
677
694
  }
678
- #line 81 "node.c.erb"
679
- case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
695
+ #line 57 "node.c.erb"
696
+ case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
680
697
  yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
681
698
  yp_node_destroy(parser, (yp_node_t *)cast->value);
682
699
  break;
683
700
  }
684
- #line 81 "node.c.erb"
685
- case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
701
+ #line 57 "node.c.erb"
702
+ case YP_LOCAL_VARIABLE_READ_NODE: {
686
703
  break;
687
704
  }
688
- #line 81 "node.c.erb"
689
- case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
705
+ #line 57 "node.c.erb"
706
+ case YP_LOCAL_VARIABLE_TARGET_NODE: {
690
707
  break;
691
708
  }
692
- #line 81 "node.c.erb"
693
- case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
709
+ #line 57 "node.c.erb"
710
+ case YP_LOCAL_VARIABLE_WRITE_NODE: {
694
711
  yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
695
712
  yp_node_destroy(parser, (yp_node_t *)cast->value);
696
713
  break;
697
714
  }
698
- #line 81 "node.c.erb"
699
- case YP_NODE_MATCH_PREDICATE_NODE: {
715
+ #line 57 "node.c.erb"
716
+ case YP_MATCH_LAST_LINE_NODE: {
717
+ yp_match_last_line_node_t *cast = (yp_match_last_line_node_t *) node;
718
+ yp_string_free(&cast->unescaped);
719
+ break;
720
+ }
721
+ #line 57 "node.c.erb"
722
+ case YP_MATCH_PREDICATE_NODE: {
700
723
  yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
701
724
  yp_node_destroy(parser, (yp_node_t *)cast->value);
702
725
  yp_node_destroy(parser, (yp_node_t *)cast->pattern);
703
726
  break;
704
727
  }
705
- #line 81 "node.c.erb"
706
- case YP_NODE_MATCH_REQUIRED_NODE: {
728
+ #line 57 "node.c.erb"
729
+ case YP_MATCH_REQUIRED_NODE: {
707
730
  yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
708
731
  yp_node_destroy(parser, (yp_node_t *)cast->value);
709
732
  yp_node_destroy(parser, (yp_node_t *)cast->pattern);
710
733
  break;
711
734
  }
712
- #line 81 "node.c.erb"
713
- case YP_NODE_MISSING_NODE: {
735
+ #line 57 "node.c.erb"
736
+ case YP_MATCH_WRITE_NODE: {
737
+ yp_match_write_node_t *cast = (yp_match_write_node_t *) node;
738
+ yp_node_destroy(parser, (yp_node_t *)cast->call);
739
+ yp_constant_id_list_free(&cast->locals);
714
740
  break;
715
741
  }
716
- #line 81 "node.c.erb"
717
- case YP_NODE_MODULE_NODE: {
742
+ #line 57 "node.c.erb"
743
+ case YP_MISSING_NODE: {
744
+ break;
745
+ }
746
+ #line 57 "node.c.erb"
747
+ case YP_MODULE_NODE: {
718
748
  yp_module_node_t *cast = (yp_module_node_t *) node;
719
749
  yp_constant_id_list_free(&cast->locals);
720
750
  yp_node_destroy(parser, (yp_node_t *)cast->constant_path);
721
751
  if (cast->body != NULL) {
722
752
  yp_node_destroy(parser, (yp_node_t *)cast->body);
723
753
  }
724
- yp_string_free(&cast->name);
725
754
  break;
726
755
  }
727
- #line 81 "node.c.erb"
728
- case YP_NODE_MULTI_WRITE_NODE: {
756
+ #line 57 "node.c.erb"
757
+ case YP_MULTI_TARGET_NODE: {
758
+ yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
759
+ yp_node_list_free(parser, &cast->targets);
760
+ break;
761
+ }
762
+ #line 57 "node.c.erb"
763
+ case YP_MULTI_WRITE_NODE: {
729
764
  yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
730
765
  yp_node_list_free(parser, &cast->targets);
731
- if (cast->value != NULL) {
732
- yp_node_destroy(parser, (yp_node_t *)cast->value);
733
- }
766
+ yp_node_destroy(parser, (yp_node_t *)cast->value);
734
767
  break;
735
768
  }
736
- #line 81 "node.c.erb"
737
- case YP_NODE_NEXT_NODE: {
769
+ #line 57 "node.c.erb"
770
+ case YP_NEXT_NODE: {
738
771
  yp_next_node_t *cast = (yp_next_node_t *) node;
739
772
  if (cast->arguments != NULL) {
740
773
  yp_node_destroy(parser, (yp_node_t *)cast->arguments);
741
774
  }
742
775
  break;
743
776
  }
744
- #line 81 "node.c.erb"
745
- case YP_NODE_NIL_NODE: {
777
+ #line 57 "node.c.erb"
778
+ case YP_NIL_NODE: {
746
779
  break;
747
780
  }
748
- #line 81 "node.c.erb"
749
- case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
781
+ #line 57 "node.c.erb"
782
+ case YP_NO_KEYWORDS_PARAMETER_NODE: {
750
783
  break;
751
784
  }
752
- #line 81 "node.c.erb"
753
- case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
785
+ #line 57 "node.c.erb"
786
+ case YP_NUMBERED_REFERENCE_READ_NODE: {
754
787
  break;
755
788
  }
756
- #line 81 "node.c.erb"
757
- case YP_NODE_OPTIONAL_PARAMETER_NODE: {
789
+ #line 57 "node.c.erb"
790
+ case YP_OPTIONAL_PARAMETER_NODE: {
758
791
  yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
759
792
  yp_node_destroy(parser, (yp_node_t *)cast->value);
760
793
  break;
761
794
  }
762
- #line 81 "node.c.erb"
763
- case YP_NODE_OR_NODE: {
795
+ #line 57 "node.c.erb"
796
+ case YP_OR_NODE: {
764
797
  yp_or_node_t *cast = (yp_or_node_t *) node;
765
798
  yp_node_destroy(parser, (yp_node_t *)cast->left);
766
799
  yp_node_destroy(parser, (yp_node_t *)cast->right);
767
800
  break;
768
801
  }
769
- #line 81 "node.c.erb"
770
- case YP_NODE_PARAMETERS_NODE: {
802
+ #line 57 "node.c.erb"
803
+ case YP_PARAMETERS_NODE: {
771
804
  yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
772
805
  yp_node_list_free(parser, &cast->requireds);
773
806
  yp_node_list_free(parser, &cast->optionals);
774
- yp_node_list_free(parser, &cast->posts);
775
807
  if (cast->rest != NULL) {
776
808
  yp_node_destroy(parser, (yp_node_t *)cast->rest);
777
809
  }
810
+ yp_node_list_free(parser, &cast->posts);
778
811
  yp_node_list_free(parser, &cast->keywords);
779
812
  if (cast->keyword_rest != NULL) {
780
813
  yp_node_destroy(parser, (yp_node_t *)cast->keyword_rest);
@@ -784,51 +817,51 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
784
817
  }
785
818
  break;
786
819
  }
787
- #line 81 "node.c.erb"
788
- case YP_NODE_PARENTHESES_NODE: {
820
+ #line 57 "node.c.erb"
821
+ case YP_PARENTHESES_NODE: {
789
822
  yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
790
823
  if (cast->body != NULL) {
791
824
  yp_node_destroy(parser, (yp_node_t *)cast->body);
792
825
  }
793
826
  break;
794
827
  }
795
- #line 81 "node.c.erb"
796
- case YP_NODE_PINNED_EXPRESSION_NODE: {
828
+ #line 57 "node.c.erb"
829
+ case YP_PINNED_EXPRESSION_NODE: {
797
830
  yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
798
831
  yp_node_destroy(parser, (yp_node_t *)cast->expression);
799
832
  break;
800
833
  }
801
- #line 81 "node.c.erb"
802
- case YP_NODE_PINNED_VARIABLE_NODE: {
834
+ #line 57 "node.c.erb"
835
+ case YP_PINNED_VARIABLE_NODE: {
803
836
  yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
804
837
  yp_node_destroy(parser, (yp_node_t *)cast->variable);
805
838
  break;
806
839
  }
807
- #line 81 "node.c.erb"
808
- case YP_NODE_POST_EXECUTION_NODE: {
840
+ #line 57 "node.c.erb"
841
+ case YP_POST_EXECUTION_NODE: {
809
842
  yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
810
843
  if (cast->statements != NULL) {
811
844
  yp_node_destroy(parser, (yp_node_t *)cast->statements);
812
845
  }
813
846
  break;
814
847
  }
815
- #line 81 "node.c.erb"
816
- case YP_NODE_PRE_EXECUTION_NODE: {
848
+ #line 57 "node.c.erb"
849
+ case YP_PRE_EXECUTION_NODE: {
817
850
  yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
818
851
  if (cast->statements != NULL) {
819
852
  yp_node_destroy(parser, (yp_node_t *)cast->statements);
820
853
  }
821
854
  break;
822
855
  }
823
- #line 81 "node.c.erb"
824
- case YP_NODE_PROGRAM_NODE: {
856
+ #line 57 "node.c.erb"
857
+ case YP_PROGRAM_NODE: {
825
858
  yp_program_node_t *cast = (yp_program_node_t *) node;
826
859
  yp_constant_id_list_free(&cast->locals);
827
860
  yp_node_destroy(parser, (yp_node_t *)cast->statements);
828
861
  break;
829
862
  }
830
- #line 81 "node.c.erb"
831
- case YP_NODE_RANGE_NODE: {
863
+ #line 57 "node.c.erb"
864
+ case YP_RANGE_NODE: {
832
865
  yp_range_node_t *cast = (yp_range_node_t *) node;
833
866
  if (cast->left != NULL) {
834
867
  yp_node_destroy(parser, (yp_node_t *)cast->left);
@@ -838,41 +871,41 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
838
871
  }
839
872
  break;
840
873
  }
841
- #line 81 "node.c.erb"
842
- case YP_NODE_RATIONAL_NODE: {
874
+ #line 57 "node.c.erb"
875
+ case YP_RATIONAL_NODE: {
843
876
  yp_rational_node_t *cast = (yp_rational_node_t *) node;
844
877
  yp_node_destroy(parser, (yp_node_t *)cast->numeric);
845
878
  break;
846
879
  }
847
- #line 81 "node.c.erb"
848
- case YP_NODE_REDO_NODE: {
880
+ #line 57 "node.c.erb"
881
+ case YP_REDO_NODE: {
849
882
  break;
850
883
  }
851
- #line 81 "node.c.erb"
852
- case YP_NODE_REGULAR_EXPRESSION_NODE: {
884
+ #line 57 "node.c.erb"
885
+ case YP_REGULAR_EXPRESSION_NODE: {
853
886
  yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
854
887
  yp_string_free(&cast->unescaped);
855
888
  break;
856
889
  }
857
- #line 81 "node.c.erb"
858
- case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
890
+ #line 57 "node.c.erb"
891
+ case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
859
892
  yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
860
893
  yp_node_list_free(parser, &cast->parameters);
861
894
  break;
862
895
  }
863
- #line 81 "node.c.erb"
864
- case YP_NODE_REQUIRED_PARAMETER_NODE: {
896
+ #line 57 "node.c.erb"
897
+ case YP_REQUIRED_PARAMETER_NODE: {
865
898
  break;
866
899
  }
867
- #line 81 "node.c.erb"
868
- case YP_NODE_RESCUE_MODIFIER_NODE: {
900
+ #line 57 "node.c.erb"
901
+ case YP_RESCUE_MODIFIER_NODE: {
869
902
  yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
870
903
  yp_node_destroy(parser, (yp_node_t *)cast->expression);
871
904
  yp_node_destroy(parser, (yp_node_t *)cast->rescue_expression);
872
905
  break;
873
906
  }
874
- #line 81 "node.c.erb"
875
- case YP_NODE_RESCUE_NODE: {
907
+ #line 57 "node.c.erb"
908
+ case YP_RESCUE_NODE: {
876
909
  yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
877
910
  yp_node_list_free(parser, &cast->exceptions);
878
911
  if (cast->reference != NULL) {
@@ -886,28 +919,28 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
886
919
  }
887
920
  break;
888
921
  }
889
- #line 81 "node.c.erb"
890
- case YP_NODE_REST_PARAMETER_NODE: {
922
+ #line 57 "node.c.erb"
923
+ case YP_REST_PARAMETER_NODE: {
891
924
  break;
892
925
  }
893
- #line 81 "node.c.erb"
894
- case YP_NODE_RETRY_NODE: {
926
+ #line 57 "node.c.erb"
927
+ case YP_RETRY_NODE: {
895
928
  break;
896
929
  }
897
- #line 81 "node.c.erb"
898
- case YP_NODE_RETURN_NODE: {
930
+ #line 57 "node.c.erb"
931
+ case YP_RETURN_NODE: {
899
932
  yp_return_node_t *cast = (yp_return_node_t *) node;
900
933
  if (cast->arguments != NULL) {
901
934
  yp_node_destroy(parser, (yp_node_t *)cast->arguments);
902
935
  }
903
936
  break;
904
937
  }
905
- #line 81 "node.c.erb"
906
- case YP_NODE_SELF_NODE: {
938
+ #line 57 "node.c.erb"
939
+ case YP_SELF_NODE: {
907
940
  break;
908
941
  }
909
- #line 81 "node.c.erb"
910
- case YP_NODE_SINGLETON_CLASS_NODE: {
942
+ #line 57 "node.c.erb"
943
+ case YP_SINGLETON_CLASS_NODE: {
911
944
  yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
912
945
  yp_constant_id_list_free(&cast->locals);
913
946
  yp_node_destroy(parser, (yp_node_t *)cast->expression);
@@ -916,49 +949,49 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
916
949
  }
917
950
  break;
918
951
  }
919
- #line 81 "node.c.erb"
920
- case YP_NODE_SOURCE_ENCODING_NODE: {
952
+ #line 57 "node.c.erb"
953
+ case YP_SOURCE_ENCODING_NODE: {
921
954
  break;
922
955
  }
923
- #line 81 "node.c.erb"
924
- case YP_NODE_SOURCE_FILE_NODE: {
956
+ #line 57 "node.c.erb"
957
+ case YP_SOURCE_FILE_NODE: {
925
958
  yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
926
959
  yp_string_free(&cast->filepath);
927
960
  break;
928
961
  }
929
- #line 81 "node.c.erb"
930
- case YP_NODE_SOURCE_LINE_NODE: {
962
+ #line 57 "node.c.erb"
963
+ case YP_SOURCE_LINE_NODE: {
931
964
  break;
932
965
  }
933
- #line 81 "node.c.erb"
934
- case YP_NODE_SPLAT_NODE: {
966
+ #line 57 "node.c.erb"
967
+ case YP_SPLAT_NODE: {
935
968
  yp_splat_node_t *cast = (yp_splat_node_t *) node;
936
969
  if (cast->expression != NULL) {
937
970
  yp_node_destroy(parser, (yp_node_t *)cast->expression);
938
971
  }
939
972
  break;
940
973
  }
941
- #line 81 "node.c.erb"
942
- case YP_NODE_STATEMENTS_NODE: {
974
+ #line 57 "node.c.erb"
975
+ case YP_STATEMENTS_NODE: {
943
976
  yp_statements_node_t *cast = (yp_statements_node_t *) node;
944
977
  yp_node_list_free(parser, &cast->body);
945
978
  break;
946
979
  }
947
- #line 81 "node.c.erb"
948
- case YP_NODE_STRING_CONCAT_NODE: {
980
+ #line 57 "node.c.erb"
981
+ case YP_STRING_CONCAT_NODE: {
949
982
  yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
950
983
  yp_node_destroy(parser, (yp_node_t *)cast->left);
951
984
  yp_node_destroy(parser, (yp_node_t *)cast->right);
952
985
  break;
953
986
  }
954
- #line 81 "node.c.erb"
955
- case YP_NODE_STRING_NODE: {
987
+ #line 57 "node.c.erb"
988
+ case YP_STRING_NODE: {
956
989
  yp_string_node_t *cast = (yp_string_node_t *) node;
957
990
  yp_string_free(&cast->unescaped);
958
991
  break;
959
992
  }
960
- #line 81 "node.c.erb"
961
- case YP_NODE_SUPER_NODE: {
993
+ #line 57 "node.c.erb"
994
+ case YP_SUPER_NODE: {
962
995
  yp_super_node_t *cast = (yp_super_node_t *) node;
963
996
  if (cast->arguments != NULL) {
964
997
  yp_node_destroy(parser, (yp_node_t *)cast->arguments);
@@ -968,24 +1001,24 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
968
1001
  }
969
1002
  break;
970
1003
  }
971
- #line 81 "node.c.erb"
972
- case YP_NODE_SYMBOL_NODE: {
1004
+ #line 57 "node.c.erb"
1005
+ case YP_SYMBOL_NODE: {
973
1006
  yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
974
1007
  yp_string_free(&cast->unescaped);
975
1008
  break;
976
1009
  }
977
- #line 81 "node.c.erb"
978
- case YP_NODE_TRUE_NODE: {
1010
+ #line 57 "node.c.erb"
1011
+ case YP_TRUE_NODE: {
979
1012
  break;
980
1013
  }
981
- #line 81 "node.c.erb"
982
- case YP_NODE_UNDEF_NODE: {
1014
+ #line 57 "node.c.erb"
1015
+ case YP_UNDEF_NODE: {
983
1016
  yp_undef_node_t *cast = (yp_undef_node_t *) node;
984
1017
  yp_node_list_free(parser, &cast->names);
985
1018
  break;
986
1019
  }
987
- #line 81 "node.c.erb"
988
- case YP_NODE_UNLESS_NODE: {
1020
+ #line 57 "node.c.erb"
1021
+ case YP_UNLESS_NODE: {
989
1022
  yp_unless_node_t *cast = (yp_unless_node_t *) node;
990
1023
  yp_node_destroy(parser, (yp_node_t *)cast->predicate);
991
1024
  if (cast->statements != NULL) {
@@ -996,8 +1029,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
996
1029
  }
997
1030
  break;
998
1031
  }
999
- #line 81 "node.c.erb"
1000
- case YP_NODE_UNTIL_NODE: {
1032
+ #line 57 "node.c.erb"
1033
+ case YP_UNTIL_NODE: {
1001
1034
  yp_until_node_t *cast = (yp_until_node_t *) node;
1002
1035
  yp_node_destroy(parser, (yp_node_t *)cast->predicate);
1003
1036
  if (cast->statements != NULL) {
@@ -1005,8 +1038,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
1005
1038
  }
1006
1039
  break;
1007
1040
  }
1008
- #line 81 "node.c.erb"
1009
- case YP_NODE_WHEN_NODE: {
1041
+ #line 57 "node.c.erb"
1042
+ case YP_WHEN_NODE: {
1010
1043
  yp_when_node_t *cast = (yp_when_node_t *) node;
1011
1044
  yp_node_list_free(parser, &cast->conditions);
1012
1045
  if (cast->statements != NULL) {
@@ -1014,8 +1047,8 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
1014
1047
  }
1015
1048
  break;
1016
1049
  }
1017
- #line 81 "node.c.erb"
1018
- case YP_NODE_WHILE_NODE: {
1050
+ #line 57 "node.c.erb"
1051
+ case YP_WHILE_NODE: {
1019
1052
  yp_while_node_t *cast = (yp_while_node_t *) node;
1020
1053
  yp_node_destroy(parser, (yp_node_t *)cast->predicate);
1021
1054
  if (cast->statements != NULL) {
@@ -1023,21 +1056,21 @@ yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
1023
1056
  }
1024
1057
  break;
1025
1058
  }
1026
- #line 81 "node.c.erb"
1027
- case YP_NODE_X_STRING_NODE: {
1059
+ #line 57 "node.c.erb"
1060
+ case YP_X_STRING_NODE: {
1028
1061
  yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
1029
1062
  yp_string_free(&cast->unescaped);
1030
1063
  break;
1031
1064
  }
1032
- #line 81 "node.c.erb"
1033
- case YP_NODE_YIELD_NODE: {
1065
+ #line 57 "node.c.erb"
1066
+ case YP_YIELD_NODE: {
1034
1067
  yp_yield_node_t *cast = (yp_yield_node_t *) node;
1035
1068
  if (cast->arguments != NULL) {
1036
1069
  yp_node_destroy(parser, (yp_node_t *)cast->arguments);
1037
1070
  }
1038
1071
  break;
1039
1072
  }
1040
- #line 110 "node.c.erb"
1073
+ #line 84 "node.c.erb"
1041
1074
  default:
1042
1075
  assert(false && "unreachable");
1043
1076
  break;
@@ -1052,48 +1085,56 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1052
1085
  switch (YP_NODE_TYPE(node)) {
1053
1086
  // We do not calculate memsize of a ScopeNode
1054
1087
  // as it should never be generated
1055
- case YP_NODE_SCOPE_NODE:
1088
+ case YP_SCOPE_NODE:
1056
1089
  return;
1057
- #line 128 "node.c.erb"
1058
- case YP_NODE_ALIAS_NODE: {
1059
- yp_alias_node_t *cast = (yp_alias_node_t *) node;
1090
+ #line 102 "node.c.erb"
1091
+ case YP_ALIAS_GLOBAL_VARIABLE_NODE: {
1092
+ yp_alias_global_variable_node_t *cast = (yp_alias_global_variable_node_t *) node;
1060
1093
  memsize->memsize += sizeof(*cast);
1061
1094
  yp_node_memsize_node((yp_node_t *)cast->new_name, memsize);
1062
1095
  yp_node_memsize_node((yp_node_t *)cast->old_name, memsize);
1063
1096
  break;
1064
1097
  }
1065
- #line 128 "node.c.erb"
1066
- case YP_NODE_ALTERNATION_PATTERN_NODE: {
1098
+ #line 102 "node.c.erb"
1099
+ case YP_ALIAS_METHOD_NODE: {
1100
+ yp_alias_method_node_t *cast = (yp_alias_method_node_t *) node;
1101
+ memsize->memsize += sizeof(*cast);
1102
+ yp_node_memsize_node((yp_node_t *)cast->new_name, memsize);
1103
+ yp_node_memsize_node((yp_node_t *)cast->old_name, memsize);
1104
+ break;
1105
+ }
1106
+ #line 102 "node.c.erb"
1107
+ case YP_ALTERNATION_PATTERN_NODE: {
1067
1108
  yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
1068
1109
  memsize->memsize += sizeof(*cast);
1069
1110
  yp_node_memsize_node((yp_node_t *)cast->left, memsize);
1070
1111
  yp_node_memsize_node((yp_node_t *)cast->right, memsize);
1071
1112
  break;
1072
1113
  }
1073
- #line 128 "node.c.erb"
1074
- case YP_NODE_AND_NODE: {
1114
+ #line 102 "node.c.erb"
1115
+ case YP_AND_NODE: {
1075
1116
  yp_and_node_t *cast = (yp_and_node_t *) node;
1076
1117
  memsize->memsize += sizeof(*cast);
1077
1118
  yp_node_memsize_node((yp_node_t *)cast->left, memsize);
1078
1119
  yp_node_memsize_node((yp_node_t *)cast->right, memsize);
1079
1120
  break;
1080
1121
  }
1081
- #line 128 "node.c.erb"
1082
- case YP_NODE_ARGUMENTS_NODE: {
1122
+ #line 102 "node.c.erb"
1123
+ case YP_ARGUMENTS_NODE: {
1083
1124
  yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
1084
1125
  memsize->memsize += sizeof(*cast);
1085
1126
  yp_node_list_memsize(&cast->arguments, memsize);
1086
1127
  break;
1087
1128
  }
1088
- #line 128 "node.c.erb"
1089
- case YP_NODE_ARRAY_NODE: {
1129
+ #line 102 "node.c.erb"
1130
+ case YP_ARRAY_NODE: {
1090
1131
  yp_array_node_t *cast = (yp_array_node_t *) node;
1091
1132
  memsize->memsize += sizeof(*cast);
1092
1133
  yp_node_list_memsize(&cast->elements, memsize);
1093
1134
  break;
1094
1135
  }
1095
- #line 128 "node.c.erb"
1096
- case YP_NODE_ARRAY_PATTERN_NODE: {
1136
+ #line 102 "node.c.erb"
1137
+ case YP_ARRAY_PATTERN_NODE: {
1097
1138
  yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
1098
1139
  memsize->memsize += sizeof(*cast);
1099
1140
  if (cast->constant != NULL) {
@@ -1106,8 +1147,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1106
1147
  yp_node_list_memsize(&cast->posts, memsize);
1107
1148
  break;
1108
1149
  }
1109
- #line 128 "node.c.erb"
1110
- case YP_NODE_ASSOC_NODE: {
1150
+ #line 102 "node.c.erb"
1151
+ case YP_ASSOC_NODE: {
1111
1152
  yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
1112
1153
  memsize->memsize += sizeof(*cast);
1113
1154
  yp_node_memsize_node((yp_node_t *)cast->key, memsize);
@@ -1116,8 +1157,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1116
1157
  }
1117
1158
  break;
1118
1159
  }
1119
- #line 128 "node.c.erb"
1120
- case YP_NODE_ASSOC_SPLAT_NODE: {
1160
+ #line 102 "node.c.erb"
1161
+ case YP_ASSOC_SPLAT_NODE: {
1121
1162
  yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
1122
1163
  memsize->memsize += sizeof(*cast);
1123
1164
  if (cast->value != NULL) {
@@ -1125,14 +1166,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1125
1166
  }
1126
1167
  break;
1127
1168
  }
1128
- #line 128 "node.c.erb"
1129
- case YP_NODE_BACK_REFERENCE_READ_NODE: {
1169
+ #line 102 "node.c.erb"
1170
+ case YP_BACK_REFERENCE_READ_NODE: {
1130
1171
  yp_back_reference_read_node_t *cast = (yp_back_reference_read_node_t *) node;
1131
1172
  memsize->memsize += sizeof(*cast);
1132
1173
  break;
1133
1174
  }
1134
- #line 128 "node.c.erb"
1135
- case YP_NODE_BEGIN_NODE: {
1175
+ #line 102 "node.c.erb"
1176
+ case YP_BEGIN_NODE: {
1136
1177
  yp_begin_node_t *cast = (yp_begin_node_t *) node;
1137
1178
  memsize->memsize += sizeof(*cast);
1138
1179
  if (cast->statements != NULL) {
@@ -1149,8 +1190,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1149
1190
  }
1150
1191
  break;
1151
1192
  }
1152
- #line 128 "node.c.erb"
1153
- case YP_NODE_BLOCK_ARGUMENT_NODE: {
1193
+ #line 102 "node.c.erb"
1194
+ case YP_BLOCK_ARGUMENT_NODE: {
1154
1195
  yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
1155
1196
  memsize->memsize += sizeof(*cast);
1156
1197
  if (cast->expression != NULL) {
@@ -1158,8 +1199,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1158
1199
  }
1159
1200
  break;
1160
1201
  }
1161
- #line 128 "node.c.erb"
1162
- case YP_NODE_BLOCK_NODE: {
1202
+ #line 102 "node.c.erb"
1203
+ case YP_BLOCK_LOCAL_VARIABLE_NODE: {
1204
+ yp_block_local_variable_node_t *cast = (yp_block_local_variable_node_t *) node;
1205
+ memsize->memsize += sizeof(*cast);
1206
+ break;
1207
+ }
1208
+ #line 102 "node.c.erb"
1209
+ case YP_BLOCK_NODE: {
1163
1210
  yp_block_node_t *cast = (yp_block_node_t *) node;
1164
1211
  memsize->memsize += sizeof(*cast);
1165
1212
  memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
@@ -1171,24 +1218,24 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1171
1218
  }
1172
1219
  break;
1173
1220
  }
1174
- #line 128 "node.c.erb"
1175
- case YP_NODE_BLOCK_PARAMETER_NODE: {
1221
+ #line 102 "node.c.erb"
1222
+ case YP_BLOCK_PARAMETER_NODE: {
1176
1223
  yp_block_parameter_node_t *cast = (yp_block_parameter_node_t *) node;
1177
1224
  memsize->memsize += sizeof(*cast);
1178
1225
  break;
1179
1226
  }
1180
- #line 128 "node.c.erb"
1181
- case YP_NODE_BLOCK_PARAMETERS_NODE: {
1227
+ #line 102 "node.c.erb"
1228
+ case YP_BLOCK_PARAMETERS_NODE: {
1182
1229
  yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
1183
1230
  memsize->memsize += sizeof(*cast);
1184
1231
  if (cast->parameters != NULL) {
1185
1232
  yp_node_memsize_node((yp_node_t *)cast->parameters, memsize);
1186
1233
  }
1187
- memsize->memsize += yp_location_list_memsize(&cast->locals);
1234
+ yp_node_list_memsize(&cast->locals, memsize);
1188
1235
  break;
1189
1236
  }
1190
- #line 128 "node.c.erb"
1191
- case YP_NODE_BREAK_NODE: {
1237
+ #line 102 "node.c.erb"
1238
+ case YP_BREAK_NODE: {
1192
1239
  yp_break_node_t *cast = (yp_break_node_t *) node;
1193
1240
  memsize->memsize += sizeof(*cast);
1194
1241
  if (cast->arguments != NULL) {
@@ -1196,8 +1243,23 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1196
1243
  }
1197
1244
  break;
1198
1245
  }
1199
- #line 128 "node.c.erb"
1200
- case YP_NODE_CALL_NODE: {
1246
+ #line 102 "node.c.erb"
1247
+ case YP_CALL_AND_WRITE_NODE: {
1248
+ yp_call_and_write_node_t *cast = (yp_call_and_write_node_t *) node;
1249
+ memsize->memsize += sizeof(*cast);
1250
+ if (cast->receiver != NULL) {
1251
+ yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
1252
+ }
1253
+ if (cast->arguments != NULL) {
1254
+ yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
1255
+ }
1256
+ memsize->memsize += yp_string_memsize(&cast->read_name);
1257
+ memsize->memsize += yp_string_memsize(&cast->write_name);
1258
+ yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1259
+ break;
1260
+ }
1261
+ #line 102 "node.c.erb"
1262
+ case YP_CALL_NODE: {
1201
1263
  yp_call_node_t *cast = (yp_call_node_t *) node;
1202
1264
  memsize->memsize += sizeof(*cast);
1203
1265
  if (cast->receiver != NULL) {
@@ -1212,40 +1274,46 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1212
1274
  memsize->memsize += yp_string_memsize(&cast->name);
1213
1275
  break;
1214
1276
  }
1215
- #line 128 "node.c.erb"
1216
- case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
1217
- yp_call_operator_and_write_node_t *cast = (yp_call_operator_and_write_node_t *) node;
1277
+ #line 102 "node.c.erb"
1278
+ case YP_CALL_OPERATOR_WRITE_NODE: {
1279
+ yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
1218
1280
  memsize->memsize += sizeof(*cast);
1219
- yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1281
+ if (cast->receiver != NULL) {
1282
+ yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
1283
+ }
1284
+ if (cast->arguments != NULL) {
1285
+ yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
1286
+ }
1287
+ memsize->memsize += yp_string_memsize(&cast->read_name);
1288
+ memsize->memsize += yp_string_memsize(&cast->write_name);
1220
1289
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1221
1290
  break;
1222
1291
  }
1223
- #line 128 "node.c.erb"
1224
- case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
1225
- yp_call_operator_or_write_node_t *cast = (yp_call_operator_or_write_node_t *) node;
1292
+ #line 102 "node.c.erb"
1293
+ case YP_CALL_OR_WRITE_NODE: {
1294
+ yp_call_or_write_node_t *cast = (yp_call_or_write_node_t *) node;
1226
1295
  memsize->memsize += sizeof(*cast);
1227
- yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1228
- yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1229
- break;
1230
- }
1231
- #line 128 "node.c.erb"
1232
- case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
1233
- yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
1234
- memsize->memsize += sizeof(*cast);
1235
- yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1296
+ if (cast->receiver != NULL) {
1297
+ yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
1298
+ }
1299
+ if (cast->arguments != NULL) {
1300
+ yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
1301
+ }
1302
+ memsize->memsize += yp_string_memsize(&cast->read_name);
1303
+ memsize->memsize += yp_string_memsize(&cast->write_name);
1236
1304
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1237
1305
  break;
1238
1306
  }
1239
- #line 128 "node.c.erb"
1240
- case YP_NODE_CAPTURE_PATTERN_NODE: {
1307
+ #line 102 "node.c.erb"
1308
+ case YP_CAPTURE_PATTERN_NODE: {
1241
1309
  yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
1242
1310
  memsize->memsize += sizeof(*cast);
1243
1311
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1244
1312
  yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1245
1313
  break;
1246
1314
  }
1247
- #line 128 "node.c.erb"
1248
- case YP_NODE_CASE_NODE: {
1315
+ #line 102 "node.c.erb"
1316
+ case YP_CASE_NODE: {
1249
1317
  yp_case_node_t *cast = (yp_case_node_t *) node;
1250
1318
  memsize->memsize += sizeof(*cast);
1251
1319
  if (cast->predicate != NULL) {
@@ -1257,8 +1325,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1257
1325
  }
1258
1326
  break;
1259
1327
  }
1260
- #line 128 "node.c.erb"
1261
- case YP_NODE_CLASS_NODE: {
1328
+ #line 102 "node.c.erb"
1329
+ case YP_CLASS_NODE: {
1262
1330
  yp_class_node_t *cast = (yp_class_node_t *) node;
1263
1331
  memsize->memsize += sizeof(*cast);
1264
1332
  memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
@@ -1269,82 +1337,79 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1269
1337
  if (cast->body != NULL) {
1270
1338
  yp_node_memsize_node((yp_node_t *)cast->body, memsize);
1271
1339
  }
1272
- memsize->memsize += yp_string_memsize(&cast->name);
1273
1340
  break;
1274
1341
  }
1275
- #line 128 "node.c.erb"
1276
- case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
1342
+ #line 102 "node.c.erb"
1343
+ case YP_CLASS_VARIABLE_AND_WRITE_NODE: {
1277
1344
  yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
1278
1345
  memsize->memsize += sizeof(*cast);
1279
1346
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1280
1347
  break;
1281
1348
  }
1282
- #line 128 "node.c.erb"
1283
- case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1349
+ #line 102 "node.c.erb"
1350
+ case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
1284
1351
  yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
1285
1352
  memsize->memsize += sizeof(*cast);
1286
1353
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1287
1354
  break;
1288
1355
  }
1289
- #line 128 "node.c.erb"
1290
- case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
1356
+ #line 102 "node.c.erb"
1357
+ case YP_CLASS_VARIABLE_OR_WRITE_NODE: {
1291
1358
  yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
1292
1359
  memsize->memsize += sizeof(*cast);
1293
1360
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1294
1361
  break;
1295
1362
  }
1296
- #line 128 "node.c.erb"
1297
- case YP_NODE_CLASS_VARIABLE_READ_NODE: {
1363
+ #line 102 "node.c.erb"
1364
+ case YP_CLASS_VARIABLE_READ_NODE: {
1298
1365
  yp_class_variable_read_node_t *cast = (yp_class_variable_read_node_t *) node;
1299
1366
  memsize->memsize += sizeof(*cast);
1300
1367
  break;
1301
1368
  }
1302
- #line 128 "node.c.erb"
1303
- case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
1369
+ #line 102 "node.c.erb"
1370
+ case YP_CLASS_VARIABLE_TARGET_NODE: {
1304
1371
  yp_class_variable_target_node_t *cast = (yp_class_variable_target_node_t *) node;
1305
1372
  memsize->memsize += sizeof(*cast);
1306
1373
  break;
1307
1374
  }
1308
- #line 128 "node.c.erb"
1309
- case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
1375
+ #line 102 "node.c.erb"
1376
+ case YP_CLASS_VARIABLE_WRITE_NODE: {
1310
1377
  yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
1311
1378
  memsize->memsize += sizeof(*cast);
1312
- if (cast->value != NULL) {
1313
- yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1314
- }
1379
+ yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1315
1380
  break;
1316
1381
  }
1317
- #line 128 "node.c.erb"
1318
- case YP_NODE_CONSTANT_AND_WRITE_NODE: {
1382
+ #line 102 "node.c.erb"
1383
+ case YP_CONSTANT_AND_WRITE_NODE: {
1319
1384
  yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
1320
1385
  memsize->memsize += sizeof(*cast);
1321
1386
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1322
1387
  break;
1323
1388
  }
1324
- #line 128 "node.c.erb"
1325
- case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
1389
+ #line 102 "node.c.erb"
1390
+ case YP_CONSTANT_OPERATOR_WRITE_NODE: {
1326
1391
  yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
1327
1392
  memsize->memsize += sizeof(*cast);
1328
1393
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1329
1394
  break;
1330
1395
  }
1331
- #line 128 "node.c.erb"
1332
- case YP_NODE_CONSTANT_OR_WRITE_NODE: {
1396
+ #line 102 "node.c.erb"
1397
+ case YP_CONSTANT_OR_WRITE_NODE: {
1333
1398
  yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
1334
1399
  memsize->memsize += sizeof(*cast);
1335
1400
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1336
1401
  break;
1337
1402
  }
1338
- #line 128 "node.c.erb"
1339
- case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
1403
+ #line 102 "node.c.erb"
1404
+ case YP_CONSTANT_PATH_AND_WRITE_NODE: {
1340
1405
  yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
1341
1406
  memsize->memsize += sizeof(*cast);
1342
1407
  yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1343
1408
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1344
1409
  break;
1345
1410
  }
1346
- #line 128 "node.c.erb"
1347
- case YP_NODE_CONSTANT_PATH_NODE: {
1411
+ #line 102 "node.c.erb"
1412
+ case YP_CONSTANT_PATH_NODE: {
1348
1413
  yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
1349
1414
  memsize->memsize += sizeof(*cast);
1350
1415
  if (cast->parent != NULL) {
@@ -1353,24 +1418,24 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1353
1418
  yp_node_memsize_node((yp_node_t *)cast->child, memsize);
1354
1419
  break;
1355
1420
  }
1356
- #line 128 "node.c.erb"
1357
- case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1421
+ #line 102 "node.c.erb"
1422
+ case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
1358
1423
  yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
1359
1424
  memsize->memsize += sizeof(*cast);
1360
1425
  yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1361
1426
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1362
1427
  break;
1363
1428
  }
1364
- #line 128 "node.c.erb"
1365
- case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
1429
+ #line 102 "node.c.erb"
1430
+ case YP_CONSTANT_PATH_OR_WRITE_NODE: {
1366
1431
  yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
1367
1432
  memsize->memsize += sizeof(*cast);
1368
1433
  yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1369
1434
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1370
1435
  break;
1371
1436
  }
1372
- #line 128 "node.c.erb"
1373
- case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
1437
+ #line 102 "node.c.erb"
1438
+ case YP_CONSTANT_PATH_TARGET_NODE: {
1374
1439
  yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
1375
1440
  memsize->memsize += sizeof(*cast);
1376
1441
  if (cast->parent != NULL) {
@@ -1379,35 +1444,35 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1379
1444
  yp_node_memsize_node((yp_node_t *)cast->child, memsize);
1380
1445
  break;
1381
1446
  }
1382
- #line 128 "node.c.erb"
1383
- case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
1447
+ #line 102 "node.c.erb"
1448
+ case YP_CONSTANT_PATH_WRITE_NODE: {
1384
1449
  yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
1385
1450
  memsize->memsize += sizeof(*cast);
1386
1451
  yp_node_memsize_node((yp_node_t *)cast->target, memsize);
1387
1452
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1388
1453
  break;
1389
1454
  }
1390
- #line 128 "node.c.erb"
1391
- case YP_NODE_CONSTANT_READ_NODE: {
1455
+ #line 102 "node.c.erb"
1456
+ case YP_CONSTANT_READ_NODE: {
1392
1457
  yp_constant_read_node_t *cast = (yp_constant_read_node_t *) node;
1393
1458
  memsize->memsize += sizeof(*cast);
1394
1459
  break;
1395
1460
  }
1396
- #line 128 "node.c.erb"
1397
- case YP_NODE_CONSTANT_TARGET_NODE: {
1461
+ #line 102 "node.c.erb"
1462
+ case YP_CONSTANT_TARGET_NODE: {
1398
1463
  yp_constant_target_node_t *cast = (yp_constant_target_node_t *) node;
1399
1464
  memsize->memsize += sizeof(*cast);
1400
1465
  break;
1401
1466
  }
1402
- #line 128 "node.c.erb"
1403
- case YP_NODE_CONSTANT_WRITE_NODE: {
1467
+ #line 102 "node.c.erb"
1468
+ case YP_CONSTANT_WRITE_NODE: {
1404
1469
  yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
1405
1470
  memsize->memsize += sizeof(*cast);
1406
1471
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1407
1472
  break;
1408
1473
  }
1409
- #line 128 "node.c.erb"
1410
- case YP_NODE_DEF_NODE: {
1474
+ #line 102 "node.c.erb"
1475
+ case YP_DEF_NODE: {
1411
1476
  yp_def_node_t *cast = (yp_def_node_t *) node;
1412
1477
  memsize->memsize += sizeof(*cast);
1413
1478
  if (cast->receiver != NULL) {
@@ -1422,15 +1487,15 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1422
1487
  memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
1423
1488
  break;
1424
1489
  }
1425
- #line 128 "node.c.erb"
1426
- case YP_NODE_DEFINED_NODE: {
1490
+ #line 102 "node.c.erb"
1491
+ case YP_DEFINED_NODE: {
1427
1492
  yp_defined_node_t *cast = (yp_defined_node_t *) node;
1428
1493
  memsize->memsize += sizeof(*cast);
1429
1494
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1430
1495
  break;
1431
1496
  }
1432
- #line 128 "node.c.erb"
1433
- case YP_NODE_ELSE_NODE: {
1497
+ #line 102 "node.c.erb"
1498
+ case YP_ELSE_NODE: {
1434
1499
  yp_else_node_t *cast = (yp_else_node_t *) node;
1435
1500
  memsize->memsize += sizeof(*cast);
1436
1501
  if (cast->statements != NULL) {
@@ -1438,8 +1503,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1438
1503
  }
1439
1504
  break;
1440
1505
  }
1441
- #line 128 "node.c.erb"
1442
- case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
1506
+ #line 102 "node.c.erb"
1507
+ case YP_EMBEDDED_STATEMENTS_NODE: {
1443
1508
  yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
1444
1509
  memsize->memsize += sizeof(*cast);
1445
1510
  if (cast->statements != NULL) {
@@ -1447,15 +1512,15 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1447
1512
  }
1448
1513
  break;
1449
1514
  }
1450
- #line 128 "node.c.erb"
1451
- case YP_NODE_EMBEDDED_VARIABLE_NODE: {
1515
+ #line 102 "node.c.erb"
1516
+ case YP_EMBEDDED_VARIABLE_NODE: {
1452
1517
  yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
1453
1518
  memsize->memsize += sizeof(*cast);
1454
1519
  yp_node_memsize_node((yp_node_t *)cast->variable, memsize);
1455
1520
  break;
1456
1521
  }
1457
- #line 128 "node.c.erb"
1458
- case YP_NODE_ENSURE_NODE: {
1522
+ #line 102 "node.c.erb"
1523
+ case YP_ENSURE_NODE: {
1459
1524
  yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
1460
1525
  memsize->memsize += sizeof(*cast);
1461
1526
  if (cast->statements != NULL) {
@@ -1463,14 +1528,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1463
1528
  }
1464
1529
  break;
1465
1530
  }
1466
- #line 128 "node.c.erb"
1467
- case YP_NODE_FALSE_NODE: {
1531
+ #line 102 "node.c.erb"
1532
+ case YP_FALSE_NODE: {
1468
1533
  yp_false_node_t *cast = (yp_false_node_t *) node;
1469
1534
  memsize->memsize += sizeof(*cast);
1470
1535
  break;
1471
1536
  }
1472
- #line 128 "node.c.erb"
1473
- case YP_NODE_FIND_PATTERN_NODE: {
1537
+ #line 102 "node.c.erb"
1538
+ case YP_FIND_PATTERN_NODE: {
1474
1539
  yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
1475
1540
  memsize->memsize += sizeof(*cast);
1476
1541
  if (cast->constant != NULL) {
@@ -1481,8 +1546,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1481
1546
  yp_node_memsize_node((yp_node_t *)cast->right, memsize);
1482
1547
  break;
1483
1548
  }
1484
- #line 128 "node.c.erb"
1485
- case YP_NODE_FLIP_FLOP_NODE: {
1549
+ #line 102 "node.c.erb"
1550
+ case YP_FLIP_FLOP_NODE: {
1486
1551
  yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
1487
1552
  memsize->memsize += sizeof(*cast);
1488
1553
  if (cast->left != NULL) {
@@ -1493,14 +1558,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1493
1558
  }
1494
1559
  break;
1495
1560
  }
1496
- #line 128 "node.c.erb"
1497
- case YP_NODE_FLOAT_NODE: {
1561
+ #line 102 "node.c.erb"
1562
+ case YP_FLOAT_NODE: {
1498
1563
  yp_float_node_t *cast = (yp_float_node_t *) node;
1499
1564
  memsize->memsize += sizeof(*cast);
1500
1565
  break;
1501
1566
  }
1502
- #line 128 "node.c.erb"
1503
- case YP_NODE_FOR_NODE: {
1567
+ #line 102 "node.c.erb"
1568
+ case YP_FOR_NODE: {
1504
1569
  yp_for_node_t *cast = (yp_for_node_t *) node;
1505
1570
  memsize->memsize += sizeof(*cast);
1506
1571
  yp_node_memsize_node((yp_node_t *)cast->index, memsize);
@@ -1510,20 +1575,20 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1510
1575
  }
1511
1576
  break;
1512
1577
  }
1513
- #line 128 "node.c.erb"
1514
- case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
1578
+ #line 102 "node.c.erb"
1579
+ case YP_FORWARDING_ARGUMENTS_NODE: {
1515
1580
  yp_forwarding_arguments_node_t *cast = (yp_forwarding_arguments_node_t *) node;
1516
1581
  memsize->memsize += sizeof(*cast);
1517
1582
  break;
1518
1583
  }
1519
- #line 128 "node.c.erb"
1520
- case YP_NODE_FORWARDING_PARAMETER_NODE: {
1584
+ #line 102 "node.c.erb"
1585
+ case YP_FORWARDING_PARAMETER_NODE: {
1521
1586
  yp_forwarding_parameter_node_t *cast = (yp_forwarding_parameter_node_t *) node;
1522
1587
  memsize->memsize += sizeof(*cast);
1523
1588
  break;
1524
1589
  }
1525
- #line 128 "node.c.erb"
1526
- case YP_NODE_FORWARDING_SUPER_NODE: {
1590
+ #line 102 "node.c.erb"
1591
+ case YP_FORWARDING_SUPER_NODE: {
1527
1592
  yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
1528
1593
  memsize->memsize += sizeof(*cast);
1529
1594
  if (cast->block != NULL) {
@@ -1531,55 +1596,55 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1531
1596
  }
1532
1597
  break;
1533
1598
  }
1534
- #line 128 "node.c.erb"
1535
- case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
1599
+ #line 102 "node.c.erb"
1600
+ case YP_GLOBAL_VARIABLE_AND_WRITE_NODE: {
1536
1601
  yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
1537
1602
  memsize->memsize += sizeof(*cast);
1538
1603
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1539
1604
  break;
1540
1605
  }
1541
- #line 128 "node.c.erb"
1542
- case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
1606
+ #line 102 "node.c.erb"
1607
+ case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
1543
1608
  yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
1544
1609
  memsize->memsize += sizeof(*cast);
1545
1610
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1546
1611
  break;
1547
1612
  }
1548
- #line 128 "node.c.erb"
1549
- case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
1613
+ #line 102 "node.c.erb"
1614
+ case YP_GLOBAL_VARIABLE_OR_WRITE_NODE: {
1550
1615
  yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
1551
1616
  memsize->memsize += sizeof(*cast);
1552
1617
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1553
1618
  break;
1554
1619
  }
1555
- #line 128 "node.c.erb"
1556
- case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
1620
+ #line 102 "node.c.erb"
1621
+ case YP_GLOBAL_VARIABLE_READ_NODE: {
1557
1622
  yp_global_variable_read_node_t *cast = (yp_global_variable_read_node_t *) node;
1558
1623
  memsize->memsize += sizeof(*cast);
1559
1624
  break;
1560
1625
  }
1561
- #line 128 "node.c.erb"
1562
- case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
1626
+ #line 102 "node.c.erb"
1627
+ case YP_GLOBAL_VARIABLE_TARGET_NODE: {
1563
1628
  yp_global_variable_target_node_t *cast = (yp_global_variable_target_node_t *) node;
1564
1629
  memsize->memsize += sizeof(*cast);
1565
1630
  break;
1566
1631
  }
1567
- #line 128 "node.c.erb"
1568
- case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
1632
+ #line 102 "node.c.erb"
1633
+ case YP_GLOBAL_VARIABLE_WRITE_NODE: {
1569
1634
  yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
1570
1635
  memsize->memsize += sizeof(*cast);
1571
1636
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1572
1637
  break;
1573
1638
  }
1574
- #line 128 "node.c.erb"
1575
- case YP_NODE_HASH_NODE: {
1639
+ #line 102 "node.c.erb"
1640
+ case YP_HASH_NODE: {
1576
1641
  yp_hash_node_t *cast = (yp_hash_node_t *) node;
1577
1642
  memsize->memsize += sizeof(*cast);
1578
1643
  yp_node_list_memsize(&cast->elements, memsize);
1579
1644
  break;
1580
1645
  }
1581
- #line 128 "node.c.erb"
1582
- case YP_NODE_HASH_PATTERN_NODE: {
1646
+ #line 102 "node.c.erb"
1647
+ case YP_HASH_PATTERN_NODE: {
1583
1648
  yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
1584
1649
  memsize->memsize += sizeof(*cast);
1585
1650
  if (cast->constant != NULL) {
@@ -1591,8 +1656,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1591
1656
  }
1592
1657
  break;
1593
1658
  }
1594
- #line 128 "node.c.erb"
1595
- case YP_NODE_IF_NODE: {
1659
+ #line 102 "node.c.erb"
1660
+ case YP_IF_NODE: {
1596
1661
  yp_if_node_t *cast = (yp_if_node_t *) node;
1597
1662
  memsize->memsize += sizeof(*cast);
1598
1663
  yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
@@ -1604,15 +1669,22 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1604
1669
  }
1605
1670
  break;
1606
1671
  }
1607
- #line 128 "node.c.erb"
1608
- case YP_NODE_IMAGINARY_NODE: {
1672
+ #line 102 "node.c.erb"
1673
+ case YP_IMAGINARY_NODE: {
1609
1674
  yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
1610
1675
  memsize->memsize += sizeof(*cast);
1611
1676
  yp_node_memsize_node((yp_node_t *)cast->numeric, memsize);
1612
1677
  break;
1613
1678
  }
1614
- #line 128 "node.c.erb"
1615
- case YP_NODE_IN_NODE: {
1679
+ #line 102 "node.c.erb"
1680
+ case YP_IMPLICIT_NODE: {
1681
+ yp_implicit_node_t *cast = (yp_implicit_node_t *) node;
1682
+ memsize->memsize += sizeof(*cast);
1683
+ yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1684
+ break;
1685
+ }
1686
+ #line 102 "node.c.erb"
1687
+ case YP_IN_NODE: {
1616
1688
  yp_in_node_t *cast = (yp_in_node_t *) node;
1617
1689
  memsize->memsize += sizeof(*cast);
1618
1690
  yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
@@ -1621,89 +1693,96 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1621
1693
  }
1622
1694
  break;
1623
1695
  }
1624
- #line 128 "node.c.erb"
1625
- case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1696
+ #line 102 "node.c.erb"
1697
+ case YP_INSTANCE_VARIABLE_AND_WRITE_NODE: {
1626
1698
  yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
1627
1699
  memsize->memsize += sizeof(*cast);
1628
1700
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1629
1701
  break;
1630
1702
  }
1631
- #line 128 "node.c.erb"
1632
- case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1703
+ #line 102 "node.c.erb"
1704
+ case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
1633
1705
  yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
1634
1706
  memsize->memsize += sizeof(*cast);
1635
1707
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1636
1708
  break;
1637
1709
  }
1638
- #line 128 "node.c.erb"
1639
- case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1710
+ #line 102 "node.c.erb"
1711
+ case YP_INSTANCE_VARIABLE_OR_WRITE_NODE: {
1640
1712
  yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
1641
1713
  memsize->memsize += sizeof(*cast);
1642
1714
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1643
1715
  break;
1644
1716
  }
1645
- #line 128 "node.c.erb"
1646
- case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
1717
+ #line 102 "node.c.erb"
1718
+ case YP_INSTANCE_VARIABLE_READ_NODE: {
1647
1719
  yp_instance_variable_read_node_t *cast = (yp_instance_variable_read_node_t *) node;
1648
1720
  memsize->memsize += sizeof(*cast);
1649
1721
  break;
1650
1722
  }
1651
- #line 128 "node.c.erb"
1652
- case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
1723
+ #line 102 "node.c.erb"
1724
+ case YP_INSTANCE_VARIABLE_TARGET_NODE: {
1653
1725
  yp_instance_variable_target_node_t *cast = (yp_instance_variable_target_node_t *) node;
1654
1726
  memsize->memsize += sizeof(*cast);
1655
1727
  break;
1656
1728
  }
1657
- #line 128 "node.c.erb"
1658
- case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
1729
+ #line 102 "node.c.erb"
1730
+ case YP_INSTANCE_VARIABLE_WRITE_NODE: {
1659
1731
  yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
1660
1732
  memsize->memsize += sizeof(*cast);
1661
1733
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1662
1734
  break;
1663
1735
  }
1664
- #line 128 "node.c.erb"
1665
- case YP_NODE_INTEGER_NODE: {
1736
+ #line 102 "node.c.erb"
1737
+ case YP_INTEGER_NODE: {
1666
1738
  yp_integer_node_t *cast = (yp_integer_node_t *) node;
1667
1739
  memsize->memsize += sizeof(*cast);
1668
1740
  break;
1669
1741
  }
1670
- #line 128 "node.c.erb"
1671
- case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1742
+ #line 102 "node.c.erb"
1743
+ case YP_INTERPOLATED_MATCH_LAST_LINE_NODE: {
1744
+ yp_interpolated_match_last_line_node_t *cast = (yp_interpolated_match_last_line_node_t *) node;
1745
+ memsize->memsize += sizeof(*cast);
1746
+ yp_node_list_memsize(&cast->parts, memsize);
1747
+ break;
1748
+ }
1749
+ #line 102 "node.c.erb"
1750
+ case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
1672
1751
  yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
1673
1752
  memsize->memsize += sizeof(*cast);
1674
1753
  yp_node_list_memsize(&cast->parts, memsize);
1675
1754
  break;
1676
1755
  }
1677
- #line 128 "node.c.erb"
1678
- case YP_NODE_INTERPOLATED_STRING_NODE: {
1756
+ #line 102 "node.c.erb"
1757
+ case YP_INTERPOLATED_STRING_NODE: {
1679
1758
  yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
1680
1759
  memsize->memsize += sizeof(*cast);
1681
1760
  yp_node_list_memsize(&cast->parts, memsize);
1682
1761
  break;
1683
1762
  }
1684
- #line 128 "node.c.erb"
1685
- case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
1763
+ #line 102 "node.c.erb"
1764
+ case YP_INTERPOLATED_SYMBOL_NODE: {
1686
1765
  yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
1687
1766
  memsize->memsize += sizeof(*cast);
1688
1767
  yp_node_list_memsize(&cast->parts, memsize);
1689
1768
  break;
1690
1769
  }
1691
- #line 128 "node.c.erb"
1692
- case YP_NODE_INTERPOLATED_X_STRING_NODE: {
1770
+ #line 102 "node.c.erb"
1771
+ case YP_INTERPOLATED_X_STRING_NODE: {
1693
1772
  yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
1694
1773
  memsize->memsize += sizeof(*cast);
1695
1774
  yp_node_list_memsize(&cast->parts, memsize);
1696
1775
  break;
1697
1776
  }
1698
- #line 128 "node.c.erb"
1699
- case YP_NODE_KEYWORD_HASH_NODE: {
1777
+ #line 102 "node.c.erb"
1778
+ case YP_KEYWORD_HASH_NODE: {
1700
1779
  yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
1701
1780
  memsize->memsize += sizeof(*cast);
1702
1781
  yp_node_list_memsize(&cast->elements, memsize);
1703
1782
  break;
1704
1783
  }
1705
- #line 128 "node.c.erb"
1706
- case YP_NODE_KEYWORD_PARAMETER_NODE: {
1784
+ #line 102 "node.c.erb"
1785
+ case YP_KEYWORD_PARAMETER_NODE: {
1707
1786
  yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
1708
1787
  memsize->memsize += sizeof(*cast);
1709
1788
  if (cast->value != NULL) {
@@ -1711,14 +1790,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1711
1790
  }
1712
1791
  break;
1713
1792
  }
1714
- #line 128 "node.c.erb"
1715
- case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
1793
+ #line 102 "node.c.erb"
1794
+ case YP_KEYWORD_REST_PARAMETER_NODE: {
1716
1795
  yp_keyword_rest_parameter_node_t *cast = (yp_keyword_rest_parameter_node_t *) node;
1717
1796
  memsize->memsize += sizeof(*cast);
1718
1797
  break;
1719
1798
  }
1720
- #line 128 "node.c.erb"
1721
- case YP_NODE_LAMBDA_NODE: {
1799
+ #line 102 "node.c.erb"
1800
+ case YP_LAMBDA_NODE: {
1722
1801
  yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
1723
1802
  memsize->memsize += sizeof(*cast);
1724
1803
  memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
@@ -1730,70 +1809,85 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1730
1809
  }
1731
1810
  break;
1732
1811
  }
1733
- #line 128 "node.c.erb"
1734
- case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
1812
+ #line 102 "node.c.erb"
1813
+ case YP_LOCAL_VARIABLE_AND_WRITE_NODE: {
1735
1814
  yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
1736
1815
  memsize->memsize += sizeof(*cast);
1737
1816
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1738
1817
  break;
1739
1818
  }
1740
- #line 128 "node.c.erb"
1741
- case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1819
+ #line 102 "node.c.erb"
1820
+ case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
1742
1821
  yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
1743
1822
  memsize->memsize += sizeof(*cast);
1744
1823
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1745
1824
  break;
1746
1825
  }
1747
- #line 128 "node.c.erb"
1748
- case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
1826
+ #line 102 "node.c.erb"
1827
+ case YP_LOCAL_VARIABLE_OR_WRITE_NODE: {
1749
1828
  yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
1750
1829
  memsize->memsize += sizeof(*cast);
1751
1830
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1752
1831
  break;
1753
1832
  }
1754
- #line 128 "node.c.erb"
1755
- case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
1833
+ #line 102 "node.c.erb"
1834
+ case YP_LOCAL_VARIABLE_READ_NODE: {
1756
1835
  yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
1757
1836
  memsize->memsize += sizeof(*cast);
1758
1837
  break;
1759
1838
  }
1760
- #line 128 "node.c.erb"
1761
- case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
1839
+ #line 102 "node.c.erb"
1840
+ case YP_LOCAL_VARIABLE_TARGET_NODE: {
1762
1841
  yp_local_variable_target_node_t *cast = (yp_local_variable_target_node_t *) node;
1763
1842
  memsize->memsize += sizeof(*cast);
1764
1843
  break;
1765
1844
  }
1766
- #line 128 "node.c.erb"
1767
- case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
1845
+ #line 102 "node.c.erb"
1846
+ case YP_LOCAL_VARIABLE_WRITE_NODE: {
1768
1847
  yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
1769
1848
  memsize->memsize += sizeof(*cast);
1770
1849
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1771
1850
  break;
1772
1851
  }
1773
- #line 128 "node.c.erb"
1774
- case YP_NODE_MATCH_PREDICATE_NODE: {
1852
+ #line 102 "node.c.erb"
1853
+ case YP_MATCH_LAST_LINE_NODE: {
1854
+ yp_match_last_line_node_t *cast = (yp_match_last_line_node_t *) node;
1855
+ memsize->memsize += sizeof(*cast);
1856
+ memsize->memsize += yp_string_memsize(&cast->unescaped);
1857
+ break;
1858
+ }
1859
+ #line 102 "node.c.erb"
1860
+ case YP_MATCH_PREDICATE_NODE: {
1775
1861
  yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
1776
1862
  memsize->memsize += sizeof(*cast);
1777
1863
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1778
1864
  yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
1779
1865
  break;
1780
1866
  }
1781
- #line 128 "node.c.erb"
1782
- case YP_NODE_MATCH_REQUIRED_NODE: {
1867
+ #line 102 "node.c.erb"
1868
+ case YP_MATCH_REQUIRED_NODE: {
1783
1869
  yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
1784
1870
  memsize->memsize += sizeof(*cast);
1785
1871
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1786
1872
  yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
1787
1873
  break;
1788
1874
  }
1789
- #line 128 "node.c.erb"
1790
- case YP_NODE_MISSING_NODE: {
1875
+ #line 102 "node.c.erb"
1876
+ case YP_MATCH_WRITE_NODE: {
1877
+ yp_match_write_node_t *cast = (yp_match_write_node_t *) node;
1878
+ memsize->memsize += sizeof(*cast);
1879
+ yp_node_memsize_node((yp_node_t *)cast->call, memsize);
1880
+ memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
1881
+ break;
1882
+ }
1883
+ #line 102 "node.c.erb"
1884
+ case YP_MISSING_NODE: {
1791
1885
  yp_missing_node_t *cast = (yp_missing_node_t *) node;
1792
1886
  memsize->memsize += sizeof(*cast);
1793
1887
  break;
1794
1888
  }
1795
- #line 128 "node.c.erb"
1796
- case YP_NODE_MODULE_NODE: {
1889
+ #line 102 "node.c.erb"
1890
+ case YP_MODULE_NODE: {
1797
1891
  yp_module_node_t *cast = (yp_module_node_t *) node;
1798
1892
  memsize->memsize += sizeof(*cast);
1799
1893
  memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
@@ -1801,21 +1895,25 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1801
1895
  if (cast->body != NULL) {
1802
1896
  yp_node_memsize_node((yp_node_t *)cast->body, memsize);
1803
1897
  }
1804
- memsize->memsize += yp_string_memsize(&cast->name);
1805
1898
  break;
1806
1899
  }
1807
- #line 128 "node.c.erb"
1808
- case YP_NODE_MULTI_WRITE_NODE: {
1900
+ #line 102 "node.c.erb"
1901
+ case YP_MULTI_TARGET_NODE: {
1902
+ yp_multi_target_node_t *cast = (yp_multi_target_node_t *) node;
1903
+ memsize->memsize += sizeof(*cast);
1904
+ yp_node_list_memsize(&cast->targets, memsize);
1905
+ break;
1906
+ }
1907
+ #line 102 "node.c.erb"
1908
+ case YP_MULTI_WRITE_NODE: {
1809
1909
  yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
1810
1910
  memsize->memsize += sizeof(*cast);
1811
1911
  yp_node_list_memsize(&cast->targets, memsize);
1812
- if (cast->value != NULL) {
1813
- yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1814
- }
1912
+ yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1815
1913
  break;
1816
1914
  }
1817
- #line 128 "node.c.erb"
1818
- case YP_NODE_NEXT_NODE: {
1915
+ #line 102 "node.c.erb"
1916
+ case YP_NEXT_NODE: {
1819
1917
  yp_next_node_t *cast = (yp_next_node_t *) node;
1820
1918
  memsize->memsize += sizeof(*cast);
1821
1919
  if (cast->arguments != NULL) {
@@ -1823,49 +1921,49 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1823
1921
  }
1824
1922
  break;
1825
1923
  }
1826
- #line 128 "node.c.erb"
1827
- case YP_NODE_NIL_NODE: {
1924
+ #line 102 "node.c.erb"
1925
+ case YP_NIL_NODE: {
1828
1926
  yp_nil_node_t *cast = (yp_nil_node_t *) node;
1829
1927
  memsize->memsize += sizeof(*cast);
1830
1928
  break;
1831
1929
  }
1832
- #line 128 "node.c.erb"
1833
- case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
1930
+ #line 102 "node.c.erb"
1931
+ case YP_NO_KEYWORDS_PARAMETER_NODE: {
1834
1932
  yp_no_keywords_parameter_node_t *cast = (yp_no_keywords_parameter_node_t *) node;
1835
1933
  memsize->memsize += sizeof(*cast);
1836
1934
  break;
1837
1935
  }
1838
- #line 128 "node.c.erb"
1839
- case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
1936
+ #line 102 "node.c.erb"
1937
+ case YP_NUMBERED_REFERENCE_READ_NODE: {
1840
1938
  yp_numbered_reference_read_node_t *cast = (yp_numbered_reference_read_node_t *) node;
1841
1939
  memsize->memsize += sizeof(*cast);
1842
1940
  break;
1843
1941
  }
1844
- #line 128 "node.c.erb"
1845
- case YP_NODE_OPTIONAL_PARAMETER_NODE: {
1942
+ #line 102 "node.c.erb"
1943
+ case YP_OPTIONAL_PARAMETER_NODE: {
1846
1944
  yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
1847
1945
  memsize->memsize += sizeof(*cast);
1848
1946
  yp_node_memsize_node((yp_node_t *)cast->value, memsize);
1849
1947
  break;
1850
1948
  }
1851
- #line 128 "node.c.erb"
1852
- case YP_NODE_OR_NODE: {
1949
+ #line 102 "node.c.erb"
1950
+ case YP_OR_NODE: {
1853
1951
  yp_or_node_t *cast = (yp_or_node_t *) node;
1854
1952
  memsize->memsize += sizeof(*cast);
1855
1953
  yp_node_memsize_node((yp_node_t *)cast->left, memsize);
1856
1954
  yp_node_memsize_node((yp_node_t *)cast->right, memsize);
1857
1955
  break;
1858
1956
  }
1859
- #line 128 "node.c.erb"
1860
- case YP_NODE_PARAMETERS_NODE: {
1957
+ #line 102 "node.c.erb"
1958
+ case YP_PARAMETERS_NODE: {
1861
1959
  yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
1862
1960
  memsize->memsize += sizeof(*cast);
1863
1961
  yp_node_list_memsize(&cast->requireds, memsize);
1864
1962
  yp_node_list_memsize(&cast->optionals, memsize);
1865
- yp_node_list_memsize(&cast->posts, memsize);
1866
1963
  if (cast->rest != NULL) {
1867
1964
  yp_node_memsize_node((yp_node_t *)cast->rest, memsize);
1868
1965
  }
1966
+ yp_node_list_memsize(&cast->posts, memsize);
1869
1967
  yp_node_list_memsize(&cast->keywords, memsize);
1870
1968
  if (cast->keyword_rest != NULL) {
1871
1969
  yp_node_memsize_node((yp_node_t *)cast->keyword_rest, memsize);
@@ -1875,8 +1973,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1875
1973
  }
1876
1974
  break;
1877
1975
  }
1878
- #line 128 "node.c.erb"
1879
- case YP_NODE_PARENTHESES_NODE: {
1976
+ #line 102 "node.c.erb"
1977
+ case YP_PARENTHESES_NODE: {
1880
1978
  yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
1881
1979
  memsize->memsize += sizeof(*cast);
1882
1980
  if (cast->body != NULL) {
@@ -1884,22 +1982,22 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1884
1982
  }
1885
1983
  break;
1886
1984
  }
1887
- #line 128 "node.c.erb"
1888
- case YP_NODE_PINNED_EXPRESSION_NODE: {
1985
+ #line 102 "node.c.erb"
1986
+ case YP_PINNED_EXPRESSION_NODE: {
1889
1987
  yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
1890
1988
  memsize->memsize += sizeof(*cast);
1891
1989
  yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
1892
1990
  break;
1893
1991
  }
1894
- #line 128 "node.c.erb"
1895
- case YP_NODE_PINNED_VARIABLE_NODE: {
1992
+ #line 102 "node.c.erb"
1993
+ case YP_PINNED_VARIABLE_NODE: {
1896
1994
  yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
1897
1995
  memsize->memsize += sizeof(*cast);
1898
1996
  yp_node_memsize_node((yp_node_t *)cast->variable, memsize);
1899
1997
  break;
1900
1998
  }
1901
- #line 128 "node.c.erb"
1902
- case YP_NODE_POST_EXECUTION_NODE: {
1999
+ #line 102 "node.c.erb"
2000
+ case YP_POST_EXECUTION_NODE: {
1903
2001
  yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
1904
2002
  memsize->memsize += sizeof(*cast);
1905
2003
  if (cast->statements != NULL) {
@@ -1907,8 +2005,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1907
2005
  }
1908
2006
  break;
1909
2007
  }
1910
- #line 128 "node.c.erb"
1911
- case YP_NODE_PRE_EXECUTION_NODE: {
2008
+ #line 102 "node.c.erb"
2009
+ case YP_PRE_EXECUTION_NODE: {
1912
2010
  yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
1913
2011
  memsize->memsize += sizeof(*cast);
1914
2012
  if (cast->statements != NULL) {
@@ -1916,16 +2014,16 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1916
2014
  }
1917
2015
  break;
1918
2016
  }
1919
- #line 128 "node.c.erb"
1920
- case YP_NODE_PROGRAM_NODE: {
2017
+ #line 102 "node.c.erb"
2018
+ case YP_PROGRAM_NODE: {
1921
2019
  yp_program_node_t *cast = (yp_program_node_t *) node;
1922
2020
  memsize->memsize += sizeof(*cast);
1923
2021
  memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
1924
2022
  yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
1925
2023
  break;
1926
2024
  }
1927
- #line 128 "node.c.erb"
1928
- case YP_NODE_RANGE_NODE: {
2025
+ #line 102 "node.c.erb"
2026
+ case YP_RANGE_NODE: {
1929
2027
  yp_range_node_t *cast = (yp_range_node_t *) node;
1930
2028
  memsize->memsize += sizeof(*cast);
1931
2029
  if (cast->left != NULL) {
@@ -1936,49 +2034,49 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1936
2034
  }
1937
2035
  break;
1938
2036
  }
1939
- #line 128 "node.c.erb"
1940
- case YP_NODE_RATIONAL_NODE: {
2037
+ #line 102 "node.c.erb"
2038
+ case YP_RATIONAL_NODE: {
1941
2039
  yp_rational_node_t *cast = (yp_rational_node_t *) node;
1942
2040
  memsize->memsize += sizeof(*cast);
1943
2041
  yp_node_memsize_node((yp_node_t *)cast->numeric, memsize);
1944
2042
  break;
1945
2043
  }
1946
- #line 128 "node.c.erb"
1947
- case YP_NODE_REDO_NODE: {
2044
+ #line 102 "node.c.erb"
2045
+ case YP_REDO_NODE: {
1948
2046
  yp_redo_node_t *cast = (yp_redo_node_t *) node;
1949
2047
  memsize->memsize += sizeof(*cast);
1950
2048
  break;
1951
2049
  }
1952
- #line 128 "node.c.erb"
1953
- case YP_NODE_REGULAR_EXPRESSION_NODE: {
2050
+ #line 102 "node.c.erb"
2051
+ case YP_REGULAR_EXPRESSION_NODE: {
1954
2052
  yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
1955
2053
  memsize->memsize += sizeof(*cast);
1956
2054
  memsize->memsize += yp_string_memsize(&cast->unescaped);
1957
2055
  break;
1958
2056
  }
1959
- #line 128 "node.c.erb"
1960
- case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
2057
+ #line 102 "node.c.erb"
2058
+ case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
1961
2059
  yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
1962
2060
  memsize->memsize += sizeof(*cast);
1963
2061
  yp_node_list_memsize(&cast->parameters, memsize);
1964
2062
  break;
1965
2063
  }
1966
- #line 128 "node.c.erb"
1967
- case YP_NODE_REQUIRED_PARAMETER_NODE: {
2064
+ #line 102 "node.c.erb"
2065
+ case YP_REQUIRED_PARAMETER_NODE: {
1968
2066
  yp_required_parameter_node_t *cast = (yp_required_parameter_node_t *) node;
1969
2067
  memsize->memsize += sizeof(*cast);
1970
2068
  break;
1971
2069
  }
1972
- #line 128 "node.c.erb"
1973
- case YP_NODE_RESCUE_MODIFIER_NODE: {
2070
+ #line 102 "node.c.erb"
2071
+ case YP_RESCUE_MODIFIER_NODE: {
1974
2072
  yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
1975
2073
  memsize->memsize += sizeof(*cast);
1976
2074
  yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
1977
2075
  yp_node_memsize_node((yp_node_t *)cast->rescue_expression, memsize);
1978
2076
  break;
1979
2077
  }
1980
- #line 128 "node.c.erb"
1981
- case YP_NODE_RESCUE_NODE: {
2078
+ #line 102 "node.c.erb"
2079
+ case YP_RESCUE_NODE: {
1982
2080
  yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
1983
2081
  memsize->memsize += sizeof(*cast);
1984
2082
  yp_node_list_memsize(&cast->exceptions, memsize);
@@ -1993,20 +2091,20 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
1993
2091
  }
1994
2092
  break;
1995
2093
  }
1996
- #line 128 "node.c.erb"
1997
- case YP_NODE_REST_PARAMETER_NODE: {
2094
+ #line 102 "node.c.erb"
2095
+ case YP_REST_PARAMETER_NODE: {
1998
2096
  yp_rest_parameter_node_t *cast = (yp_rest_parameter_node_t *) node;
1999
2097
  memsize->memsize += sizeof(*cast);
2000
2098
  break;
2001
2099
  }
2002
- #line 128 "node.c.erb"
2003
- case YP_NODE_RETRY_NODE: {
2100
+ #line 102 "node.c.erb"
2101
+ case YP_RETRY_NODE: {
2004
2102
  yp_retry_node_t *cast = (yp_retry_node_t *) node;
2005
2103
  memsize->memsize += sizeof(*cast);
2006
2104
  break;
2007
2105
  }
2008
- #line 128 "node.c.erb"
2009
- case YP_NODE_RETURN_NODE: {
2106
+ #line 102 "node.c.erb"
2107
+ case YP_RETURN_NODE: {
2010
2108
  yp_return_node_t *cast = (yp_return_node_t *) node;
2011
2109
  memsize->memsize += sizeof(*cast);
2012
2110
  if (cast->arguments != NULL) {
@@ -2014,14 +2112,14 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2014
2112
  }
2015
2113
  break;
2016
2114
  }
2017
- #line 128 "node.c.erb"
2018
- case YP_NODE_SELF_NODE: {
2115
+ #line 102 "node.c.erb"
2116
+ case YP_SELF_NODE: {
2019
2117
  yp_self_node_t *cast = (yp_self_node_t *) node;
2020
2118
  memsize->memsize += sizeof(*cast);
2021
2119
  break;
2022
2120
  }
2023
- #line 128 "node.c.erb"
2024
- case YP_NODE_SINGLETON_CLASS_NODE: {
2121
+ #line 102 "node.c.erb"
2122
+ case YP_SINGLETON_CLASS_NODE: {
2025
2123
  yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
2026
2124
  memsize->memsize += sizeof(*cast);
2027
2125
  memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
@@ -2031,27 +2129,27 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2031
2129
  }
2032
2130
  break;
2033
2131
  }
2034
- #line 128 "node.c.erb"
2035
- case YP_NODE_SOURCE_ENCODING_NODE: {
2132
+ #line 102 "node.c.erb"
2133
+ case YP_SOURCE_ENCODING_NODE: {
2036
2134
  yp_source_encoding_node_t *cast = (yp_source_encoding_node_t *) node;
2037
2135
  memsize->memsize += sizeof(*cast);
2038
2136
  break;
2039
2137
  }
2040
- #line 128 "node.c.erb"
2041
- case YP_NODE_SOURCE_FILE_NODE: {
2138
+ #line 102 "node.c.erb"
2139
+ case YP_SOURCE_FILE_NODE: {
2042
2140
  yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
2043
2141
  memsize->memsize += sizeof(*cast);
2044
2142
  memsize->memsize += yp_string_memsize(&cast->filepath);
2045
2143
  break;
2046
2144
  }
2047
- #line 128 "node.c.erb"
2048
- case YP_NODE_SOURCE_LINE_NODE: {
2145
+ #line 102 "node.c.erb"
2146
+ case YP_SOURCE_LINE_NODE: {
2049
2147
  yp_source_line_node_t *cast = (yp_source_line_node_t *) node;
2050
2148
  memsize->memsize += sizeof(*cast);
2051
2149
  break;
2052
2150
  }
2053
- #line 128 "node.c.erb"
2054
- case YP_NODE_SPLAT_NODE: {
2151
+ #line 102 "node.c.erb"
2152
+ case YP_SPLAT_NODE: {
2055
2153
  yp_splat_node_t *cast = (yp_splat_node_t *) node;
2056
2154
  memsize->memsize += sizeof(*cast);
2057
2155
  if (cast->expression != NULL) {
@@ -2059,30 +2157,30 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2059
2157
  }
2060
2158
  break;
2061
2159
  }
2062
- #line 128 "node.c.erb"
2063
- case YP_NODE_STATEMENTS_NODE: {
2160
+ #line 102 "node.c.erb"
2161
+ case YP_STATEMENTS_NODE: {
2064
2162
  yp_statements_node_t *cast = (yp_statements_node_t *) node;
2065
2163
  memsize->memsize += sizeof(*cast);
2066
2164
  yp_node_list_memsize(&cast->body, memsize);
2067
2165
  break;
2068
2166
  }
2069
- #line 128 "node.c.erb"
2070
- case YP_NODE_STRING_CONCAT_NODE: {
2167
+ #line 102 "node.c.erb"
2168
+ case YP_STRING_CONCAT_NODE: {
2071
2169
  yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
2072
2170
  memsize->memsize += sizeof(*cast);
2073
2171
  yp_node_memsize_node((yp_node_t *)cast->left, memsize);
2074
2172
  yp_node_memsize_node((yp_node_t *)cast->right, memsize);
2075
2173
  break;
2076
2174
  }
2077
- #line 128 "node.c.erb"
2078
- case YP_NODE_STRING_NODE: {
2175
+ #line 102 "node.c.erb"
2176
+ case YP_STRING_NODE: {
2079
2177
  yp_string_node_t *cast = (yp_string_node_t *) node;
2080
2178
  memsize->memsize += sizeof(*cast);
2081
2179
  memsize->memsize += yp_string_memsize(&cast->unescaped);
2082
2180
  break;
2083
2181
  }
2084
- #line 128 "node.c.erb"
2085
- case YP_NODE_SUPER_NODE: {
2182
+ #line 102 "node.c.erb"
2183
+ case YP_SUPER_NODE: {
2086
2184
  yp_super_node_t *cast = (yp_super_node_t *) node;
2087
2185
  memsize->memsize += sizeof(*cast);
2088
2186
  if (cast->arguments != NULL) {
@@ -2093,28 +2191,28 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2093
2191
  }
2094
2192
  break;
2095
2193
  }
2096
- #line 128 "node.c.erb"
2097
- case YP_NODE_SYMBOL_NODE: {
2194
+ #line 102 "node.c.erb"
2195
+ case YP_SYMBOL_NODE: {
2098
2196
  yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
2099
2197
  memsize->memsize += sizeof(*cast);
2100
2198
  memsize->memsize += yp_string_memsize(&cast->unescaped);
2101
2199
  break;
2102
2200
  }
2103
- #line 128 "node.c.erb"
2104
- case YP_NODE_TRUE_NODE: {
2201
+ #line 102 "node.c.erb"
2202
+ case YP_TRUE_NODE: {
2105
2203
  yp_true_node_t *cast = (yp_true_node_t *) node;
2106
2204
  memsize->memsize += sizeof(*cast);
2107
2205
  break;
2108
2206
  }
2109
- #line 128 "node.c.erb"
2110
- case YP_NODE_UNDEF_NODE: {
2207
+ #line 102 "node.c.erb"
2208
+ case YP_UNDEF_NODE: {
2111
2209
  yp_undef_node_t *cast = (yp_undef_node_t *) node;
2112
2210
  memsize->memsize += sizeof(*cast);
2113
2211
  yp_node_list_memsize(&cast->names, memsize);
2114
2212
  break;
2115
2213
  }
2116
- #line 128 "node.c.erb"
2117
- case YP_NODE_UNLESS_NODE: {
2214
+ #line 102 "node.c.erb"
2215
+ case YP_UNLESS_NODE: {
2118
2216
  yp_unless_node_t *cast = (yp_unless_node_t *) node;
2119
2217
  memsize->memsize += sizeof(*cast);
2120
2218
  yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
@@ -2126,8 +2224,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2126
2224
  }
2127
2225
  break;
2128
2226
  }
2129
- #line 128 "node.c.erb"
2130
- case YP_NODE_UNTIL_NODE: {
2227
+ #line 102 "node.c.erb"
2228
+ case YP_UNTIL_NODE: {
2131
2229
  yp_until_node_t *cast = (yp_until_node_t *) node;
2132
2230
  memsize->memsize += sizeof(*cast);
2133
2231
  yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
@@ -2136,8 +2234,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2136
2234
  }
2137
2235
  break;
2138
2236
  }
2139
- #line 128 "node.c.erb"
2140
- case YP_NODE_WHEN_NODE: {
2237
+ #line 102 "node.c.erb"
2238
+ case YP_WHEN_NODE: {
2141
2239
  yp_when_node_t *cast = (yp_when_node_t *) node;
2142
2240
  memsize->memsize += sizeof(*cast);
2143
2241
  yp_node_list_memsize(&cast->conditions, memsize);
@@ -2146,8 +2244,8 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2146
2244
  }
2147
2245
  break;
2148
2246
  }
2149
- #line 128 "node.c.erb"
2150
- case YP_NODE_WHILE_NODE: {
2247
+ #line 102 "node.c.erb"
2248
+ case YP_WHILE_NODE: {
2151
2249
  yp_while_node_t *cast = (yp_while_node_t *) node;
2152
2250
  memsize->memsize += sizeof(*cast);
2153
2251
  yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
@@ -2156,15 +2254,15 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2156
2254
  }
2157
2255
  break;
2158
2256
  }
2159
- #line 128 "node.c.erb"
2160
- case YP_NODE_X_STRING_NODE: {
2257
+ #line 102 "node.c.erb"
2258
+ case YP_X_STRING_NODE: {
2161
2259
  yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
2162
2260
  memsize->memsize += sizeof(*cast);
2163
2261
  memsize->memsize += yp_string_memsize(&cast->unescaped);
2164
2262
  break;
2165
2263
  }
2166
- #line 128 "node.c.erb"
2167
- case YP_NODE_YIELD_NODE: {
2264
+ #line 102 "node.c.erb"
2265
+ case YP_YIELD_NODE: {
2168
2266
  yp_yield_node_t *cast = (yp_yield_node_t *) node;
2169
2267
  memsize->memsize += sizeof(*cast);
2170
2268
  if (cast->arguments != NULL) {
@@ -2172,7 +2270,7 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
2172
2270
  }
2173
2271
  break;
2174
2272
  }
2175
- #line 156 "node.c.erb"
2273
+ #line 128 "node.c.erb"
2176
2274
  }
2177
2275
  }
2178
2276
 
@@ -2188,274 +2286,288 @@ YP_EXPORTED_FUNCTION const char *
2188
2286
  yp_node_type_to_str(yp_node_type_t node_type)
2189
2287
  {
2190
2288
  switch (node_type) {
2191
- case YP_NODE_ALIAS_NODE:
2192
- return "YP_NODE_ALIAS_NODE";
2193
- case YP_NODE_ALTERNATION_PATTERN_NODE:
2194
- return "YP_NODE_ALTERNATION_PATTERN_NODE";
2195
- case YP_NODE_AND_NODE:
2196
- return "YP_NODE_AND_NODE";
2197
- case YP_NODE_ARGUMENTS_NODE:
2198
- return "YP_NODE_ARGUMENTS_NODE";
2199
- case YP_NODE_ARRAY_NODE:
2200
- return "YP_NODE_ARRAY_NODE";
2201
- case YP_NODE_ARRAY_PATTERN_NODE:
2202
- return "YP_NODE_ARRAY_PATTERN_NODE";
2203
- case YP_NODE_ASSOC_NODE:
2204
- return "YP_NODE_ASSOC_NODE";
2205
- case YP_NODE_ASSOC_SPLAT_NODE:
2206
- return "YP_NODE_ASSOC_SPLAT_NODE";
2207
- case YP_NODE_BACK_REFERENCE_READ_NODE:
2208
- return "YP_NODE_BACK_REFERENCE_READ_NODE";
2209
- case YP_NODE_BEGIN_NODE:
2210
- return "YP_NODE_BEGIN_NODE";
2211
- case YP_NODE_BLOCK_ARGUMENT_NODE:
2212
- return "YP_NODE_BLOCK_ARGUMENT_NODE";
2213
- case YP_NODE_BLOCK_NODE:
2214
- return "YP_NODE_BLOCK_NODE";
2215
- case YP_NODE_BLOCK_PARAMETER_NODE:
2216
- return "YP_NODE_BLOCK_PARAMETER_NODE";
2217
- case YP_NODE_BLOCK_PARAMETERS_NODE:
2218
- return "YP_NODE_BLOCK_PARAMETERS_NODE";
2219
- case YP_NODE_BREAK_NODE:
2220
- return "YP_NODE_BREAK_NODE";
2221
- case YP_NODE_CALL_NODE:
2222
- return "YP_NODE_CALL_NODE";
2223
- case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE:
2224
- return "YP_NODE_CALL_OPERATOR_AND_WRITE_NODE";
2225
- case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE:
2226
- return "YP_NODE_CALL_OPERATOR_OR_WRITE_NODE";
2227
- case YP_NODE_CALL_OPERATOR_WRITE_NODE:
2228
- return "YP_NODE_CALL_OPERATOR_WRITE_NODE";
2229
- case YP_NODE_CAPTURE_PATTERN_NODE:
2230
- return "YP_NODE_CAPTURE_PATTERN_NODE";
2231
- case YP_NODE_CASE_NODE:
2232
- return "YP_NODE_CASE_NODE";
2233
- case YP_NODE_CLASS_NODE:
2234
- return "YP_NODE_CLASS_NODE";
2235
- case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE:
2236
- return "YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE";
2237
- case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
2238
- return "YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE";
2239
- case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE:
2240
- return "YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE";
2241
- case YP_NODE_CLASS_VARIABLE_READ_NODE:
2242
- return "YP_NODE_CLASS_VARIABLE_READ_NODE";
2243
- case YP_NODE_CLASS_VARIABLE_TARGET_NODE:
2244
- return "YP_NODE_CLASS_VARIABLE_TARGET_NODE";
2245
- case YP_NODE_CLASS_VARIABLE_WRITE_NODE:
2246
- return "YP_NODE_CLASS_VARIABLE_WRITE_NODE";
2247
- case YP_NODE_CONSTANT_AND_WRITE_NODE:
2248
- return "YP_NODE_CONSTANT_AND_WRITE_NODE";
2249
- case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE:
2250
- return "YP_NODE_CONSTANT_OPERATOR_WRITE_NODE";
2251
- case YP_NODE_CONSTANT_OR_WRITE_NODE:
2252
- return "YP_NODE_CONSTANT_OR_WRITE_NODE";
2253
- case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE:
2254
- return "YP_NODE_CONSTANT_PATH_AND_WRITE_NODE";
2255
- case YP_NODE_CONSTANT_PATH_NODE:
2256
- return "YP_NODE_CONSTANT_PATH_NODE";
2257
- case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE:
2258
- return "YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE";
2259
- case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE:
2260
- return "YP_NODE_CONSTANT_PATH_OR_WRITE_NODE";
2261
- case YP_NODE_CONSTANT_PATH_TARGET_NODE:
2262
- return "YP_NODE_CONSTANT_PATH_TARGET_NODE";
2263
- case YP_NODE_CONSTANT_PATH_WRITE_NODE:
2264
- return "YP_NODE_CONSTANT_PATH_WRITE_NODE";
2265
- case YP_NODE_CONSTANT_READ_NODE:
2266
- return "YP_NODE_CONSTANT_READ_NODE";
2267
- case YP_NODE_CONSTANT_TARGET_NODE:
2268
- return "YP_NODE_CONSTANT_TARGET_NODE";
2269
- case YP_NODE_CONSTANT_WRITE_NODE:
2270
- return "YP_NODE_CONSTANT_WRITE_NODE";
2271
- case YP_NODE_DEF_NODE:
2272
- return "YP_NODE_DEF_NODE";
2273
- case YP_NODE_DEFINED_NODE:
2274
- return "YP_NODE_DEFINED_NODE";
2275
- case YP_NODE_ELSE_NODE:
2276
- return "YP_NODE_ELSE_NODE";
2277
- case YP_NODE_EMBEDDED_STATEMENTS_NODE:
2278
- return "YP_NODE_EMBEDDED_STATEMENTS_NODE";
2279
- case YP_NODE_EMBEDDED_VARIABLE_NODE:
2280
- return "YP_NODE_EMBEDDED_VARIABLE_NODE";
2281
- case YP_NODE_ENSURE_NODE:
2282
- return "YP_NODE_ENSURE_NODE";
2283
- case YP_NODE_FALSE_NODE:
2284
- return "YP_NODE_FALSE_NODE";
2285
- case YP_NODE_FIND_PATTERN_NODE:
2286
- return "YP_NODE_FIND_PATTERN_NODE";
2287
- case YP_NODE_FLIP_FLOP_NODE:
2288
- return "YP_NODE_FLIP_FLOP_NODE";
2289
- case YP_NODE_FLOAT_NODE:
2290
- return "YP_NODE_FLOAT_NODE";
2291
- case YP_NODE_FOR_NODE:
2292
- return "YP_NODE_FOR_NODE";
2293
- case YP_NODE_FORWARDING_ARGUMENTS_NODE:
2294
- return "YP_NODE_FORWARDING_ARGUMENTS_NODE";
2295
- case YP_NODE_FORWARDING_PARAMETER_NODE:
2296
- return "YP_NODE_FORWARDING_PARAMETER_NODE";
2297
- case YP_NODE_FORWARDING_SUPER_NODE:
2298
- return "YP_NODE_FORWARDING_SUPER_NODE";
2299
- case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE:
2300
- return "YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE";
2301
- case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
2302
- return "YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE";
2303
- case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE:
2304
- return "YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE";
2305
- case YP_NODE_GLOBAL_VARIABLE_READ_NODE:
2306
- return "YP_NODE_GLOBAL_VARIABLE_READ_NODE";
2307
- case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE:
2308
- return "YP_NODE_GLOBAL_VARIABLE_TARGET_NODE";
2309
- case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE:
2310
- return "YP_NODE_GLOBAL_VARIABLE_WRITE_NODE";
2311
- case YP_NODE_HASH_NODE:
2312
- return "YP_NODE_HASH_NODE";
2313
- case YP_NODE_HASH_PATTERN_NODE:
2314
- return "YP_NODE_HASH_PATTERN_NODE";
2315
- case YP_NODE_IF_NODE:
2316
- return "YP_NODE_IF_NODE";
2317
- case YP_NODE_IMAGINARY_NODE:
2318
- return "YP_NODE_IMAGINARY_NODE";
2319
- case YP_NODE_IN_NODE:
2320
- return "YP_NODE_IN_NODE";
2321
- case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE:
2322
- return "YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE";
2323
- case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
2324
- return "YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE";
2325
- case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE:
2326
- return "YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE";
2327
- case YP_NODE_INSTANCE_VARIABLE_READ_NODE:
2328
- return "YP_NODE_INSTANCE_VARIABLE_READ_NODE";
2329
- case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE:
2330
- return "YP_NODE_INSTANCE_VARIABLE_TARGET_NODE";
2331
- case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE:
2332
- return "YP_NODE_INSTANCE_VARIABLE_WRITE_NODE";
2333
- case YP_NODE_INTEGER_NODE:
2334
- return "YP_NODE_INTEGER_NODE";
2335
- case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE:
2336
- return "YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE";
2337
- case YP_NODE_INTERPOLATED_STRING_NODE:
2338
- return "YP_NODE_INTERPOLATED_STRING_NODE";
2339
- case YP_NODE_INTERPOLATED_SYMBOL_NODE:
2340
- return "YP_NODE_INTERPOLATED_SYMBOL_NODE";
2341
- case YP_NODE_INTERPOLATED_X_STRING_NODE:
2342
- return "YP_NODE_INTERPOLATED_X_STRING_NODE";
2343
- case YP_NODE_KEYWORD_HASH_NODE:
2344
- return "YP_NODE_KEYWORD_HASH_NODE";
2345
- case YP_NODE_KEYWORD_PARAMETER_NODE:
2346
- return "YP_NODE_KEYWORD_PARAMETER_NODE";
2347
- case YP_NODE_KEYWORD_REST_PARAMETER_NODE:
2348
- return "YP_NODE_KEYWORD_REST_PARAMETER_NODE";
2349
- case YP_NODE_LAMBDA_NODE:
2350
- return "YP_NODE_LAMBDA_NODE";
2351
- case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE:
2352
- return "YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE";
2353
- case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
2354
- return "YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE";
2355
- case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE:
2356
- return "YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE";
2357
- case YP_NODE_LOCAL_VARIABLE_READ_NODE:
2358
- return "YP_NODE_LOCAL_VARIABLE_READ_NODE";
2359
- case YP_NODE_LOCAL_VARIABLE_TARGET_NODE:
2360
- return "YP_NODE_LOCAL_VARIABLE_TARGET_NODE";
2361
- case YP_NODE_LOCAL_VARIABLE_WRITE_NODE:
2362
- return "YP_NODE_LOCAL_VARIABLE_WRITE_NODE";
2363
- case YP_NODE_MATCH_PREDICATE_NODE:
2364
- return "YP_NODE_MATCH_PREDICATE_NODE";
2365
- case YP_NODE_MATCH_REQUIRED_NODE:
2366
- return "YP_NODE_MATCH_REQUIRED_NODE";
2367
- case YP_NODE_MISSING_NODE:
2368
- return "YP_NODE_MISSING_NODE";
2369
- case YP_NODE_MODULE_NODE:
2370
- return "YP_NODE_MODULE_NODE";
2371
- case YP_NODE_MULTI_WRITE_NODE:
2372
- return "YP_NODE_MULTI_WRITE_NODE";
2373
- case YP_NODE_NEXT_NODE:
2374
- return "YP_NODE_NEXT_NODE";
2375
- case YP_NODE_NIL_NODE:
2376
- return "YP_NODE_NIL_NODE";
2377
- case YP_NODE_NO_KEYWORDS_PARAMETER_NODE:
2378
- return "YP_NODE_NO_KEYWORDS_PARAMETER_NODE";
2379
- case YP_NODE_NUMBERED_REFERENCE_READ_NODE:
2380
- return "YP_NODE_NUMBERED_REFERENCE_READ_NODE";
2381
- case YP_NODE_OPTIONAL_PARAMETER_NODE:
2382
- return "YP_NODE_OPTIONAL_PARAMETER_NODE";
2383
- case YP_NODE_OR_NODE:
2384
- return "YP_NODE_OR_NODE";
2385
- case YP_NODE_PARAMETERS_NODE:
2386
- return "YP_NODE_PARAMETERS_NODE";
2387
- case YP_NODE_PARENTHESES_NODE:
2388
- return "YP_NODE_PARENTHESES_NODE";
2389
- case YP_NODE_PINNED_EXPRESSION_NODE:
2390
- return "YP_NODE_PINNED_EXPRESSION_NODE";
2391
- case YP_NODE_PINNED_VARIABLE_NODE:
2392
- return "YP_NODE_PINNED_VARIABLE_NODE";
2393
- case YP_NODE_POST_EXECUTION_NODE:
2394
- return "YP_NODE_POST_EXECUTION_NODE";
2395
- case YP_NODE_PRE_EXECUTION_NODE:
2396
- return "YP_NODE_PRE_EXECUTION_NODE";
2397
- case YP_NODE_PROGRAM_NODE:
2398
- return "YP_NODE_PROGRAM_NODE";
2399
- case YP_NODE_RANGE_NODE:
2400
- return "YP_NODE_RANGE_NODE";
2401
- case YP_NODE_RATIONAL_NODE:
2402
- return "YP_NODE_RATIONAL_NODE";
2403
- case YP_NODE_REDO_NODE:
2404
- return "YP_NODE_REDO_NODE";
2405
- case YP_NODE_REGULAR_EXPRESSION_NODE:
2406
- return "YP_NODE_REGULAR_EXPRESSION_NODE";
2407
- case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE:
2408
- return "YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE";
2409
- case YP_NODE_REQUIRED_PARAMETER_NODE:
2410
- return "YP_NODE_REQUIRED_PARAMETER_NODE";
2411
- case YP_NODE_RESCUE_MODIFIER_NODE:
2412
- return "YP_NODE_RESCUE_MODIFIER_NODE";
2413
- case YP_NODE_RESCUE_NODE:
2414
- return "YP_NODE_RESCUE_NODE";
2415
- case YP_NODE_REST_PARAMETER_NODE:
2416
- return "YP_NODE_REST_PARAMETER_NODE";
2417
- case YP_NODE_RETRY_NODE:
2418
- return "YP_NODE_RETRY_NODE";
2419
- case YP_NODE_RETURN_NODE:
2420
- return "YP_NODE_RETURN_NODE";
2421
- case YP_NODE_SELF_NODE:
2422
- return "YP_NODE_SELF_NODE";
2423
- case YP_NODE_SINGLETON_CLASS_NODE:
2424
- return "YP_NODE_SINGLETON_CLASS_NODE";
2425
- case YP_NODE_SOURCE_ENCODING_NODE:
2426
- return "YP_NODE_SOURCE_ENCODING_NODE";
2427
- case YP_NODE_SOURCE_FILE_NODE:
2428
- return "YP_NODE_SOURCE_FILE_NODE";
2429
- case YP_NODE_SOURCE_LINE_NODE:
2430
- return "YP_NODE_SOURCE_LINE_NODE";
2431
- case YP_NODE_SPLAT_NODE:
2432
- return "YP_NODE_SPLAT_NODE";
2433
- case YP_NODE_STATEMENTS_NODE:
2434
- return "YP_NODE_STATEMENTS_NODE";
2435
- case YP_NODE_STRING_CONCAT_NODE:
2436
- return "YP_NODE_STRING_CONCAT_NODE";
2437
- case YP_NODE_STRING_NODE:
2438
- return "YP_NODE_STRING_NODE";
2439
- case YP_NODE_SUPER_NODE:
2440
- return "YP_NODE_SUPER_NODE";
2441
- case YP_NODE_SYMBOL_NODE:
2442
- return "YP_NODE_SYMBOL_NODE";
2443
- case YP_NODE_TRUE_NODE:
2444
- return "YP_NODE_TRUE_NODE";
2445
- case YP_NODE_UNDEF_NODE:
2446
- return "YP_NODE_UNDEF_NODE";
2447
- case YP_NODE_UNLESS_NODE:
2448
- return "YP_NODE_UNLESS_NODE";
2449
- case YP_NODE_UNTIL_NODE:
2450
- return "YP_NODE_UNTIL_NODE";
2451
- case YP_NODE_WHEN_NODE:
2452
- return "YP_NODE_WHEN_NODE";
2453
- case YP_NODE_WHILE_NODE:
2454
- return "YP_NODE_WHILE_NODE";
2455
- case YP_NODE_X_STRING_NODE:
2456
- return "YP_NODE_X_STRING_NODE";
2457
- case YP_NODE_YIELD_NODE:
2458
- return "YP_NODE_YIELD_NODE";
2289
+ case YP_ALIAS_GLOBAL_VARIABLE_NODE:
2290
+ return "YP_ALIAS_GLOBAL_VARIABLE_NODE";
2291
+ case YP_ALIAS_METHOD_NODE:
2292
+ return "YP_ALIAS_METHOD_NODE";
2293
+ case YP_ALTERNATION_PATTERN_NODE:
2294
+ return "YP_ALTERNATION_PATTERN_NODE";
2295
+ case YP_AND_NODE:
2296
+ return "YP_AND_NODE";
2297
+ case YP_ARGUMENTS_NODE:
2298
+ return "YP_ARGUMENTS_NODE";
2299
+ case YP_ARRAY_NODE:
2300
+ return "YP_ARRAY_NODE";
2301
+ case YP_ARRAY_PATTERN_NODE:
2302
+ return "YP_ARRAY_PATTERN_NODE";
2303
+ case YP_ASSOC_NODE:
2304
+ return "YP_ASSOC_NODE";
2305
+ case YP_ASSOC_SPLAT_NODE:
2306
+ return "YP_ASSOC_SPLAT_NODE";
2307
+ case YP_BACK_REFERENCE_READ_NODE:
2308
+ return "YP_BACK_REFERENCE_READ_NODE";
2309
+ case YP_BEGIN_NODE:
2310
+ return "YP_BEGIN_NODE";
2311
+ case YP_BLOCK_ARGUMENT_NODE:
2312
+ return "YP_BLOCK_ARGUMENT_NODE";
2313
+ case YP_BLOCK_LOCAL_VARIABLE_NODE:
2314
+ return "YP_BLOCK_LOCAL_VARIABLE_NODE";
2315
+ case YP_BLOCK_NODE:
2316
+ return "YP_BLOCK_NODE";
2317
+ case YP_BLOCK_PARAMETER_NODE:
2318
+ return "YP_BLOCK_PARAMETER_NODE";
2319
+ case YP_BLOCK_PARAMETERS_NODE:
2320
+ return "YP_BLOCK_PARAMETERS_NODE";
2321
+ case YP_BREAK_NODE:
2322
+ return "YP_BREAK_NODE";
2323
+ case YP_CALL_AND_WRITE_NODE:
2324
+ return "YP_CALL_AND_WRITE_NODE";
2325
+ case YP_CALL_NODE:
2326
+ return "YP_CALL_NODE";
2327
+ case YP_CALL_OPERATOR_WRITE_NODE:
2328
+ return "YP_CALL_OPERATOR_WRITE_NODE";
2329
+ case YP_CALL_OR_WRITE_NODE:
2330
+ return "YP_CALL_OR_WRITE_NODE";
2331
+ case YP_CAPTURE_PATTERN_NODE:
2332
+ return "YP_CAPTURE_PATTERN_NODE";
2333
+ case YP_CASE_NODE:
2334
+ return "YP_CASE_NODE";
2335
+ case YP_CLASS_NODE:
2336
+ return "YP_CLASS_NODE";
2337
+ case YP_CLASS_VARIABLE_AND_WRITE_NODE:
2338
+ return "YP_CLASS_VARIABLE_AND_WRITE_NODE";
2339
+ case YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
2340
+ return "YP_CLASS_VARIABLE_OPERATOR_WRITE_NODE";
2341
+ case YP_CLASS_VARIABLE_OR_WRITE_NODE:
2342
+ return "YP_CLASS_VARIABLE_OR_WRITE_NODE";
2343
+ case YP_CLASS_VARIABLE_READ_NODE:
2344
+ return "YP_CLASS_VARIABLE_READ_NODE";
2345
+ case YP_CLASS_VARIABLE_TARGET_NODE:
2346
+ return "YP_CLASS_VARIABLE_TARGET_NODE";
2347
+ case YP_CLASS_VARIABLE_WRITE_NODE:
2348
+ return "YP_CLASS_VARIABLE_WRITE_NODE";
2349
+ case YP_CONSTANT_AND_WRITE_NODE:
2350
+ return "YP_CONSTANT_AND_WRITE_NODE";
2351
+ case YP_CONSTANT_OPERATOR_WRITE_NODE:
2352
+ return "YP_CONSTANT_OPERATOR_WRITE_NODE";
2353
+ case YP_CONSTANT_OR_WRITE_NODE:
2354
+ return "YP_CONSTANT_OR_WRITE_NODE";
2355
+ case YP_CONSTANT_PATH_AND_WRITE_NODE:
2356
+ return "YP_CONSTANT_PATH_AND_WRITE_NODE";
2357
+ case YP_CONSTANT_PATH_NODE:
2358
+ return "YP_CONSTANT_PATH_NODE";
2359
+ case YP_CONSTANT_PATH_OPERATOR_WRITE_NODE:
2360
+ return "YP_CONSTANT_PATH_OPERATOR_WRITE_NODE";
2361
+ case YP_CONSTANT_PATH_OR_WRITE_NODE:
2362
+ return "YP_CONSTANT_PATH_OR_WRITE_NODE";
2363
+ case YP_CONSTANT_PATH_TARGET_NODE:
2364
+ return "YP_CONSTANT_PATH_TARGET_NODE";
2365
+ case YP_CONSTANT_PATH_WRITE_NODE:
2366
+ return "YP_CONSTANT_PATH_WRITE_NODE";
2367
+ case YP_CONSTANT_READ_NODE:
2368
+ return "YP_CONSTANT_READ_NODE";
2369
+ case YP_CONSTANT_TARGET_NODE:
2370
+ return "YP_CONSTANT_TARGET_NODE";
2371
+ case YP_CONSTANT_WRITE_NODE:
2372
+ return "YP_CONSTANT_WRITE_NODE";
2373
+ case YP_DEF_NODE:
2374
+ return "YP_DEF_NODE";
2375
+ case YP_DEFINED_NODE:
2376
+ return "YP_DEFINED_NODE";
2377
+ case YP_ELSE_NODE:
2378
+ return "YP_ELSE_NODE";
2379
+ case YP_EMBEDDED_STATEMENTS_NODE:
2380
+ return "YP_EMBEDDED_STATEMENTS_NODE";
2381
+ case YP_EMBEDDED_VARIABLE_NODE:
2382
+ return "YP_EMBEDDED_VARIABLE_NODE";
2383
+ case YP_ENSURE_NODE:
2384
+ return "YP_ENSURE_NODE";
2385
+ case YP_FALSE_NODE:
2386
+ return "YP_FALSE_NODE";
2387
+ case YP_FIND_PATTERN_NODE:
2388
+ return "YP_FIND_PATTERN_NODE";
2389
+ case YP_FLIP_FLOP_NODE:
2390
+ return "YP_FLIP_FLOP_NODE";
2391
+ case YP_FLOAT_NODE:
2392
+ return "YP_FLOAT_NODE";
2393
+ case YP_FOR_NODE:
2394
+ return "YP_FOR_NODE";
2395
+ case YP_FORWARDING_ARGUMENTS_NODE:
2396
+ return "YP_FORWARDING_ARGUMENTS_NODE";
2397
+ case YP_FORWARDING_PARAMETER_NODE:
2398
+ return "YP_FORWARDING_PARAMETER_NODE";
2399
+ case YP_FORWARDING_SUPER_NODE:
2400
+ return "YP_FORWARDING_SUPER_NODE";
2401
+ case YP_GLOBAL_VARIABLE_AND_WRITE_NODE:
2402
+ return "YP_GLOBAL_VARIABLE_AND_WRITE_NODE";
2403
+ case YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
2404
+ return "YP_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE";
2405
+ case YP_GLOBAL_VARIABLE_OR_WRITE_NODE:
2406
+ return "YP_GLOBAL_VARIABLE_OR_WRITE_NODE";
2407
+ case YP_GLOBAL_VARIABLE_READ_NODE:
2408
+ return "YP_GLOBAL_VARIABLE_READ_NODE";
2409
+ case YP_GLOBAL_VARIABLE_TARGET_NODE:
2410
+ return "YP_GLOBAL_VARIABLE_TARGET_NODE";
2411
+ case YP_GLOBAL_VARIABLE_WRITE_NODE:
2412
+ return "YP_GLOBAL_VARIABLE_WRITE_NODE";
2413
+ case YP_HASH_NODE:
2414
+ return "YP_HASH_NODE";
2415
+ case YP_HASH_PATTERN_NODE:
2416
+ return "YP_HASH_PATTERN_NODE";
2417
+ case YP_IF_NODE:
2418
+ return "YP_IF_NODE";
2419
+ case YP_IMAGINARY_NODE:
2420
+ return "YP_IMAGINARY_NODE";
2421
+ case YP_IMPLICIT_NODE:
2422
+ return "YP_IMPLICIT_NODE";
2423
+ case YP_IN_NODE:
2424
+ return "YP_IN_NODE";
2425
+ case YP_INSTANCE_VARIABLE_AND_WRITE_NODE:
2426
+ return "YP_INSTANCE_VARIABLE_AND_WRITE_NODE";
2427
+ case YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
2428
+ return "YP_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE";
2429
+ case YP_INSTANCE_VARIABLE_OR_WRITE_NODE:
2430
+ return "YP_INSTANCE_VARIABLE_OR_WRITE_NODE";
2431
+ case YP_INSTANCE_VARIABLE_READ_NODE:
2432
+ return "YP_INSTANCE_VARIABLE_READ_NODE";
2433
+ case YP_INSTANCE_VARIABLE_TARGET_NODE:
2434
+ return "YP_INSTANCE_VARIABLE_TARGET_NODE";
2435
+ case YP_INSTANCE_VARIABLE_WRITE_NODE:
2436
+ return "YP_INSTANCE_VARIABLE_WRITE_NODE";
2437
+ case YP_INTEGER_NODE:
2438
+ return "YP_INTEGER_NODE";
2439
+ case YP_INTERPOLATED_MATCH_LAST_LINE_NODE:
2440
+ return "YP_INTERPOLATED_MATCH_LAST_LINE_NODE";
2441
+ case YP_INTERPOLATED_REGULAR_EXPRESSION_NODE:
2442
+ return "YP_INTERPOLATED_REGULAR_EXPRESSION_NODE";
2443
+ case YP_INTERPOLATED_STRING_NODE:
2444
+ return "YP_INTERPOLATED_STRING_NODE";
2445
+ case YP_INTERPOLATED_SYMBOL_NODE:
2446
+ return "YP_INTERPOLATED_SYMBOL_NODE";
2447
+ case YP_INTERPOLATED_X_STRING_NODE:
2448
+ return "YP_INTERPOLATED_X_STRING_NODE";
2449
+ case YP_KEYWORD_HASH_NODE:
2450
+ return "YP_KEYWORD_HASH_NODE";
2451
+ case YP_KEYWORD_PARAMETER_NODE:
2452
+ return "YP_KEYWORD_PARAMETER_NODE";
2453
+ case YP_KEYWORD_REST_PARAMETER_NODE:
2454
+ return "YP_KEYWORD_REST_PARAMETER_NODE";
2455
+ case YP_LAMBDA_NODE:
2456
+ return "YP_LAMBDA_NODE";
2457
+ case YP_LOCAL_VARIABLE_AND_WRITE_NODE:
2458
+ return "YP_LOCAL_VARIABLE_AND_WRITE_NODE";
2459
+ case YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
2460
+ return "YP_LOCAL_VARIABLE_OPERATOR_WRITE_NODE";
2461
+ case YP_LOCAL_VARIABLE_OR_WRITE_NODE:
2462
+ return "YP_LOCAL_VARIABLE_OR_WRITE_NODE";
2463
+ case YP_LOCAL_VARIABLE_READ_NODE:
2464
+ return "YP_LOCAL_VARIABLE_READ_NODE";
2465
+ case YP_LOCAL_VARIABLE_TARGET_NODE:
2466
+ return "YP_LOCAL_VARIABLE_TARGET_NODE";
2467
+ case YP_LOCAL_VARIABLE_WRITE_NODE:
2468
+ return "YP_LOCAL_VARIABLE_WRITE_NODE";
2469
+ case YP_MATCH_LAST_LINE_NODE:
2470
+ return "YP_MATCH_LAST_LINE_NODE";
2471
+ case YP_MATCH_PREDICATE_NODE:
2472
+ return "YP_MATCH_PREDICATE_NODE";
2473
+ case YP_MATCH_REQUIRED_NODE:
2474
+ return "YP_MATCH_REQUIRED_NODE";
2475
+ case YP_MATCH_WRITE_NODE:
2476
+ return "YP_MATCH_WRITE_NODE";
2477
+ case YP_MISSING_NODE:
2478
+ return "YP_MISSING_NODE";
2479
+ case YP_MODULE_NODE:
2480
+ return "YP_MODULE_NODE";
2481
+ case YP_MULTI_TARGET_NODE:
2482
+ return "YP_MULTI_TARGET_NODE";
2483
+ case YP_MULTI_WRITE_NODE:
2484
+ return "YP_MULTI_WRITE_NODE";
2485
+ case YP_NEXT_NODE:
2486
+ return "YP_NEXT_NODE";
2487
+ case YP_NIL_NODE:
2488
+ return "YP_NIL_NODE";
2489
+ case YP_NO_KEYWORDS_PARAMETER_NODE:
2490
+ return "YP_NO_KEYWORDS_PARAMETER_NODE";
2491
+ case YP_NUMBERED_REFERENCE_READ_NODE:
2492
+ return "YP_NUMBERED_REFERENCE_READ_NODE";
2493
+ case YP_OPTIONAL_PARAMETER_NODE:
2494
+ return "YP_OPTIONAL_PARAMETER_NODE";
2495
+ case YP_OR_NODE:
2496
+ return "YP_OR_NODE";
2497
+ case YP_PARAMETERS_NODE:
2498
+ return "YP_PARAMETERS_NODE";
2499
+ case YP_PARENTHESES_NODE:
2500
+ return "YP_PARENTHESES_NODE";
2501
+ case YP_PINNED_EXPRESSION_NODE:
2502
+ return "YP_PINNED_EXPRESSION_NODE";
2503
+ case YP_PINNED_VARIABLE_NODE:
2504
+ return "YP_PINNED_VARIABLE_NODE";
2505
+ case YP_POST_EXECUTION_NODE:
2506
+ return "YP_POST_EXECUTION_NODE";
2507
+ case YP_PRE_EXECUTION_NODE:
2508
+ return "YP_PRE_EXECUTION_NODE";
2509
+ case YP_PROGRAM_NODE:
2510
+ return "YP_PROGRAM_NODE";
2511
+ case YP_RANGE_NODE:
2512
+ return "YP_RANGE_NODE";
2513
+ case YP_RATIONAL_NODE:
2514
+ return "YP_RATIONAL_NODE";
2515
+ case YP_REDO_NODE:
2516
+ return "YP_REDO_NODE";
2517
+ case YP_REGULAR_EXPRESSION_NODE:
2518
+ return "YP_REGULAR_EXPRESSION_NODE";
2519
+ case YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE:
2520
+ return "YP_REQUIRED_DESTRUCTURED_PARAMETER_NODE";
2521
+ case YP_REQUIRED_PARAMETER_NODE:
2522
+ return "YP_REQUIRED_PARAMETER_NODE";
2523
+ case YP_RESCUE_MODIFIER_NODE:
2524
+ return "YP_RESCUE_MODIFIER_NODE";
2525
+ case YP_RESCUE_NODE:
2526
+ return "YP_RESCUE_NODE";
2527
+ case YP_REST_PARAMETER_NODE:
2528
+ return "YP_REST_PARAMETER_NODE";
2529
+ case YP_RETRY_NODE:
2530
+ return "YP_RETRY_NODE";
2531
+ case YP_RETURN_NODE:
2532
+ return "YP_RETURN_NODE";
2533
+ case YP_SELF_NODE:
2534
+ return "YP_SELF_NODE";
2535
+ case YP_SINGLETON_CLASS_NODE:
2536
+ return "YP_SINGLETON_CLASS_NODE";
2537
+ case YP_SOURCE_ENCODING_NODE:
2538
+ return "YP_SOURCE_ENCODING_NODE";
2539
+ case YP_SOURCE_FILE_NODE:
2540
+ return "YP_SOURCE_FILE_NODE";
2541
+ case YP_SOURCE_LINE_NODE:
2542
+ return "YP_SOURCE_LINE_NODE";
2543
+ case YP_SPLAT_NODE:
2544
+ return "YP_SPLAT_NODE";
2545
+ case YP_STATEMENTS_NODE:
2546
+ return "YP_STATEMENTS_NODE";
2547
+ case YP_STRING_CONCAT_NODE:
2548
+ return "YP_STRING_CONCAT_NODE";
2549
+ case YP_STRING_NODE:
2550
+ return "YP_STRING_NODE";
2551
+ case YP_SUPER_NODE:
2552
+ return "YP_SUPER_NODE";
2553
+ case YP_SYMBOL_NODE:
2554
+ return "YP_SYMBOL_NODE";
2555
+ case YP_TRUE_NODE:
2556
+ return "YP_TRUE_NODE";
2557
+ case YP_UNDEF_NODE:
2558
+ return "YP_UNDEF_NODE";
2559
+ case YP_UNLESS_NODE:
2560
+ return "YP_UNLESS_NODE";
2561
+ case YP_UNTIL_NODE:
2562
+ return "YP_UNTIL_NODE";
2563
+ case YP_WHEN_NODE:
2564
+ return "YP_WHEN_NODE";
2565
+ case YP_WHILE_NODE:
2566
+ return "YP_WHILE_NODE";
2567
+ case YP_X_STRING_NODE:
2568
+ return "YP_X_STRING_NODE";
2569
+ case YP_YIELD_NODE:
2570
+ return "YP_YIELD_NODE";
2459
2571
  }
2460
2572
  return "";
2461
2573
  }