Hojun-Cho
08a76cf4c8
Splice @test N_FNDECLs out of the unit after the body-check passes, mirroring harec's checked-but-not-emitted: a broken @test body still errors loudly in non-T; @test-free units are emission-unchanged. 910/997 table rows pin keep/test x non-T/-T, head+consecutive unlink, undef-body reject, and plain-calls-dropped loud link-fail. w6c+wwdump combined.ww regen. (#6-team)
269 lines
9.4 KiB
C
269 lines
9.4 KiB
C
/*
|
|
* 910_at_test — drives the compiler's `-T` @test mode (task #15).
|
|
*
|
|
* Under `w6c -T`, the checker collects every @test fn and synthesizes
|
|
* `export fn main() i32 { t0(); t1(); ...; return 0; }`, calling each in
|
|
* source order; a test that runs to completion passes, an abort/div0/
|
|
* nonzero exit FAILS the run. This replaces the old driver-side regex
|
|
* scan (find_attest) — the @test set now comes from the AST, the single
|
|
* source of truth (rob #15 ruling). cgen is untouched: the synthesized
|
|
* entry rides the existing cgfn path.
|
|
*
|
|
* Probes:
|
|
* 1. RUN — `w6c -T` the @test-only fixture, assemble, link, run; the
|
|
* synthesized entry must exit 0 (every @test passed). Imports are
|
|
* resolved by `ww build` into a *.combined.ww (the fixture uses
|
|
* `alloc`, whose rt_malloc symbol the driver concatenates); we then
|
|
* compile that combined unit with `-T`.
|
|
* 2. REJECT — `-T` of a fixture that also defines a user `main` must
|
|
* exit nonzero (the synth entry owns main).
|
|
* 3. GUARD — `-T` of a fixture whose @test fn is not `fn() void` must
|
|
* exit nonzero (rule-7 loud, no silent skip/coerce).
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.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;
|
|
}
|
|
|
|
/* run_fixture — `<comp> -T` the @test fixture (import-resolved into a
|
|
* combined unit by <drv> build), assemble, link, run; the synthesized
|
|
* entry must exit 0. Returns 0 on success. */
|
|
static int
|
|
run_fixture(const char *bin, const char *comp, const char *drv)
|
|
{
|
|
int pid = getpid();
|
|
char src[256], comb[256], asmf[256], obj[256], exe[256];
|
|
char rt[1024], cmd[4096];
|
|
snprintf(src, sizeof src, "/tmp/at910_%s_%d.ww", comp, pid);
|
|
snprintf(comb, sizeof comb, "/tmp/at910_%s_%d.combined.ww", comp, pid);
|
|
snprintf(asmf, sizeof asmf, "/tmp/at910_%s_%d.s", comp, pid);
|
|
snprintf(obj, sizeof obj, "/tmp/at910_%s_%d.o", comp, pid);
|
|
snprintf(exe, sizeof exe, "/tmp/at910_%s_%d.exe", comp, 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, "910 FAIL: cp\n"); return 1; }
|
|
|
|
/* Driver resolves `import rt` into <src>.combined.ww. The build
|
|
* itself exits nonzero (the @test-only fixture has no main — that
|
|
* is exactly what -T synthesizes), but the combined unit is written
|
|
* before any compile step, so we depend on the ARTIFACT, not the
|
|
* exit code. */
|
|
snprintf(cmd, sizeof cmd, "%s/%s build %s > /dev/null 2>&1", bin, drv, src);
|
|
runwait(cmd);
|
|
if (access(comb, 0) != 0) {
|
|
fprintf(stderr, "910 FAIL: %s build produced no %s\n", drv, comb);
|
|
return 1;
|
|
}
|
|
|
|
snprintf(cmd, sizeof cmd, "%s/%s -T %s -o %s 2>/dev/null", bin, comp, comb, asmf);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "910 FAIL: %s -T errored\n", comp);
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s/w6a -o %s %s 2>/dev/null", bin, obj, asmf);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "910 FAIL: w6a\n"); return 1; }
|
|
snprintf(cmd, sizeof cmd, "%s/w6l -o %s %s %s 2>/dev/null", bin, exe, obj, rt);
|
|
if (runwait(cmd) != 0) { fprintf(stderr, "910 FAIL: w6l\n"); return 1; }
|
|
|
|
int rc = runwait(exe);
|
|
if (rc != 0) {
|
|
fprintf(stderr, "910 FAIL: synth entry exited %d (a @test failed)\n", rc);
|
|
return 1;
|
|
}
|
|
unlink(src); unlink(comb); unlink(asmf); unlink(obj); unlink(exe);
|
|
return 0;
|
|
}
|
|
|
|
/* reject — `<comp> -T <fixture>` must exit nonzero. */
|
|
static int
|
|
reject(const char *bin, const char *comp, const char *fixture, const char *what)
|
|
{
|
|
char cmd[4096];
|
|
snprintf(cmd, sizeof cmd, "%s/%s -T %s -o /dev/null 2>/dev/null",
|
|
bin, comp, fixture);
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "910 FAIL: %s -T accepted %s (expected reject)\n",
|
|
comp, what);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Each row: a fixture `-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: each row asserts whether a symbol's TEXT def appears in the asm
|
|
* `<comp>` emits for attest_nondrop.ww in a given mode. A @test fn is
|
|
* spliced out of a non-test build (harec ref/harec/src/check.c:3941 —
|
|
* checked but never emitted) and kept under -T (the synth entry calls
|
|
* it); a plain fn is always emitted.
|
|
*/
|
|
static const struct {
|
|
const char *sym; /* TEXT label to grep for */
|
|
int testmode; /* 1 => -T, 0 => plain build */
|
|
int present; /* expected: 1 present, 0 absent */
|
|
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 — compile attest_nondrop.ww plain and `-T`, then assert each
|
|
* row's TEXT def is present/absent. */
|
|
static int
|
|
nondrop(const char *bin, const char *comp)
|
|
{
|
|
int pid = getpid();
|
|
char plain[256], tee[256], cmd[4096];
|
|
snprintf(plain, sizeof plain, "/tmp/at910nd_%s_p_%d.s", comp, pid);
|
|
snprintf(tee, sizeof tee, "/tmp/at910nd_%s_t_%d.s", comp, pid);
|
|
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/%s test/wcc/data/attest_nondrop.ww -o %s 2>/dev/null",
|
|
bin, comp, plain);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "910 FAIL: %s non-T nondrop compile\n", comp);
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/%s -T test/wcc/data/attest_nondrop.ww -o %s 2>/dev/null",
|
|
bin, comp, tee);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "910 FAIL: %s -T nondrop compile\n", comp);
|
|
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 ? tee : plain;
|
|
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, "910 FAIL: %s — %s: %s %s (expected %s)\n",
|
|
comp, nondrop_rows[i].what, nondrop_rows[i].sym,
|
|
found ? "present" : "absent",
|
|
nondrop_rows[i].present ? "present" : "absent");
|
|
rc = 1;
|
|
break;
|
|
}
|
|
}
|
|
unlink(plain); unlink(tee);
|
|
return rc;
|
|
}
|
|
|
|
/* reject_plain — `<comp> <fixture>` (NON-T) must exit nonzero. Pins that
|
|
* a @test body is type-checked before the #6 splice drops it: an
|
|
* undefined symbol in the body is caught loud even though the fn never
|
|
* reaches codegen (harec checks at :3913, drops at :3941). */
|
|
static int
|
|
reject_plain(const char *bin, const char *comp, const char *fixture,
|
|
const char *what)
|
|
{
|
|
char cmd[4096];
|
|
snprintf(cmd, sizeof cmd, "%s/%s %s -o /dev/null 2>/dev/null",
|
|
bin, comp, fixture);
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "910 FAIL: %s (non-T) accepted %s "
|
|
"(expected reject)\n", comp, what);
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* linkfail — a plain fn calling a @test fn, built non-T: compile +
|
|
* assemble succeed, but the link MUST fail (the dropped @test def leaves
|
|
* the call's symbol dangling — harec-faithful loud failure, never a
|
|
* silent mis-link). Linker behavior is stage-independent, so cstage
|
|
* suffices; 997's byte-id proves the wwstage .s is identical. */
|
|
static int
|
|
linkfail(const char *bin, const char *comp)
|
|
{
|
|
int pid = getpid();
|
|
char asmf[256], obj[256], exe[256], rt[1024], cmd[4096];
|
|
snprintf(asmf, sizeof asmf, "/tmp/at910lf_%s_%d.s", comp, pid);
|
|
snprintf(obj, sizeof obj, "/tmp/at910lf_%s_%d.o", comp, pid);
|
|
snprintf(exe, sizeof exe, "/tmp/at910lf_%s_%d.exe", comp, pid);
|
|
snprintf(rt, sizeof rt, "%s/../lib/libwwrt.a", bin);
|
|
|
|
snprintf(cmd, sizeof cmd,
|
|
"%s/%s test/wcc/data/attest_calldropped.ww -o %s 2>/dev/null",
|
|
bin, comp, asmf);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "910 FAIL: %s non-T calldropped compile\n", comp);
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s/w6a -o %s %s 2>/dev/null", bin, obj, asmf);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "910 FAIL: w6a calldropped\n");
|
|
unlink(asmf);
|
|
return 1;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s/w6l -o %s %s %s 2>/dev/null",
|
|
bin, exe, obj, rt);
|
|
int rc = 0;
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "910 FAIL: calldropped linked (expected "
|
|
"undefined-reference to the dropped @test sym)\n");
|
|
rc = 1;
|
|
}
|
|
unlink(asmf); unlink(obj); unlink(exe);
|
|
return rc;
|
|
}
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
const char *bin = absbin();
|
|
if (!bin) { fprintf(stderr, "910 FAIL: getcwd\n"); return 1; }
|
|
|
|
if (run_fixture(bin, "w6c", "ww") != 0) return 1;
|
|
for (size_t i = 0; i < sizeof rejects / sizeof rejects[0]; i++)
|
|
if (reject(bin, "w6c", rejects[i].fixture, rejects[i].what) != 0)
|
|
return 1;
|
|
if (nondrop(bin, "w6c") != 0) return 1;
|
|
if (reject_plain(bin, "w6c", "test/wcc/data/attest_undefbody.ww",
|
|
"undefined symbol in @test body") != 0) return 1;
|
|
if (linkfail(bin, "w6c") != 0) return 1;
|
|
|
|
printf("@test -T: run ok + user-main and bad-signature rejected + "
|
|
"non-T @test drop + checked-body + dangling-call link-fail (#6)\n");
|
|
return 0;
|
|
}
|