From 50ba7cf91d107e80b545cf92df1c1f05ea91a7a0 Mon Sep 17 00:00:00 2001
From: Charlie Gordon <github@chqrlie.org>
Date: Thu, 29 Jan 2026 00:38:57 +0100
Subject: [PATCH] Compiler: use size and get accessors in visitor functions

* allow for array reallocation in visitor handlers
---
 analyser/scope.c2                   | 22 ++++------
 ast/ast.c2                          | 67 ++++++++++++-----------------
 ast/call_expr.c2                    |  4 ++
 ast/function_decl_list.c2           |  4 ++
 ast/import_decl_list.c2             |  4 +-
 ast/struct_type_decl.c2             |  5 +--
 ast/symbol_table.c2                 |  7 ++-
 ast/type_ref.c2                     | 10 ++++-
 generator/c/c_generator_special.c2  |  9 ++--
 generator/c2i/c2i_generator_expr.c2 |  4 +-
 plugins/unit_test_plugin.c2         | 12 ++----
 11 files changed, 67 insertions(+), 81 deletions(-)

diff --git a/analyser/scope.c2 b/analyser/scope.c2
index 0c5c5649b..1ed429ed6 100644
--- a/analyser/scope.c2
+++ b/analyser/scope.c2
@@ -106,10 +106,8 @@ public fn void Scope.reset(Scope* s) {
 fn void Scope.addImports(Scope* s) {
     // Note: this also adds the module itself (import[0])
 
-    u32 num_imports = s.imports.size();
-    ast.ImportDecl** imports = s.imports.getDecls();
-    for (u32 i=0; i<num_imports; i++) {
-        ast.ImportDecl* id = imports[i];
+    for (u32 i = 0; i < s.imports.size(); i++) {
+        ast.ImportDecl* id = s.imports.get(i);
         ast.Decl* d = (ast.Decl*)id;
         u32 name_idx = id.getImportNameIdx();
 
@@ -308,11 +306,9 @@ public fn ast.Decl* Scope.find(Scope* s, u32 name_idx, SrcLoc loc, bool usedPubl
 
 // returns false if symbol exists and will give errors then
 public fn bool Scope.checkGlobalSymbol(Scope* s, u32 name_idx, SrcLoc loc) {
-    u32 num_imports = s.imports.size();
-    ast.ImportDecl** imports = s.imports.getDecls();
     ast.Decl* decl = nil;
-    for (u32 i=0; i<num_imports; i++) {
-        ast.ImportDecl* id = imports[i];
+    for (u32 i = 0; i < s.imports.size(); i++) {
+        ast.ImportDecl* id = s.imports.get(i);
         // check if it is the import itself
         if (name_idx == id.getImportNameIdx()) {
             decl = (ast.Decl*)id;
@@ -418,10 +414,8 @@ fn ast.Decl* Scope.findGlobalSymbol(Scope* s, u32 name_idx, SrcLoc loc, bool* ot
     ast.ImportDecl* used_import = nil;
     bool ambiguous = false;
 
-    u32 num_imports = s.imports.size();
-    ast.ImportDecl** imports = s.imports.getDecls();
-    for (u32 i=0; i<num_imports; i++) {
-        ast.ImportDecl* id = imports[i];
+    for (u32 i = 0; i < s.imports.size(); i++) {
+        ast.ImportDecl* id = s.imports.get(i);
         if (!id.isLocal()) continue;    // this includes implicit self-import
 
         ast.Module* dest = id.getDest();
@@ -477,8 +471,8 @@ fn ast.Decl* Scope.findGlobalSymbol(Scope* s, u32 name_idx, SrcLoc loc, bool* ot
     } else {
         if (search_privates) {
             // try finding a non-public symbol
-            for (u32 i=0; i<num_imports; i++) {
-                ast.ImportDecl* id = imports[i];
+            for (u32 i = 0; i < s.imports.size(); i++) {
+                ast.ImportDecl* id = s.imports.get(i);
                 if (!id.isLocal()) continue;
                 ast.Module* dest = id.getDest();
                 ast.Decl* d = dest.findPrivateSymbol(name_idx);
diff --git a/ast/ast.c2 b/ast/ast.c2
index f5b893304..09f9adb0c 100644
--- a/ast/ast.c2
+++ b/ast/ast.c2
@@ -90,8 +90,8 @@ public fn u32 AST.getNameIdx(const AST* a) {
 }
 
 public fn SrcLoc AST.getLoc(const AST* a) {
-    ImportDecl** imports = a.imports.getDecls();
-    Decl* d = (Decl*)imports[0];
+    // Note: use the first 'Import' since it is really the module statement
+    Decl* d = (Decl*)a.imports.get(0);
     return d.getLoc();
 }
 
@@ -106,11 +106,9 @@ public fn void AST.addImport(AST* a, ImportDecl* d) {
 }
 
 public fn ImportDecl* AST.findImport(const AST* a, u32 name) {
-    ImportDecl** imports = a.imports.getDecls();
     for (u32 i=1; i<a.imports.size(); i++) {
-        ImportDecl* d = imports[i];
+        ImportDecl* d = a.imports.get(i);
         if (d.asDecl().getNameIdx() == name) return d;
-
     }
     return nil;
 }
@@ -146,10 +144,9 @@ public fn void AST.addArrayValue(AST* a, ArrayValue* v) {
 public type ImportVisitor fn void (void* arg, ImportDecl* d);
 
 public fn void AST.visitImports(const AST* a, ImportVisitor visitor, void* arg) {
-    ImportDecl** imports = a.imports.getDecls();
     // Note: skip first 'Import' since it is really the module statement
     for (u32 i=1; i<a.imports.size(); i++) {
-        visitor(arg, imports[i]);
+        visitor(arg, a.imports.get(i));
     }
 }
 
@@ -167,17 +164,15 @@ fn void AST.visitArrayValues(AST* a, ArrayValueVisitor visitor, void* arg) {
 public type FunctionVisitor fn void (void* arg, FunctionDecl* d);
 
 fn void AST.visitTypeFunctions(const AST* a, FunctionVisitor visitor, void* arg) {
-    FunctionDecl** functions = a.functions.getDecls();
     for (u32 i=0; i<a.functions.size(); i++) {
-        FunctionDecl* d = functions[i];
+        FunctionDecl* d = a.functions.get(i);
         if (d.hasPrefix()) visitor(arg, d);
     }
 }
 
 public fn void AST.visitFunctions(const AST* a, FunctionVisitor visitor, void* arg) {
-    FunctionDecl** functions = a.functions.getDecls();
     for (u32 i=0; i<a.functions.size(); i++) {
-        FunctionDecl* d = functions[i];
+        FunctionDecl* d = a.functions.get(i);
         visitor(arg, d);
     }
 }
@@ -185,18 +180,16 @@ public fn void AST.visitFunctions(const AST* a, FunctionVisitor visitor, void* a
 public type TypeDeclVisitor fn void (void* arg, Decl* d);
 
 public fn void AST.visitTypeDecls(const AST* a, TypeDeclVisitor visitor, void* arg) {
-    Decl** types = a.types.getDecls();
     for (u32 i=0; i<a.types.size(); i++) {
-        visitor(arg, types[i]);
+        visitor(arg, a.types.get(i));
     }
 }
 
 public type VarDeclVisitor fn void (void* arg, VarDecl* d);
 
 public fn void AST.visitVarDecls(const AST* a, VarDeclVisitor visitor, void* arg) {
-    Decl** variables = a.variables.getDecls();
     for (u32 i=0; i<a.variables.size(); i++) {
-        visitor(arg, (VarDecl*)variables[i]);
+        visitor(arg, (VarDecl*)a.variables.get(i));
     }
 }
 
@@ -213,9 +206,8 @@ public type DeclVisitor fn void (void* arg, Decl* d);
 
 public fn void AST.visitDecls(const AST* a, DeclVisitor visitor, void* arg) {
     // imports
-    ImportDecl** imports = a.imports.getDecls();
     for (u32 i=0; i<a.imports.size(); i++) {
-        visitor(arg, (Decl*)imports[i]);
+        visitor(arg, (Decl*)a.imports.get(i));
     }
 
     a.visitDeclsWithoutImports(visitor, arg);
@@ -223,29 +215,24 @@ public fn void AST.visitDecls(const AST* a, DeclVisitor visitor, void* arg) {
 
 fn void AST.visitDeclsWithoutImports(const AST* a, DeclVisitor visitor, void* arg) {
     // types
-    Decl** types = a.types.getDecls();
     for (u32 i=0; i<a.types.size(); i++) {
-        visitor(arg, types[i]);
+        visitor(arg, a.types.get(i));
     }
 
     // variables
-    Decl** variables = a.variables.getDecls();
     for (u32 i=0; i<a.variables.size(); i++) {
-        visitor(arg, variables[i]);
+        visitor(arg, a.variables.get(i));
     }
 
     // functions
-    FunctionDecl** functions = a.functions.getDecls();
     for (u32 i=0; i<a.functions.size(); i++) {
-        FunctionDecl* d = functions[i];
-        visitor(arg, (Decl*)d);
+        visitor(arg, (Decl*)a.functions.get(i));
     }
 }
 
 fn Decl* AST.findType(const AST* a, u32 name_idx) {
-    Decl** types = a.types.getDecls();
     for (u32 i=0; i<a.types.size(); i++) {
-        Decl* d = types[i];
+        Decl* d = a.types.get(i);
         if (d.getNameIdx() == name_idx) return d;
     }
     return nil;
@@ -274,28 +261,28 @@ fn void AST.print(const AST* a, string_buffer.Buf* out, bool show_funcs) {
     out.color(col_Normal);
     out.print("---- AST %s ----\n", a.getFilename());
 
-    ImportDecl** imports = a.imports.getDecls();
     for (u32 i=1; i<a.imports.size(); i++) {
-        imports[i].print(out, 0);
+        ImportDecl* d = a.imports.get(i);
+        d.print(out, 0);
     }
     if (a.imports.size() > 1) out.newline();
 
-    Decl** types = a.types.getDecls();
     for (u32 i=0; i<a.types.size(); i++) {
-        types[i].print(out, 0);
+        Decl* d = a.types.get(i);
+        d.print(out, 0);
         out.newline();
     }
 
-    Decl** variables = a.variables.getDecls();
     for (u32 i=0; i<a.variables.size(); i++) {
-        variables[i].print(out, 0);
+        Decl* d = a.variables.get(i);
+        d.print(out, 0);
         out.newline();
     }
 
     if (show_funcs) {
-        FunctionDecl** functions = a.functions.getDecls();
         for (u32 i=0; i<a.functions.size(); i++) {
-            functions[i].print(out, 0);
+            FunctionDecl* d = a.functions.get(i);
+            d.print(out, 0);
             out.newline();
         }
     }
@@ -308,21 +295,21 @@ fn void AST.print(const AST* a, string_buffer.Buf* out, bool show_funcs) {
 
 fn void AST.setExported(AST* a) {
     // types, cannot be really exported, but do mark as such (for used?)
-    Decl** types = a.types.getDecls();
     for (u32 i=0; i<a.types.size(); i++) {
-        types[i].setExportedIfPublic();
+        Decl* d = a.types.get(i);
+        d.setExportedIfPublic();
     }
 
     // variables
-    Decl** variables = a.variables.getDecls();
     for (u32 i=0; i<a.variables.size(); i++) {
-        variables[i].setExportedIfPublic();
+        Decl* d = a.variables.get(i);
+        d.setExportedIfPublic();
     }
 
     // functions
-    Decl** functions = (Decl**)a.functions.getDecls();
     for (u32 i=0; i<a.functions.size(); i++) {
-        functions[i].setExportedIfPublic();
+        Decl* d = (Decl*)a.functions.get(i);
+        d.setExportedIfPublic();
     }
 }
 
diff --git a/ast/call_expr.c2 b/ast/call_expr.c2
index d846e4054..e33f2ea58 100644
--- a/ast/call_expr.c2
+++ b/ast/call_expr.c2
@@ -190,6 +190,10 @@ public fn Expr** CallExpr.getArgs(CallExpr* e) {
     return e.args;
 }
 
+public fn Expr* CallExpr.getArg(const CallExpr* e, u32 i) {
+    return e.args[i];
+}
+
 fn void CallExpr.printLiteral(const CallExpr* e, string_buffer.Buf* out) {
     e.func.printLiteral(out);
     out.lparen();
diff --git a/ast/function_decl_list.c2 b/ast/function_decl_list.c2
index ba0cb16f6..c58e539b7 100644
--- a/ast/function_decl_list.c2
+++ b/ast/function_decl_list.c2
@@ -56,6 +56,10 @@ public fn u32 FunctionDeclList.size(const FunctionDeclList* l) {
     return l.count;
 }
 
+public fn FunctionDecl* FunctionDeclList.get(const FunctionDeclList* l, u32 i) @(unused) {
+    return l.decls[i];
+}
+
 public fn FunctionDecl** FunctionDeclList.getDecls(const FunctionDeclList* l) {
     return l.decls;
 }
diff --git a/ast/import_decl_list.c2 b/ast/import_decl_list.c2
index 2d3e339cf..92868e74e 100644
--- a/ast/import_decl_list.c2
+++ b/ast/import_decl_list.c2
@@ -52,8 +52,8 @@ public fn u32 ImportDeclList.size(const ImportDeclList* l) {
     return l.count;
 }
 
-public fn ImportDecl** ImportDeclList.getDecls(const ImportDeclList* l) {
-    return l.decls;
+public fn ImportDecl* ImportDeclList.get(const ImportDeclList* l, u32 i) {
+    return l.decls[i];
 }
 
 public fn ImportDecl* ImportDeclList.find(const ImportDeclList* l, u32 name_idx) {
diff --git a/ast/struct_type_decl.c2 b/ast/struct_type_decl.c2
index a379bb276..87399615e 100644
--- a/ast/struct_type_decl.c2
+++ b/ast/struct_type_decl.c2
@@ -166,9 +166,8 @@ public fn bool StructTypeDecl.isUnion(const StructTypeDecl* d) {
     return !d.base.structTypeDeclBits.is_struct;
 }
 
-fn const FunctionDecl** StructTypeDecl.getStructFunctions(const StructTypeDecl* d) {
-    // TEMP const-cast until ptr-ptr -> const ptr-ptr is fixed in analyser
-    return (const FunctionDecl**)d.struct_functions;
+fn FunctionDecl* StructTypeDecl.getStructFunction(const StructTypeDecl* d, u32 i) {
+    return d.struct_functions[i];
 }
 
 fn u32 StructTypeDecl.getNumStructFunctions(const StructTypeDecl* d) {
diff --git a/ast/symbol_table.c2 b/ast/symbol_table.c2
index ffec898bd..3ea9c8a16 100644
--- a/ast/symbol_table.c2
+++ b/ast/symbol_table.c2
@@ -46,8 +46,8 @@ public fn u32 SymbolTable.size(const SymbolTable* t) {
     return t.num_public + t.num_private;
 }
 
-public fn Decl** SymbolTable.getDecls(const SymbolTable* t) {
-    return t.decls;
+public fn Decl* SymbolTable.get(const SymbolTable* t, u32 i) {
+    return t.decls[i];
 }
 
 fn void SymbolTable.resize(SymbolTable* t, u32 capacity) {
@@ -124,9 +124,8 @@ public fn void SymbolTable.print(const SymbolTable* t, string_buffer.Buf* out) {
         out.newline();
         if (d.isStructType()) {
             StructTypeDecl* std = (StructTypeDecl*)d;
-            const FunctionDecl** fds = std.getStructFunctions();
             for (u32 j=0; j<std.getNumStructFunctions(); j++) {
-                Decl* fd = (Decl*)fds[j];
+                Decl* fd = (Decl*)std.getStructFunction(j);
                 out.color(fd.isUsed() ? color.Normal : color.Grey);
                 out.indent(6);
                 out.print("%s.%s()", name, fd.getName());
diff --git a/ast/type_ref.c2 b/ast/type_ref.c2
index af04cfcd4..a803e412f 100644
--- a/ast/type_ref.c2
+++ b/ast/type_ref.c2
@@ -227,8 +227,7 @@ fn void TypeRef.init(TypeRef* dest, const TypeRefHolder* h) {
     }
 
     for (u32 i=0; i<r.flags.num_arrays; i++) {
-        Expr** a = dest.getArray2(i);
-        *a = h.arrays[i];
+        dest.setArray(i, h.arrays[i]);
     }
 }
 
@@ -417,6 +416,13 @@ public fn Expr** TypeRef.getArray2(TypeRef* r, u32 idx) {
     return &arrays[idx];
 }
 
+fn void TypeRef.setArray(TypeRef* r, u32 idx, Expr* d) {
+    const u32 numrefs = r.isUser() + r.flags.has_prefix;
+    const u8* ptr = (u8*)r.refs + numrefs * sizeof(Ref);
+    Expr** arrays = (Expr**)ptr;
+    arrays[idx] = d;
+}
+
 fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bool print_prefix) {
     if (r.isConst()) out.add("const ");
     if (r.isVolatile()) out.add("volatile ");
diff --git a/generator/c/c_generator_special.c2 b/generator/c/c_generator_special.c2
index 49ee809e3..af0c77e26 100644
--- a/generator/c/c_generator_special.c2
+++ b/generator/c/c_generator_special.c2
@@ -242,14 +242,11 @@ fn void Generator.createExportsFile(Generator* gen, const char* output_dir, comp
 
     // iterate all mods in main Component
     module_list.List* mods = mainComp.getModules();
-    u32 count = mods.length();
 
-    for (u32 i=0; i<count; i++) {
+    for (u32 i = 0; i < mods.length(); i++) {
         const ast.SymbolTable* symbols = mods.at(i).getSymbols();
-        ast.Decl** decls = symbols.getDecls();
-        u32 num_symbols = symbols.size();
-        for (u32 j=0; j<num_symbols; j++) {
-            ast.Decl* d = decls[j];
+        for (u32 j = 0; j < symbols.size(); j++) {
+            ast.Decl* d = symbols.get(j);
             if (!d.isExported()) continue;
             if (!d.isFunction() && !d.isVariable()) continue;
             out.add("\t\t");
diff --git a/generator/c2i/c2i_generator_expr.c2 b/generator/c2i/c2i_generator_expr.c2
index 1bae7a748..1adbc4f68 100644
--- a/generator/c2i/c2i_generator_expr.c2
+++ b/generator/c2i/c2i_generator_expr.c2
@@ -250,9 +250,9 @@ fn void Generator.emitCall(Generator* gen, string_buffer.Buf* out, const CallExp
     // arguments
     u32 num_args = call.getNumArgs();
     Expr** args = ((CallExpr*)call).getArgs();
-    for (u32 i=0; i<num_args; i++) {
+    for (u32 i = 0; i < call.getNumArgs(); i++) {
         if (i != 0) out.add(", ");
-        gen.emitExpr(out, args[i]);
+        gen.emitExpr(out, call.getArg(i));
     }
 
     out.rparen();
diff --git a/plugins/unit_test_plugin.c2 b/plugins/unit_test_plugin.c2
index 7d7e98b43..188a10d21 100644
--- a/plugins/unit_test_plugin.c2
+++ b/plugins/unit_test_plugin.c2
@@ -134,9 +134,8 @@ fn void generate_tests(void* arg) {
     console.debug("unittest: generating tests");
     u64 t1 = utils.now();
 
-    Decl** decls = p.decls.getDecls();
     for (u32 i=0; i<p.decls.size(); i++) {
-        Decl* d = decls[i];
+        Decl* d = p.decls.get(i);
         Module* m = d.getModule();
         p.cur_prefix = d.getNameIdx();
 
@@ -151,9 +150,8 @@ fn void generate_tests(void* arg) {
         out.add("import c2test as ct;\n\n");
 
         out.add("public const ct.C2Test[] Test_functions = {\n");
-        FunctionDecl** tests = p.tests.getDecls();
         for (u32 j=0; j<p.tests.size(); j++) {
-            Decl* func = (Decl*)tests[j];
+            Decl* func = (Decl*)p.tests.get(j);
             // TODO dont use fullName since we dont need the module prefix
             out.print("   { \"%s\", (ct.TestFn)(%s) },\n", func.getName(), func.getFullName());
         }
@@ -189,8 +187,6 @@ fn void generate_tests(void* arg) {
 }
 
 fn void Plugin.generate_c2test_main(Plugin* p) {
-    Decl** decls = p.decls.getDecls();
-
     string_buffer.Buf* out = string_buffer.create(1024, false, 2);
 
     // Note: this would be so much easier if we used the load_file plugin. But that
@@ -199,7 +195,7 @@ fn void Plugin.generate_c2test_main(Plugin* p) {
     out.add("import c2test local;\n\n");
 
     for (u32 i=0; i<p.decls.size(); i++) {
-        Module* m = decls[i].getModule();
+        Module* m = p.decls.get(i).getModule();
         out.print("import %s;\n", m.getName());
     }
 
@@ -207,7 +203,7 @@ fn void Plugin.generate_c2test_main(Plugin* p) {
 
     out.add("const Group*[] groups = {\n");
     for (u32 i=0; i<p.decls.size(); i++) {
-        Module* m = decls[i].getModule();
+        Module* m = p.decls.get(i).getModule();
         out.print("  &%s.TestGroup,\n", m.getName());
     }
     out.add("}\n\n");