Harden struct semantics: reserved init, static sharing, cast and self-inherit guards

Four audit findings:

- data fields named 'init' are now rejected like 'new' (the name is
  reserved for the lifecycle hook); a data-init previously vanished
  silently when inherited by a child struct
- inherited statics are copied by reference at the child's declaration
  (Child.f = Parent.f, same lifecycle as flattened methods): struct
  instances stored in statics are shared by the whole hierarchy, and
  uninitialized parent statics assigned before the child are inherited
  correctly; previously they were merged by type only, so the type
  said string while the runtime read nil. Static-static overrides via
  the child's static block work; child-static vs parent-instance is
  still a conflict
- casting a table literal to a struct type is rejected (the result
  would lack the metatable wiring and crash on first method call);
  casting variables remains the interop escape hatch
- 'struct A:A' is rejected with "cannot extend itself" (it previously
  typechecked and generated a struct table set as its own ancestor)

Adds specs for all four (75 struct specs total, 2001 in the suite).

Author: akvilary

docs/src/structs.md

@@ -188,9 +188,9 @@ code, refer to the parent by name: `A.init(self)`.
 ### Methods are flattened, not dispatched
 
 Method calls on struct instances are a **single table lookup**. There is
-no metatable chain between structs and no method resolution at call
-time. Instead, at the point a child struct is declared, every method
-known on its parent is copied into the child:
+no method resolution at call time and no per-call overhead: at the point
+a child struct is declared, every method known on its parent is copied
+into the child:
 
 ```lua
 local struct Shape
@@ -222,7 +222,9 @@ Circle.new = function(opts) ... end       -- init chain: none here
 ```
 
 So `c:describe()` resolves as: instance table → (miss) → `__index` →
-`Circle.describe` → hit. One hop, always.
+`Circle.describe` → hit. One hop, always. Struct tables carry no
+metatable of their own — everything inherited (methods, statics) is
+copied onto the child at declaration time.
 
 **Overrides are just later assignments.** A method defined on the child
 *after* its declaration overwrites the flattened copy:
@@ -248,6 +250,7 @@ parent methods before child structs; the checker enforces this order.
 |---|---|---|
 | `__index = X` | once, at declaration | one metatable hop on instance field miss |
 | method flattening (`X.m = P.m`) | once, at declaration | none — direct table entry |
+| static copying (`X.s = P.s`) | once, at declaration | none — direct table entry |
 | init chain | fixed call list inside `.new` | none — unconditional direct calls |
 | defaults | one `if` per defaulted field in `.new` | `== nil` check only |
 
