diff --git a/ast.c b/ast.c
index cc35a69a22..12b3996f94 100644
--- a/ast.c
+++ b/ast.c
@@ -16,7 +16,7 @@ static VALUE rb_mAST;
 static VALUE rb_cNode;
 
 struct ASTNodeData {
-    VALUE vast;
+    VALUE ast_value;
     const NODE *node;
 };
 
@@ -24,14 +24,14 @@ static void
 node_gc_mark(void *ptr)
 {
     struct ASTNodeData *data = (struct ASTNodeData *)ptr;
-    rb_gc_mark(data->vast);
+    rb_gc_mark(data->ast_value);
 }
 
 static size_t
 node_memsize(const void *ptr)
 {
     struct ASTNodeData *data = (struct ASTNodeData *)ptr;
-    rb_ast_t *ast = rb_ruby_ast_data_get(data->vast);
+    rb_ast_t *ast = rb_ruby_ast_data_get(data->ast_value);
 
     return sizeof(struct ASTNodeData) + rb_ast_memsize(ast);
 }
@@ -46,22 +46,22 @@ static const rb_data_type_t rb_node_type = {
 static VALUE rb_ast_node_alloc(VALUE klass);
 
 static void
-setup_node(VALUE obj, VALUE vast, const NODE *node)
+setup_node(VALUE obj, VALUE ast_value, const NODE *node)
 {
     struct ASTNodeData *data;
 
     TypedData_Get_Struct(obj, struct ASTNodeData, &rb_node_type, data);
-    data->vast = vast;
+    data->ast_value = ast_value;
     data->node = node;
 }
 
 static VALUE
-ast_new_internal(VALUE vast, const NODE *node)
+ast_new_internal(VALUE ast_value, const NODE *node)
 {
     VALUE obj;
 
     obj = rb_ast_node_alloc(rb_cNode);
-    setup_node(obj, vast, node);
+    setup_node(obj, ast_value, node);
 
     return obj;
 }
@@ -76,16 +76,16 @@ ast_parse_new(void)
 }
 
 static VALUE
-ast_parse_done(VALUE vast)
+ast_parse_done(VALUE ast_value)
 {
-    rb_ast_t *ast = rb_ruby_ast_data_get(vast);
+    rb_ast_t *ast = rb_ruby_ast_data_get(ast_value);
 
     if (!ast->body.root) {
         rb_ast_dispose(ast);
         rb_exc_raise(GET_EC()->errinfo);
     }
 
-    return ast_new_internal(vast, (NODE *)ast->body.root);
+    return ast_new_internal(ast_value, (NODE *)ast->body.root);
 }
 
 static VALUE
@@ -97,15 +97,15 @@ ast_s_parse(rb_execution_context_t *ec, VALUE module, VALUE str, VALUE keep_scri
 static VALUE
 rb_ast_parse_str(VALUE str, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
 {
-    VALUE vast;
+    VALUE ast_value;
 
     StringValue(str);
     VALUE vparser = ast_parse_new();
     if (RTEST(keep_script_lines)) rb_parser_set_script_lines(vparser);
     if (RTEST(error_tolerant)) rb_parser_error_tolerant(vparser);
     if (RTEST(keep_tokens)) rb_parser_keep_tokens(vparser);
-    vast = rb_parser_compile_string_path(vparser, Qnil, str, 1);
-    return ast_parse_done(vast);
+    ast_value = rb_parser_compile_string_path(vparser, Qnil, str, 1);
+    return ast_parse_done(ast_value);
 }
 
 static VALUE
@@ -118,7 +118,7 @@ static VALUE
 rb_ast_parse_file(VALUE path, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
 {
     VALUE f;
-    VALUE vast = Qnil;
+    VALUE ast_value = Qnil;
     rb_encoding *enc = rb_utf8_encoding();
 
     f = rb_file_open_str(path, "r");
@@ -127,23 +127,23 @@ rb_ast_parse_file(VALUE path, VALUE keep_script_lines, VALUE error_tolerant, VAL
     if (RTEST(keep_script_lines)) rb_parser_set_script_lines(vparser);
     if (RTEST(error_tolerant))  rb_parser_error_tolerant(vparser);
     if (RTEST(keep_tokens))  rb_parser_keep_tokens(vparser);
-    vast = rb_parser_compile_file_path(vparser, Qnil, f, 1);
+    ast_value = rb_parser_compile_file_path(vparser, Qnil, f, 1);
     rb_io_close(f);
-    return ast_parse_done(vast);
+    return ast_parse_done(ast_value);
 }
 
 static VALUE
 rb_ast_parse_array(VALUE array, VALUE keep_script_lines, VALUE error_tolerant, VALUE keep_tokens)
 {
-    VALUE vast = Qnil;
+    VALUE ast_value = Qnil;
 
     array = rb_check_array_type(array);
     VALUE vparser = ast_parse_new();
     if (RTEST(keep_script_lines)) rb_parser_set_script_lines(vparser);
     if (RTEST(error_tolerant)) rb_parser_error_tolerant(vparser);
     if (RTEST(keep_tokens)) rb_parser_keep_tokens(vparser);
-    vast = rb_parser_compile_array(vparser, Qnil, array, 1);
-    return ast_parse_done(vast);
+    ast_value = rb_parser_compile_array(vparser, Qnil, array, 1);
+    return ast_parse_done(ast_value);
 }
 
 static VALUE node_children(VALUE, const NODE*);
@@ -158,7 +158,7 @@ node_find(VALUE self, const int node_id)
 
     if (nd_node_id(data->node) == node_id) return self;
 
-    ary = node_children(data->vast, data->node);
+    ary = node_children(data->ast_value, data->node);
 
     for (i = 0; i < RARRAY_LEN(ary); i++) {
         VALUE child = RARRAY_AREF(ary, i);
@@ -281,10 +281,10 @@ ast_node_node_id(rb_execution_context_t *ec, VALUE self)
     return INT2FIX(nd_node_id(data->node));
 }
 
-#define NEW_CHILD(vast, node) (node ? ast_new_internal(vast, node) : Qnil)
+#define NEW_CHILD(ast_value, node) (node ? ast_new_internal(ast_value, node) : Qnil)
 
 static VALUE
-rb_ary_new_from_node_args(VALUE vast, long n, ...)
+rb_ary_new_from_node_args(VALUE ast_value, long n, ...)
 {
     va_list ar;
     VALUE ary;
@@ -296,39 +296,39 @@ rb_ary_new_from_node_args(VALUE vast, long n, ...)
     for (i=0; i<n; i++) {
         NODE *node;
         node = va_arg(ar, NODE *);
-        rb_ary_push(ary, NEW_CHILD(vast, node));
+        rb_ary_push(ary, NEW_CHILD(ast_value, node));
     }
     va_end(ar);
     return ary;
 }
 
 static VALUE
-dump_block(VALUE vast, const struct RNode_BLOCK *node)
+dump_block(VALUE ast_value, const struct RNode_BLOCK *node)
 {
     VALUE ary = rb_ary_new();
     do {
-        rb_ary_push(ary, NEW_CHILD(vast, node->nd_head));
+        rb_ary_push(ary, NEW_CHILD(ast_value, node->nd_head));
     } while (node->nd_next &&
         nd_type_p(node->nd_next, NODE_BLOCK) &&
         (node = RNODE_BLOCK(node->nd_next), 1));
     if (node->nd_next) {
-        rb_ary_push(ary, NEW_CHILD(vast, node->nd_next));
+        rb_ary_push(ary, NEW_CHILD(ast_value, node->nd_next));
     }
 
     return ary;
 }
 
 static VALUE
-dump_array(VALUE vast, const struct RNode_LIST *node)
+dump_array(VALUE ast_value, const struct RNode_LIST *node)
 {
     VALUE ary = rb_ary_new();
-    rb_ary_push(ary, NEW_CHILD(vast, node->nd_head));
+    rb_ary_push(ary, NEW_CHILD(ast_value, node->nd_head));
 
     while (node->nd_next && nd_type_p(node->nd_next, NODE_LIST)) {
         node = RNODE_LIST(node->nd_next);
-        rb_ary_push(ary, NEW_CHILD(vast, node->nd_head));
+        rb_ary_push(ary, NEW_CHILD(ast_value, node->nd_head));
     }
-    rb_ary_push(ary, NEW_CHILD(vast, node->nd_next));
+    rb_ary_push(ary, NEW_CHILD(ast_value, node->nd_next));
 
     return ary;
 }
@@ -350,155 +350,155 @@ no_name_rest(void)
 }
 
 static VALUE
-rest_arg(VALUE vast, const NODE *rest_arg)
+rest_arg(VALUE ast_value, const NODE *rest_arg)
 {
-    return NODE_NAMED_REST_P(rest_arg) ? NEW_CHILD(vast, rest_arg) : no_name_rest();
+    return NODE_NAMED_REST_P(rest_arg) ? NEW_CHILD(ast_value, rest_arg) : no_name_rest();
 }
 
 static VALUE
-node_children(VALUE vast, const NODE *node)
+node_children(VALUE ast_value, const NODE *node)
 {
     char name[sizeof("$") + DECIMAL_SIZE_OF(long)];
 
     enum node_type type = nd_type(node);
     switch (type) {
       case NODE_BLOCK:
-        return dump_block(vast, RNODE_BLOCK(node));
+        return dump_block(ast_value, RNODE_BLOCK(node));
       case NODE_IF:
-        return rb_ary_new_from_node_args(vast, 3, RNODE_IF(node)->nd_cond, RNODE_IF(node)->nd_body, RNODE_IF(node)->nd_else);
+        return rb_ary_new_from_node_args(ast_value, 3, RNODE_IF(node)->nd_cond, RNODE_IF(node)->nd_body, RNODE_IF(node)->nd_else);
       case NODE_UNLESS:
-        return rb_ary_new_from_node_args(vast, 3, RNODE_UNLESS(node)->nd_cond, RNODE_UNLESS(node)->nd_body, RNODE_UNLESS(node)->nd_else);
+        return rb_ary_new_from_node_args(ast_value, 3, RNODE_UNLESS(node)->nd_cond, RNODE_UNLESS(node)->nd_body, RNODE_UNLESS(node)->nd_else);
       case NODE_CASE:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_CASE(node)->nd_head, RNODE_CASE(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_CASE(node)->nd_head, RNODE_CASE(node)->nd_body);
       case NODE_CASE2:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_CASE2(node)->nd_head, RNODE_CASE2(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_CASE2(node)->nd_head, RNODE_CASE2(node)->nd_body);
       case NODE_CASE3:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_CASE3(node)->nd_head, RNODE_CASE3(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_CASE3(node)->nd_head, RNODE_CASE3(node)->nd_body);
       case NODE_WHEN:
-        return rb_ary_new_from_node_args(vast, 3, RNODE_WHEN(node)->nd_head, RNODE_WHEN(node)->nd_body, RNODE_WHEN(node)->nd_next);
+        return rb_ary_new_from_node_args(ast_value, 3, RNODE_WHEN(node)->nd_head, RNODE_WHEN(node)->nd_body, RNODE_WHEN(node)->nd_next);
       case NODE_IN:
-        return rb_ary_new_from_node_args(vast, 3, RNODE_IN(node)->nd_head, RNODE_IN(node)->nd_body, RNODE_IN(node)->nd_next);
+        return rb_ary_new_from_node_args(ast_value, 3, RNODE_IN(node)->nd_head, RNODE_IN(node)->nd_body, RNODE_IN(node)->nd_next);
       case NODE_WHILE:
       case NODE_UNTIL:
-        return rb_ary_push(rb_ary_new_from_node_args(vast, 2, RNODE_WHILE(node)->nd_cond, RNODE_WHILE(node)->nd_body),
+        return rb_ary_push(rb_ary_new_from_node_args(ast_value, 2, RNODE_WHILE(node)->nd_cond, RNODE_WHILE(node)->nd_body),
                            RBOOL(RNODE_WHILE(node)->nd_state));
       case NODE_ITER:
       case NODE_FOR:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_ITER(node)->nd_iter, RNODE_ITER(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_ITER(node)->nd_iter, RNODE_ITER(node)->nd_body);
       case NODE_FOR_MASGN:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_FOR_MASGN(node)->nd_var);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_FOR_MASGN(node)->nd_var);
       case NODE_BREAK:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_BREAK(node)->nd_stts);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_BREAK(node)->nd_stts);
       case NODE_NEXT:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_NEXT(node)->nd_stts);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_NEXT(node)->nd_stts);
       case NODE_RETURN:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_RETURN(node)->nd_stts);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_RETURN(node)->nd_stts);
       case NODE_REDO:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_RETRY:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_BEGIN:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_BEGIN(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_BEGIN(node)->nd_body);
       case NODE_RESCUE:
-        return rb_ary_new_from_node_args(vast, 3, RNODE_RESCUE(node)->nd_head, RNODE_RESCUE(node)->nd_resq, RNODE_RESCUE(node)->nd_else);
+        return rb_ary_new_from_node_args(ast_value, 3, RNODE_RESCUE(node)->nd_head, RNODE_RESCUE(node)->nd_resq, RNODE_RESCUE(node)->nd_else);
       case NODE_RESBODY:
-        return rb_ary_new_from_node_args(vast, 3, RNODE_RESBODY(node)->nd_args, RNODE_RESBODY(node)->nd_body, RNODE_RESBODY(node)->nd_next);
+        return rb_ary_new_from_node_args(ast_value, 3, RNODE_RESBODY(node)->nd_args, RNODE_RESBODY(node)->nd_body, RNODE_RESBODY(node)->nd_next);
       case NODE_ENSURE:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_ENSURE(node)->nd_head, RNODE_ENSURE(node)->nd_ensr);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_ENSURE(node)->nd_head, RNODE_ENSURE(node)->nd_ensr);
       case NODE_AND:
       case NODE_OR:
         {
             VALUE ary = rb_ary_new();
 
             while (1) {
-                rb_ary_push(ary, NEW_CHILD(vast, RNODE_AND(node)->nd_1st));
+                rb_ary_push(ary, NEW_CHILD(ast_value, RNODE_AND(node)->nd_1st));
                 if (!RNODE_AND(node)->nd_2nd || !nd_type_p(RNODE_AND(node)->nd_2nd, type))
                     break;
                 node = RNODE_AND(node)->nd_2nd;
             }
-            rb_ary_push(ary, NEW_CHILD(vast, RNODE_AND(node)->nd_2nd));
+            rb_ary_push(ary, NEW_CHILD(ast_value, RNODE_AND(node)->nd_2nd));
             return ary;
         }
       case NODE_MASGN:
         if (NODE_NAMED_REST_P(RNODE_MASGN(node)->nd_args)) {
-            return rb_ary_new_from_node_args(vast, 3, RNODE_MASGN(node)->nd_value, RNODE_MASGN(node)->nd_head, RNODE_MASGN(node)->nd_args);
+            return rb_ary_new_from_node_args(ast_value, 3, RNODE_MASGN(node)->nd_value, RNODE_MASGN(node)->nd_head, RNODE_MASGN(node)->nd_args);
         }
         else {
-            return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_MASGN(node)->nd_value),
-                                        NEW_CHILD(vast, RNODE_MASGN(node)->nd_head),
+            return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_MASGN(node)->nd_value),
+                                        NEW_CHILD(ast_value, RNODE_MASGN(node)->nd_head),
                                         no_name_rest());
         }
       case NODE_LASGN:
         if (NODE_REQUIRED_KEYWORD_P(RNODE_LASGN(node)->nd_value)) {
             return rb_ary_new_from_args(2, var_name(RNODE_LASGN(node)->nd_vid), ID2SYM(rb_intern("NODE_SPECIAL_REQUIRED_KEYWORD")));
         }
-        return rb_ary_new_from_args(2, var_name(RNODE_LASGN(node)->nd_vid), NEW_CHILD(vast, RNODE_LASGN(node)->nd_value));
+        return rb_ary_new_from_args(2, var_name(RNODE_LASGN(node)->nd_vid), NEW_CHILD(ast_value, RNODE_LASGN(node)->nd_value));
       case NODE_DASGN:
         if (NODE_REQUIRED_KEYWORD_P(RNODE_DASGN(node)->nd_value)) {
             return rb_ary_new_from_args(2, var_name(RNODE_DASGN(node)->nd_vid), ID2SYM(rb_intern("NODE_SPECIAL_REQUIRED_KEYWORD")));
         }
-        return rb_ary_new_from_args(2, var_name(RNODE_DASGN(node)->nd_vid), NEW_CHILD(vast, RNODE_DASGN(node)->nd_value));
+        return rb_ary_new_from_args(2, var_name(RNODE_DASGN(node)->nd_vid), NEW_CHILD(ast_value, RNODE_DASGN(node)->nd_value));
       case NODE_IASGN:
-        return rb_ary_new_from_args(2, var_name(RNODE_IASGN(node)->nd_vid), NEW_CHILD(vast, RNODE_IASGN(node)->nd_value));
+        return rb_ary_new_from_args(2, var_name(RNODE_IASGN(node)->nd_vid), NEW_CHILD(ast_value, RNODE_IASGN(node)->nd_value));
       case NODE_CVASGN:
-        return rb_ary_new_from_args(2, var_name(RNODE_CVASGN(node)->nd_vid), NEW_CHILD(vast, RNODE_CVASGN(node)->nd_value));
+        return rb_ary_new_from_args(2, var_name(RNODE_CVASGN(node)->nd_vid), NEW_CHILD(ast_value, RNODE_CVASGN(node)->nd_value));
       case NODE_GASGN:
-        return rb_ary_new_from_args(2, var_name(RNODE_GASGN(node)->nd_vid), NEW_CHILD(vast, RNODE_GASGN(node)->nd_value));
+        return rb_ary_new_from_args(2, var_name(RNODE_GASGN(node)->nd_vid), NEW_CHILD(ast_value, RNODE_GASGN(node)->nd_value));
       case NODE_CDECL:
         if (RNODE_CDECL(node)->nd_vid) {
-            return rb_ary_new_from_args(2, ID2SYM(RNODE_CDECL(node)->nd_vid), NEW_CHILD(vast, RNODE_CDECL(node)->nd_value));
+            return rb_ary_new_from_args(2, ID2SYM(RNODE_CDECL(node)->nd_vid), NEW_CHILD(ast_value, RNODE_CDECL(node)->nd_value));
         }
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_CDECL(node)->nd_else), ID2SYM(RNODE_COLON2(RNODE_CDECL(node)->nd_else)->nd_mid), NEW_CHILD(vast, RNODE_CDECL(node)->nd_value));
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_CDECL(node)->nd_else), ID2SYM(RNODE_COLON2(RNODE_CDECL(node)->nd_else)->nd_mid), NEW_CHILD(ast_value, RNODE_CDECL(node)->nd_value));
       case NODE_OP_ASGN1:
-        return rb_ary_new_from_args(4, NEW_CHILD(vast, RNODE_OP_ASGN1(node)->nd_recv),
+        return rb_ary_new_from_args(4, NEW_CHILD(ast_value, RNODE_OP_ASGN1(node)->nd_recv),
                                     ID2SYM(RNODE_OP_ASGN1(node)->nd_mid),
-                                    NEW_CHILD(vast, RNODE_OP_ASGN1(node)->nd_index),
-                                    NEW_CHILD(vast, RNODE_OP_ASGN1(node)->nd_rvalue));
+                                    NEW_CHILD(ast_value, RNODE_OP_ASGN1(node)->nd_index),
+                                    NEW_CHILD(ast_value, RNODE_OP_ASGN1(node)->nd_rvalue));
       case NODE_OP_ASGN2:
-        return rb_ary_new_from_args(5, NEW_CHILD(vast, RNODE_OP_ASGN2(node)->nd_recv),
+        return rb_ary_new_from_args(5, NEW_CHILD(ast_value, RNODE_OP_ASGN2(node)->nd_recv),
                                     RBOOL(RNODE_OP_ASGN2(node)->nd_aid),
                                     ID2SYM(RNODE_OP_ASGN2(node)->nd_vid),
                                     ID2SYM(RNODE_OP_ASGN2(node)->nd_mid),
-                                    NEW_CHILD(vast, RNODE_OP_ASGN2(node)->nd_value));
+                                    NEW_CHILD(ast_value, RNODE_OP_ASGN2(node)->nd_value));
       case NODE_OP_ASGN_AND:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_OP_ASGN_AND(node)->nd_head), ID2SYM(idANDOP),
-                                    NEW_CHILD(vast, RNODE_OP_ASGN_AND(node)->nd_value));
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_OP_ASGN_AND(node)->nd_head), ID2SYM(idANDOP),
+                                    NEW_CHILD(ast_value, RNODE_OP_ASGN_AND(node)->nd_value));
       case NODE_OP_ASGN_OR:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_OP_ASGN_OR(node)->nd_head), ID2SYM(idOROP),
-                                    NEW_CHILD(vast, RNODE_OP_ASGN_OR(node)->nd_value));
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_OP_ASGN_OR(node)->nd_head), ID2SYM(idOROP),
+                                    NEW_CHILD(ast_value, RNODE_OP_ASGN_OR(node)->nd_value));
       case NODE_OP_CDECL:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_OP_CDECL(node)->nd_head),
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_OP_CDECL(node)->nd_head),
                                     ID2SYM(RNODE_OP_CDECL(node)->nd_aid),
-                                    NEW_CHILD(vast, RNODE_OP_CDECL(node)->nd_value));
+                                    NEW_CHILD(ast_value, RNODE_OP_CDECL(node)->nd_value));
       case NODE_CALL:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_CALL(node)->nd_recv),
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_CALL(node)->nd_recv),
                                     ID2SYM(RNODE_CALL(node)->nd_mid),
-                                    NEW_CHILD(vast, RNODE_CALL(node)->nd_args));
+                                    NEW_CHILD(ast_value, RNODE_CALL(node)->nd_args));
       case NODE_OPCALL:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_OPCALL(node)->nd_recv),
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_OPCALL(node)->nd_recv),
                                     ID2SYM(RNODE_OPCALL(node)->nd_mid),
-                                    NEW_CHILD(vast, RNODE_OPCALL(node)->nd_args));
+                                    NEW_CHILD(ast_value, RNODE_OPCALL(node)->nd_args));
       case NODE_QCALL:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_QCALL(node)->nd_recv),
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_QCALL(node)->nd_recv),
                                     ID2SYM(RNODE_QCALL(node)->nd_mid),
-                                    NEW_CHILD(vast, RNODE_QCALL(node)->nd_args));
+                                    NEW_CHILD(ast_value, RNODE_QCALL(node)->nd_args));
       case NODE_FCALL:
         return rb_ary_new_from_args(2, ID2SYM(RNODE_FCALL(node)->nd_mid),
-                                    NEW_CHILD(vast, RNODE_FCALL(node)->nd_args));
+                                    NEW_CHILD(ast_value, RNODE_FCALL(node)->nd_args));
       case NODE_VCALL:
         return rb_ary_new_from_args(1, ID2SYM(RNODE_VCALL(node)->nd_mid));
       case NODE_SUPER:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_SUPER(node)->nd_args);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_SUPER(node)->nd_args);
       case NODE_ZSUPER:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_LIST:
-        return dump_array(vast, RNODE_LIST(node));
+        return dump_array(ast_value, RNODE_LIST(node));
       case NODE_ZLIST:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_HASH:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_HASH(node)->nd_head);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_HASH(node)->nd_head);
       case NODE_YIELD:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_YIELD(node)->nd_head);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_YIELD(node)->nd_head);
       case NODE_LVAR:
         return rb_ary_new_from_args(1, var_name(RNODE_LVAR(node)->nd_vid));
       case NODE_DVAR:
@@ -523,11 +523,11 @@ node_children(VALUE vast, const NODE *node)
         return rb_ary_new_from_args(1, rb_node_regx_string_val(node));
       case NODE_MATCH2:
         if (RNODE_MATCH2(node)->nd_args) {
-            return rb_ary_new_from_node_args(vast, 3, RNODE_MATCH2(node)->nd_recv, RNODE_MATCH2(node)->nd_value, RNODE_MATCH2(node)->nd_args);
+            return rb_ary_new_from_node_args(ast_value, 3, RNODE_MATCH2(node)->nd_recv, RNODE_MATCH2(node)->nd_value, RNODE_MATCH2(node)->nd_args);
         }
-        return rb_ary_new_from_node_args(vast, 2, RNODE_MATCH2(node)->nd_recv, RNODE_MATCH2(node)->nd_value);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_MATCH2(node)->nd_recv, RNODE_MATCH2(node)->nd_value);
       case NODE_MATCH3:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_MATCH3(node)->nd_recv, RNODE_MATCH3(node)->nd_value);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_MATCH3(node)->nd_recv, RNODE_MATCH3(node)->nd_value);
       case NODE_STR:
       case NODE_XSTR:
         return rb_ary_new_from_args(1, rb_node_str_string_val(node));
@@ -542,7 +542,7 @@ node_children(VALUE vast, const NODE *node)
       case NODE_REGX:
         return rb_ary_new_from_args(1, rb_node_regx_string_val(node));
       case NODE_ONCE:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_ONCE(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_ONCE(node)->nd_body);
       case NODE_DSTR:
       case NODE_DXSTR:
       case NODE_DREGX:
