679653fda8
A struct constant whose every field serializes — literals, enum tags,
nested aggregates, and (new) const EXPRESSIONS over named consts /
const-aggregate leaves ('r = K + 1', 'g = LIT.r', 'b = A[1]') — becomes
an immutable global: one storage, reads load/GEP it, '@LIT' is
addressable, dead-global elimination drops unused ones. constExprValue
gained a fold-through tail (evalConstIntExpr/evalConstFloatExpr,
source-aware), which also enables const-expression ELEMENTS in array
consts.
A const with a NON-serializable field (a call, a runtime read) keeps
inline re-lowering, and that per-use evaluation is now the documented
contract for the class (pinned: 'CALL.r' reads 1 then 2, side effects
run per use; '#run' is the evaluate-once tool).
Examples: 0180 (migrated shapes + @ptr + copy independence),
0181 (the inline-fallback contract). m3te (23/23) + game rebuilt green.
24 lines
745 B
Plaintext
24 lines
745 B
Plaintext
// Serializable struct constants are IMMUTABLE GLOBALS (one storage, no
|
|
// per-use rebuild): literal fields, const-EXPRESSION fields (`K + 1`),
|
|
// another const's field (`LIT.r`), and a const array's element (`A[1]`)
|
|
// all serialize. The const is addressable (`@LIT`) and copies stay
|
|
// independent.
|
|
|
|
#import "modules/std.sx";
|
|
|
|
Color :: struct { r, g, b: s64; }
|
|
K :: 10;
|
|
A : [2]s64 : .[7, 8];
|
|
LIT :: Color.{ r = 255, g = 0, b = 0 };
|
|
EXPR :: Color.{ r = K + 1, g = K * 2, b = A[1] };
|
|
REF :: Color.{ r = LIT.r, g = 1, b = 2 };
|
|
|
|
main :: () {
|
|
print("lit={} expr={} {} {} ref={}\n", LIT.r, EXPR.r, EXPR.g, EXPR.b, REF.r);
|
|
p := @LIT;
|
|
print("via-ptr={}\n", p.r);
|
|
c := LIT;
|
|
c.r = 9;
|
|
print("copy={} const={}\n", c.r, LIT.r);
|
|
}
|