ww/test/wcc/989_c6soak_run.c

/*
 * 989_c6soak_run — M3-tail commit-6 separate-compilation soak gate
 * (#46 c6, rob-c6-spec.md Tier-A/B + §3 collision).
 *
 * The standing real-code regression gate for separate compilation. The
 * oracle is observable output plus byte-identical per-package compiler
 * artifacts across the C and WW driver stages.
 *
 * Targets (real library chains):
 *   - utf8   : encoding.utf8 (DOTTED-path #57) + strings → decode + count
 *              runes ("héllo" = 5). Exercises the multi-component import
 *              resolution by the full dotted path.
 *   - collide: strings.contains AND bytes.contains — the SAME leaf `contains`
 *              exported by two packages (rob-c6-spec §3, the #48/#49 class
 *              on real code). The driver path-qualifies them to DISTINCT
 *              symbols;
 *              the program computes both correct results; the §3 non-vacuity
 *              check below greps the per-pkg .s to prove the two labels are
 *              genuinely distinct (disambiguation is real, not luck).
 *
 * Asserts per target (direct per-stage builds use fresh output stems under
 * an invocation-owned root; retained scratch is inspected, then removed by
 * final carrier cleanup):
 *  1. RUN-EXIT: both driver stages build and run to the expected result.
 *  2. cs==ww (rule 10): the cstage `ww` and wwstage `ww_ww` sep-drivers emit
 *     byte-identical per-package .s and .wwi (the .wwi enters the compare
 *     set — rob-c6-spec). Both also link to a binary that runs to `expect`.
 *  3. §3 NON-VACUITY (collide only): the per-package strings.s defines
 *     `TEXT strings.contains` and bytes.s defines `TEXT bytes.contains` —
 *     two DISTINCT symbols. The w6l dup-gate stays silent (no collision);
 *     both resolve; the program returns 7.
 *
 * The heavy Tier-C capstone (real tool w6c/wwdump self-compile output
 * equivalence) is FOLDED into the 990-997 bootstrap oracle (994_w6c_ww),
 * not bolted on here (rob-c6-spec §2 / amendment-B).
 *
 * All intermediates are `-o`-redirected to /tmp for isolation. Models
 * 989_sepbuild_run.c / 989_sepdotpath_run.c conventions; 989 prefix per
 * the sep-gate precedent.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <dirent.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
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;
}

/* cs==ww over a sep-build's per-package output: every .s/.wwi the cstage
 * driver produced in `csdir` must be byte-identical to the wwstage
 * driver's same-named file in `wwdir`. Returns the count of mismatches. */
static int
cmp_sepwork(const char *csdir, const char *wwdir, const char *label)
{
	DIR *d = opendir(csdir);
	if (!d) {
		fprintf(stderr, "c6soak FAIL: %s — no cs sepwork %s\n", label, csdir);
		return 1;
	}
	int bad = 0, seen = 0;
	struct dirent *ent;
	while ((ent = readdir(d)) != NULL) {
		const char *nm = ent->d_name;
		size_t nl = strlen(nm);
		int is_s = (nl > 2 && strcmp(nm + nl - 2, ".s") == 0);
		int is_wwi = (nl > 4 && strcmp(nm + nl - 4, ".wwi") == 0);
		if (!is_s && !is_wwi) continue;
		seen++;
		char a[2048], b[2048];
		snprintf(a, sizeof a, "%s/%s", csdir, nm);
		snprintf(b, sizeof b, "%s/%s", wwdir, nm);
		if (files_eq(a, b) != 0) {
			fprintf(stderr, "c6soak FAIL: %s — cs!=ww for %s (rule 10)\n",
			    label, nm);
			bad++;
		}
	}
	closedir(d);
	/* An existing-but-empty sepwork would pass the cs==ww loop vacuously
	 * (no per-pkg .s/.wwi to compare); the utf8 root has no other cs==ww
	 * anchor, so demand at least one compared file. */
	if (seen == 0) {
		fprintf(stderr, "c6soak FAIL: %s — no .s/.wwi in %s\n", label, csdir);
		bad++;
	}
	return bad;
}

struct root {
	const char *label;
	const char *src;
	int expect;
	int collide;	/* run the §3 distinct-label non-vacuity check */
};

static struct root roots[] = {
	{ "utf8",
	  "package main;\n"
	  "import encoding.utf8;\n"
	  "import strings;\n"
	  "fn main() i32 = {\n"
	  "  let d = utf8.decode(strings.toutf8(\"h\303\251llo\"));\n"
	  "  let n: i32 = 0;\n"
	  "  for (true) {\n"
	  "    match (utf8.next(&d)) {\n"
	  "    case rune => n += 1;\n"
	  "    case => break;\n"
	  "    };\n"
	  "  };\n"
	  "  return n;\n"
	  "};\n", 5, 0 },
	{ "collide",
	  "package main;\n"
	  "import strings;\n"
	  "import bytes;\n"
	  "fn main() i32 = {\n"
	  "  let s = strings.contains(\"hello\", \"ell\");\n"
	  "  let b = bytes.contains(strings.toutf8(\"hello\"), strings.toutf8(\"ell\"));\n"
	  "  if (s && b) { return 7; };\n"
	  "  return 1;\n"
	  "};\n", 7, 1 },
	{ NULL, NULL, 0, 0 },
};

