yarp 0.9.0 → 0.10.0

data/src/node.c

@@ -84,722 +84,960 @@ YP_EXPORTED_FUNCTION void
 yp_node_destroy(yp_parser_t *parser, yp_node_t *node) {
     switch (YP_NODE_TYPE(node)) {
 #line 81 "node.c.erb"
-        case YP_NODE_ALIAS_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_alias_node_t *)node)->new_name);
-            yp_node_destroy(parser, (yp_node_t *)((yp_alias_node_t *)node)->old_name);
+        case YP_NODE_ALIAS_NODE: {
+            yp_alias_node_t *cast = (yp_alias_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->new_name);
+            yp_node_destroy(parser, (yp_node_t *)cast->old_name);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ALTERNATION_PATTERN_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->left);
-            yp_node_destroy(parser, (yp_node_t *)((yp_alternation_pattern_node_t *)node)->right);
+        case YP_NODE_ALTERNATION_PATTERN_NODE: {
+            yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->left);
+            yp_node_destroy(parser, (yp_node_t *)cast->right);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_AND_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_and_node_t *)node)->left);
-            yp_node_destroy(parser, (yp_node_t *)((yp_and_node_t *)node)->right);
+        case YP_NODE_AND_NODE: {
+            yp_and_node_t *cast = (yp_and_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->left);
+            yp_node_destroy(parser, (yp_node_t *)cast->right);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ARGUMENTS_NODE:
-            yp_node_list_free(parser, &((yp_arguments_node_t *)node)->arguments);
+        case YP_NODE_ARGUMENTS_NODE: {
+            yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
+            yp_node_list_free(parser, &cast->arguments);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ARRAY_NODE:
-            yp_node_list_free(parser, &((yp_array_node_t *)node)->elements);
+        case YP_NODE_ARRAY_NODE: {
+            yp_array_node_t *cast = (yp_array_node_t *) node;
+            yp_node_list_free(parser, &cast->elements);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ARRAY_PATTERN_NODE:
-            if (((yp_array_pattern_node_t *)node)->constant != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_array_pattern_node_t *)node)->constant);
+        case YP_NODE_ARRAY_PATTERN_NODE: {
+            yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
+            if (cast->constant != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->constant);
             }
-            yp_node_list_free(parser, &((yp_array_pattern_node_t *)node)->requireds);
-            if (((yp_array_pattern_node_t *)node)->rest != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_array_pattern_node_t *)node)->rest);
+            yp_node_list_free(parser, &cast->requireds);
+            if (cast->rest != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->rest);
             }
-            yp_node_list_free(parser, &((yp_array_pattern_node_t *)node)->posts);
+            yp_node_list_free(parser, &cast->posts);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ASSOC_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_assoc_node_t *)node)->key);
-            if (((yp_assoc_node_t *)node)->value != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_assoc_node_t *)node)->value);
+        case YP_NODE_ASSOC_NODE: {
+            yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->key);
+            if (cast->value != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->value);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ASSOC_SPLAT_NODE:
-            if (((yp_assoc_splat_node_t *)node)->value != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_assoc_splat_node_t *)node)->value);
+        case YP_NODE_ASSOC_SPLAT_NODE: {
+            yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
+            if (cast->value != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->value);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_BACK_REFERENCE_READ_NODE:
+        case YP_NODE_BACK_REFERENCE_READ_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_BEGIN_NODE:
-            if (((yp_begin_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_begin_node_t *)node)->statements);
+        case YP_NODE_BEGIN_NODE: {
+            yp_begin_node_t *cast = (yp_begin_node_t *) node;
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
-            if (((yp_begin_node_t *)node)->rescue_clause != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_begin_node_t *)node)->rescue_clause);
+            if (cast->rescue_clause != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->rescue_clause);
             }
-            if (((yp_begin_node_t *)node)->else_clause != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_begin_node_t *)node)->else_clause);
+            if (cast->else_clause != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->else_clause);
             }
-            if (((yp_begin_node_t *)node)->ensure_clause != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_begin_node_t *)node)->ensure_clause);
+            if (cast->ensure_clause != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->ensure_clause);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_BLOCK_ARGUMENT_NODE:
-            if (((yp_block_argument_node_t *)node)->expression != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_block_argument_node_t *)node)->expression);
+        case YP_NODE_BLOCK_ARGUMENT_NODE: {
+            yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
+            if (cast->expression != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->expression);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_BLOCK_NODE:
-            yp_constant_id_list_free(&((yp_block_node_t *)node)->locals);
-            if (((yp_block_node_t *)node)->parameters != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_block_node_t *)node)->parameters);
+        case YP_NODE_BLOCK_NODE: {
+            yp_block_node_t *cast = (yp_block_node_t *) node;
+            yp_constant_id_list_free(&cast->locals);
+            if (cast->parameters != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->parameters);
             }
-            if (((yp_block_node_t *)node)->body != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_block_node_t *)node)->body);
+            if (cast->body != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->body);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_BLOCK_PARAMETER_NODE:
+        case YP_NODE_BLOCK_PARAMETER_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_BLOCK_PARAMETERS_NODE:
-            if (((yp_block_parameters_node_t *)node)->parameters != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_block_parameters_node_t *)node)->parameters);
+        case YP_NODE_BLOCK_PARAMETERS_NODE: {
+            yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
+            if (cast->parameters != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->parameters);
             }
-            yp_location_list_free(&((yp_block_parameters_node_t *)node)->locals);
+            yp_location_list_free(&cast->locals);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_BREAK_NODE:
-            if (((yp_break_node_t *)node)->arguments != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_break_node_t *)node)->arguments);
+        case YP_NODE_BREAK_NODE: {
+            yp_break_node_t *cast = (yp_break_node_t *) node;
+            if (cast->arguments != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->arguments);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CALL_NODE:
-            if (((yp_call_node_t *)node)->receiver != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_call_node_t *)node)->receiver);
+        case YP_NODE_CALL_NODE: {
+            yp_call_node_t *cast = (yp_call_node_t *) node;
+            if (cast->receiver != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->receiver);
             }
-            if (((yp_call_node_t *)node)->arguments != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_call_node_t *)node)->arguments);
+            if (cast->arguments != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->arguments);
             }
-            if (((yp_call_node_t *)node)->block != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_call_node_t *)node)->block);
+            if (cast->block != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->block);
             }
-            yp_string_free(&((yp_call_node_t *)node)->name);
+            yp_string_free(&cast->name);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_call_operator_and_write_node_t *)node)->target);
-            yp_node_destroy(parser, (yp_node_t *)((yp_call_operator_and_write_node_t *)node)->value);
+        case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
+            yp_call_operator_and_write_node_t *cast = (yp_call_operator_and_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_call_operator_or_write_node_t *)node)->target);
-            yp_node_destroy(parser, (yp_node_t *)((yp_call_operator_or_write_node_t *)node)->value);
+        case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
+            yp_call_operator_or_write_node_t *cast = (yp_call_operator_or_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CALL_OPERATOR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->target);
-            yp_node_destroy(parser, (yp_node_t *)((yp_call_operator_write_node_t *)node)->value);
+        case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
+            yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CAPTURE_PATTERN_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->value);
-            yp_node_destroy(parser, (yp_node_t *)((yp_capture_pattern_node_t *)node)->target);
+        case YP_NODE_CAPTURE_PATTERN_NODE: {
+            yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CASE_NODE:
-            if (((yp_case_node_t *)node)->predicate != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_case_node_t *)node)->predicate);
+        case YP_NODE_CASE_NODE: {
+            yp_case_node_t *cast = (yp_case_node_t *) node;
+            if (cast->predicate != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->predicate);
             }
-            yp_node_list_free(parser, &((yp_case_node_t *)node)->conditions);
-            if (((yp_case_node_t *)node)->consequent != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_case_node_t *)node)->consequent);
+            yp_node_list_free(parser, &cast->conditions);
+            if (cast->consequent != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->consequent);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CLASS_NODE:
-            yp_constant_id_list_free(&((yp_class_node_t *)node)->locals);
-            yp_node_destroy(parser, (yp_node_t *)((yp_class_node_t *)node)->constant_path);
-            if (((yp_class_node_t *)node)->superclass != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_class_node_t *)node)->superclass);
+        case YP_NODE_CLASS_NODE: {
+            yp_class_node_t *cast = (yp_class_node_t *) node;
+            yp_constant_id_list_free(&cast->locals);
+            yp_node_destroy(parser, (yp_node_t *)cast->constant_path);
+            if (cast->superclass != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->superclass);
             }
-            if (((yp_class_node_t *)node)->body != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_class_node_t *)node)->body);
+            if (cast->body != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->body);
             }
