// Valid typed module-level constants compile, fold, and print correctly across
// every initializer/annotation pairing the registrar accepts:
//   - integer literal → integer     (`K : s64 : 4`)   — usable as an array count too
//   - integer literal → float       (`W : f32 : 800`)
//   - float literal   → float       (`PI : f32 : 3.14159`)
//   - string literal  → string      (`S : string : "hi"`)
//   - null            → pointer     (`P : *void : null`)
//   - integer EXPRESSION → integer  (`KE : s64 : M + 2`) — usable as a count too
//   - integer EXPRESSION → float    (`WE : f32 : M + 2`)
//
// Companion to the negative example 1143: the issue-0088 fix rejects a typed
// const whose initializer mismatches its annotation, and these correctly-typed
// consts must keep working (no over-rejection) — including const-EXPRESSION
// initializers, whose type-based validation (attempt 2) must accept a correctly
// typed expression even though it isn't a literal.
#import "modules/std.sx";

M :: 2;

K  : s64    : 4;
W  : f32    : 800;
PI : f32    : 3.14159;
S  : string : "hi";
P  : *void  : null;
KE : s64    : M + 2;
WE : f32    : M + 2;

main :: () {
    // Integer const: prints AND drives an array dimension (len 4).
    a : [K]s64 = ---;
    a[0] = 10;
    a[3] = 40;
    print("K={} len={} a0={} a3={}\n", K, a.len, a[0], a[3]);

    // Integer-into-float and float consts print as floats.
    print("W={} PI={}\n", W, PI);

    // String const prints its text.
    print("S={}\n", S);

    // Null pointer const is null.
    print("P_is_null={}\n", P == null);

    // Integer const-EXPRESSION: prints AND drives an array dimension (len 4).
    b : [KE]s64 = ---;
    print("KE={} len={} WE={}\n", KE, b.len, WE);
}