int
main(void)
{
	const char *bin = absbin();
	if (!bin) return 1;
	char cwd[1024];
	if (getcwd(cwd, sizeof cwd) == NULL) return 1;

	/* The real include set the sep producer needs to resolve the lib +
	 * frontend package graph (verified live). */
	char inc[4096];
	snprintf(inc, sizeof inc, "-I %s/lib -I %s/lib/ww -I %s/selfhost/cmd/wcc",
	    cwd, cwd, cwd);

	char td[] = "/tmp/wwc6soak_XXXXXX";
	char cmd[8192];
	int fail = 0;
	int source_created[2] = { 0, 0 };
	int stage_started[2][2] = { { 0, 0 }, { 0, 0 } };
	if (mkdtemp(td) == NULL) {
		perror("wwc6soak: mkdtemp");
		return 1;
	}

	for (int i = 0; roots[i].label; i++) {
		struct root *r = &roots[i];
		char rootww[1024];
		snprintf(rootww, sizeof rootww, "%s/%s.ww", td, r->label);
		if (write_file(rootww, r->src)) { fail++; continue; }
		source_created[i] = 1;

		/* Both stages produce every per-package
		 * .s/.wwi artifact this gate inspects. */
		struct { const char *drv, *tag; char prog[1024]; int rc; }
		stg[] = { { "ww", "cs", {0}, -1 }, { "ww_ww", "ww", {0}, -1 } };
		int built = 1;
		for (int s = 0; s < 2; s++) {
			/* `.bin` infix keeps the stage-`ww` output distinct from the
			 * `<label>.ww` SOURCE (else the build clobbers its own input). */
			snprintf(stg[s].prog, sizeof stg[s].prog, "%s/%s.%s.bin",
			    td, r->label, stg[s].tag);
			snprintf(cmd, sizeof cmd,
			    "timeout 240 %s/%s build "
			    "%s -o %s %s >/dev/null 2>&1",
			    bin, stg[s].drv, inc,
			    stg[s].prog, rootww);
			stage_started[i][s] = 1;
			if (runwait(cmd) != 0) {
				fprintf(stderr, "c6soak FAIL: %s %s build\n",
				    r->label, stg[s].drv);
				fail++;
				built = 0;
				continue;
			}
			stg[s].rc = runwait(stg[s].prog);
		}
		if (!built) continue;

		/* 1. Runtime behavior agrees across both stages. */
		if (stg[0].rc != r->expect || stg[1].rc != r->expect) {
			fprintf(stderr, "c6soak FAIL: %s exits cs=%d ww=%d "
			    "(expected %d)\n", r->label, stg[0].rc, stg[1].rc,
			    r->expect);
			fail++;
		}

		/* 2. cs==ww (rule 10): per-package .s/.wwi byte-identical. */
		char csdir[1024], wwdir[1024];
		snprintf(csdir, sizeof csdir, "%s/%s.cs.bin.sepwork", td, r->label);
		snprintf(wwdir, sizeof wwdir, "%s/%s.ww.bin.sepwork", td, r->label);
		fail += cmp_sepwork(csdir, wwdir, r->label);

		/* 3. §3 non-vacuity: distinct same-leaf labels in distinct .s. */
		if (r->collide) {
			char ss[2048], bs[2048];
			snprintf(ss, sizeof ss, "%s/strings.s", csdir);
			snprintf(bs, sizeof bs, "%s/bytes.s", csdir);
			if (file_contains(ss, "TEXT strings.contains") != 0) {
				fprintf(stderr, "c6soak FAIL: %s — strings.s lacks "
				    "`TEXT strings.contains` (§3 disambiguation)\n",
				    r->label);
				fail++;
			}
			if (file_contains(bs, "TEXT bytes.contains") != 0) {
				fprintf(stderr, "c6soak FAIL: %s — bytes.s lacks "
				    "`TEXT bytes.contains` (§3 disambiguation)\n",
				    r->label);
				fail++;
			}
		}
	}

	{
		int cleanfail = 0;
		char path[1024];
		const char *labels[] = { "utf8", "collide" };
		const char *tags[] = { "cs", "ww" };
		for (int i = 0; i < 2; i++) {
			for (int s = 0; s < 2; s++) {
				if (!stage_started[i][s]) continue;
				snprintf(path, sizeof path, "%s/%s.%s.bin.sepwork",
				    td, labels[i], tags[s]);
				snprintf(cmd, sizeof cmd, "rm -rf %s", path);
				if (runwait(cmd) != 0) cleanfail = 1;
				snprintf(path, sizeof path, "%s/%s.%s.bin",
				    td, labels[i], tags[s]);
				if (unlink(path) != 0 && errno != ENOENT) cleanfail = 1;
			}
			if (source_created[i]) {
				snprintf(path, sizeof path, "%s/%s.ww", td, labels[i]);
				if (unlink(path) != 0 && errno != ENOENT) cleanfail = 1;
			}
		}
		if (rmdir(td) != 0) cleanfail = 1;
		if (cleanfail) {
			fprintf(stderr, "c6soak FAIL: temporary cleanup failed\n");
			fail++;
		}
	}
	if (fail) {
		fprintf(stderr, "c6soak: %d check(s) failed\n", fail);
		return 1;
	}
	printf("c6soak: separate-compilation behavior on real chains "
	    "(encoding.utf8 dotted + strings/bytes same-leaf `contains`) — "
	    "cs==ww per-pkg .s/.wwi + §3 distinct labels\n");
	return 0;
}