-            yp_string_free(&((yp_class_node_t *)node)->name);
+            yp_string_free(&cast->name);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_and_write_node_t *)node)->value);
+        case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
+            yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_operator_write_node_t *)node)->value);
+        case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
+            yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_or_write_node_t *)node)->value);
+        case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
+            yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CLASS_VARIABLE_READ_NODE:
+        case YP_NODE_CLASS_VARIABLE_READ_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CLASS_VARIABLE_TARGET_NODE:
+        case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CLASS_VARIABLE_WRITE_NODE:
-            if (((yp_class_variable_write_node_t *)node)->value != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_class_variable_write_node_t *)node)->value);
+        case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
+            yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
+            if (cast->value != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->value);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_AND_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_and_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_AND_WRITE_NODE: {
+            yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_operator_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
+            yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_OR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_or_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_OR_WRITE_NODE: {
+            yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->target);
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_and_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
+            yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_PATH_NODE:
-            if (((yp_constant_path_node_t *)node)->parent != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_node_t *)node)->parent);
+        case YP_NODE_CONSTANT_PATH_NODE: {
+            yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
+            if (cast->parent != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->parent);
             }
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_node_t *)node)->child);
+            yp_node_destroy(parser, (yp_node_t *)cast->child);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target);
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
+            yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->target);
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_or_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
+            yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_PATH_TARGET_NODE:
-            if (((yp_constant_path_target_node_t *)node)->parent != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_target_node_t *)node)->parent);
+        case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
+            yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
+            if (cast->parent != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->parent);
             }
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_target_node_t *)node)->child);
+            yp_node_destroy(parser, (yp_node_t *)cast->child);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_PATH_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->target);
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_path_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
+            yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->target);
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_READ_NODE:
+        case YP_NODE_CONSTANT_READ_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_TARGET_NODE:
+        case YP_NODE_CONSTANT_TARGET_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_CONSTANT_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_constant_write_node_t *)node)->value);
+        case YP_NODE_CONSTANT_WRITE_NODE: {
+            yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_DEF_NODE:
-            if (((yp_def_node_t *)node)->receiver != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_def_node_t *)node)->receiver);
+        case YP_NODE_DEF_NODE: {
+            yp_def_node_t *cast = (yp_def_node_t *) node;
+            if (cast->receiver != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->receiver);
             }
-            if (((yp_def_node_t *)node)->parameters != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_def_node_t *)node)->parameters);
+            if (cast->parameters != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->parameters);
             }
-            if (((yp_def_node_t *)node)->body != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_def_node_t *)node)->body);
+            if (cast->body != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->body);
             }
-            yp_constant_id_list_free(&((yp_def_node_t *)node)->locals);
+            yp_constant_id_list_free(&cast->locals);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_DEFINED_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_defined_node_t *)node)->value);
+        case YP_NODE_DEFINED_NODE: {
+            yp_defined_node_t *cast = (yp_defined_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ELSE_NODE:
-            if (((yp_else_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_else_node_t *)node)->statements);
+        case YP_NODE_ELSE_NODE: {
+            yp_else_node_t *cast = (yp_else_node_t *) node;
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_EMBEDDED_STATEMENTS_NODE:
-            if (((yp_embedded_statements_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_embedded_statements_node_t *)node)->statements);
+        case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
+            yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_EMBEDDED_VARIABLE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_embedded_variable_node_t *)node)->variable);
+        case YP_NODE_EMBEDDED_VARIABLE_NODE: {
+            yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->variable);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_ENSURE_NODE:
-            if (((yp_ensure_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_ensure_node_t *)node)->statements);
+        case YP_NODE_ENSURE_NODE: {
+            yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FALSE_NODE:
+        case YP_NODE_FALSE_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FIND_PATTERN_NODE:
-            if (((yp_find_pattern_node_t *)node)->constant != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_find_pattern_node_t *)node)->constant);
+        case YP_NODE_FIND_PATTERN_NODE: {
+            yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
+            if (cast->constant != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->constant);
             }
-            yp_node_destroy(parser, (yp_node_t *)((yp_find_pattern_node_t *)node)->left);
-            yp_node_list_free(parser, &((yp_find_pattern_node_t *)node)->requireds);
-            yp_node_destroy(parser, (yp_node_t *)((yp_find_pattern_node_t *)node)->right);
+            yp_node_destroy(parser, (yp_node_t *)cast->left);
+            yp_node_list_free(parser, &cast->requireds);
+            yp_node_destroy(parser, (yp_node_t *)cast->right);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FLIP_FLOP_NODE:
-            if (((yp_flip_flop_node_t *)node)->left != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_flip_flop_node_t *)node)->left);
+        case YP_NODE_FLIP_FLOP_NODE: {
+            yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
+            if (cast->left != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->left);
             }
-            if (((yp_flip_flop_node_t *)node)->right != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_flip_flop_node_t *)node)->right);
+            if (cast->right != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->right);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FLOAT_NODE:
+        case YP_NODE_FLOAT_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FOR_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_for_node_t *)node)->index);
-            yp_node_destroy(parser, (yp_node_t *)((yp_for_node_t *)node)->collection);
-            if (((yp_for_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_for_node_t *)node)->statements);
+        case YP_NODE_FOR_NODE: {
+            yp_for_node_t *cast = (yp_for_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->index);
+            yp_node_destroy(parser, (yp_node_t *)cast->collection);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FORWARDING_ARGUMENTS_NODE:
+        case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FORWARDING_PARAMETER_NODE:
+        case YP_NODE_FORWARDING_PARAMETER_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_FORWARDING_SUPER_NODE:
-            if (((yp_forwarding_super_node_t *)node)->block != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_forwarding_super_node_t *)node)->block);
+        case YP_NODE_FORWARDING_SUPER_NODE: {
+            yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
+            if (cast->block != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->block);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_and_write_node_t *)node)->value);
+        case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
+            yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value);
+        case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
+            yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_or_write_node_t *)node)->value);
+        case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
+            yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_GLOBAL_VARIABLE_READ_NODE:
+        case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE:
+        case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_global_variable_write_node_t *)node)->value);
+        case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
+            yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_HASH_NODE:
-            yp_node_list_free(parser, &((yp_hash_node_t *)node)->elements);
+        case YP_NODE_HASH_NODE: {
+            yp_hash_node_t *cast = (yp_hash_node_t *) node;
+            yp_node_list_free(parser, &cast->elements);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_HASH_PATTERN_NODE:
-            if (((yp_hash_pattern_node_t *)node)->constant != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_hash_pattern_node_t *)node)->constant);
+        case YP_NODE_HASH_PATTERN_NODE: {
+            yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
+            if (cast->constant != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->constant);
             }
-            yp_node_list_free(parser, &((yp_hash_pattern_node_t *)node)->assocs);
-            if (((yp_hash_pattern_node_t *)node)->kwrest != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_hash_pattern_node_t *)node)->kwrest);
+            yp_node_list_free(parser, &cast->assocs);
+            if (cast->kwrest != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->kwrest);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_IF_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_if_node_t *)node)->predicate);
-            if (((yp_if_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_if_node_t *)node)->statements);
+        case YP_NODE_IF_NODE: {
+            yp_if_node_t *cast = (yp_if_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->predicate);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
-            if (((yp_if_node_t *)node)->consequent != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_if_node_t *)node)->consequent);
+            if (cast->consequent != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->consequent);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_IMAGINARY_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_imaginary_node_t *)node)->numeric);
+        case YP_NODE_IMAGINARY_NODE: {
+            yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->numeric);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_IN_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_in_node_t *)node)->pattern);
-            if (((yp_in_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_in_node_t *)node)->statements);
+        case YP_NODE_IN_NODE: {
+            yp_in_node_t *cast = (yp_in_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->pattern);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_and_write_node_t *)node)->value);
+        case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
+            yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_operator_write_node_t *)node)->value);
+        case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
+            yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_or_write_node_t *)node)->value);
+        case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
+            yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INSTANCE_VARIABLE_READ_NODE:
+        case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE:
+        case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_instance_variable_write_node_t *)node)->value);
+        case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
+            yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INTEGER_NODE:
+        case YP_NODE_INTEGER_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE:
-            yp_node_list_free(parser, &((yp_interpolated_regular_expression_node_t *)node)->parts);
+        case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
+            yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
+            yp_node_list_free(parser, &cast->parts);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INTERPOLATED_STRING_NODE:
-            yp_node_list_free(parser, &((yp_interpolated_string_node_t *)node)->parts);
+        case YP_NODE_INTERPOLATED_STRING_NODE: {
+            yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
+            yp_node_list_free(parser, &cast->parts);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INTERPOLATED_SYMBOL_NODE:
-            yp_node_list_free(parser, &((yp_interpolated_symbol_node_t *)node)->parts);
+        case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
+            yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
+            yp_node_list_free(parser, &cast->parts);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_INTERPOLATED_X_STRING_NODE:
-            yp_node_list_free(parser, &((yp_interpolated_x_string_node_t *)node)->parts);
+        case YP_NODE_INTERPOLATED_X_STRING_NODE: {
+            yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
+            yp_node_list_free(parser, &cast->parts);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_KEYWORD_HASH_NODE:
-            yp_node_list_free(parser, &((yp_keyword_hash_node_t *)node)->elements);
+        case YP_NODE_KEYWORD_HASH_NODE: {
+            yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
+            yp_node_list_free(parser, &cast->elements);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_KEYWORD_PARAMETER_NODE:
-            if (((yp_keyword_parameter_node_t *)node)->value != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_keyword_parameter_node_t *)node)->value);
+        case YP_NODE_KEYWORD_PARAMETER_NODE: {
+            yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
+            if (cast->value != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->value);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_KEYWORD_REST_PARAMETER_NODE:
+        case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_LAMBDA_NODE:
-            yp_constant_id_list_free(&((yp_lambda_node_t *)node)->locals);
-            if (((yp_lambda_node_t *)node)->parameters != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_lambda_node_t *)node)->parameters);
+        case YP_NODE_LAMBDA_NODE: {
+            yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
+            yp_constant_id_list_free(&cast->locals);
+            if (cast->parameters != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->parameters);
             }
