yarp 0.8.0 → 0.10.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (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
  }