lang: reject writes through constants (PLAN-CONST-AGG step 2, fixes 0116)

Any assignment / compound-assignment whose target chain is ROOTED at a
constant — a const-flagged global (array consts, #run consts) or a
module value const (struct consts incl.) — diagnoses 'cannot assign
through constant X' at compile time. A struct const's field write used
to compile and bus-error at runtime (issue 0116); scalars misfired
silently. A deref along the chain (p.*) breaks the root — pointer
writes stay the documented escape until the const-ness steps; a local
shadowing the const name stays writable.

Also: typed struct constants ('W : Color : Color.{...}') register —
the shape list skipped struct_literal, leaving the typed form
unresolved while the untyped one worked.

Examples: 1162 (all rejection shapes incl. the 0116 crash repro),
0178 (typed struct const reads + copy independence).

examples/0178-types-typed-struct-const.sx

@@ -0,0 +1,16 @@
+// A TYPED struct constant ('W : Color : Color.{...}') registers like the
+// untyped form ('WHITE :: Color.{...}') — value reads, field reads, and
+// independent copies. (Both shapes keep inline re-lowering semantics
+// until PLAN-CONST-AGG step 4 migrates them to const globals.)
+
+#import "modules/std.sx";
+
+Color :: struct { r, g, b: s64; }
+W : Color : Color.{ r = 1, g = 2, b = 3 };
+
+main :: () {
+    print("{} {} {}\n", W.r, W.g, W.b);
+    c := W;
+    c.g = 99;
+    print("copy={} const={}\n", c.g, W.g);
+}

examples/1162-diagnostics-const-write-rejected.sx

@@ -0,0 +1,19 @@
+// Writes through a module constant are compile errors — for every target
+// chain rooted at a const: a struct const's field (this used to compile
+// and BUS-ERROR at runtime — issue 0116), an array const's element,
+// a compound assignment, and a bare scalar const. A local that shadows
+// the const name stays writable (see 0177/0178 for the value semantics).
+
+#import "modules/std.sx";
+
+Color :: struct { r, g, b: s64; }
+WHITE :: Color.{ r = 255, g = 255, b = 255 };
+K : [4]s64 : .[11, 22, 33, 44];
+N : s64 : 4;
+
+main :: () {
+    WHITE.r = 0;
+    K[0] = 5;
+    K[1] += 2;
+    N = 9;
+}

examples/expected/0178-types-typed-struct-const.exit

@@ -0,0 +1 @@
+0

examples/expected/0178-types-typed-struct-const.stderr

@@ -0,0 +1 @@
+

examples/expected/0178-types-typed-struct-const.stdout

@@ -0,0 +1,2 @@
+1 2 3
+copy=99 const=2

examples/expected/1162-diagnostics-const-write-rejected.exit

@@ -0,0 +1 @@
+1

examples/expected/1162-diagnostics-const-write-rejected.stderr

@@ -0,0 +1,23 @@
+error: cannot assign through constant 'WHITE' — constants are immutable (use a '=' global or a local copy for mutable data)
+  --> examples/1162-diagnostics-const-write-rejected.sx:15:5
+   |
+15 |     WHITE.r = 0;
+   |     ^^^^^^^
+
+error: cannot assign through constant 'K' — constants are immutable (use a '=' global or a local copy for mutable data)
+  --> examples/1162-diagnostics-const-write-rejected.sx:16:5
+   |
+16 |     K[0] = 5;
+   |     ^^^^
+
+error: cannot assign through constant 'K' — constants are immutable (use a '=' global or a local copy for mutable data)
+  --> examples/1162-diagnostics-const-write-rejected.sx:17:5
+   |
+17 |     K[1] += 2;
+   |     ^^^^
+
+error: cannot assign through constant 'N' — constants are immutable (use a '=' global or a local copy for mutable data)
+  --> examples/1162-diagnostics-const-write-rejected.sx:18:5
+   |
+18 |     N = 9;
+   |     ^^^^^^

examples/expected/1162-diagnostics-const-write-rejected.stdout

@@ -0,0 +1 @@
+

issues/0116-const-write-not-rejected.md

@@ -1,5 +1,15 @@
 # 0116 — writes through module consts are not rejected (struct-const write bus-errors at runtime)
 
+> **RESOLVED** (2026-06-11, PLAN-CONST-AGG step 2). The assignment
+> lowering rejects any target chain ROOTED at a constant — a
+> const-flagged global (array consts, #run consts) or a module value
+> const (struct consts incl.) — with `cannot assign through constant
+> 'X'`. A deref along the chain (`p.*`) breaks the root (pointer writes
+> stay the documented escape until the const-ness steps); a local
+> shadowing the const name stays writable. Regression test:
+> examples/1162-diagnostics-const-write-rejected.sx (struct field — the
+> crash repro, array element, compound, bare scalar).
+
 **Symptom.** Assigning through a module-level constant compiles silently.
 For a struct-literal const the store lands in read-only memory and the
 program crashes at runtime.

src/ir/lower/decl.zig

@@ -801,7 +801,7 @@ pub fn registerTypedModuleConst(self: *Lowering, cd: *const ast.ConstDecl) void
     // foldable / emittable const, so it cannot manifest a
     // wrong-type fold/emit; a use-site diagnostic covers it.
     switch (cd.value.data) {
-        .int_literal, .float_literal, .bool_literal, .string_literal, .undef_literal, .null_literal, .binary_op, .unary_op => {},
+        .int_literal, .float_literal, .bool_literal, .string_literal, .undef_literal, .null_literal, .binary_op, .unary_op, .struct_literal => {},
         else => return,
     }
     const ty = self.resolveType(ta);

src/ir/lower/stmt.zig

@@ -540,7 +540,49 @@ pub fn lowerReturn(self: *Lowering, rs: *const ast.ReturnStmt) void {
     }
 }
 
+/// The ROOT identifier of an assignment-target chain (`K[0].x` → "K",
+/// `WHITE.r` → "WHITE"). A deref along the chain (`p.*`, `p.*[i]`) breaks
+/// it — writing through a pointer VALUE is not a write to the named root.
+fn assignmentRootIdent(target: *const Node) ?[]const u8 {
+    var n = target;
+    while (true) {
+        switch (n.data) {
+            .identifier => |id| return id.name,
+            .index_expr => |ie| n = ie.object,
+            .field_access => |fa| n = fa.object,
+            else => return null,
+        }
+    }
+}
+
+/// True when `root` names a module CONSTANT from the current source —
+/// a const-flagged global (array/struct consts, #run consts) or a
+/// module value const. Locals shadow (caller checks scope first).
+fn rootIsConstant(self: *Lowering, root: []const u8) bool {
+    switch (self.selectGlobalAuthor(root)) {
+        .resolved => |g| if (self.module.globals.items[g.id.index()].is_const) return true,
+        else => {},
+    }
+    return switch (self.selectModuleConst(root)) {
+        .resolved, .own_opaque => true,
+        .ambiguous, .none => false,
+    };
+}
+
 pub fn lowerAssignment(self: *Lowering, asgn: *const ast.Assignment) void {
+    // Writes through a constant are rejected at compile time (issue 0116):
+    // the target chain's root naming a const global (array/struct consts,
+    // #run consts) or a module value const cannot be stored to — for a
+    // struct const the store previously compiled and bus-errored at
+    // runtime; for scalars it silently misfired.
+    if (assignmentRootIdent(asgn.target)) |root| {
+        const shadowed = if (self.scope) |s| s.lookup(root) != null else false;
+        if (!shadowed and rootIsConstant(self, root)) {
+            if (self.diagnostics) |d|
+                d.addFmt(.err, asgn.target.span, "cannot assign through constant '{s}' — constants are immutable (use a '=' global or a local copy for mutable data)", .{root});
+            return;
+        }
+    }
     // Set target_type from LHS for RHS lowering (enum literals, struct literals, etc.)
     const old_target = self.target_type;
     if (asgn.target.data == .identifier) {