@@ -551,91 +551,91 @@ node_children(VALUE vast, const NODE *node)
             struct RNode_LIST *n = RNODE_DSTR(node)->nd_next;
             VALUE head = Qnil, next = Qnil;
             if (n) {
-                head = NEW_CHILD(vast, n->nd_head);
-                next = NEW_CHILD(vast, n->nd_next);
+                head = NEW_CHILD(ast_value, n->nd_head);
+                next = NEW_CHILD(ast_value, n->nd_next);
             }
             return rb_ary_new_from_args(3, rb_node_dstr_string_val(node), head, next);
         }
       case NODE_SYM:
         return rb_ary_new_from_args(1, rb_node_sym_string_val(node));
       case NODE_EVSTR:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_EVSTR(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_EVSTR(node)->nd_body);
       case NODE_ARGSCAT:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_ARGSCAT(node)->nd_head, RNODE_ARGSCAT(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_ARGSCAT(node)->nd_head, RNODE_ARGSCAT(node)->nd_body);
       case NODE_ARGSPUSH:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_ARGSPUSH(node)->nd_head, RNODE_ARGSPUSH(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_ARGSPUSH(node)->nd_head, RNODE_ARGSPUSH(node)->nd_body);
       case NODE_SPLAT:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_SPLAT(node)->nd_head);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_SPLAT(node)->nd_head);
       case NODE_BLOCK_PASS:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_BLOCK_PASS(node)->nd_head, RNODE_BLOCK_PASS(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_BLOCK_PASS(node)->nd_head, RNODE_BLOCK_PASS(node)->nd_body);
       case NODE_DEFN:
-        return rb_ary_new_from_args(2, ID2SYM(RNODE_DEFN(node)->nd_mid), NEW_CHILD(vast, RNODE_DEFN(node)->nd_defn));
+        return rb_ary_new_from_args(2, ID2SYM(RNODE_DEFN(node)->nd_mid), NEW_CHILD(ast_value, RNODE_DEFN(node)->nd_defn));
       case NODE_DEFS:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_DEFS(node)->nd_recv), ID2SYM(RNODE_DEFS(node)->nd_mid), NEW_CHILD(vast, RNODE_DEFS(node)->nd_defn));
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_DEFS(node)->nd_recv), ID2SYM(RNODE_DEFS(node)->nd_mid), NEW_CHILD(ast_value, RNODE_DEFS(node)->nd_defn));
       case NODE_ALIAS:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_ALIAS(node)->nd_1st, RNODE_ALIAS(node)->nd_2nd);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_ALIAS(node)->nd_1st, RNODE_ALIAS(node)->nd_2nd);
       case NODE_VALIAS:
         return rb_ary_new_from_args(2, ID2SYM(RNODE_VALIAS(node)->nd_alias), ID2SYM(RNODE_VALIAS(node)->nd_orig));
       case NODE_UNDEF:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_UNDEF(node)->nd_undef);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_UNDEF(node)->nd_undef);
       case NODE_CLASS:
-        return rb_ary_new_from_node_args(vast, 3, RNODE_CLASS(node)->nd_cpath, RNODE_CLASS(node)->nd_super, RNODE_CLASS(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 3, RNODE_CLASS(node)->nd_cpath, RNODE_CLASS(node)->nd_super, RNODE_CLASS(node)->nd_body);
       case NODE_MODULE:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_MODULE(node)->nd_cpath, RNODE_MODULE(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_MODULE(node)->nd_cpath, RNODE_MODULE(node)->nd_body);
       case NODE_SCLASS:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_SCLASS(node)->nd_recv, RNODE_SCLASS(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_SCLASS(node)->nd_recv, RNODE_SCLASS(node)->nd_body);
       case NODE_COLON2:
-        return rb_ary_new_from_args(2, NEW_CHILD(vast, RNODE_COLON2(node)->nd_head), ID2SYM(RNODE_COLON2(node)->nd_mid));
+        return rb_ary_new_from_args(2, NEW_CHILD(ast_value, RNODE_COLON2(node)->nd_head), ID2SYM(RNODE_COLON2(node)->nd_mid));
       case NODE_COLON3:
         return rb_ary_new_from_args(1, ID2SYM(RNODE_COLON3(node)->nd_mid));
       case NODE_DOT2:
       case NODE_DOT3:
       case NODE_FLIP2:
       case NODE_FLIP3:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_DOT2(node)->nd_beg, RNODE_DOT2(node)->nd_end);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_DOT2(node)->nd_beg, RNODE_DOT2(node)->nd_end);
       case NODE_SELF:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_NIL:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_TRUE:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_FALSE:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_ERRINFO:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_DEFINED:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_DEFINED(node)->nd_head);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_DEFINED(node)->nd_head);
       case NODE_POSTEXE:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_POSTEXE(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_POSTEXE(node)->nd_body);
       case NODE_ATTRASGN:
-        return rb_ary_new_from_args(3, NEW_CHILD(vast, RNODE_ATTRASGN(node)->nd_recv), ID2SYM(RNODE_ATTRASGN(node)->nd_mid), NEW_CHILD(vast, RNODE_ATTRASGN(node)->nd_args));
+        return rb_ary_new_from_args(3, NEW_CHILD(ast_value, RNODE_ATTRASGN(node)->nd_recv), ID2SYM(RNODE_ATTRASGN(node)->nd_mid), NEW_CHILD(ast_value, RNODE_ATTRASGN(node)->nd_args));
       case NODE_LAMBDA:
-        return rb_ary_new_from_node_args(vast, 1, RNODE_LAMBDA(node)->nd_body);
+        return rb_ary_new_from_node_args(ast_value, 1, RNODE_LAMBDA(node)->nd_body);
       case NODE_OPT_ARG:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_OPT_ARG(node)->nd_body, RNODE_OPT_ARG(node)->nd_next);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_OPT_ARG(node)->nd_body, RNODE_OPT_ARG(node)->nd_next);
       case NODE_KW_ARG:
-        return rb_ary_new_from_node_args(vast, 2, RNODE_KW_ARG(node)->nd_body, RNODE_KW_ARG(node)->nd_next);
+        return rb_ary_new_from_node_args(ast_value, 2, RNODE_KW_ARG(node)->nd_body, RNODE_KW_ARG(node)->nd_next);
       case NODE_POSTARG:
         if (NODE_NAMED_REST_P(RNODE_POSTARG(node)->nd_1st)) {
-            return rb_ary_new_from_node_args(vast, 2, RNODE_POSTARG(node)->nd_1st, RNODE_POSTARG(node)->nd_2nd);
+            return rb_ary_new_from_node_args(ast_value, 2, RNODE_POSTARG(node)->nd_1st, RNODE_POSTARG(node)->nd_2nd);
         }
         return rb_ary_new_from_args(2, no_name_rest(),
-                                    NEW_CHILD(vast, RNODE_POSTARG(node)->nd_2nd));
+                                    NEW_CHILD(ast_value, RNODE_POSTARG(node)->nd_2nd));
       case NODE_ARGS:
         {
             struct rb_args_info *ainfo = &RNODE_ARGS(node)->nd_ainfo;
             return rb_ary_new_from_args(10,
                                         INT2NUM(ainfo->pre_args_num),
-                                        NEW_CHILD(vast, ainfo->pre_init),
-                                        NEW_CHILD(vast, (NODE *)ainfo->opt_args),
+                                        NEW_CHILD(ast_value, ainfo->pre_init),
+                                        NEW_CHILD(ast_value, (NODE *)ainfo->opt_args),
                                         var_name(ainfo->first_post_arg),
                                         INT2NUM(ainfo->post_args_num),
-                                        NEW_CHILD(vast, ainfo->post_init),
+                                        NEW_CHILD(ast_value, ainfo->post_init),
                                         (ainfo->rest_arg == NODE_SPECIAL_EXCESSIVE_COMMA
                                             ? ID2SYM(rb_intern("NODE_SPECIAL_EXCESSIVE_COMMA"))
                                             : var_name(ainfo->rest_arg)),
-                                        (ainfo->no_kwarg ? Qfalse : NEW_CHILD(vast, (NODE *)ainfo->kw_args)),
-                                        (ainfo->no_kwarg ? Qfalse : NEW_CHILD(vast, ainfo->kw_rest_arg)),
+                                        (ainfo->no_kwarg ? Qfalse : NEW_CHILD(ast_value, (NODE *)ainfo->kw_args)),
+                                        (ainfo->no_kwarg ? Qfalse : NEW_CHILD(ast_value, ainfo->kw_rest_arg)),
                                         var_name(ainfo->block_arg));
         }
       case NODE_SCOPE:
@@ -646,35 +646,35 @@ node_children(VALUE vast, const NODE *node)
             for (i = 0; i < size; i++) {
                 rb_ary_push(locals, var_name(tbl->ids[i]));
             }
