support constant initializers for global struct/array variables

Author: cs01

src/codegen.ts

@@ -6476,16 +6476,60 @@ export class Codegen {
 
   private usedSatIntrinsics?: Set<string>;
 
+  private tryConstantExpr(expr: import("./hir").HIRExpr): string | null {
+    switch (expr.kind) {
+      case "IntLit": return expr.value.toString();
+      case "FloatLit": {
+        const buf = new ArrayBuffer(8);
+        new Float64Array(buf)[0] = expr.value;
+        const bits = new BigUint64Array(buf)[0];
+        return `0x${bits.toString(16).toUpperCase().padStart(16, "0")}`;
+      }
+      case "BoolLit": return expr.value ? "1" : "0";
+      case "Cast":
+        if (expr.type.tag === "ptr") return "null";
+        return null;
+      case "StructLit": {
+        const layout = this.structLayouts.get(expr.name);
+        if (!layout) return null;
+        const fieldVals: string[] = [];
+        for (const lf of layout.fields) {
+          const ef = expr.fields.find(f => f.name === lf.name);
+          if (!ef) return null;
+          const val = this.tryConstantExpr(ef.value);
+          if (val === null) return null;
+          fieldVals.push(`${lf.type} ${val}`);
+        }
+        return `{ ${fieldVals.join(", ")} }`;
+      }
+      case "ArrayLit": {
+        if (expr.type.tag !== "array" || expr.type.size === null) return null;
+        const elemTy = this.llvmType(expr.type.element);
+        const elemVals: string[] = [];
+        for (const elem of expr.elements) {
+          const val = this.tryConstantExpr(elem);
+          if (val === null) return null;
+          elemVals.push(`${elemTy} ${val}`);
+        }
+        return `[${elemVals.join(", ")}]`;
+      }
+      case "ArrayRepeat": {
+        const elemKind = expr.type.tag === "array" ? expr.type.element : { tag: "int" as const, bits: 32, signed: true };
+        const elemTy = this.llvmType(elemKind);
+        const val = this.tryConstantExpr(expr.value);
+        if (val === null) return null;
+        if (val === "0" || val === "zeroinitializer") return "zeroinitializer";
+        const elems = Array(expr.count).fill(`${elemTy} ${val}`);
+        return `[${elems.join(", ")}]`;
+      }
+      default:
+        return null;
+    }
+  }
+
   private getConstantInitializer(g: import("./hir").HIRGlobal): string {
-    if (g.value.kind === "IntLit") return g.value.value.toString();
-    if (g.value.kind === "FloatLit") {
-      const buf = new ArrayBuffer(8);
-      new Float64Array(buf)[0] = g.value.value;
-      const bits = new BigUint64Array(buf)[0];
-      return `0x${bits.toString(16).toUpperCase().padStart(16, "0")}`;
-    }
-    if (g.value.kind === "BoolLit") return g.value.value ? "1" : "0";
-    if (g.value.kind === "Cast" && g.type.tag === "ptr") return "null";
+    const constVal = this.tryConstantExpr(g.value);
+    if (constVal !== null) return constVal;
     if (g.type.tag === "ptr") return "null";
     const tag = g.type.tag;
     if (tag === "struct" || tag === "array" || tag === "enum" || tag === "string" || tag === "vec" || tag === "hashmap" || tag === "tuple") {

tests/fixtures/globalArrayInit.milo

@@ -0,0 +1,31 @@
+var scores: [i32; 5] = [10, 20, 30, 40, 50]
+var flags: [bool; 3] = [true, false, true]
+let repeatedF64: [f64; 3] = [3.14; 3]
+
+fn main(): i32 {
+  print(scores[0])
+  print(scores[2])
+  print(scores[4])
+
+  scores[2] = 999
+  print(scores[2])
+
+  print(flags[0])
+  print(flags[1])
+  print(flags[2])
+
+  print(repeatedF64[0])
+  print(repeatedF64[2])
+
+  return 0
+}
+
+// @expect: 10
+// @expect: 30
+// @expect: 50
+// @expect: 999
+// @expect: true
+// @expect: false
+// @expect: true
+// @expect: 3.14
+// @expect: 3.14

tests/fixtures/globalStructArray.milo

@@ -0,0 +1,38 @@
+struct Timer {
+  id: i32,
+  active: bool,
+  delayMs: i32,
+}
+
+var timers: [Timer; 4] = [Timer { id: 0, active: false, delayMs: 0 }; 4]
+
+fn main(): i32 {
+  // verify zero-init values
+  print(timers[0].id)
+  print(timers[0].active)
+  print(timers[0].delayMs)
+
+  // mutate one element
+  timers[1].id = 42
+  timers[1].active = true
+  timers[1].delayMs = 1000
+
+  print(timers[1].id)
+  print(timers[1].active)
+  print(timers[1].delayMs)
+
+  // confirm others unchanged
+  print(timers[2].id)
+  print(timers[3].active)
+
+  return 0
+}
+
+// @expect: 0
+// @expect: false
+// @expect: 0
+// @expect: 42
+// @expect: true
+// @expect: 1000
+// @expect: 0
+// @expect: false

tests/fixtures/globalStructInit.milo

@@ -0,0 +1,36 @@
+struct Point {
+  x: i32,
+  y: i32,
+}
+
+struct Config {
+  width: i32,
+  height: i32,
+  scale: f64,
+  enabled: bool,
+}
+
+var origin: Point = Point { x: 10, y: 20 }
+let config: Config = Config { width: 1920, height: 1080, scale: 2.5, enabled: true }
+
+fn main(): i32 {
+  print(origin.x)
+  print(origin.y)
+  print(config.width)
+  print(config.height)
+  print(config.scale)
+  print(config.enabled)
+
+  origin.x = 99
+  print(origin.x)
+
+  return 0
+}
+
+// @expect: 10
+// @expect: 20
+// @expect: 1920
+// @expect: 1080
+// @expect: 2.5
+// @expect: true
+// @expect: 99