yarp 0.10.0 → 0.11.0

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