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