yarp 0.9.0 → 0.11.0

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