-            if (((yp_lambda_node_t *)node)->body != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_lambda_node_t *)node)->body);
+            if (cast->body != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->body);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_and_write_node_t *)node)->value);
+        case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
+            yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value);
+        case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
+            yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_or_write_node_t *)node)->value);
+        case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
+            yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_LOCAL_VARIABLE_READ_NODE:
+        case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_LOCAL_VARIABLE_TARGET_NODE:
+        case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_LOCAL_VARIABLE_WRITE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_local_variable_write_node_t *)node)->value);
+        case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
+            yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_MATCH_PREDICATE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->value);
-            yp_node_destroy(parser, (yp_node_t *)((yp_match_predicate_node_t *)node)->pattern);
+        case YP_NODE_MATCH_PREDICATE_NODE: {
+            yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
+            yp_node_destroy(parser, (yp_node_t *)cast->pattern);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_MATCH_REQUIRED_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_match_required_node_t *)node)->value);
-            yp_node_destroy(parser, (yp_node_t *)((yp_match_required_node_t *)node)->pattern);
+        case YP_NODE_MATCH_REQUIRED_NODE: {
+            yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
+            yp_node_destroy(parser, (yp_node_t *)cast->pattern);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_MISSING_NODE:
+        case YP_NODE_MISSING_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_MODULE_NODE:
-            yp_constant_id_list_free(&((yp_module_node_t *)node)->locals);
-            yp_node_destroy(parser, (yp_node_t *)((yp_module_node_t *)node)->constant_path);
-            if (((yp_module_node_t *)node)->body != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_module_node_t *)node)->body);
+        case YP_NODE_MODULE_NODE: {
+            yp_module_node_t *cast = (yp_module_node_t *) node;
+            yp_constant_id_list_free(&cast->locals);
+            yp_node_destroy(parser, (yp_node_t *)cast->constant_path);
+            if (cast->body != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->body);
             }
-            yp_string_free(&((yp_module_node_t *)node)->name);
+            yp_string_free(&cast->name);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_MULTI_WRITE_NODE:
-            yp_node_list_free(parser, &((yp_multi_write_node_t *)node)->targets);
-            if (((yp_multi_write_node_t *)node)->value != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_multi_write_node_t *)node)->value);
+        case YP_NODE_MULTI_WRITE_NODE: {
+            yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
+            yp_node_list_free(parser, &cast->targets);
+            if (cast->value != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->value);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_NEXT_NODE:
-            if (((yp_next_node_t *)node)->arguments != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_next_node_t *)node)->arguments);
+        case YP_NODE_NEXT_NODE: {
+            yp_next_node_t *cast = (yp_next_node_t *) node;
+            if (cast->arguments != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->arguments);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_NIL_NODE:
+        case YP_NODE_NIL_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_NO_KEYWORDS_PARAMETER_NODE:
+        case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_NUMBERED_REFERENCE_READ_NODE:
+        case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_OPTIONAL_PARAMETER_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_optional_parameter_node_t *)node)->value);
+        case YP_NODE_OPTIONAL_PARAMETER_NODE: {
+            yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->value);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_OR_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_or_node_t *)node)->left);
-            yp_node_destroy(parser, (yp_node_t *)((yp_or_node_t *)node)->right);
+        case YP_NODE_OR_NODE: {
+            yp_or_node_t *cast = (yp_or_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->left);
+            yp_node_destroy(parser, (yp_node_t *)cast->right);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_PARAMETERS_NODE:
-            yp_node_list_free(parser, &((yp_parameters_node_t *)node)->requireds);
-            yp_node_list_free(parser, &((yp_parameters_node_t *)node)->optionals);
-            yp_node_list_free(parser, &((yp_parameters_node_t *)node)->posts);
-            if (((yp_parameters_node_t *)node)->rest != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_parameters_node_t *)node)->rest);
+        case YP_NODE_PARAMETERS_NODE: {
+            yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
+            yp_node_list_free(parser, &cast->requireds);
+            yp_node_list_free(parser, &cast->optionals);
+            yp_node_list_free(parser, &cast->posts);
+            if (cast->rest != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->rest);
             }
-            yp_node_list_free(parser, &((yp_parameters_node_t *)node)->keywords);
-            if (((yp_parameters_node_t *)node)->keyword_rest != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_parameters_node_t *)node)->keyword_rest);
+            yp_node_list_free(parser, &cast->keywords);
+            if (cast->keyword_rest != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->keyword_rest);
             }
-            if (((yp_parameters_node_t *)node)->block != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_parameters_node_t *)node)->block);
+            if (cast->block != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->block);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_PARENTHESES_NODE:
-            if (((yp_parentheses_node_t *)node)->body != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_parentheses_node_t *)node)->body);
+        case YP_NODE_PARENTHESES_NODE: {
+            yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
+            if (cast->body != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->body);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_PINNED_EXPRESSION_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_pinned_expression_node_t *)node)->expression);
+        case YP_NODE_PINNED_EXPRESSION_NODE: {
+            yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->expression);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_PINNED_VARIABLE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_pinned_variable_node_t *)node)->variable);
+        case YP_NODE_PINNED_VARIABLE_NODE: {
+            yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->variable);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_POST_EXECUTION_NODE:
-            if (((yp_post_execution_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_post_execution_node_t *)node)->statements);
+        case YP_NODE_POST_EXECUTION_NODE: {
+            yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_PRE_EXECUTION_NODE:
-            if (((yp_pre_execution_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_pre_execution_node_t *)node)->statements);
+        case YP_NODE_PRE_EXECUTION_NODE: {
+            yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_PROGRAM_NODE:
-            yp_constant_id_list_free(&((yp_program_node_t *)node)->locals);
-            yp_node_destroy(parser, (yp_node_t *)((yp_program_node_t *)node)->statements);
+        case YP_NODE_PROGRAM_NODE: {
+            yp_program_node_t *cast = (yp_program_node_t *) node;
+            yp_constant_id_list_free(&cast->locals);
+            yp_node_destroy(parser, (yp_node_t *)cast->statements);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_RANGE_NODE:
-            if (((yp_range_node_t *)node)->left != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_range_node_t *)node)->left);
+        case YP_NODE_RANGE_NODE: {
+            yp_range_node_t *cast = (yp_range_node_t *) node;
+            if (cast->left != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->left);
             }
-            if (((yp_range_node_t *)node)->right != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_range_node_t *)node)->right);
+            if (cast->right != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->right);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_RATIONAL_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_rational_node_t *)node)->numeric);
+        case YP_NODE_RATIONAL_NODE: {
+            yp_rational_node_t *cast = (yp_rational_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->numeric);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_REDO_NODE:
+        case YP_NODE_REDO_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_REGULAR_EXPRESSION_NODE:
-            yp_string_free(&((yp_regular_expression_node_t *)node)->unescaped);
+        case YP_NODE_REGULAR_EXPRESSION_NODE: {
+            yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
+            yp_string_free(&cast->unescaped);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE:
-            yp_node_list_free(parser, &((yp_required_destructured_parameter_node_t *)node)->parameters);
+        case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
+            yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
+            yp_node_list_free(parser, &cast->parameters);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_REQUIRED_PARAMETER_NODE:
+        case YP_NODE_REQUIRED_PARAMETER_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_RESCUE_MODIFIER_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->expression);
-            yp_node_destroy(parser, (yp_node_t *)((yp_rescue_modifier_node_t *)node)->rescue_expression);
+        case YP_NODE_RESCUE_MODIFIER_NODE: {
+            yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->expression);
+            yp_node_destroy(parser, (yp_node_t *)cast->rescue_expression);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_RESCUE_NODE:
-            yp_node_list_free(parser, &((yp_rescue_node_t *)node)->exceptions);
-            if (((yp_rescue_node_t *)node)->reference != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_rescue_node_t *)node)->reference);
+        case YP_NODE_RESCUE_NODE: {
+            yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
+            yp_node_list_free(parser, &cast->exceptions);
+            if (cast->reference != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->reference);
             }
