yarp 0.8.0 → 0.10.0

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