Untested ast iterator

core_compiler_interface.hpp

@@ -366,7 +366,10 @@ enum {
 struct Ast {
     uint64_t di; // Debug id, shouldn't ever be used in the program
     Token *pos;
+
     Ast_Kind kind;
+    uint32_t visit_id;
+
     Ast_Scope *parent_scope;
     Ast_Flag flags;
 };
@@ -554,7 +557,6 @@ struct Ast_Scope : Ast {
     List<Ast_Decl *> decls;
     Array<Ast *> stmts;
 
-    uint32_t visit_id;
     uint32_t scope_id;
     Ast_Scope *file; // Self referential for file and module
     Ast_Module *module;

core_polymorph.cpp

@@ -23,90 +23,195 @@ struct Ast_Iter {
     Array<Ast *> stack;
     Ast *ast;
     Ast_Kind kind;
+    uint32_t visit_id;
 };
 
+uint32_t Ast_Iter_VisitIDGen;
 Ast_Iter iterate_depth_first(Allocator *a, Ast *ast) {
     Ast_Iter result = {};
     result.stack = {a};
-    result.ast = ast;
+    result.stack.add(ast);
-    result.kind = ast->kind;
+    result.visit_id = ++Ast_Iter_VisitIDGen;
     return result;
 }
 
 void next(Ast_Iter *iter) {
-    Ast *ast = iter->ast;
+    if (iter->stack.len <= 0) {
-    switch (ast->kind) {
+        iter->ast = 0;
-        case AST_NAMESPACE: {
+        iter->kind = AST_NONE;
-        } break;
+        return;
-        case AST_MODULE: {
+    }
-        } break;
+
-        case AST_FILE: {
+    Ast *ast = iter->stack.pop();
-        } break;
+    assert(ast != 0);
+    iter->ast = ast;
+    iter->kind = ast->kind;
+    if (ast->visit_id == iter->visit_id) {
+        iter->kind = (Ast_Kind)((unsigned)iter->kind + 128);
+    }
+    ast->visit_id = iter->visit_id;
+
+    switch (iter->kind) {
         case AST_SCOPE: {
+            Ast_Scope *node = (Ast_Scope *)ast;
+            For(node->decls) {
+                iter->stack.add(it);
+            }
+            For(node->stmts) {
+                iter->stack.add(it);
+            }
+            iter->stack.add(node);
         } break;
+
+        case AST_MODULE: invalid_codepath; break;
+        case AST_FILE: invalid_codepath; break;
+
+        case AST_IDENT:
         case AST_VALUE: {
+            Ast_Atom *node = (Ast_Atom *)ast;
         } break;
-        case AST_IDENT: {
+
-        } break;
         case AST_INDEX: {
+            Ast_Index *node = (Ast_Index *)ast;
+            iter->stack.add(node->expr);
+            iter->stack.add(node->index);
+            iter->stack.add(node);
         } break;
+
         case AST_UNARY: {
+            Ast_Unary *node = (Ast_Unary *)ast;
+            iter->stack.add(node->expr);
+            iter->stack.add(node);
         } break;
+
         case AST_BINARY: {
+            Ast_Binary *node = (Ast_Binary *)ast;
+            iter->stack.add(node->left);
+            iter->stack.add(node->right);
+            iter->stack.add(node);
         } break;
+
         case AST_CALL_ITEM: {
+            Ast_Call_Item *node = (Ast_Call_Item *)ast;
+            iter->stack.add(node->item);
+            if (node->call_flags & CALL_INDEX) {
+                iter->stack.add(node->index);
+            }
+            else if (node->call_flags & CALL_NAME) {
+                iter->stack.add(node->name);
+            }
+            iter->stack.add(node);
         } break;
+
+        case AST_COMPOUND:
         case AST_CALL: {
+            Ast_Call *node = (Ast_Call *)ast;
+            iter->stack.add(node->name);
+            For(node->exprs) {
+                iter->stack.add(it);
+            }
+            iter->stack.add(node);
         } break;
+
+        case AST_TYPE_OF:
+        case AST_LENGTH_OF:
+        case AST_ALIGN_OF:
+        case AST_SIZE_OF:
+        case AST_RUNTIME_ASSERT:
         case AST_CONSTANT_ASSERT: {
+            Ast_Builtin *node = (Ast_Builtin *)ast;
+            iter->stack.add(node->expr);
+            iter->stack.add(node);
         } break;
-        case AST_RUNTIME_ASSERT: {
+
-        } break;
-        case AST_SIZE_OF: {
-        } break;
-        case AST_LENGTH_OF: {
-        } break;
-        case AST_ALIGN_OF: {
-        } break;
-        case AST_TYPE_OF: {
-        } break;
         case AST_SWITCH: {
+            Ast_Switch *node = (Ast_Switch *)ast;
+            iter->stack.add(node->value);
+            For(node->cases) iter->stack.add(it);
+            iter->stack.add(node->default_scope);
+            iter->stack.add(node);
         } break;
+
         case AST_SWITCH_CASE: {
+            Ast_Switch_Case *node = (Ast_Switch_Case *)ast;
+            For(node->labels) iter->stack.add(it);
+            iter->stack.add(node->scope);
+            iter->stack.add(node);
         } break;
+
         case AST_VAR_UNPACK: {
+            Ast_Var_Unpack *node = (Ast_Var_Unpack *)ast;
+            For(node->vars) iter->stack.add(it);
+            iter->stack.add(node->expr);
+            iter->stack.add(node);
         } break;
+
+        case AST_PASS:
         case AST_BREAK: {
+            Ast *node = (Ast *)ast;
         } break;
-        case AST_COMPOUND: {
+
-        } break;
+        case AST_NAMESPACE:
-        case AST_TYPE: {
+        case AST_STRUCT:
-        } break;
+        case AST_UNION:
+        case AST_ENUM:
+        case AST_LAMBDA:
+        case AST_TYPE: // @cleanup: what is this used for?
+        case AST_CONST:
         case AST_VAR: {
+            Ast_Decl *node = (Ast_Decl *)ast;
+
+            iter->stack.add(node->typespec);
+            iter->stack.add(node->expr);
+            iter->stack.add(node->scope);
+            iter->stack.add(node);
+
+            // omitting polymorphs
+            // omitting polymorph parameters
         } break;
-        case AST_CONST: {
+
-        } break;
         case AST_ARRAY: {
+            Ast_Array *node = (Ast_Array *)ast;
+            iter->stack.add(node->expr);
+            iter->stack.add(node);
+            // dst->expr = (Ast_Expr *)ast_copy(node->expr, parent_scope);
         } break;
+
         case AST_FOR: {
+            Ast_For *node = (Ast_For *)ast;
+            if (node->init) iter->stack.add(node->init);
+            if (node->cond) iter->stack.add(node->cond);
+            if (node->iter) iter->stack.add(node->iter);
+            iter->stack.add(node->scope);
+            iter->stack.add(node);
         } break;
+
         case AST_IF: {
+            Ast_If *node = (Ast_If *)ast;
+            For(node->ifs) iter->stack.add(it);
+            iter->stack.add(node);
         } break;
+
         case AST_IF_NODE: {
+            Ast_If_Node *node = (Ast_If_Node *)ast;
+            if (node->init) iter->stack.add(node->init);
+            iter->stack.add(node->expr);
+            iter->stack.add(node->scope);
+            iter->stack.add(node);
         } break;
+
         case AST_RETURN: {
+            Ast_Return *node = (Ast_Return *)ast;
+            For(node->expr) iter->stack.add(it);
+            iter->stack.add(node);
         } break;
-        case AST_PASS: {
+
-        } break;
-        case AST_LAMBDA: {
-        } break;
         case AST_LAMBDA_EXPR: {
-        } break;
+            Ast_Lambda *node = (Ast_Lambda *)ast;
-        case AST_ENUM: {
+            For(node->args) iter->stack.add(it);
-        } break;
+            For(node->ret) iter->stack.add(it);
-        case AST_STRUCT: {
+            iter->stack.add(node->scope);
-        } break;
+            iter->stack.add(node);
-        case AST_UNION: {
         } break;
     }
 }
@@ -121,12 +226,6 @@ Ast *ast_copy(Ast *ast, Ast_Scope *parent_scope) {
             Ast_Scope *dst = push_struct_copy(pctx->perm, Ast_Scope, ast);
             dst->parent_scope = parent_scope;
 
-            dst->implicit_imports = {};
-            For(src->implicit_imports) {
-                Ast_Scope *copy = (Ast_Scope *)ast_copy(it, dst);
-                add(pctx->perm, &dst->implicit_imports, copy);
-            }
-
             dst->decls = {};
             For(src->decls) {
                 Ast_Decl *copy = (Ast_Decl *)ast_copy(it, dst);