Hojun-Cho
19e9535ef4
installdecl routes all four kinds (fn/type/def/let) through installtop, which turns scopedefineinmodule's nil return into cstage's exact "duplicate <kind> <name>" reject, keyed (name,mod) so cross-package same-leaf decls coexist. Builtin redecls are dropped, not dup-errored: cstage never scopes builtins (lookup_builtin first, check.c:69), so a user redecl is dead there — wwstage mirrors via scopesamekeysym + no-source-decl test. -T synth __wwtests installs direct, mirroring check.c:3079. Closes the silent dup-fn hole (user fn run vs lib/test run built a broken test binary with no diagnostic). Per-kind reject rows + cross-package/builtin accept byte-id rows + -T collision parity row in 910/997. (#23-team, category-A addendum closed)
407 lines
14 KiB
C
407 lines
14 KiB
C
/*
|
|
* 997_at_test_ww — the wwstage twin of 910_at_test, driving the `-T`
|
|
* @test mode through `w6c_ww` (the ww-built compiler) instead of `w6c`
|
|
* (the C bootstrap). Task #15.
|
|
*
|
|
* Probes:
|
|
* 1. RUN — `w6c_ww -T` the @test-only fixture (import-resolved by
|
|
* `ww_ww build` into a combined unit), assemble, link, run; the
|
|
* synthesized entry must exit 0.
|
|
* 2. BYTE-ID (rule 10) — `w6c -T` and `w6c_ww -T` must emit
|
|
* byte-identical asm for the same source. The synthesized entry
|
|
* rides cgfn at the gated choke point, so the @test set + the
|
|
* collection-order calls are identical by construction. This is
|
|
* the new entry-synth byte-id gate.
|
|
* 3. REJECT — `-T` of a user-main fixture exits nonzero.
|
|
* 4. GUARD — `-T` of a non-`fn() void` @test exits nonzero.
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/wait.h>
|
|
|
|
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
|
|
run_fixture(const char *bin)
|
|
{
|
|
int pid = getpid();
|
|
char src[256], comb[256], binout[256], asmf[256], obj[256], exe[256];
|
|
char rt[1024], cmd[4096];
|
|
snprintf(src, sizeof src, "/tmp/at997_%d.ww", pid);
|
|
snprintf(binout, sizeof binout, "/tmp/at997_%d", pid);
|
|
snprintf(comb, sizeof comb, "/tmp/at997_%d.combined.ww", pid);
|
|
snprintf(asmf, sizeof asmf, "/tmp/at997_%d.s", pid);
|
|
snprintf(obj, sizeof obj, "/tmp/at997_%d.o", pid);
|
|
snprintf(exe, sizeof exe, "/tmp/at997_%d.exe", pid);
|
|
snprintf(rt, sizeof rt, "%s/../lib/libwwrt.a", bin);
|
|
|
|
snprintf(cmd, sizeof cmd, "cp test/wcc/data/attest_pass.ww %s", src);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: cp\n"); return 1; }
|
|
|
|
/* `ww_ww test -c -o <stem>` (compile-only) resolves imports AND auto-
|
|
* bundles lib/test (#17) into <stem>.combined.ww — the synth's run()
|
|
* callee must link below — WITHOUT running the harness. We gate on the
|
|
* combined ARTIFACT existing; `-o` keeps the binary off the CWD. */
|
|
snprintf(cmd, sizeof cmd, "%s/ww_ww test -c -o %s %s > /dev/null 2>&1",
|
|
bin, binout, src);
|
|
runwait(cmd);
|
|
if (access(comb, 0) != 0) {
|
|
fprintf(stderr, "997 FAIL: ww_ww build produced no %s\n", comb);
|
|
return 1;
|
|
}
|
|
|
|
snprintf(cmd, sizeof cmd, "%s/w6c_ww -T %s -o %s 2>/dev/null", bin, comb, asmf);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6c_ww -T errored\n"); return 1; }
|
|
snprintf(cmd, sizeof cmd, "%s/w6a_ww -o %s %s 2>/dev/null", bin, obj, asmf);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6a_ww\n"); return 1; }
|
|
snprintf(cmd, sizeof cmd, "%s/w6l_ww -o %s %s %s 2>/dev/null", bin, exe, obj, rt);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6l_ww\n"); return 1; }
|
|
|
|
int rc = runwait(exe);
|
|
if (rc != 0) {
|
|
fprintf(stderr, "997 FAIL: synth entry exited %d (a @test failed)\n", rc);
|
|
return 1;
|
|
}
|
|
unlink(src); unlink(comb); unlink(asmf); unlink(obj); unlink(exe);
|
|
unlink(binout);
|
|
char tmp[300];
|
|
snprintf(tmp, sizeof tmp, "%s.s", binout); unlink(tmp);
|
|
snprintf(tmp, sizeof tmp, "%s.o", binout); unlink(tmp);
|
|
return 0;
|
|
}
|
|
|
|
/* byteid — `w6c -T` and `w6c_ww -T` on the same unit must agree. The #17
|
|
* synth's run() callee only resolves against the auto-bundled lib/test, so
|
|
* we byte-compare the lib/test-INCLUSIVE combined (raw -T of the fixture
|
|
* would loud-reject the undefined run); `ww test -c` writes that combined. */
|
|
static int
|
|
byteid(const char *bin)
|
|
{
|
|
int pid = getpid();
|
|
char stem[256], comb[256], cs[256], ws[256], cmd[4096];
|
|
snprintf(stem, sizeof stem, "/tmp/at997_bid_%d", pid);
|
|
snprintf(comb, sizeof comb, "%s.combined.ww", stem);
|
|
snprintf(cs, sizeof cs, "/tmp/at997_bid_c_%d.s", pid);
|
|
snprintf(ws, sizeof ws, "/tmp/at997_bid_w_%d.s", pid);
|
|
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/ww test -c -o %s test/wcc/data/attest_pass.ww > /dev/null 2>&1",
|
|
bin, stem);
|
|
runwait(cmd);
|
|
if (access(comb, 0) != 0) {
|
|
fprintf(stderr, "997 FAIL: ww test -c produced no %s\n", comb);
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s/w6c -T %s -o %s 2>/dev/null", bin, comb, cs);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6c -T (byteid)\n"); return 1; }
|
|
snprintf(cmd, sizeof cmd, "%s/w6c_ww -T %s -o %s 2>/dev/null", bin, comb, ws);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "997 FAIL: w6c_ww -T (byteid)\n"); return 1; }
|
|
|
|
char *bc = NULL, *bw = NULL;
|
|
size_t nc = 0, nw = 0;
|
|
int rc = 0;
|
|
if (slurp(cs, &bc, &nc) < 0 || slurp(ws, &bw, &nw) < 0) {
|
|
fprintf(stderr, "997 FAIL: slurp byteid asm\n");
|
|
rc = 1;
|
|
} else if (nc != nw || memcmp(bc, bw, nc) != 0) {
|
|
fprintf(stderr, "997 FAIL: -T asm differs (cs %zu, ww %zu)\n", nc, nw);
|
|
rc = 1;
|
|
}
|
|
free(bc); free(bw);
|
|
unlink(comb); unlink(cs); unlink(ws);
|
|
char tmp[300];
|
|
snprintf(tmp, sizeof tmp, "%s.s", stem); unlink(tmp);
|
|
snprintf(tmp, sizeof tmp, "%s.o", stem); unlink(tmp);
|
|
unlink(stem);
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
reject(const char *bin, const char *fixture, const char *what)
|
|
{
|
|
char cmd[4096];
|
|
snprintf(cmd, sizeof cmd, "%s/w6c_ww -T %s -o /dev/null 2>/dev/null", bin, fixture);
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "997 FAIL: w6c_ww -T accepted %s (expected reject)\n", what);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Each row: a fixture `w6c_ww -T` must loud-reject, and why. */
|
|
static const struct {
|
|
const char *fixture;
|
|
const char *what;
|
|
} rejects[] = {
|
|
{ "test/wcc/data/attest_userman.ww", "user main" },
|
|
{ "test/wcc/data/attest_badsig.ww", "non-void @test" },
|
|
};
|
|
|
|
/* #6: TEXT-def present/absent rows for attest_nondrop.ww (mirror 910). */
|
|
static const struct {
|
|
const char *sym;
|
|
int testmode; /* 1 => -T, 0 => plain build */
|
|
int present;
|
|
const char *what;
|
|
} nondrop_rows[] = {
|
|
{ "data.nondrop_keep", 0, 1, "plain fn kept non-T" },
|
|
{ "data.nondrop_test_a", 0, 0, "head @test dropped non-T" },
|
|
{ "data.nondrop_test_b", 0, 0, "mid @test dropped non-T" },
|
|
{ "data.nondrop_test_c", 0, 0, "consecutive @test dropped non-T" },
|
|
{ "data.nondrop_keep", 1, 1, "plain fn kept under -T" },
|
|
{ "data.nondrop_test_a", 1, 1, "head @test kept under -T" },
|
|
{ "data.nondrop_test_b", 1, 1, "mid @test kept under -T" },
|
|
{ "data.nondrop_test_c", 1, 1, "consecutive @test kept under -T" },
|
|
};
|
|
|
|
/* nondrop — drive the #6 splice through w6c_ww (rows) AND assert the
|
|
* non-T asm is cs/ww byte-identical (rule 10: the drop must be symmetric,
|
|
* not just cstage-side — 997's byteid above only covered -T mode). */
|
|
static int
|
|
nondrop(const char *bin)
|
|
{
|
|
int pid = getpid();
|
|
char wp[256], wt[256], cp[256], stem[256], comb[300], cmd[4096];
|
|
snprintf(wp, sizeof wp, "/tmp/at997nd_wp_%d.s", pid);
|
|
snprintf(wt, sizeof wt, "/tmp/at997nd_wt_%d.s", pid);
|
|
snprintf(cp, sizeof cp, "/tmp/at997nd_cp_%d.s", pid);
|
|
snprintf(stem, sizeof stem, "/tmp/at997nd_c_%d", pid);
|
|
snprintf(comb, sizeof comb, "%s.combined.ww", stem);
|
|
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/w6c_ww test/wcc/data/attest_nondrop.ww -o %s 2>/dev/null", bin, wp);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "997 FAIL: w6c_ww non-T nondrop compile\n");
|
|
return 1;
|
|
}
|
|
/* the -T compile synthesizes a main calling lib/test's run(), so it
|
|
* needs the lib/test-inclusive combined `ww test -c` writes. */
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/ww test -c -o %s test/wcc/data/attest_nondrop.ww > /dev/null 2>&1",
|
|
bin, stem);
|
|
runwait(cmd);
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/w6c_ww -T %s -o %s 2>/dev/null", bin, comb, wt);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "997 FAIL: w6c_ww -T nondrop compile\n");
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/w6c test/wcc/data/attest_nondrop.ww -o %s 2>/dev/null", bin, cp);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "997 FAIL: w6c non-T nondrop compile\n");
|
|
return 1;
|
|
}
|
|
|
|
int rc = 0;
|
|
for (size_t i = 0; i < sizeof nondrop_rows / sizeof nondrop_rows[0]; i++) {
|
|
const char *f = nondrop_rows[i].testmode ? wt : wp;
|
|
snprintf(cmd, sizeof cmd, "grep -q '^TEXT %s,' %s",
|
|
nondrop_rows[i].sym, f);
|
|
int found = runwait(cmd) == 0;
|
|
if (found != nondrop_rows[i].present) {
|
|
fprintf(stderr, "997 FAIL: w6c_ww — %s: %s %s (expected %s)\n",
|
|
nondrop_rows[i].what, nondrop_rows[i].sym,
|
|
found ? "present" : "absent",
|
|
nondrop_rows[i].present ? "present" : "absent");
|
|
rc = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (rc == 0) {
|
|
char *bc = NULL, *bw = NULL;
|
|
size_t nc = 0, nw = 0;
|
|
if (slurp(cp, &bc, &nc) < 0 || slurp(wp, &bw, &nw) < 0) {
|
|
fprintf(stderr, "997 FAIL: slurp non-T nondrop asm\n");
|
|
rc = 1;
|
|
} else if (nc != nw || memcmp(bc, bw, nc) != 0) {
|
|
fprintf(stderr, "997 FAIL: non-T @test-drop asm differs "
|
|
"(cs %zu, ww %zu)\n", nc, nw);
|
|
rc = 1;
|
|
}
|
|
free(bc); free(bw);
|
|
}
|
|
unlink(wp); unlink(wt); unlink(cp); unlink(comb);
|
|
char tmp[300];
|
|
snprintf(tmp, sizeof tmp, "%s.s", stem); unlink(tmp);
|
|
snprintf(tmp, sizeof tmp, "%s.o", stem); unlink(tmp);
|
|
unlink(stem);
|
|
return rc;
|
|
}
|
|
|
|
/* reject_plain — `w6c_ww <fixture>` (NON-T) must exit nonzero. Pins (as
|
|
* 910 does for cstage) that wwstage type-checks a @test body before the
|
|
* #6 splice drops it: an undefined symbol is caught loud even though the
|
|
* fn never reaches codegen (checked at check.ww pass 2/3, dropped after). */
|
|
static int
|
|
reject_plain(const char *bin, const char *fixture, const char *what)
|
|
{
|
|
char cmd[4096];
|
|
snprintf(cmd, sizeof cmd, "%s/w6c_ww %s -o /dev/null 2>/dev/null",
|
|
bin, fixture);
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "997 FAIL: w6c_ww (non-T) accepted %s "
|
|
"(expected reject)\n", what);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* accept_byteid — a #23 legal-accept control: `<fixture>` must COMPILE on
|
|
* BOTH stages (no false dup reject) AND be cs/ww byte-identical (rule 10).
|
|
* Used for the cross-package same-leaf control (keying is (name, mod), so
|
|
* distinct-package leaves coexist) and the builtin-redecl carve-out (the
|
|
* one structural point where wwstage seeds builtins and cstage does not —
|
|
* byte-id proves the drop-the-redecl mirror is exact). */
|
|
static int
|
|
accept_byteid(const char *bin, const char *fixture, const char *what)
|
|
{
|
|
int pid = getpid();
|
|
char cs[256], ws[256], cmd[4096];
|
|
snprintf(cs, sizeof cs, "/tmp/at997ab_c_%d.s", pid);
|
|
snprintf(ws, sizeof ws, "/tmp/at997ab_w_%d.s", pid);
|
|
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/w6c %s -o %s 2>/dev/null", bin, fixture, cs);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "997 FAIL: w6c rejected %s\n", what);
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/w6c_ww %s -o %s 2>/dev/null", bin, fixture, ws);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "997 FAIL: w6c_ww rejected %s\n", what);
|
|
return 1;
|
|
}
|
|
char *bc = NULL, *bw = NULL;
|
|
size_t nc = 0, nw = 0;
|
|
int rc = 0;
|
|
if (slurp(cs, &bc, &nc) < 0 || slurp(ws, &bw, &nw) < 0) {
|
|
fprintf(stderr, "997 FAIL: slurp %s asm\n", what);
|
|
rc = 1;
|
|
} else if (nc != nw || memcmp(bc, bw, nc) != 0) {
|
|
fprintf(stderr, "997 FAIL: %s asm differs (cs %zu, ww %zu)\n",
|
|
what, nc, nw);
|
|
rc = 1;
|
|
}
|
|
free(bc); free(bw);
|
|
unlink(cs); unlink(ws);
|
|
return rc;
|
|
}
|
|
|
|
/* collide_run — a @test unit defining a user `fn run` collides with
|
|
* lib/test's bound runner once `ww test -c` bundles it; `w6c_ww -T` of the
|
|
* combined must loud-reject the duplicate (#23). Pre-fix wwstage built a
|
|
* binary that called the user run and silently skipped every @test. */
|
|
static int
|
|
collide_run(const char *bin)
|
|
{
|
|
int pid = getpid();
|
|
char stem[256], comb[300], cmd[4096];
|
|
snprintf(stem, sizeof stem, "/tmp/at997cr_%d", pid);
|
|
snprintf(comb, sizeof comb, "%s.combined.ww", stem);
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/ww test -c -o %s test/wcc/data/attest_userrun.ww > /dev/null 2>&1",
|
|
bin, stem);
|
|
runwait(cmd);
|
|
if (access(comb, 0) != 0) {
|
|
fprintf(stderr, "997 FAIL: ww build produced no %s\n", comb);
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s/w6c_ww -T %s -o /dev/null 2>/dev/null",
|
|
bin, comb);
|
|
int rc = 0;
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "997 FAIL: w6c_ww -T accepted user `fn run` collision "
|
|
"(expected duplicate-fn reject)\n");
|
|
rc = 1;
|
|
}
|
|
unlink(comb);
|
|
char tmp[320];
|
|
snprintf(tmp, sizeof tmp, "%s.s", stem); unlink(tmp);
|
|
snprintf(tmp, sizeof tmp, "%s.o", stem); unlink(tmp);
|
|
unlink(stem);
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
const char *bin = absbin();
|
|
if (!bin) { fprintf(stderr, "997 FAIL: getcwd\n"); return 1; }
|
|
|
|
if (run_fixture(bin) != 0) return 1;
|
|
if (byteid(bin) != 0) return 1;
|
|
for (size_t i = 0; i < sizeof rejects / sizeof rejects[0]; i++)
|
|
if (reject(bin, rejects[i].fixture, rejects[i].what) != 0)
|
|
return 1;
|
|
if (nondrop(bin) != 0) return 1;
|
|
if (reject_plain(bin, "test/wcc/data/attest_undefbody.ww",
|
|
"undefined symbol in @test body") != 0) return 1;
|
|
|
|
/* #23 — wwstage top-level duplicate-decl reject (one row per kind:
|
|
* all four route through installtop) + legal cross-package control
|
|
* (byte-id) + the builtin-redecl carve-out (byte-id) + the -T
|
|
* `fn run` collision parity row. */
|
|
if (reject_plain(bin, "test/wcc/data/dup_fn.ww",
|
|
"same-module duplicate fn") != 0) return 1;
|
|
if (reject_plain(bin, "test/wcc/data/dup_type.ww",
|
|
"same-module duplicate type") != 0) return 1;
|
|
if (reject_plain(bin, "test/wcc/data/dup_def.ww",
|
|
"same-module duplicate def") != 0) return 1;
|
|
if (reject_plain(bin, "test/wcc/data/dup_let.ww",
|
|
"same-module duplicate let") != 0) return 1;
|
|
if (accept_byteid(bin, "test/wcc/data/dup_xpkg_ok.ww",
|
|
"cross-package same-name") != 0) return 1;
|
|
if (accept_byteid(bin, "test/wcc/data/builtin_redecl_ok.ww",
|
|
"builtin nomem redecl (carve-out)") != 0) return 1;
|
|
if (collide_run(bin) != 0) return 1;
|
|
|
|
printf("@test -T (ww_ww): run ok + cs/ww byte-id + rejects + "
|
|
"non-T @test drop cs/ww byte-id + checked-body (#6) + "
|
|
"dup fn/type/def/let reject + xpkg/builtin-redecl byte-id + "
|
|
"fn-run collision (#23)\n");
|
|
return 0;
|
|
}
|