-            if (((yp_rescue_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_rescue_node_t *)node)->statements);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
-            if (((yp_rescue_node_t *)node)->consequent != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_rescue_node_t *)node)->consequent);
+            if (cast->consequent != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->consequent);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_REST_PARAMETER_NODE:
+        case YP_NODE_REST_PARAMETER_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_RETRY_NODE:
+        case YP_NODE_RETRY_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_RETURN_NODE:
-            if (((yp_return_node_t *)node)->arguments != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_return_node_t *)node)->arguments);
+        case YP_NODE_RETURN_NODE: {
+            yp_return_node_t *cast = (yp_return_node_t *) node;
+            if (cast->arguments != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->arguments);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SELF_NODE:
+        case YP_NODE_SELF_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SINGLETON_CLASS_NODE:
-            yp_constant_id_list_free(&((yp_singleton_class_node_t *)node)->locals);
-            yp_node_destroy(parser, (yp_node_t *)((yp_singleton_class_node_t *)node)->expression);
-            if (((yp_singleton_class_node_t *)node)->body != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_singleton_class_node_t *)node)->body);
+        case YP_NODE_SINGLETON_CLASS_NODE: {
+            yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
+            yp_constant_id_list_free(&cast->locals);
+            yp_node_destroy(parser, (yp_node_t *)cast->expression);
+            if (cast->body != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->body);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SOURCE_ENCODING_NODE:
+        case YP_NODE_SOURCE_ENCODING_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SOURCE_FILE_NODE:
-            yp_string_free(&((yp_source_file_node_t *)node)->filepath);
+        case YP_NODE_SOURCE_FILE_NODE: {
+            yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
+            yp_string_free(&cast->filepath);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SOURCE_LINE_NODE:
+        case YP_NODE_SOURCE_LINE_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SPLAT_NODE:
-            if (((yp_splat_node_t *)node)->expression != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_splat_node_t *)node)->expression);
+        case YP_NODE_SPLAT_NODE: {
+            yp_splat_node_t *cast = (yp_splat_node_t *) node;
+            if (cast->expression != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->expression);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_STATEMENTS_NODE:
-            yp_node_list_free(parser, &((yp_statements_node_t *)node)->body);
+        case YP_NODE_STATEMENTS_NODE: {
+            yp_statements_node_t *cast = (yp_statements_node_t *) node;
+            yp_node_list_free(parser, &cast->body);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_STRING_CONCAT_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_string_concat_node_t *)node)->left);
-            yp_node_destroy(parser, (yp_node_t *)((yp_string_concat_node_t *)node)->right);
+        case YP_NODE_STRING_CONCAT_NODE: {
+            yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->left);
+            yp_node_destroy(parser, (yp_node_t *)cast->right);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_STRING_NODE:
-            yp_string_free(&((yp_string_node_t *)node)->unescaped);
+        case YP_NODE_STRING_NODE: {
+            yp_string_node_t *cast = (yp_string_node_t *) node;
+            yp_string_free(&cast->unescaped);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SUPER_NODE:
-            if (((yp_super_node_t *)node)->arguments != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_super_node_t *)node)->arguments);
+        case YP_NODE_SUPER_NODE: {
+            yp_super_node_t *cast = (yp_super_node_t *) node;
+            if (cast->arguments != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->arguments);
             }
-            if (((yp_super_node_t *)node)->block != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_super_node_t *)node)->block);
+            if (cast->block != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->block);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_SYMBOL_NODE:
-            yp_string_free(&((yp_symbol_node_t *)node)->unescaped);
+        case YP_NODE_SYMBOL_NODE: {
+            yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
+            yp_string_free(&cast->unescaped);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_TRUE_NODE:
+        case YP_NODE_TRUE_NODE: {
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_UNDEF_NODE:
-            yp_node_list_free(parser, &((yp_undef_node_t *)node)->names);
+        case YP_NODE_UNDEF_NODE: {
+            yp_undef_node_t *cast = (yp_undef_node_t *) node;
+            yp_node_list_free(parser, &cast->names);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_UNLESS_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_unless_node_t *)node)->predicate);
-            if (((yp_unless_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_unless_node_t *)node)->statements);
+        case YP_NODE_UNLESS_NODE: {
+            yp_unless_node_t *cast = (yp_unless_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->predicate);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
-            if (((yp_unless_node_t *)node)->consequent != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_unless_node_t *)node)->consequent);
+            if (cast->consequent != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->consequent);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_UNTIL_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_until_node_t *)node)->predicate);
-            if (((yp_until_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_until_node_t *)node)->statements);
+        case YP_NODE_UNTIL_NODE: {
+            yp_until_node_t *cast = (yp_until_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->predicate);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_WHEN_NODE:
-            yp_node_list_free(parser, &((yp_when_node_t *)node)->conditions);
-            if (((yp_when_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_when_node_t *)node)->statements);
+        case YP_NODE_WHEN_NODE: {
+            yp_when_node_t *cast = (yp_when_node_t *) node;
+            yp_node_list_free(parser, &cast->conditions);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_WHILE_NODE:
-            yp_node_destroy(parser, (yp_node_t *)((yp_while_node_t *)node)->predicate);
-            if (((yp_while_node_t *)node)->statements != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_while_node_t *)node)->statements);
+        case YP_NODE_WHILE_NODE: {
+            yp_while_node_t *cast = (yp_while_node_t *) node;
+            yp_node_destroy(parser, (yp_node_t *)cast->predicate);
+            if (cast->statements != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->statements);
             }
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_X_STRING_NODE:
-            yp_string_free(&((yp_x_string_node_t *)node)->unescaped);
+        case YP_NODE_X_STRING_NODE: {
+            yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
+            yp_string_free(&cast->unescaped);
             break;
+        }
 #line 81 "node.c.erb"
-        case YP_NODE_YIELD_NODE:
-            if (((yp_yield_node_t *)node)->arguments != NULL) {
-                yp_node_destroy(parser, (yp_node_t *)((yp_yield_node_t *)node)->arguments);
+        case YP_NODE_YIELD_NODE: {
+            yp_yield_node_t *cast = (yp_yield_node_t *) node;
+            if (cast->arguments != NULL) {
+                yp_node_destroy(parser, (yp_node_t *)cast->arguments);
             }
             break;
-#line 106 "node.c.erb"
+        }
+#line 110 "node.c.erb"
         default:
             assert(false && "unreachable");
             break;
@@ -816,991 +1054,1125 @@ yp_node_memsize_node(yp_node_t *node, yp_memsize_t *memsize) {
         // as it should never be generated
         case YP_NODE_SCOPE_NODE:
             return;
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ALIAS_NODE: {
-            memsize->memsize += sizeof(yp_alias_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_alias_node_t *)node)->new_name, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_alias_node_t *)node)->old_name, memsize);
+            yp_alias_node_t *cast = (yp_alias_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->new_name, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->old_name, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ALTERNATION_PATTERN_NODE: {
-            memsize->memsize += sizeof(yp_alternation_pattern_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_alternation_pattern_node_t *)node)->left, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_alternation_pattern_node_t *)node)->right, memsize);
+            yp_alternation_pattern_node_t *cast = (yp_alternation_pattern_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->left, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->right, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_AND_NODE: {
-            memsize->memsize += sizeof(yp_and_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_and_node_t *)node)->left, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_and_node_t *)node)->right, memsize);
+            yp_and_node_t *cast = (yp_and_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->left, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->right, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ARGUMENTS_NODE: {
-            memsize->memsize += sizeof(yp_arguments_node_t);
-            yp_node_list_memsize(&((yp_arguments_node_t *)node)->arguments, memsize);
+            yp_arguments_node_t *cast = (yp_arguments_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->arguments, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ARRAY_NODE: {
-            memsize->memsize += sizeof(yp_array_node_t);
-            yp_node_list_memsize(&((yp_array_node_t *)node)->elements, memsize);
+            yp_array_node_t *cast = (yp_array_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->elements, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ARRAY_PATTERN_NODE: {
-            memsize->memsize += sizeof(yp_array_pattern_node_t);
-            if (((yp_array_pattern_node_t *)node)->constant != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_array_pattern_node_t *)node)->constant, memsize);
+            yp_array_pattern_node_t *cast = (yp_array_pattern_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->constant != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->constant, memsize);
             }
-            yp_node_list_memsize(&((yp_array_pattern_node_t *)node)->requireds, memsize);
-            if (((yp_array_pattern_node_t *)node)->rest != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_array_pattern_node_t *)node)->rest, memsize);
+            yp_node_list_memsize(&cast->requireds, memsize);
+            if (cast->rest != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->rest, memsize);
             }
-            yp_node_list_memsize(&((yp_array_pattern_node_t *)node)->posts, memsize);
+            yp_node_list_memsize(&cast->posts, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ASSOC_NODE: {
-            memsize->memsize += sizeof(yp_assoc_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_assoc_node_t *)node)->key, memsize);
-            if (((yp_assoc_node_t *)node)->value != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_assoc_node_t *)node)->value, memsize);
+            yp_assoc_node_t *cast = (yp_assoc_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->key, memsize);
+            if (cast->value != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ASSOC_SPLAT_NODE: {
-            memsize->memsize += sizeof(yp_assoc_splat_node_t);
-            if (((yp_assoc_splat_node_t *)node)->value != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_assoc_splat_node_t *)node)->value, memsize);
+            yp_assoc_splat_node_t *cast = (yp_assoc_splat_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->value != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_BACK_REFERENCE_READ_NODE: {
-            memsize->memsize += sizeof(yp_back_reference_read_node_t);
+            yp_back_reference_read_node_t *cast = (yp_back_reference_read_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_BEGIN_NODE: {
-            memsize->memsize += sizeof(yp_begin_node_t);
-            if (((yp_begin_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_begin_node_t *)node)->statements, memsize);
+            yp_begin_node_t *cast = (yp_begin_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
-            if (((yp_begin_node_t *)node)->rescue_clause != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_begin_node_t *)node)->rescue_clause, memsize);
+            if (cast->rescue_clause != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->rescue_clause, memsize);
             }
-            if (((yp_begin_node_t *)node)->else_clause != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_begin_node_t *)node)->else_clause, memsize);
+            if (cast->else_clause != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->else_clause, memsize);
             }