@@ -475,9 +478,22 @@ end
 print(Derived.klass)              -- "Base" (inherited)
 ```
 
-Initialized statics are re-emitted per child (an independent copy of the
-initializer); a static declared without an initializer on a parent is not
-readable through a child — assign it on the child explicitly if needed.
+Statics are copied **by reference** at the child's declaration — the
+generated code emits `Derived.klass = Base.klass` (and so on for every
+parent static), the same lifecycle and zero-dispatch approach as
+flattened methods. Consequences:
+
+- **struct instances stored in statics are shared by reference** across
+  the whole hierarchy: there is a single `config` instance, and
+  mutating `App.config.debug` is seen by every child — the common
+  pattern (shared configuration, singletons, pools) works exactly as
+  expected;
+- **scalar statics become per-child values**: rebinding `Base.count = 5`
+  after a child was declared is not seen by that child's slot (mutate a
+  shared holder instance instead if you need live updates);
+- **shadowing**: assigning `Derived.count = 100` creates the child's
+  own slot and leaves `Base.count` untouched; a child `static` block
+  entry with its own initializer does the same declaratively.
 
 ## Cross-module inheritance
 
@@ -520,9 +536,11 @@ error:
   presence at the child's declaration site;
 - the parent must not inherit `init` from its own ancestors (those
   ancestor tables are not visible outside the parent's module);
-- the parent's default values must be literals — computed defaults may
-  reference the parent module's locals, which don't exist in the
-  inheriting module;
+- the parent's *instance* default values must be literals — computed
+  defaults may reference the parent module's locals, which don't exist
+  in the inheriting module. Static initializers are exempt: inherited
+  statics are copied by value, so their expressions are never re-emitted
+  in the inheriting module;
 - structs described by declaration files (`.d.tl`) cannot be extended:
   their runtime shape is by contract and may not follow struct
   semantics.

spec/lang/declaration/struct_spec.lua

@@ -244,6 +244,123 @@ describe("struct", function()
          print(Derived.count)
       ]]))
 
+      it("snapshots parent static scalars at the child's declaration (runtime)", function()
+         local code = [[
+            local struct Base
+               static
+                  count: number = 0
+               end
+            end
+
+            local struct Early:Base
+            end
+
+            Base.count = 5
+
+            local struct Late:Base
+            end
+
+            print(Early.count, Late.count)   -- 0 5: reference copies at declaration
+         ]]
+         local check_result = tl.check_string(code)
+         assert.same({}, check_result.type_errors)
+         local generated = tl.gen(code)
+         local chunk = load(generated, "@main.lua")
+         assert.truthy(chunk, "generated code must compile")
+         local out = {}
+         local orig_print = _G.print
+         _G.print = function(...) table.insert(out, table.concat({ ... }, "\t")) end
+         chunk()
+         _G.print = orig_print
+         assert.same({ "0\t5" }, out)
+      end)
+
+      it("shares static struct instances by reference across the hierarchy (runtime)", function()
+         local code = [[
+            local struct Config
+               debug: boolean
+            end
+
+            local struct App
+               static
+                  config: Config = Config.new { debug = false }
+               end
+            end
+
+            local struct DevApp:App
+            end
+
+            print(App.config == DevApp.config)   -- true: one shared instance
+            App.config.debug = true
+            print(DevApp.config.debug)           -- true: mutation is shared
+         ]]
+         local check_result = tl.check_string(code)
+         assert.same({}, check_result.type_errors)
+         local generated = tl.gen(code)
+         local chunk = load(generated, "@main.lua")
+         assert.truthy(chunk)
+         local out = {}
+         local orig_print = _G.print
+         _G.print = function(...)
+            local parts = {}
+            for i = 1, select("#", ...) do
+               table.insert(parts, tostring(select(i, ...)))
+            end
+            table.insert(out, table.concat(parts, "\t"))
+         end
+         chunk()
+         _G.print = orig_print
+         assert.same({ "true", "true" }, out)
+      end)
+
+      it("shadowing a parent static via the child creates the child's own slot", util.check([[
+         local struct Base
+            static
+               count: number = 0
+            end
+         end
+
+         local struct Child:Base
+         end
+
+         Base.count = 5
+         Child.count = 100                       -- shadow: child's own slot
+         print(Base.count, Child.count)          -- 5 100
+      ]]))
+
+      it("inherits uninitialized statics assigned before the child", util.check([[
+         local struct Parent
+            x: number
+            static
+               version: string
+            end
+         end
+
+         Parent.version = "1.0"                  -- BEFORE the child
+
+         local struct Child:Parent
+            y: number
+         end
+
+         print(Parent.version, Child.version)   -- 1.0  1.0
+      ]]))
+
+      it("allows overriding an inherited static with the child's own initializer", util.check([[
+         local struct Parent
+            static
+               tag: string = "parent"
+            end
+         end
+
+         local struct Child:Parent
+            static
+               tag: string = "child"
+            end
+         end
+
+         print(Parent.tag, Child.tag)   -- parent  child
+      ]]))
+
       it("allows only one static block per struct", function()
          local result, err = tl.check_string([[
             local struct Foo
@@ -658,7 +775,54 @@ describe("struct", function()
          ]])
          assert.truthy(result.syntax_errors and #result.syntax_errors > 0)
       end)
-   end)
+
+      it("rejects a struct extending itself", function()
+         local result = tl.check_string([[
+            local struct A:A
+               x: number
+            end
+         ]])
+         assert.truthy(result.type_errors and #result.type_errors > 0)
+         assert.match("cannot extend itself", result.type_errors[1].msg)
+      end)
+
+      it("rejects casting a table literal to a struct type", function()
+         local result = tl.check_string([[
+            local struct Point
+               x: number
+               y: number
+            end
+
+            function Point:len(): number
+               return self.x + self.y
+            end
+
+            local p = { x = 1, y = 2 } as Point
+            print(p:len())
+         ]])
+         assert.truthy(result.type_errors and #result.type_errors > 0)
+         assert.match("instead of casting a table literal", result.type_errors[1].msg)
+      end)
+
+      it("allows casting variables to struct types (interop escape hatch)", util.check([[
+         local struct Point
+            x: number
+            y: number
+         end
+
+         function Point:len(): number
+            return self.x + self.y
+         end
+
+         local p = Point.new { x = 1, y = 2 }
+         local q = p as Point
+         print(q:len())
+
+         local external: any = Point.new { x = 3, y = 4 }
+         local r = external as Point
+         print(r:len())
+      ]]))
+    end)
 
    describe(":Parent syntax ergonomics", function()
       it("allows a field named 'from' in first position of the body", util.check([[
@@ -890,14 +1054,17 @@ describe("struct", function()
          assert.match("new' is reserved", result.type_errors[1].msg)
       end)
 
-      it("allows a data field named 'init'", util.check([[
-         local struct A
-            x: number
-            init: number = 7
-         end
-         local a = A.new { x = 1 }
-         print(a.init)
-      ]]))
+      it("rejects a data field named 'init' with a clear error", function()
+         local result, err = tl.check_string([[
+            local struct A
+               x: number
+               init: number = 7
+            end
+            local a = A.new { x = 1 }
+         ]])
+         assert.truthy(result.type_errors and #result.type_errors > 0)
+         assert.match("init' is reserved", result.type_errors[1].msg)
+      end)
 
       it("rejects a static field shadowing an instance field", function()
          local result, err = tl.check_string([[