-            return rb_ary_new_from_args(3, locals, NEW_CHILD(vast, (NODE *)RNODE_SCOPE(node)->nd_args), NEW_CHILD(vast, RNODE_SCOPE(node)->nd_body));
+            return rb_ary_new_from_args(3, locals, NEW_CHILD(ast_value, (NODE *)RNODE_SCOPE(node)->nd_args), NEW_CHILD(ast_value, RNODE_SCOPE(node)->nd_body));
         }
       case NODE_ARYPTN:
         {
-            VALUE rest = rest_arg(vast, RNODE_ARYPTN(node)->rest_arg);
+            VALUE rest = rest_arg(ast_value, RNODE_ARYPTN(node)->rest_arg);
             return rb_ary_new_from_args(4,
-                                        NEW_CHILD(vast, RNODE_ARYPTN(node)->nd_pconst),
-                                        NEW_CHILD(vast, RNODE_ARYPTN(node)->pre_args),
+                                        NEW_CHILD(ast_value, RNODE_ARYPTN(node)->nd_pconst),
+                                        NEW_CHILD(ast_value, RNODE_ARYPTN(node)->pre_args),
                                         rest,
-                                        NEW_CHILD(vast, RNODE_ARYPTN(node)->post_args));
+                                        NEW_CHILD(ast_value, RNODE_ARYPTN(node)->post_args));
         }
       case NODE_FNDPTN:
         {
-            VALUE pre_rest = rest_arg(vast, RNODE_FNDPTN(node)->pre_rest_arg);
-            VALUE post_rest = rest_arg(vast, RNODE_FNDPTN(node)->post_rest_arg);
+            VALUE pre_rest = rest_arg(ast_value, RNODE_FNDPTN(node)->pre_rest_arg);
+            VALUE post_rest = rest_arg(ast_value, RNODE_FNDPTN(node)->post_rest_arg);
             return rb_ary_new_from_args(4,
-                                        NEW_CHILD(vast, RNODE_FNDPTN(node)->nd_pconst),
+                                        NEW_CHILD(ast_value, RNODE_FNDPTN(node)->nd_pconst),
                                         pre_rest,
-                                        NEW_CHILD(vast, RNODE_FNDPTN(node)->args),
+                                        NEW_CHILD(ast_value, RNODE_FNDPTN(node)->args),
                                         post_rest);
         }
       case NODE_HSHPTN:
         {
             VALUE kwrest = RNODE_HSHPTN(node)->nd_pkwrestarg == NODE_SPECIAL_NO_REST_KEYWORD ? ID2SYM(rb_intern("NODE_SPECIAL_NO_REST_KEYWORD")) :
-                                                                                 NEW_CHILD(vast, RNODE_HSHPTN(node)->nd_pkwrestarg);
+                                                                                 NEW_CHILD(ast_value, RNODE_HSHPTN(node)->nd_pkwrestarg);
 
             return rb_ary_new_from_args(3,
-                                        NEW_CHILD(vast, RNODE_HSHPTN(node)->nd_pconst),
-                                        NEW_CHILD(vast, RNODE_HSHPTN(node)->nd_pkwargs),
+                                        NEW_CHILD(ast_value, RNODE_HSHPTN(node)->nd_pconst),
+                                        NEW_CHILD(ast_value, RNODE_HSHPTN(node)->nd_pkwargs),
                                         kwrest);
         }
       case NODE_LINE:
@@ -684,7 +684,7 @@ node_children(VALUE vast, const NODE *node)
       case NODE_ENCODING:
         return rb_ary_new_from_args(1, rb_node_encoding_val(node));
       case NODE_ERROR:
-        return rb_ary_new_from_node_args(vast, 0);
+        return rb_ary_new_from_node_args(ast_value, 0);
       case NODE_ARGS_AUX:
       case NODE_LAST:
         break;
@@ -699,7 +699,7 @@ ast_node_children(rb_execution_context_t *ec, VALUE self)
     struct ASTNodeData *data;
     TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
 
-    return node_children(data->vast, data->node);
+    return node_children(data->ast_value, data->node);
 }
 
 static VALUE
@@ -749,7 +749,7 @@ ast_node_all_tokens(rb_execution_context_t *ec, VALUE self)
     VALUE str, loc, token, all_tokens;
 
     TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
-    ast = rb_ruby_ast_data_get(data->vast);
+    ast = rb_ruby_ast_data_get(data->ast_value);
 
     parser_tokens = ast->node_buffer->tokens;
     if (parser_tokens == NULL) {
@@ -800,7 +800,7 @@ ast_node_script_lines(rb_execution_context_t *ec, VALUE self)
     struct ASTNodeData *data;
     rb_ast_t *ast;
     TypedData_Get_Struct(self, struct ASTNodeData, &rb_node_type, data);
-    ast = rb_ruby_ast_data_get(data->vast);
+    ast = rb_ruby_ast_data_get(data->ast_value);
     rb_parser_ary_t *ret = ast->body.script_lines;
     return rb_parser_build_script_lines_from(ret);
 }