-            if (((yp_begin_node_t *)node)->ensure_clause != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_begin_node_t *)node)->ensure_clause, memsize);
+            if (cast->ensure_clause != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->ensure_clause, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_BLOCK_ARGUMENT_NODE: {
-            memsize->memsize += sizeof(yp_block_argument_node_t);
-            if (((yp_block_argument_node_t *)node)->expression != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_block_argument_node_t *)node)->expression, memsize);
+            yp_block_argument_node_t *cast = (yp_block_argument_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->expression != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_BLOCK_NODE: {
-            memsize->memsize += sizeof(yp_block_node_t);
-            memsize->memsize += yp_constant_id_list_memsize(&((yp_block_node_t *)node)->locals);
-            if (((yp_block_node_t *)node)->parameters != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_block_node_t *)node)->parameters, memsize);
+            yp_block_node_t *cast = (yp_block_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
+            if (cast->parameters != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->parameters, memsize);
             }
-            if (((yp_block_node_t *)node)->body != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_block_node_t *)node)->body, memsize);
+            if (cast->body != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->body, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_BLOCK_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_block_parameter_node_t);
+            yp_block_parameter_node_t *cast = (yp_block_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_BLOCK_PARAMETERS_NODE: {
-            memsize->memsize += sizeof(yp_block_parameters_node_t);
-            if (((yp_block_parameters_node_t *)node)->parameters != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_block_parameters_node_t *)node)->parameters, memsize);
+            yp_block_parameters_node_t *cast = (yp_block_parameters_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->parameters != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->parameters, memsize);
             }
-            memsize->memsize += yp_location_list_memsize(&((yp_block_parameters_node_t *)node)->locals);
+            memsize->memsize += yp_location_list_memsize(&cast->locals);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_BREAK_NODE: {
-            memsize->memsize += sizeof(yp_break_node_t);
-            if (((yp_break_node_t *)node)->arguments != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_break_node_t *)node)->arguments, memsize);
+            yp_break_node_t *cast = (yp_break_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->arguments != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CALL_NODE: {
-            memsize->memsize += sizeof(yp_call_node_t);
-            if (((yp_call_node_t *)node)->receiver != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_call_node_t *)node)->receiver, memsize);
+            yp_call_node_t *cast = (yp_call_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->receiver != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
             }
-            if (((yp_call_node_t *)node)->arguments != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_call_node_t *)node)->arguments, memsize);
+            if (cast->arguments != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
             }
-            if (((yp_call_node_t *)node)->block != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_call_node_t *)node)->block, memsize);
+            if (cast->block != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->block, memsize);
             }
-            memsize->memsize += yp_string_memsize(&((yp_call_node_t *)node)->name);
+            memsize->memsize += yp_string_memsize(&cast->name);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CALL_OPERATOR_AND_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_call_operator_and_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_call_operator_and_write_node_t *)node)->target, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_call_operator_and_write_node_t *)node)->value, memsize);
+            yp_call_operator_and_write_node_t *cast = (yp_call_operator_and_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CALL_OPERATOR_OR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_call_operator_or_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_call_operator_or_write_node_t *)node)->target, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_call_operator_or_write_node_t *)node)->value, memsize);
+            yp_call_operator_or_write_node_t *cast = (yp_call_operator_or_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CALL_OPERATOR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_call_operator_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_call_operator_write_node_t *)node)->target, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_call_operator_write_node_t *)node)->value, memsize);
+            yp_call_operator_write_node_t *cast = (yp_call_operator_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CAPTURE_PATTERN_NODE: {
-            memsize->memsize += sizeof(yp_capture_pattern_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_capture_pattern_node_t *)node)->value, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_capture_pattern_node_t *)node)->target, memsize);
+            yp_capture_pattern_node_t *cast = (yp_capture_pattern_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CASE_NODE: {
-            memsize->memsize += sizeof(yp_case_node_t);
-            if (((yp_case_node_t *)node)->predicate != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_case_node_t *)node)->predicate, memsize);
+            yp_case_node_t *cast = (yp_case_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->predicate != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
             }
-            yp_node_list_memsize(&((yp_case_node_t *)node)->conditions, memsize);
-            if (((yp_case_node_t *)node)->consequent != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_case_node_t *)node)->consequent, memsize);
+            yp_node_list_memsize(&cast->conditions, memsize);
+            if (cast->consequent != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->consequent, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CLASS_NODE: {
-            memsize->memsize += sizeof(yp_class_node_t);
-            memsize->memsize += yp_constant_id_list_memsize(&((yp_class_node_t *)node)->locals);
-            yp_node_memsize_node((yp_node_t *)((yp_class_node_t *)node)->constant_path, memsize);
-            if (((yp_class_node_t *)node)->superclass != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_class_node_t *)node)->superclass, memsize);
+            yp_class_node_t *cast = (yp_class_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
+            yp_node_memsize_node((yp_node_t *)cast->constant_path, memsize);
+            if (cast->superclass != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->superclass, memsize);
             }
-            if (((yp_class_node_t *)node)->body != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_class_node_t *)node)->body, memsize);
+            if (cast->body != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->body, memsize);
             }
-            memsize->memsize += yp_string_memsize(&((yp_class_node_t *)node)->name);
+            memsize->memsize += yp_string_memsize(&cast->name);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CLASS_VARIABLE_AND_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_class_variable_and_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_class_variable_and_write_node_t *)node)->value, memsize);
+            yp_class_variable_and_write_node_t *cast = (yp_class_variable_and_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CLASS_VARIABLE_OPERATOR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_class_variable_operator_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_class_variable_operator_write_node_t *)node)->value, memsize);
+            yp_class_variable_operator_write_node_t *cast = (yp_class_variable_operator_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CLASS_VARIABLE_OR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_class_variable_or_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_class_variable_or_write_node_t *)node)->value, memsize);
+            yp_class_variable_or_write_node_t *cast = (yp_class_variable_or_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CLASS_VARIABLE_READ_NODE: {
-            memsize->memsize += sizeof(yp_class_variable_read_node_t);
+            yp_class_variable_read_node_t *cast = (yp_class_variable_read_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CLASS_VARIABLE_TARGET_NODE: {
-            memsize->memsize += sizeof(yp_class_variable_target_node_t);
+            yp_class_variable_target_node_t *cast = (yp_class_variable_target_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CLASS_VARIABLE_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_class_variable_write_node_t);
-            if (((yp_class_variable_write_node_t *)node)->value != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_class_variable_write_node_t *)node)->value, memsize);
+            yp_class_variable_write_node_t *cast = (yp_class_variable_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->value != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_AND_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_and_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_and_write_node_t *)node)->value, memsize);
+            yp_constant_and_write_node_t *cast = (yp_constant_and_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_OPERATOR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_operator_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_operator_write_node_t *)node)->value, memsize);
+            yp_constant_operator_write_node_t *cast = (yp_constant_operator_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_OR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_or_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_or_write_node_t *)node)->value, memsize);
+            yp_constant_or_write_node_t *cast = (yp_constant_or_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_PATH_AND_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_path_and_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_and_write_node_t *)node)->target, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_and_write_node_t *)node)->value, memsize);
+            yp_constant_path_and_write_node_t *cast = (yp_constant_path_and_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_PATH_NODE: {
-            memsize->memsize += sizeof(yp_constant_path_node_t);
-            if (((yp_constant_path_node_t *)node)->parent != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_constant_path_node_t *)node)->parent, memsize);
+            yp_constant_path_node_t *cast = (yp_constant_path_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->parent != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->parent, memsize);
             }
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_node_t *)node)->child, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->child, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_PATH_OPERATOR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_path_operator_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->target, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_operator_write_node_t *)node)->value, memsize);
+            yp_constant_path_operator_write_node_t *cast = (yp_constant_path_operator_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_PATH_OR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_path_or_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_or_write_node_t *)node)->target, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_or_write_node_t *)node)->value, memsize);
+            yp_constant_path_or_write_node_t *cast = (yp_constant_path_or_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_PATH_TARGET_NODE: {
-            memsize->memsize += sizeof(yp_constant_path_target_node_t);
-            if (((yp_constant_path_target_node_t *)node)->parent != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_constant_path_target_node_t *)node)->parent, memsize);
+            yp_constant_path_target_node_t *cast = (yp_constant_path_target_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->parent != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->parent, memsize);
             }
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_target_node_t *)node)->child, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->child, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_PATH_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_path_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_write_node_t *)node)->target, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_path_write_node_t *)node)->value, memsize);
+            yp_constant_path_write_node_t *cast = (yp_constant_path_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->target, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_READ_NODE: {
-            memsize->memsize += sizeof(yp_constant_read_node_t);
+            yp_constant_read_node_t *cast = (yp_constant_read_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_TARGET_NODE: {
-            memsize->memsize += sizeof(yp_constant_target_node_t);
+            yp_constant_target_node_t *cast = (yp_constant_target_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_CONSTANT_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_constant_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_constant_write_node_t *)node)->value, memsize);
+            yp_constant_write_node_t *cast = (yp_constant_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_DEF_NODE: {
-            memsize->memsize += sizeof(yp_def_node_t);
-            if (((yp_def_node_t *)node)->receiver != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_def_node_t *)node)->receiver, memsize);
+            yp_def_node_t *cast = (yp_def_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->receiver != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->receiver, memsize);
             }
-            if (((yp_def_node_t *)node)->parameters != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_def_node_t *)node)->parameters, memsize);
+            if (cast->parameters != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->parameters, memsize);
             }
-            if (((yp_def_node_t *)node)->body != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_def_node_t *)node)->body, memsize);
+            if (cast->body != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->body, memsize);
             }
