wcc/ww: serialize aggregate exported defs as value-less .wwi prototypes (BUG-2, #70)
The .wwi (separate-compile interface) producer could not serialize an
exported def whose initializer is a struct/array literal (N_STRUCTLIT/
N_ARRLIT) — `export def f64info: floatinfo = floatinfo{...}` aborted with
"unhandled const-expr node kind 15". Such a def is a DATA-global per the
#52 model, so its value lives once in the defining package's .o; the
interface needs only the type+symbol. Emit a value-less prototype
`export def X: T;` for aggregate-initializer defs; scalar fold-eligible
defs keep their value (the importer const-folds those). The parser gains
an optional-init arm so the importer can parse the prototype — value-less
`def X: T;` is now legal in any source, symmetric with the existing
bodyless-fn prototype `fn f();` (USER ruling: unconditional; a value-less
def with no defining .o is a loud undefined-symbol error at link, never
silent). Both stages; producer + parser fold into one commit (the
producer's output is unparseable without the parser arm).
M3-tail commit-6 prerequisite #2 (surfaced by the c6 scout). The
aggregate-def-field const-fold boundary is documented inline (#71). Gate
989_sepstructdef_run proves struct+array exported defs sep-build, link,
and run via external DATA refs, cs==ww, with a value-less .wwi.
This commit is contained in:
251
test/wcc/989_sepstructdef_run.c
Normal file
251
test/wcc/989_sepstructdef_run.c
Normal file
@@ -0,0 +1,251 @@
|
||||
/*
|
||||
* 989_sepstructdef_run — sep-build of a dep package that EXPORTS aggregate-
|
||||
* initializer defs: `export def info: s = s{a=7,b=11};` (N_STRUCTLIT) and
|
||||
* `export def arr: [3]i32 = [1,2,3];` (N_ARRLIT) — BUG-2 (#70).
|
||||
*
|
||||
* Root cause it guards: the `.wwi` producer's const-expr emitter handled
|
||||
* scalar/N_BIN/N_UN/N_DOT but NOT N_STRUCTLIT(15)/N_ARRLIT(16). An exported
|
||||
* aggregate-init def aborted the producer with "unhandled const-expr node
|
||||
* kind 15", so the dep never produced a `.wwi` and the sep-build failed.
|
||||
*
|
||||
* Fix (producer, both stages): an aggregate-init def is a DATA-global (#52),
|
||||
* so the producer emits a value-LESS prototype `export def X: T;` — the
|
||||
* defining package's own `.o` emits the struct/array DATA; the importer
|
||||
* registers the def by TYPE only (cgen's emit_defs/emit_lets already skip a
|
||||
* NULL-rhs def, no dup DATA) and reads resolve to external refs the linker
|
||||
* fills. Consuming the prototype also required the def parser (both stages)
|
||||
* to accept the bodyless form, mirroring the existing fn-prototype arm.
|
||||
*
|
||||
* Graph (smallest reproducing shape): root -> { d (one real dep package) }.
|
||||
* d exports an aggregate STRUCT def (info), an aggregate ARRAY def (arr),
|
||||
* and three reader fns; root sums them at RUNTIME.
|
||||
*
|
||||
* Asserts (all COLD — per-stage WW_PKGCACHE wipes the package cache):
|
||||
* 1. Build + LINK + run, BOTH stages -> exit EXPECT_EXIT. The link+run is
|
||||
* the external-DATA-ref proof: the importer's CALL d.geta / d.getelem /
|
||||
* d.getb and d's own LEAQ d.info/d.arr(SB) refs resolve against the dep
|
||||
* `.o`. Pre-fix the dep producer aborted ("node kind 15") -> no binary.
|
||||
* 2. cs==ww (rule 10): per-package `.s`/`.wwi`/`.unit.ww` for {d,__root}
|
||||
* AND the final binary are byte-identical between the two drivers.
|
||||
* 3. The dep `.wwi` carries the value-LESS prototypes `export def info: s;`
|
||||
* and `export def arr: [3]i32;` (the fix's surface), and NOT the old
|
||||
* value-serialized `export def info: s = ` form (NON-VACUITY: proves the
|
||||
* producer took the new aggregate arm, not the scalar arm).
|
||||
*
|
||||
* Light wwstage-driver test (CLAUDE.md rule 14): all intermediates are
|
||||
* `-o`-redirected to /tmp, so it is phase-1 parallel-safe. Models
|
||||
* 989_seproot_export_run.c conventions; 989 prefix per the sep-gate precedent.
|
||||
*/
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <sys/wait.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#define EXPECT_EXIT 20 /* info.a(7) + arr[1](2) + info.b(11) */
|
||||
|
||||
static int
|
||||
runwait(const char *cmd)
|
||||
{
|
||||
int rc = system(cmd);
|
||||
if (rc == -1) return -1;
|
||||
if (WIFEXITED(rc)) return WEXITSTATUS(rc);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const char *
|
||||
absbin(void)
|
||||
{
|
||||
const char *b = getenv("BIN");
|
||||
if (!b) b = "out/bin";
|
||||
if (b[0] == '/') return b;
|
||||
static char buf[2048];
|
||||
char cwd[1024];
|
||||
if (getcwd(cwd, sizeof cwd) == NULL) return NULL;
|
||||
snprintf(buf, sizeof buf, "%s/%s", cwd, b);
|
||||
return buf;
|
||||
}
|
||||
|
||||
static int
|
||||
slurp(const char *path, char **outbuf, size_t *outlen)
|
||||
{
|
||||
FILE *f = fopen(path, "rb");
|
||||
if (!f) return -1;
|
||||
fseek(f, 0, SEEK_END);
|
||||
long n = ftell(f);
|
||||
fseek(f, 0, SEEK_SET);
|
||||
if (n < 0) { fclose(f); return -1; }
|
||||
char *b = malloc((size_t)n + 1);
|
||||
if (!b) { fclose(f); return -1; }
|
||||
if (fread(b, 1, (size_t)n, f) != (size_t)n) { free(b); fclose(f); return -1; }
|
||||
b[n] = '\0';
|
||||
fclose(f);
|
||||
*outbuf = b;
|
||||
*outlen = (size_t)n;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
files_eq(const char *a, const char *b)
|
||||
{
|
||||
char *ba = NULL, *bb = NULL;
|
||||
size_t na = 0, nb = 0;
|
||||
if (slurp(a, &ba, &na) < 0 || slurp(b, &bb, &nb) < 0) {
|
||||
free(ba); free(bb);
|
||||
return -1;
|
||||
}
|
||||
int eq = (na == nb && memcmp(ba, bb, na) == 0);
|
||||
free(ba); free(bb);
|
||||
return eq ? 0 : 1;
|
||||
}
|
||||
|
||||
/* 0 if `needle` occurs in the file at `path`, 1 if absent, -1 on read err. */
|
||||
static int
|
||||
file_contains(const char *path, const char *needle)
|
||||
{
|
||||
char *b = NULL;
|
||||
size_t n = 0;
|
||||
if (slurp(path, &b, &n) < 0) return -1;
|
||||
int found = (strstr(b, needle) != NULL);
|
||||
free(b);
|
||||
return found ? 0 : 1;
|
||||
}
|
||||
|
||||
static int
|
||||
write_file(const char *path, const char *body)
|
||||
{
|
||||
FILE *f = fopen(path, "wb");
|
||||
if (!f) return -1;
|
||||
fputs(body, f);
|
||||
fclose(f);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
main(void)
|
||||
{
|
||||
const char *bin = absbin();
|
||||
if (!bin) return 1;
|
||||
char td[64], cmd[8192], p[1024];
|
||||
int fail = 0;
|
||||
|
||||
snprintf(td, sizeof td, "/tmp/wwsepstructdef_%d", getpid());
|
||||
snprintf(cmd, sizeof cmd, "rm -rf %s", td);
|
||||
runwait(cmd);
|
||||
mkdir(td, 0755);
|
||||
|
||||
/* lib/d — the dep package exporting aggregate-init defs + reader fns.
|
||||
* The struct type must be EXPORTED so the prototype names a visible
|
||||
* type (an exported def over an unexported type is a separate loud
|
||||
* reject, check_exported_type). */
|
||||
snprintf(p, sizeof p, "%s/lib", td); mkdir(p, 0755);
|
||||
snprintf(p, sizeof p, "%s/lib/d", td); mkdir(p, 0755);
|
||||
snprintf(p, sizeof p, "%s/lib/d/mod.ww", td);
|
||||
if (write_file(p,
|
||||
"package d;\n"
|
||||
"export type s = struct { a: i32, b: i32 };\n"
|
||||
"export def info: s = s { a = 7, b = 11 };\n"
|
||||
"export def arr: [3]i32 = [1, 2, 3];\n"
|
||||
"export fn geta() i32 = { return info.a; };\n"
|
||||
"export fn getb() i32 = { return info.b; };\n"
|
||||
"export fn getelem(i: i32) i32 = { return arr[i]; };\n"))
|
||||
{ fail++; goto out; }
|
||||
|
||||
char rootww[1024];
|
||||
snprintf(rootww, sizeof rootww, "%s/root.ww", td);
|
||||
if (write_file(rootww,
|
||||
"package main;\n"
|
||||
"import d;\n"
|
||||
"fn main() i32 = {\n"
|
||||
"\treturn d.geta() + d.getelem(1) + d.getb();\n"
|
||||
"};\n"))
|
||||
{ fail++; goto out; }
|
||||
|
||||
struct { const char *drv, *tag; char prog[1024]; }
|
||||
stg[] = { { "ww", "cs", {0} }, { "ww_ww", "ww", {0} } };
|
||||
|
||||
for (int s = 0; s < 2; s++) {
|
||||
snprintf(stg[s].prog, sizeof stg[s].prog, "%s/prog.%s", td, stg[s].tag);
|
||||
/* Per-stage fresh WW_PKGCACHE -> every package compiles COLD, so the
|
||||
* `.s`/`.wwi`/`.unit.ww` this gate inspects are always produced. */
|
||||
snprintf(cmd, sizeof cmd,
|
||||
"WW_PKGCACHE='%s/cache.%s' timeout 240 %s/%s build --sep "
|
||||
"-I %s/lib -o %s %s >/dev/null 2>&1",
|
||||
td, stg[s].tag, bin, stg[s].drv, td, stg[s].prog, rootww);
|
||||
if (runwait(cmd) != 0) {
|
||||
fprintf(stderr, "sepstructdef FAIL: %s build --sep (pre-fix: the "
|
||||
"aggregate-init def aborts the producer with \"node kind 15\")\n",
|
||||
stg[s].drv);
|
||||
fail++;
|
||||
continue;
|
||||
}
|
||||
int rc = runwait(stg[s].prog);
|
||||
if (rc != EXPECT_EXIT) {
|
||||
fprintf(stderr, "sepstructdef FAIL: %s prog exit=%d expected %d "
|
||||
"(external aggregate-DATA ref did not resolve)\n",
|
||||
stg[s].drv, rc, EXPECT_EXIT);
|
||||
fail++;
|
||||
}
|
||||
}
|
||||
|
||||
/* cs==ww (rule 10): per-package .s/.wwi/.unit.ww + final binary. */
|
||||
const char *pkgs[] = { "d", "__root" };
|
||||
for (int i = 0; i < 2; i++) {
|
||||
const char *suf[] = { ".s", ".wwi", ".unit.ww" };
|
||||
for (int k = 0; k < 3; k++) {
|
||||
/* the root's `.wwi` is intentionally not produced (BUG-1 fix). */
|
||||
if (strcmp(pkgs[i], "__root") == 0 && strcmp(suf[k], ".wwi") == 0)
|
||||
continue;
|
||||
char a[1024], b[1024];
|
||||
snprintf(a, sizeof a, "%s/prog.%s.sepwork/%s%s",
|
||||
td, stg[0].tag, pkgs[i], suf[k]);
|
||||
snprintf(b, sizeof b, "%s/prog.%s.sepwork/%s%s",
|
||||
td, stg[1].tag, pkgs[i], suf[k]);
|
||||
if (files_eq(a, b) != 0) {
|
||||
fprintf(stderr, "sepstructdef FAIL: cs!=ww for %s%s (rule 10)\n",
|
||||
pkgs[i], suf[k]);
|
||||
fail++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (files_eq(stg[0].prog, stg[1].prog) != 0) {
|
||||
fprintf(stderr, "sepstructdef FAIL: cs exe != ww exe (rule 10)\n");
|
||||
fail++;
|
||||
}
|
||||
|
||||
/* The dep `.wwi` carries the value-LESS aggregate prototypes — and NOT
|
||||
* the old value-serialized form (NON-VACUITY: the producer took the new
|
||||
* aggregate arm, not the scalar `= <init>` arm). */
|
||||
{
|
||||
char wwi[1024];
|
||||
snprintf(wwi, sizeof wwi, "%s/prog.cs.sepwork/d.wwi", td);
|
||||
if (file_contains(wwi, "export def info: s;\n") != 0) {
|
||||
fprintf(stderr, "sepstructdef FAIL: d.wwi lacks value-less "
|
||||
"`export def info: s;` (struct-lit def prototype)\n");
|
||||
fail++;
|
||||
}
|
||||
if (file_contains(wwi, "export def arr: [3]i32;\n") != 0) {
|
||||
fprintf(stderr, "sepstructdef FAIL: d.wwi lacks value-less "
|
||||
"`export def arr: [3]i32;` (array-lit def prototype)\n");
|
||||
fail++;
|
||||
}
|
||||
if (file_contains(wwi, "export def info: s = ") == 0) {
|
||||
fprintf(stderr, "sepstructdef FAIL: d.wwi serialized the aggregate "
|
||||
"value (`export def info: s = ...`) -> vacuous gate\n");
|
||||
fail++;
|
||||
}
|
||||
}
|
||||
|
||||
out:
|
||||
snprintf(cmd, sizeof cmd, "rm -rf %s", td);
|
||||
runwait(cmd);
|
||||
if (fail) {
|
||||
fprintf(stderr, "sepstructdef: %d check(s) failed\n", fail);
|
||||
return 1;
|
||||
}
|
||||
printf("sepstructdef: exported struct-lit + array-lit defs via "
|
||||
"build_one_sep — build+link+run (exit %d) + cs==ww per-pkg + binary "
|
||||
"+ value-less `.wwi` prototypes (both stages)\n", EXPECT_EXIT);
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user