diff --git a/compile.c b/compile.c
index 588ce0c7ee..c319b72b52 100644
--- a/compile.c
+++ b/compile.c
@@ -1479,11 +1479,11 @@ new_child_iseq(rb_iseq_t *iseq, const NODE *const node,
                VALUE name, const rb_iseq_t *parent, enum rb_iseq_type type, int line_no)
 {
     rb_iseq_t *ret_iseq;
-    VALUE vast = rb_ruby_ast_new(node);
+    VALUE ast_value = rb_ruby_ast_new(node);
 
     debugs("[new_child_iseq]> ---------------------------------------\n");
     int isolated_depth = ISEQ_COMPILE_DATA(iseq)->isolated_depth;
-    ret_iseq = rb_iseq_new_with_opt(vast, name,
+    ret_iseq = rb_iseq_new_with_opt(ast_value, name,
                                     rb_iseq_path(iseq), rb_iseq_realpath(iseq),
                                     line_no, parent,
                                     isolated_depth ? isolated_depth + 1 : 0,
@@ -8771,10 +8771,10 @@ compile_builtin_mandatory_only_method(rb_iseq_t *iseq, const NODE *node, const N
     scope_node.nd_body = mandatory_node(iseq, node);
     scope_node.nd_args = &args_node;
 
-    VALUE vast = rb_ruby_ast_new(RNODE(&scope_node));
+    VALUE ast_value = rb_ruby_ast_new(RNODE(&scope_node));
 
     ISEQ_BODY(iseq)->mandatory_only_iseq =
-      rb_iseq_new_with_opt(vast, rb_iseq_base_label(iseq),
+      rb_iseq_new_with_opt(ast_value, rb_iseq_base_label(iseq),
                            rb_iseq_path(iseq), rb_iseq_realpath(iseq),
                            nd_line(line_node), NULL, 0,
                            ISEQ_TYPE_METHOD, ISEQ_COMPILE_DATA(iseq)->option,
diff --git a/internal/ruby_parser.h b/internal/ruby_parser.h
index 98c3461954..f7f859cb70 100644
--- a/internal/ruby_parser.h
+++ b/internal/ruby_parser.h
@@ -97,6 +97,6 @@ enum lex_state_e {
 };
 
 VALUE rb_ruby_ast_new(const NODE *const root);
-rb_ast_t *rb_ruby_ast_data_get(VALUE vast);
+rb_ast_t *rb_ruby_ast_data_get(VALUE ast_value);
 
 #endif /* INTERNAL_RUBY_PARSE_H */
diff --git a/iseq.c b/iseq.c
index 231cac19b8..aab58e3760 100644
--- a/iseq.c
+++ b/iseq.c
@@ -839,18 +839,18 @@ make_compile_option_value(rb_compile_option_t *option)
 }
 
 rb_iseq_t *
-rb_iseq_new(const VALUE vast, VALUE name, VALUE path, VALUE realpath,
+rb_iseq_new(const VALUE ast_value, VALUE name, VALUE path, VALUE realpath,
             const rb_iseq_t *parent, enum rb_iseq_type type)
 {
-    return rb_iseq_new_with_opt(vast, name, path, realpath, 0, parent,
+    return rb_iseq_new_with_opt(ast_value, name, path, realpath, 0, parent,
                                 0, type, &COMPILE_OPTION_DEFAULT,
                                 Qnil);
 }
 
 static int
-ast_line_count(const VALUE vast)
+ast_line_count(const VALUE ast_value)
 {
-    rb_ast_t *ast = rb_ruby_ast_data_get(vast);
+    rb_ast_t *ast = rb_ruby_ast_data_get(ast_value);
     return ast->body.line_count;
 }
 
@@ -880,11 +880,11 @@ iseq_new_setup_coverage(VALUE path, int line_count)
 }
 
 rb_iseq_t *
-rb_iseq_new_top(const VALUE vast, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent)
+rb_iseq_new_top(const VALUE ast_value, VALUE name, VALUE path, VALUE realpath, const rb_iseq_t *parent)
 {
-    iseq_new_setup_coverage(path, ast_line_count(vast));
+    iseq_new_setup_coverage(path, ast_line_count(ast_value));
 
-    return rb_iseq_new_with_opt(vast, name, path, realpath, 0, parent, 0,
+    return rb_iseq_new_with_opt(ast_value, name, path, realpath, 0, parent, 0,
                                 ISEQ_TYPE_TOP, &COMPILE_OPTION_DEFAULT,
                                 Qnil);
 }
@@ -902,11 +902,11 @@ pm_iseq_new_top(pm_scope_node_t *node, VALUE name, VALUE path, VALUE realpath, c
 }
 
 rb_iseq_t *
-rb_iseq_new_main(const VALUE vast, VALUE path, VALUE realpath, const rb_iseq_t *parent, int opt)
+rb_iseq_new_main(const VALUE ast_value, VALUE path, VALUE realpath, const rb_iseq_t *parent, int opt)
 {
-    iseq_new_setup_coverage(path, ast_line_count(vast));
+    iseq_new_setup_coverage(path, ast_line_count(ast_value));
 
-    return rb_iseq_new_with_opt(vast, rb_fstring_lit("<main>"),
+    return rb_iseq_new_with_opt(ast_value, rb_fstring_lit("<main>"),
                                 path, realpath, 0,
                                 parent, 0, ISEQ_TYPE_MAIN, opt ? &COMPILE_OPTION_DEFAULT : &COMPILE_OPTION_FALSE,
                                 Qnil);
@@ -927,16 +927,16 @@ pm_iseq_new_main(pm_scope_node_t *node, VALUE path, VALUE realpath, const rb_ise
 }
 
 rb_iseq_t *
-rb_iseq_new_eval(const VALUE vast, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth)
+rb_iseq_new_eval(const VALUE ast_value, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth)
 {
     if (rb_get_coverage_mode() & COVERAGE_TARGET_EVAL) {
         VALUE coverages = rb_get_coverages();
         if (RTEST(coverages) && RTEST(path) && !RTEST(rb_hash_has_key(coverages, path))) {
-            iseq_setup_coverage(coverages, path, ast_line_count(vast) + first_lineno - 1);
+            iseq_setup_coverage(coverages, path, ast_line_count(ast_value) + first_lineno - 1);
         }
     }
 
-    return rb_iseq_new_with_opt(vast, name, path, realpath, first_lineno,
+    return rb_iseq_new_with_opt(ast_value, name, path, realpath, first_lineno,
                                 parent, isolated_depth, ISEQ_TYPE_EVAL, &COMPILE_OPTION_DEFAULT,
                                 Qnil);
 }
@@ -971,12 +971,12 @@ iseq_translate(rb_iseq_t *iseq)
 }
 
 rb_iseq_t *
-rb_iseq_new_with_opt(const VALUE vast, VALUE name, VALUE path, VALUE realpath,
+rb_iseq_new_with_opt(const VALUE ast_value, VALUE name, VALUE path, VALUE realpath,
                      int first_lineno, const rb_iseq_t *parent, int isolated_depth,
                      enum rb_iseq_type type, const rb_compile_option_t *option,
                      VALUE script_lines)
 {
-    rb_ast_t *ast = rb_ruby_ast_data_get(vast);
+    rb_ast_t *ast = rb_ruby_ast_data_get(ast_value);
     rb_ast_body_t *body = ast ? &ast->body : NULL;
     const NODE *node = body ? body->root : 0;
     /* TODO: argument check */
@@ -1217,7 +1217,7 @@ rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE realpath, VALUE line, V
 #endif
     VALUE (*parse)(VALUE vparser, VALUE fname, VALUE file, int start);
     int ln;
-    VALUE INITIALIZED vast;
+    VALUE INITIALIZED ast_value;
     rb_ast_t *ast;
     VALUE name = rb_fstring_lit("<compiled>");
 
@@ -1239,17 +1239,17 @@ rb_iseq_compile_with_option(VALUE src, VALUE file, VALUE realpath, VALUE line, V
         rb_parser_set_context(parser, outer_scope, FALSE);
         if (ruby_vm_keep_script_lines) rb_parser_set_script_lines(parser);
         RB_GC_GUARD(outer_scope_v);
-        vast = (*parse)(parser, file, src, ln);
+        ast_value = (*parse)(parser, file, src, ln);
     }
 
-    ast = rb_ruby_ast_data_get(vast);
+    ast = rb_ruby_ast_data_get(ast_value);
 
     if (!ast || !ast->body.root) {
         rb_ast_dispose(ast);
         rb_exc_raise(GET_EC()->errinfo);
     }
     else {
-        iseq = rb_iseq_new_with_opt(vast, name, file, realpath, ln,
+        iseq = rb_iseq_new_with_opt(ast_value, name, file, realpath, ln,
                                     NULL, 0, ISEQ_TYPE_TOP, &option,
                                     Qnil);
         rb_ast_dispose(ast);
@@ -1624,7 +1624,7 @@ iseqw_s_compile_file(int argc, VALUE *argv, VALUE self)
     VALUE file, opt = Qnil;
     VALUE parser, f, exc = Qnil, ret;
     rb_ast_t *ast;
-    VALUE vast;
+    VALUE ast_value;
     rb_compile_option_t option;
     int i;
 
@@ -1643,8 +1643,8 @@ iseqw_s_compile_file(int argc, VALUE *argv, VALUE self)
 
     parser = rb_parser_new();
     rb_parser_set_context(parser, NULL, FALSE);
-    vast = rb_parser_load_file(parser, file);
-    ast = rb_ruby_ast_data_get(vast);
+    ast_value = rb_parser_load_file(parser, file);
+    ast = rb_ruby_ast_data_get(ast_value);
     if (!ast->body.root) exc = GET_EC()->errinfo;
 
     rb_io_close(f);
@@ -1655,7 +1655,7 @@ iseqw_s_compile_file(int argc, VALUE *argv, VALUE self)
 
     make_compile_option(&option, opt);
 
-    ret = iseqw_new(rb_iseq_new_with_opt(vast, rb_fstring_lit("<main>"),
+    ret = iseqw_new(rb_iseq_new_with_opt(ast_value, rb_fstring_lit("<main>"),
                                          file,
                                          rb_realpath_internal(Qnil, file, 1),
                                          1, NULL, 0, ISEQ_TYPE_TOP, &option,
diff --git a/load.c b/load.c
index 1309d566b9..37f7248b7d 100644
--- a/load.c
+++ b/load.c
@@ -762,13 +762,13 @@ load_iseq_eval(rb_execution_context_t *ec, VALUE fname)
         }
         else {
             rb_ast_t *ast;
-            VALUE vast;
+            VALUE ast_value;
             VALUE parser = rb_parser_new();
             rb_parser_set_context(parser, NULL, FALSE);
-            vast = rb_parser_load_file(parser, fname);
-            ast = rb_ruby_ast_data_get(vast);
+            ast_value = rb_parser_load_file(parser, fname);
+            ast = rb_ruby_ast_data_get(ast_value);
 
-            iseq = rb_iseq_new_top(vast, rb_fstring_lit("<top (required)>"),
+            iseq = rb_iseq_new_top(ast_value, rb_fstring_lit("<top (required)>"),
                                    fname, realpath_internal_cached(realpath_map, fname), NULL);
             rb_ast_dispose(ast);
         }
diff --git a/mini_builtin.c b/mini_builtin.c
index b38642e89b..810125fa2e 100644
--- a/mini_builtin.c
+++ b/mini_builtin.c
@@ -12,17 +12,17 @@
 static struct st_table *loaded_builtin_table;
 #endif
 
-VALUE rb_builtin_vast(const char *feature_name, VALUE *name_str);
+VALUE rb_builtin_ast_value(const char *feature_name, VALUE *name_str);
 
 static const rb_iseq_t *
 builtin_iseq_load(const char *feature_name, const struct rb_builtin_function *table)
 {
     VALUE name_str = 0;
     rb_ast_t *ast;
-    VALUE vast = rb_builtin_vast(feature_name, &name_str);
+    VALUE ast_value = rb_builtin_ast_value(feature_name, &name_str);
     rb_vm_t *vm = GET_VM();
 
-    if (NIL_P(vast)) {
+    if (NIL_P(ast_value)) {
         rb_fatal("builtin_iseq_load: can not find %s; "
                  "probably miniprelude.c is out of date",
                  feature_name);
@@ -40,8 +40,8 @@ builtin_iseq_load(const char *feature_name, const struct rb_builtin_function *ta
         .coverage_enabled = FALSE,
         .debug_level = 0,
     };
-    ast = rb_ruby_ast_data_get(vast);
-    const rb_iseq_t *iseq = rb_iseq_new_with_opt(vast, name_str, name_str, Qnil, 0, NULL, 0, ISEQ_TYPE_TOP, &optimization, Qnil);
+    ast = rb_ruby_ast_data_get(ast_value);
+    const rb_iseq_t *iseq = rb_iseq_new_with_opt(ast_value, name_str, name_str, Qnil, 0, NULL, 0, ISEQ_TYPE_TOP, &optimization, Qnil);
     GET_VM()->builtin_function_table = NULL;
 
     rb_ast_dispose(ast);
diff --git a/ruby.c b/ruby.c
index bfff15ba30..cd7f9ad4b8 100644
--- a/ruby.c
+++ b/ruby.c
@@ -2060,7 +2060,7 @@ static VALUE
 process_script(ruby_cmdline_options_t *opt)
 {
     rb_ast_t *ast;
-    VALUE vast;
+    VALUE ast_value;
     VALUE parser = rb_parser_new();
     const unsigned int dump = opt->dump;
 
@@ -2080,7 +2080,7 @@ process_script(ruby_cmdline_options_t *opt)
         ruby_set_script_name(progname);
         rb_parser_set_options(parser, opt->do_print, opt->do_loop,
                               opt->do_line, opt->do_split);
-        vast = rb_parser_compile_string(parser, opt->script, opt->e_script, 1);
+        ast_value = rb_parser_compile_string(parser, opt->script, opt->e_script, 1);
     }
     else {
         VALUE f;
@@ -2088,14 +2088,14 @@ process_script(ruby_cmdline_options_t *opt)
         f = open_load_file(opt->script_name, &xflag);
         opt->xflag = xflag != 0;
         rb_parser_set_context(parser, 0, f == rb_stdin);
-        vast = load_file(parser, opt->script_name, f, 1, opt);
+        ast_value = load_file(parser, opt->script_name, f, 1, opt);
     }
-    ast = rb_ruby_ast_data_get(vast);
+    ast = rb_ruby_ast_data_get(ast_value);
     if (!ast->body.root) {
         rb_ast_dispose(ast);
         return Qnil;
     }
-    return vast;
+    return ast_value;
 }
 
 /**
@@ -2239,7 +2239,7 @@ process_options_global_setup(const ruby_cmdline_options_t *opt, const rb_iseq_t
 static VALUE
 process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
 {
-    VALUE vast = Qnil;
+    VALUE ast_value = Qnil;
     struct {
         rb_ast_t *ast;
         pm_parse_result_t prism;
@@ -2474,8 +2474,8 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
     }
 
     if (!(*rb_ruby_prism_ptr())) {
-        vast = process_script(opt);
-        if (!(result.ast = rb_ruby_ast_data_get(vast))) return Qfalse;
+        ast_value = process_script(opt);
+        if (!(result.ast = rb_ruby_ast_data_get(ast_value))) return Qfalse;
     }
     else {
         prism_script(opt, &result.prism);
@@ -2557,7 +2557,7 @@ process_options(int argc, char **argv, ruby_cmdline_options_t *opt)
         }
         else {
             rb_ast_t *ast = result.ast;
-            iseq = rb_iseq_new_main(vast, opt->script_name, path, parent, optimize);
+            iseq = rb_iseq_new_main(ast_value, opt->script_name, path, parent, optimize);
             rb_ast_dispose(ast);
         }
     }
@@ -2608,7 +2608,7 @@ load_file_internal(VALUE argp_v)
     ruby_cmdline_options_t *opt = argp->opt;
     VALUE f = argp->f;
     int line_start = 1;
-    VALUE vast = Qnil;
+    VALUE ast_value = Qnil;
     rb_encoding *enc;
     ID set_encoding;
 
@@ -2709,7 +2709,7 @@ load_file_internal(VALUE argp_v)
         return rb_parser_compile_string_path(parser, orig_fname, f, line_start);
     }
     rb_funcall(f, set_encoding, 2, rb_enc_from_encoding(enc), rb_str_new_cstr("-"));
-    vast = rb_parser_compile_file_path(parser, orig_fname, f, line_start);
+    ast_value = rb_parser_compile_file_path(parser, orig_fname, f, line_start);
     rb_funcall(f, set_encoding, 1, rb_parser_encoding(parser));
     if (script && rb_parser_end_seen_p(parser)) {
         /*
@@ -2727,7 +2727,7 @@ load_file_internal(VALUE argp_v)
         rb_define_global_const("DATA", f);
         argp->f = Qnil;
     }
-    return vast;
+    return ast_value;
 }
 
 /* disabling O_NONBLOCK, and returns 0 on success, otherwise errno */
@@ -2859,9 +2859,9 @@ rb_load_file(const char *fname)
 void *
 rb_load_file_str(VALUE fname_v)
 {
-    VALUE vast;
-    vast = rb_parser_load_file(rb_parser_new(), fname_v);
-    return (void *)rb_ruby_ast_data_get(vast);
+    VALUE ast_value;
+    ast_value = rb_parser_load_file(rb_parser_new(), fname_v);
+    return (void *)rb_ruby_ast_data_get(ast_value);
 }
 
 VALUE
diff --git a/ruby_parser.c b/ruby_parser.c
index 4c981df29d..085ba99dfa 100644
--- a/ruby_parser.c
+++ b/ruby_parser.c
@@ -791,65 +791,65 @@ VALUE
 rb_parser_compile_file_path(VALUE vparser, VALUE fname, VALUE file, int start)
 {
     struct ruby_parser *parser;
-    VALUE vast = ast_alloc();
+    VALUE ast_value = ast_alloc();
 
     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
-    DATA_PTR(vast) = parser_compile_file_path(parser, fname, file, start);
+    DATA_PTR(ast_value) = parser_compile_file_path(parser, fname, file, start);
     RB_GC_GUARD(vparser);
 
-    return vast;
+    return ast_value;
 }
 
 VALUE
 rb_parser_compile_array(VALUE vparser, VALUE fname, VALUE array, int start)
 {
     struct ruby_parser *parser;
-    VALUE vast = ast_alloc();
+    VALUE ast_value = ast_alloc();
 
     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
-    DATA_PTR(vast) = parser_compile_array(parser, fname, array, start);
+    DATA_PTR(ast_value) = parser_compile_array(parser, fname, array, start);
     RB_GC_GUARD(vparser);
 
-    return vast;
+    return ast_value;
 }
 
 VALUE
 rb_parser_compile_generic(VALUE vparser, rb_parser_lex_gets_func *lex_gets, VALUE fname, VALUE input, int start)
 {
     struct ruby_parser *parser;
-    VALUE vast = ast_alloc();
+    VALUE ast_value = ast_alloc();
 
     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
-    DATA_PTR(vast) = parser_compile_generic(parser, lex_gets, fname, input, start);
+    DATA_PTR(ast_value) = parser_compile_generic(parser, lex_gets, fname, input, start);
     RB_GC_GUARD(vparser);
 
-    return vast;
+    return ast_value;
 }
 
 VALUE
 rb_parser_compile_string(VALUE vparser, const char *f, VALUE s, int line)
 {
     struct ruby_parser *parser;
-    VALUE vast = ast_alloc();
+    VALUE ast_value = ast_alloc();
 
     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
-    DATA_PTR(vast) = parser_compile_string(parser, f, s, line);
+    DATA_PTR(ast_value) = parser_compile_string(parser, f, s, line);
     RB_GC_GUARD(vparser);
 
-    return vast;
+    return ast_value;
 }
 
 VALUE
 rb_parser_compile_string_path(VALUE vparser, VALUE f, VALUE s, int line)
 {
     struct ruby_parser *parser;
-    VALUE vast = ast_alloc();
+    VALUE ast_value = ast_alloc();
 
     TypedData_Get_Struct(vparser, struct ruby_parser, &ruby_parser_data_type, parser);
-    DATA_PTR(vast) = parser_compile_string_path(parser, f, s, line);
+    DATA_PTR(ast_value) = parser_compile_string_path(parser, f, s, line);
     RB_GC_GUARD(vparser);
 
-    return vast;
+    return ast_value;
 }
 
 VALUE
@@ -1137,7 +1137,7 @@ VALUE
 rb_ruby_ast_new(const NODE *const root)
 {
     rb_ast_t *ast;
-    VALUE vast = TypedData_Make_Struct(0, rb_ast_t, &ast_data_type, ast);
+    VALUE ast_value = TypedData_Make_Struct(0, rb_ast_t, &ast_data_type, ast);
 #ifdef UNIVERSAL_PARSER
     ast->config = &rb_global_parser_config;
 #endif
@@ -1148,14 +1148,14 @@ rb_ruby_ast_new(const NODE *const root)
         .script_lines = NULL,
         .line_count = 0,
     };
-    return vast;
+    return ast_value;
 }
 
 rb_ast_t *
-rb_ruby_ast_data_get(VALUE vast)
+rb_ruby_ast_data_get(VALUE ast_value)
 {
     rb_ast_t *ast;
-    if (NIL_P(vast)) return NULL;
-    TypedData_Get_Struct(vast, rb_ast_t, &ast_data_type, ast);
+    if (NIL_P(ast_value)) return NULL;
+    TypedData_Get_Struct(ast_value, rb_ast_t, &ast_data_type, ast);
     return ast;
 }
diff --git a/template/prelude.c.tmpl b/template/prelude.c.tmpl
index 386511f20c..e17a75da79 100644
--- a/template/prelude.c.tmpl
+++ b/template/prelude.c.tmpl
@@ -142,16 +142,16 @@ COMPILER_WARNING_POP
 #define PRELUDE_CODE(n) rb_utf8_str_new_static(prelude_code##n.L0, sizeof(prelude_code##n))
 
 static VALUE
-prelude_vast(VALUE name, VALUE code, int line)
+prelude_ast_value(VALUE name, VALUE code, int line)
 {
     rb_ast_t *ast;
-    VALUE vast = rb_parser_compile_string_path(rb_parser_new(), name, code, line);
-    ast = rb_ruby_ast_data_get(vast);
+    VALUE ast_value = rb_parser_compile_string_path(rb_parser_new(), name, code, line);
+    ast = rb_ruby_ast_data_get(ast_value);
     if (!ast || !ast->body.root) {
         if (ast) rb_ast_dispose(ast);
         rb_exc_raise(rb_errinfo());
     }
-    return vast;
+    return ast_value;
 }
 
 % end
@@ -159,21 +159,21 @@ prelude_vast(VALUE name, VALUE code, int line)
 #define PRELUDE_VAST(n, name_str, start_line) \
     (((sizeof(prelude_name<%='##'%><%=%>n) - prefix_len - 2) == namelen) && \
      (strncmp(prelude_name<%='##'%><%=%>n + prefix_len, feature_name, namelen) == 0) ? \
-     prelude_vast((name_str) = PRELUDE_NAME(n), PRELUDE_CODE(n), start_line) : Qnil)
+     prelude_ast_value((name_str) = PRELUDE_NAME(n), PRELUDE_CODE(n), start_line) : Qnil)
 
 VALUE
-rb_builtin_vast(const char *feature_name, VALUE *name_str)
+rb_builtin_ast_value(const char *feature_name, VALUE *name_str)
 {
     const size_t prefix_len = rb_strlen_lit("<internal:");
     size_t namelen = strlen(feature_name);
-    VALUE vast = Qnil;
+    VALUE ast_value = Qnil;
 
 %   @preludes.each_value do |i, prelude, lines, sub, start_line|
 %     if sub
-    if (!NIL_P(vast = PRELUDE_VAST(<%=i%><%=%>, *name_str, <%=start_line%>))) return vast;
+    if (!NIL_P(ast_value = PRELUDE_VAST(<%=i%><%=%>, *name_str, <%=start_line%>))) return ast_value;
 %     end
 %   end
-    return vast;
+    return ast_value;
 }
 
 % end
@@ -199,9 +199,9 @@ prelude_eval(VALUE code, VALUE name, int line)
     };
 
     rb_ast_t *ast;
-    VALUE vast = prelude_vast(name, code, line);
-    ast = rb_ruby_ast_data_get(vast);
-    rb_iseq_eval(rb_iseq_new_with_opt(vast, name, name, Qnil, line,
+    VALUE ast_value = prelude_ast_value(name, code, line);
+    ast = rb_ruby_ast_data_get(ast_value);
+    rb_iseq_eval(rb_iseq_new_with_opt(ast_value, name, name, Qnil, line,
                                       NULL, 0, ISEQ_TYPE_TOP, &optimization,
                                       Qnil));
     rb_ast_dispose(ast);
diff --git a/vm.c b/vm.c
index dbee303851..7e39940017 100644
--- a/vm.c
+++ b/vm.c
@@ -1480,14 +1480,14 @@ rb_binding_add_dynavars(VALUE bindval, rb_binding_t *bind, int dyncount, const I
     tmp_node.nd_body = 0;
     tmp_node.nd_args = 0;
 
-    VALUE vast = rb_ruby_ast_new(RNODE(&tmp_node));
+    VALUE ast_value = rb_ruby_ast_new(RNODE(&tmp_node));
 
     if (base_iseq) {
-        iseq = rb_iseq_new(vast, ISEQ_BODY(base_iseq)->location.label, path, realpath, base_iseq, ISEQ_TYPE_EVAL);
+        iseq = rb_iseq_new(ast_value, ISEQ_BODY(base_iseq)->location.label, path, realpath, base_iseq, ISEQ_TYPE_EVAL);
     }
     else {
         VALUE tempstr = rb_fstring_lit("<temp>");
-        iseq = rb_iseq_new_top(vast, tempstr, tempstr, tempstr, NULL);
+        iseq = rb_iseq_new_top(ast_value, tempstr, tempstr, tempstr, NULL);
     }
     tmp_node.nd_tbl = 0; /* reset table */
     ALLOCV_END(idtmp);
diff --git a/vm_core.h b/vm_core.h
index 69b7899ec4..30e06c48ed 100644
--- a/vm_core.h
+++ b/vm_core.h
@@ -1209,11 +1209,11 @@ typedef enum {
 RUBY_SYMBOL_EXPORT_BEGIN
 
 /* node -> iseq */
-rb_iseq_t *rb_iseq_new         (const VALUE vast, VALUE name, VALUE path, VALUE realpath,                   const rb_iseq_t *parent, enum rb_iseq_type);
-rb_iseq_t *rb_iseq_new_top     (const VALUE vast, VALUE name, VALUE path, VALUE realpath,                   const rb_iseq_t *parent);
-rb_iseq_t *rb_iseq_new_main    (const VALUE vast,             VALUE path, VALUE realpath,                   const rb_iseq_t *parent, int opt);
-rb_iseq_t *rb_iseq_new_eval    (const VALUE vast, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth);
-rb_iseq_t *rb_iseq_new_with_opt(const VALUE vast, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth,
+rb_iseq_t *rb_iseq_new         (const VALUE ast_value, VALUE name, VALUE path, VALUE realpath,                   const rb_iseq_t *parent, enum rb_iseq_type);
+rb_iseq_t *rb_iseq_new_top     (const VALUE ast_value, VALUE name, VALUE path, VALUE realpath,                   const rb_iseq_t *parent);
+rb_iseq_t *rb_iseq_new_main    (const VALUE ast_value,             VALUE path, VALUE realpath,                   const rb_iseq_t *parent, int opt);
+rb_iseq_t *rb_iseq_new_eval    (const VALUE ast_value, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth);
+rb_iseq_t *rb_iseq_new_with_opt(const VALUE ast_value, VALUE name, VALUE path, VALUE realpath, int first_lineno, const rb_iseq_t *parent, int isolated_depth,
                                 enum rb_iseq_type, const rb_compile_option_t*,
                                 VALUE script_lines);
 
diff --git a/vm_eval.c b/vm_eval.c
index 4dfff02f6b..7eafb2d5f7 100644
--- a/vm_eval.c
+++ b/vm_eval.c
@@ -1753,7 +1753,7 @@ eval_make_iseq(VALUE src, VALUE fname, int line,
     const VALUE parser = rb_parser_new();
     const rb_iseq_t *const parent = vm_block_iseq(base_block);
     rb_iseq_t *iseq = NULL;
-    VALUE vast;
+    VALUE ast_value;
     rb_ast_t *ast;
     int isolated_depth = 0;
 
@@ -1791,13 +1791,13 @@ eval_make_iseq(VALUE src, VALUE fname, int line,
 
     rb_parser_set_context(parser, parent, FALSE);
     if (ruby_vm_keep_script_lines) rb_parser_set_script_lines(parser);
-    vast = rb_parser_compile_string_path(parser, fname, src, line);
+    ast_value = rb_parser_compile_string_path(parser, fname, src, line);
 
-    ast = rb_ruby_ast_data_get(vast);
+    ast = rb_ruby_ast_data_get(ast_value);
 
     if (ast->body.root) {
         ast->body.coverage_enabled = coverage_enabled;
-        iseq = rb_iseq_new_eval(vast,
+        iseq = rb_iseq_new_eval(ast_value,
                                 ISEQ_BODY(parent)->location.label,
                                 fname, Qnil, line,
                                 parent, isolated_depth);