-            memsize->memsize += yp_constant_id_list_memsize(&((yp_def_node_t *)node)->locals);
+            memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_DEFINED_NODE: {
-            memsize->memsize += sizeof(yp_defined_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_defined_node_t *)node)->value, memsize);
+            yp_defined_node_t *cast = (yp_defined_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ELSE_NODE: {
-            memsize->memsize += sizeof(yp_else_node_t);
-            if (((yp_else_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_else_node_t *)node)->statements, memsize);
+            yp_else_node_t *cast = (yp_else_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_EMBEDDED_STATEMENTS_NODE: {
-            memsize->memsize += sizeof(yp_embedded_statements_node_t);
-            if (((yp_embedded_statements_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_embedded_statements_node_t *)node)->statements, memsize);
+            yp_embedded_statements_node_t *cast = (yp_embedded_statements_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_EMBEDDED_VARIABLE_NODE: {
-            memsize->memsize += sizeof(yp_embedded_variable_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_embedded_variable_node_t *)node)->variable, memsize);
+            yp_embedded_variable_node_t *cast = (yp_embedded_variable_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->variable, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_ENSURE_NODE: {
-            memsize->memsize += sizeof(yp_ensure_node_t);
-            if (((yp_ensure_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_ensure_node_t *)node)->statements, memsize);
+            yp_ensure_node_t *cast = (yp_ensure_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FALSE_NODE: {
-            memsize->memsize += sizeof(yp_false_node_t);
+            yp_false_node_t *cast = (yp_false_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FIND_PATTERN_NODE: {
-            memsize->memsize += sizeof(yp_find_pattern_node_t);
-            if (((yp_find_pattern_node_t *)node)->constant != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_find_pattern_node_t *)node)->constant, memsize);
+            yp_find_pattern_node_t *cast = (yp_find_pattern_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->constant != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->constant, memsize);
             }
-            yp_node_memsize_node((yp_node_t *)((yp_find_pattern_node_t *)node)->left, memsize);
-            yp_node_list_memsize(&((yp_find_pattern_node_t *)node)->requireds, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_find_pattern_node_t *)node)->right, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->left, memsize);
+            yp_node_list_memsize(&cast->requireds, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->right, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FLIP_FLOP_NODE: {
-            memsize->memsize += sizeof(yp_flip_flop_node_t);
-            if (((yp_flip_flop_node_t *)node)->left != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_flip_flop_node_t *)node)->left, memsize);
+            yp_flip_flop_node_t *cast = (yp_flip_flop_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->left != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->left, memsize);
             }
-            if (((yp_flip_flop_node_t *)node)->right != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_flip_flop_node_t *)node)->right, memsize);
+            if (cast->right != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->right, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FLOAT_NODE: {
-            memsize->memsize += sizeof(yp_float_node_t);
+            yp_float_node_t *cast = (yp_float_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FOR_NODE: {
-            memsize->memsize += sizeof(yp_for_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_for_node_t *)node)->index, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_for_node_t *)node)->collection, memsize);
-            if (((yp_for_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_for_node_t *)node)->statements, memsize);
+            yp_for_node_t *cast = (yp_for_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->index, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->collection, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FORWARDING_ARGUMENTS_NODE: {
-            memsize->memsize += sizeof(yp_forwarding_arguments_node_t);
+            yp_forwarding_arguments_node_t *cast = (yp_forwarding_arguments_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FORWARDING_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_forwarding_parameter_node_t);
+            yp_forwarding_parameter_node_t *cast = (yp_forwarding_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_FORWARDING_SUPER_NODE: {
-            memsize->memsize += sizeof(yp_forwarding_super_node_t);
-            if (((yp_forwarding_super_node_t *)node)->block != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_forwarding_super_node_t *)node)->block, memsize);
+            yp_forwarding_super_node_t *cast = (yp_forwarding_super_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->block != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->block, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_GLOBAL_VARIABLE_AND_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_global_variable_and_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_global_variable_and_write_node_t *)node)->value, memsize);
+            yp_global_variable_and_write_node_t *cast = (yp_global_variable_and_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_GLOBAL_VARIABLE_OPERATOR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_global_variable_operator_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_global_variable_operator_write_node_t *)node)->value, memsize);
+            yp_global_variable_operator_write_node_t *cast = (yp_global_variable_operator_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_GLOBAL_VARIABLE_OR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_global_variable_or_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_global_variable_or_write_node_t *)node)->value, memsize);
+            yp_global_variable_or_write_node_t *cast = (yp_global_variable_or_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_GLOBAL_VARIABLE_READ_NODE: {
-            memsize->memsize += sizeof(yp_global_variable_read_node_t);
+            yp_global_variable_read_node_t *cast = (yp_global_variable_read_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_GLOBAL_VARIABLE_TARGET_NODE: {
-            memsize->memsize += sizeof(yp_global_variable_target_node_t);
+            yp_global_variable_target_node_t *cast = (yp_global_variable_target_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_GLOBAL_VARIABLE_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_global_variable_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_global_variable_write_node_t *)node)->value, memsize);
+            yp_global_variable_write_node_t *cast = (yp_global_variable_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_HASH_NODE: {
-            memsize->memsize += sizeof(yp_hash_node_t);
-            yp_node_list_memsize(&((yp_hash_node_t *)node)->elements, memsize);
+            yp_hash_node_t *cast = (yp_hash_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->elements, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_HASH_PATTERN_NODE: {
-            memsize->memsize += sizeof(yp_hash_pattern_node_t);
-            if (((yp_hash_pattern_node_t *)node)->constant != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_hash_pattern_node_t *)node)->constant, memsize);
+            yp_hash_pattern_node_t *cast = (yp_hash_pattern_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->constant != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->constant, memsize);
             }
-            yp_node_list_memsize(&((yp_hash_pattern_node_t *)node)->assocs, memsize);
-            if (((yp_hash_pattern_node_t *)node)->kwrest != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_hash_pattern_node_t *)node)->kwrest, memsize);
+            yp_node_list_memsize(&cast->assocs, memsize);
+            if (cast->kwrest != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->kwrest, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_IF_NODE: {
-            memsize->memsize += sizeof(yp_if_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_if_node_t *)node)->predicate, memsize);
-            if (((yp_if_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_if_node_t *)node)->statements, memsize);
+            yp_if_node_t *cast = (yp_if_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
-            if (((yp_if_node_t *)node)->consequent != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_if_node_t *)node)->consequent, memsize);
+            if (cast->consequent != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->consequent, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_IMAGINARY_NODE: {
-            memsize->memsize += sizeof(yp_imaginary_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_imaginary_node_t *)node)->numeric, memsize);
+            yp_imaginary_node_t *cast = (yp_imaginary_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->numeric, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_IN_NODE: {
-            memsize->memsize += sizeof(yp_in_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_in_node_t *)node)->pattern, memsize);
-            if (((yp_in_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_in_node_t *)node)->statements, memsize);
+            yp_in_node_t *cast = (yp_in_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INSTANCE_VARIABLE_AND_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_instance_variable_and_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_instance_variable_and_write_node_t *)node)->value, memsize);
+            yp_instance_variable_and_write_node_t *cast = (yp_instance_variable_and_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INSTANCE_VARIABLE_OPERATOR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_instance_variable_operator_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_instance_variable_operator_write_node_t *)node)->value, memsize);
+            yp_instance_variable_operator_write_node_t *cast = (yp_instance_variable_operator_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INSTANCE_VARIABLE_OR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_instance_variable_or_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_instance_variable_or_write_node_t *)node)->value, memsize);
+            yp_instance_variable_or_write_node_t *cast = (yp_instance_variable_or_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INSTANCE_VARIABLE_READ_NODE: {
-            memsize->memsize += sizeof(yp_instance_variable_read_node_t);
+            yp_instance_variable_read_node_t *cast = (yp_instance_variable_read_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INSTANCE_VARIABLE_TARGET_NODE: {
-            memsize->memsize += sizeof(yp_instance_variable_target_node_t);
+            yp_instance_variable_target_node_t *cast = (yp_instance_variable_target_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INSTANCE_VARIABLE_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_instance_variable_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_instance_variable_write_node_t *)node)->value, memsize);
+            yp_instance_variable_write_node_t *cast = (yp_instance_variable_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INTEGER_NODE: {
-            memsize->memsize += sizeof(yp_integer_node_t);
+            yp_integer_node_t *cast = (yp_integer_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INTERPOLATED_REGULAR_EXPRESSION_NODE: {
-            memsize->memsize += sizeof(yp_interpolated_regular_expression_node_t);
-            yp_node_list_memsize(&((yp_interpolated_regular_expression_node_t *)node)->parts, memsize);
+            yp_interpolated_regular_expression_node_t *cast = (yp_interpolated_regular_expression_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->parts, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INTERPOLATED_STRING_NODE: {
-            memsize->memsize += sizeof(yp_interpolated_string_node_t);
-            yp_node_list_memsize(&((yp_interpolated_string_node_t *)node)->parts, memsize);
+            yp_interpolated_string_node_t *cast = (yp_interpolated_string_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->parts, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INTERPOLATED_SYMBOL_NODE: {
-            memsize->memsize += sizeof(yp_interpolated_symbol_node_t);
-            yp_node_list_memsize(&((yp_interpolated_symbol_node_t *)node)->parts, memsize);
+            yp_interpolated_symbol_node_t *cast = (yp_interpolated_symbol_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->parts, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_INTERPOLATED_X_STRING_NODE: {
-            memsize->memsize += sizeof(yp_interpolated_x_string_node_t);
-            yp_node_list_memsize(&((yp_interpolated_x_string_node_t *)node)->parts, memsize);
+            yp_interpolated_x_string_node_t *cast = (yp_interpolated_x_string_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->parts, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_KEYWORD_HASH_NODE: {
-            memsize->memsize += sizeof(yp_keyword_hash_node_t);
-            yp_node_list_memsize(&((yp_keyword_hash_node_t *)node)->elements, memsize);
+            yp_keyword_hash_node_t *cast = (yp_keyword_hash_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->elements, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_KEYWORD_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_keyword_parameter_node_t);
-            if (((yp_keyword_parameter_node_t *)node)->value != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_keyword_parameter_node_t *)node)->value, memsize);
+            yp_keyword_parameter_node_t *cast = (yp_keyword_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->value != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_KEYWORD_REST_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_keyword_rest_parameter_node_t);
+            yp_keyword_rest_parameter_node_t *cast = (yp_keyword_rest_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_LAMBDA_NODE: {
-            memsize->memsize += sizeof(yp_lambda_node_t);
-            memsize->memsize += yp_constant_id_list_memsize(&((yp_lambda_node_t *)node)->locals);
-            if (((yp_lambda_node_t *)node)->parameters != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_lambda_node_t *)node)->parameters, memsize);
+            yp_lambda_node_t *cast = (yp_lambda_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
+            if (cast->parameters != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->parameters, memsize);
             }
-            if (((yp_lambda_node_t *)node)->body != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_lambda_node_t *)node)->body, memsize);
+            if (cast->body != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->body, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_LOCAL_VARIABLE_AND_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_local_variable_and_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_local_variable_and_write_node_t *)node)->value, memsize);
+            yp_local_variable_and_write_node_t *cast = (yp_local_variable_and_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_LOCAL_VARIABLE_OPERATOR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_local_variable_operator_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_local_variable_operator_write_node_t *)node)->value, memsize);
+            yp_local_variable_operator_write_node_t *cast = (yp_local_variable_operator_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_LOCAL_VARIABLE_OR_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_local_variable_or_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_local_variable_or_write_node_t *)node)->value, memsize);
+            yp_local_variable_or_write_node_t *cast = (yp_local_variable_or_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_LOCAL_VARIABLE_READ_NODE: {
-            memsize->memsize += sizeof(yp_local_variable_read_node_t);
+            yp_local_variable_read_node_t *cast = (yp_local_variable_read_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_LOCAL_VARIABLE_TARGET_NODE: {
-            memsize->memsize += sizeof(yp_local_variable_target_node_t);
+            yp_local_variable_target_node_t *cast = (yp_local_variable_target_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_LOCAL_VARIABLE_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_local_variable_write_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_local_variable_write_node_t *)node)->value, memsize);
+            yp_local_variable_write_node_t *cast = (yp_local_variable_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_MATCH_PREDICATE_NODE: {
-            memsize->memsize += sizeof(yp_match_predicate_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_match_predicate_node_t *)node)->value, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_match_predicate_node_t *)node)->pattern, memsize);
+            yp_match_predicate_node_t *cast = (yp_match_predicate_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_MATCH_REQUIRED_NODE: {
-            memsize->memsize += sizeof(yp_match_required_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_match_required_node_t *)node)->value, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_match_required_node_t *)node)->pattern, memsize);
+            yp_match_required_node_t *cast = (yp_match_required_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->pattern, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_MISSING_NODE: {
-            memsize->memsize += sizeof(yp_missing_node_t);
+            yp_missing_node_t *cast = (yp_missing_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_MODULE_NODE: {
-            memsize->memsize += sizeof(yp_module_node_t);
-            memsize->memsize += yp_constant_id_list_memsize(&((yp_module_node_t *)node)->locals);
-            yp_node_memsize_node((yp_node_t *)((yp_module_node_t *)node)->constant_path, memsize);
-            if (((yp_module_node_t *)node)->body != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_module_node_t *)node)->body, memsize);
+            yp_module_node_t *cast = (yp_module_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
+            yp_node_memsize_node((yp_node_t *)cast->constant_path, memsize);
+            if (cast->body != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->body, memsize);
             }
-            memsize->memsize += yp_string_memsize(&((yp_module_node_t *)node)->name);
+            memsize->memsize += yp_string_memsize(&cast->name);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_MULTI_WRITE_NODE: {
-            memsize->memsize += sizeof(yp_multi_write_node_t);
-            yp_node_list_memsize(&((yp_multi_write_node_t *)node)->targets, memsize);
-            if (((yp_multi_write_node_t *)node)->value != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_multi_write_node_t *)node)->value, memsize);
+            yp_multi_write_node_t *cast = (yp_multi_write_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->targets, memsize);
+            if (cast->value != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_NEXT_NODE: {
-            memsize->memsize += sizeof(yp_next_node_t);
-            if (((yp_next_node_t *)node)->arguments != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_next_node_t *)node)->arguments, memsize);
+            yp_next_node_t *cast = (yp_next_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->arguments != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_NIL_NODE: {
-            memsize->memsize += sizeof(yp_nil_node_t);
+            yp_nil_node_t *cast = (yp_nil_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_NO_KEYWORDS_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_no_keywords_parameter_node_t);
+            yp_no_keywords_parameter_node_t *cast = (yp_no_keywords_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_NUMBERED_REFERENCE_READ_NODE: {
-            memsize->memsize += sizeof(yp_numbered_reference_read_node_t);
+            yp_numbered_reference_read_node_t *cast = (yp_numbered_reference_read_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_OPTIONAL_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_optional_parameter_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_optional_parameter_node_t *)node)->value, memsize);
+            yp_optional_parameter_node_t *cast = (yp_optional_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->value, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_OR_NODE: {
-            memsize->memsize += sizeof(yp_or_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_or_node_t *)node)->left, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_or_node_t *)node)->right, memsize);
+            yp_or_node_t *cast = (yp_or_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->left, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->right, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_PARAMETERS_NODE: {
-            memsize->memsize += sizeof(yp_parameters_node_t);
-            yp_node_list_memsize(&((yp_parameters_node_t *)node)->requireds, memsize);
-            yp_node_list_memsize(&((yp_parameters_node_t *)node)->optionals, memsize);
-            yp_node_list_memsize(&((yp_parameters_node_t *)node)->posts, memsize);
-            if (((yp_parameters_node_t *)node)->rest != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_parameters_node_t *)node)->rest, memsize);
+            yp_parameters_node_t *cast = (yp_parameters_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->requireds, memsize);
+            yp_node_list_memsize(&cast->optionals, memsize);
+            yp_node_list_memsize(&cast->posts, memsize);
+            if (cast->rest != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->rest, memsize);
             }
-            yp_node_list_memsize(&((yp_parameters_node_t *)node)->keywords, memsize);
-            if (((yp_parameters_node_t *)node)->keyword_rest != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_parameters_node_t *)node)->keyword_rest, memsize);
+            yp_node_list_memsize(&cast->keywords, memsize);
+            if (cast->keyword_rest != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->keyword_rest, memsize);
             }
-            if (((yp_parameters_node_t *)node)->block != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_parameters_node_t *)node)->block, memsize);
+            if (cast->block != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->block, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_PARENTHESES_NODE: {
-            memsize->memsize += sizeof(yp_parentheses_node_t);
-            if (((yp_parentheses_node_t *)node)->body != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_parentheses_node_t *)node)->body, memsize);
+            yp_parentheses_node_t *cast = (yp_parentheses_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->body != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->body, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_PINNED_EXPRESSION_NODE: {
-            memsize->memsize += sizeof(yp_pinned_expression_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_pinned_expression_node_t *)node)->expression, memsize);
+            yp_pinned_expression_node_t *cast = (yp_pinned_expression_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_PINNED_VARIABLE_NODE: {
-            memsize->memsize += sizeof(yp_pinned_variable_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_pinned_variable_node_t *)node)->variable, memsize);
+            yp_pinned_variable_node_t *cast = (yp_pinned_variable_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->variable, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_POST_EXECUTION_NODE: {
-            memsize->memsize += sizeof(yp_post_execution_node_t);
-            if (((yp_post_execution_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_post_execution_node_t *)node)->statements, memsize);
+            yp_post_execution_node_t *cast = (yp_post_execution_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_PRE_EXECUTION_NODE: {
-            memsize->memsize += sizeof(yp_pre_execution_node_t);
-            if (((yp_pre_execution_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_pre_execution_node_t *)node)->statements, memsize);
+            yp_pre_execution_node_t *cast = (yp_pre_execution_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_PROGRAM_NODE: {
-            memsize->memsize += sizeof(yp_program_node_t);
-            memsize->memsize += yp_constant_id_list_memsize(&((yp_program_node_t *)node)->locals);
-            yp_node_memsize_node((yp_node_t *)((yp_program_node_t *)node)->statements, memsize);
+            yp_program_node_t *cast = (yp_program_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
+            yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_RANGE_NODE: {
-            memsize->memsize += sizeof(yp_range_node_t);
-            if (((yp_range_node_t *)node)->left != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_range_node_t *)node)->left, memsize);
+            yp_range_node_t *cast = (yp_range_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->left != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->left, memsize);
             }
-            if (((yp_range_node_t *)node)->right != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_range_node_t *)node)->right, memsize);
+            if (cast->right != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->right, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_RATIONAL_NODE: {
-            memsize->memsize += sizeof(yp_rational_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_rational_node_t *)node)->numeric, memsize);
+            yp_rational_node_t *cast = (yp_rational_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->numeric, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_REDO_NODE: {
-            memsize->memsize += sizeof(yp_redo_node_t);
+            yp_redo_node_t *cast = (yp_redo_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_REGULAR_EXPRESSION_NODE: {
-            memsize->memsize += sizeof(yp_regular_expression_node_t);
-            memsize->memsize += yp_string_memsize(&((yp_regular_expression_node_t *)node)->unescaped);
+            yp_regular_expression_node_t *cast = (yp_regular_expression_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_string_memsize(&cast->unescaped);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_REQUIRED_DESTRUCTURED_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_required_destructured_parameter_node_t);
-            yp_node_list_memsize(&((yp_required_destructured_parameter_node_t *)node)->parameters, memsize);
+            yp_required_destructured_parameter_node_t *cast = (yp_required_destructured_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->parameters, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_REQUIRED_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_required_parameter_node_t);
+            yp_required_parameter_node_t *cast = (yp_required_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_RESCUE_MODIFIER_NODE: {
-            memsize->memsize += sizeof(yp_rescue_modifier_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_rescue_modifier_node_t *)node)->expression, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_rescue_modifier_node_t *)node)->rescue_expression, memsize);
+            yp_rescue_modifier_node_t *cast = (yp_rescue_modifier_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->rescue_expression, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_RESCUE_NODE: {
-            memsize->memsize += sizeof(yp_rescue_node_t);
-            yp_node_list_memsize(&((yp_rescue_node_t *)node)->exceptions, memsize);
-            if (((yp_rescue_node_t *)node)->reference != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_rescue_node_t *)node)->reference, memsize);
+            yp_rescue_node_t *cast = (yp_rescue_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->exceptions, memsize);
+            if (cast->reference != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->reference, memsize);
             }
-            if (((yp_rescue_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_rescue_node_t *)node)->statements, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
-            if (((yp_rescue_node_t *)node)->consequent != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_rescue_node_t *)node)->consequent, memsize);
+            if (cast->consequent != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->consequent, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_REST_PARAMETER_NODE: {
-            memsize->memsize += sizeof(yp_rest_parameter_node_t);
+            yp_rest_parameter_node_t *cast = (yp_rest_parameter_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_RETRY_NODE: {
-            memsize->memsize += sizeof(yp_retry_node_t);
+            yp_retry_node_t *cast = (yp_retry_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_RETURN_NODE: {
-            memsize->memsize += sizeof(yp_return_node_t);
-            if (((yp_return_node_t *)node)->arguments != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_return_node_t *)node)->arguments, memsize);
+            yp_return_node_t *cast = (yp_return_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->arguments != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SELF_NODE: {
-            memsize->memsize += sizeof(yp_self_node_t);
+            yp_self_node_t *cast = (yp_self_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SINGLETON_CLASS_NODE: {
-            memsize->memsize += sizeof(yp_singleton_class_node_t);
-            memsize->memsize += yp_constant_id_list_memsize(&((yp_singleton_class_node_t *)node)->locals);
-            yp_node_memsize_node((yp_node_t *)((yp_singleton_class_node_t *)node)->expression, memsize);
-            if (((yp_singleton_class_node_t *)node)->body != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_singleton_class_node_t *)node)->body, memsize);
+            yp_singleton_class_node_t *cast = (yp_singleton_class_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_constant_id_list_memsize(&cast->locals);
+            yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
+            if (cast->body != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->body, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SOURCE_ENCODING_NODE: {
-            memsize->memsize += sizeof(yp_source_encoding_node_t);
+            yp_source_encoding_node_t *cast = (yp_source_encoding_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SOURCE_FILE_NODE: {
-            memsize->memsize += sizeof(yp_source_file_node_t);
-            memsize->memsize += yp_string_memsize(&((yp_source_file_node_t *)node)->filepath);
+            yp_source_file_node_t *cast = (yp_source_file_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_string_memsize(&cast->filepath);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SOURCE_LINE_NODE: {
-            memsize->memsize += sizeof(yp_source_line_node_t);
+            yp_source_line_node_t *cast = (yp_source_line_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SPLAT_NODE: {
-            memsize->memsize += sizeof(yp_splat_node_t);
-            if (((yp_splat_node_t *)node)->expression != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_splat_node_t *)node)->expression, memsize);
+            yp_splat_node_t *cast = (yp_splat_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->expression != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->expression, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_STATEMENTS_NODE: {
-            memsize->memsize += sizeof(yp_statements_node_t);
-            yp_node_list_memsize(&((yp_statements_node_t *)node)->body, memsize);
+            yp_statements_node_t *cast = (yp_statements_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->body, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_STRING_CONCAT_NODE: {
-            memsize->memsize += sizeof(yp_string_concat_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_string_concat_node_t *)node)->left, memsize);
-            yp_node_memsize_node((yp_node_t *)((yp_string_concat_node_t *)node)->right, memsize);
+            yp_string_concat_node_t *cast = (yp_string_concat_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->left, memsize);
+            yp_node_memsize_node((yp_node_t *)cast->right, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_STRING_NODE: {
-            memsize->memsize += sizeof(yp_string_node_t);
-            memsize->memsize += yp_string_memsize(&((yp_string_node_t *)node)->unescaped);
+            yp_string_node_t *cast = (yp_string_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_string_memsize(&cast->unescaped);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SUPER_NODE: {
-            memsize->memsize += sizeof(yp_super_node_t);
-            if (((yp_super_node_t *)node)->arguments != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_super_node_t *)node)->arguments, memsize);
+            yp_super_node_t *cast = (yp_super_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->arguments != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
             }
-            if (((yp_super_node_t *)node)->block != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_super_node_t *)node)->block, memsize);
+            if (cast->block != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->block, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_SYMBOL_NODE: {
-            memsize->memsize += sizeof(yp_symbol_node_t);
-            memsize->memsize += yp_string_memsize(&((yp_symbol_node_t *)node)->unescaped);
+            yp_symbol_node_t *cast = (yp_symbol_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_string_memsize(&cast->unescaped);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_TRUE_NODE: {
-            memsize->memsize += sizeof(yp_true_node_t);
+            yp_true_node_t *cast = (yp_true_node_t *) node;
+            memsize->memsize += sizeof(*cast);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_UNDEF_NODE: {
-            memsize->memsize += sizeof(yp_undef_node_t);
-            yp_node_list_memsize(&((yp_undef_node_t *)node)->names, memsize);
+            yp_undef_node_t *cast = (yp_undef_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->names, memsize);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_UNLESS_NODE: {
-            memsize->memsize += sizeof(yp_unless_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_unless_node_t *)node)->predicate, memsize);
-            if (((yp_unless_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_unless_node_t *)node)->statements, memsize);
+            yp_unless_node_t *cast = (yp_unless_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
-            if (((yp_unless_node_t *)node)->consequent != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_unless_node_t *)node)->consequent, memsize);
+            if (cast->consequent != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->consequent, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_UNTIL_NODE: {
-            memsize->memsize += sizeof(yp_until_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_until_node_t *)node)->predicate, memsize);
-            if (((yp_until_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_until_node_t *)node)->statements, memsize);
+            yp_until_node_t *cast = (yp_until_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_WHEN_NODE: {
-            memsize->memsize += sizeof(yp_when_node_t);
-            yp_node_list_memsize(&((yp_when_node_t *)node)->conditions, memsize);
-            if (((yp_when_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_when_node_t *)node)->statements, memsize);
+            yp_when_node_t *cast = (yp_when_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_list_memsize(&cast->conditions, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_WHILE_NODE: {
-            memsize->memsize += sizeof(yp_while_node_t);
-            yp_node_memsize_node((yp_node_t *)((yp_while_node_t *)node)->predicate, memsize);
-            if (((yp_while_node_t *)node)->statements != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_while_node_t *)node)->statements, memsize);
+            yp_while_node_t *cast = (yp_while_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            yp_node_memsize_node((yp_node_t *)cast->predicate, memsize);
+            if (cast->statements != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->statements, memsize);
             }
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_X_STRING_NODE: {
-            memsize->memsize += sizeof(yp_x_string_node_t);
-            memsize->memsize += yp_string_memsize(&((yp_x_string_node_t *)node)->unescaped);
+            yp_x_string_node_t *cast = (yp_x_string_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            memsize->memsize += yp_string_memsize(&cast->unescaped);
             break;
         }
-#line 124 "node.c.erb"
+#line 128 "node.c.erb"
         case YP_NODE_YIELD_NODE: {
-            memsize->memsize += sizeof(yp_yield_node_t);
-            if (((yp_yield_node_t *)node)->arguments != NULL) {
-                yp_node_memsize_node((yp_node_t *)((yp_yield_node_t *)node)->arguments, memsize);
+            yp_yield_node_t *cast = (yp_yield_node_t *) node;
+            memsize->memsize += sizeof(*cast);
+            if (cast->arguments != NULL) {
+                yp_node_memsize_node((yp_node_t *)cast->arguments, memsize);
             }
             break;
         }
-#line 151 "node.c.erb"
+#line 156 "node.c.erb"
     }
 }
 
@@ -2085,5 +2457,5 @@ yp_node_type_to_str(yp_node_type_t node_type)
         case YP_NODE_YIELD_NODE:
             return "YP_NODE_YIELD_NODE";
     }
-    return "\0";
+    return "";
 }