/* * 849_dupfield_reject (catB-7/14) — cstage and wwstage LOUD-REJECT a * struct declaration that carries two fields with the same name. * * cstage already rejected at cmd/wcc/check.c:943-950 (the regular-named- * field arm of resolve_type's N_TSTRUCT). wwstage silently ACCEPTED — it * never compared field names. The fix adds validatestructfields(), a pure * read-only O(n^2) named-field dup walk, fired once per struct decl from * resolvewalk's eager type-decl dispatch (selfhost/cmd/wcc/check.ww), the * rule-10 twin of cstage's once-per-resolve_type site. ww has no struct * embedding (parser gap catB-89), so cstage's embed-collision arm * (check.c:961-985) is intentionally NOT ported — named fields only. * * Byte-id: pure diagnostic, no n.type_ / offset / checker-state mutation; * the valid corpus has no duplicate fields, so codegen of every valid * program is unchanged → cstage == wwstage byte-id holds. * * row | shape | expect * -------------+------------------------------------+-------- * adj_dup | struct { a: i32, a: i32 } | REJECT * nonadj_dup | struct { a: i32, b: i32, a: i32 } | REJECT * dup_difftype | struct { a: i32, a: bool } | REJECT * distinct | struct { x: i32, y: i32 }, use x+y | BUILD, run 7 */ #include #include #include #include #include #include static int runwait(const char *cmd) { int rc = system(cmd); if (rc == -1) return -1; if (WIFEXITED(rc)) return WEXITSTATUS(rc); return -1; } static void outbin(char *dst, size_t n, const char *tmpdir, const char *src) { const char *base = strrchr(src, '/'); base = base ? base + 1 : src; snprintf(dst, n, "%s/%s", tmpdir, base); char *dot = strrchr(dst, '.'); if (dot && strcmp(dot, ".ww") == 0) *dot = '\0'; } static int filehas(const char *path, const char *needle) { char buf[8192]; FILE *f = fopen(path, "rb"); if (!f) return 0; size_t n = fread(buf, 1, sizeof buf - 1, f); fclose(f); buf[n] = '\0'; return strstr(buf, needle) != NULL; } /* A reject row passes only when the build FAILS *and* the stage's clean * diagnostic appears; a crash (segfault) wraps as a nonzero "w6c failed" * with no diagnostic, so the substring check distinguishes it (#20). */ static int build_should_fail(const char *driver, const char *label, const char *src, const char *diag, int i) { char s[64], tmpdir[64], cmd[1024], bin[128], errf[64]; snprintf(s, sizeof s, "/tmp/dupf_%d_%d.ww", getpid(), i); snprintf(tmpdir, sizeof tmpdir, "/tmp/dupf_%d_d_%d", getpid(), i); snprintf(errf, sizeof errf, "/tmp/dupf_%d_e_%d.txt", getpid(), i); FILE *f = fopen(s, "wb"); if (!f) return -1; fputs(src, f); fclose(f); mkdir(tmpdir, 0755); snprintf(cmd, sizeof cmd, "cd %s && %s build %s >/dev/null 2>%s", tmpdir, driver, s, errf); int rc = runwait(cmd); int hasmsg = filehas(errf, diag); outbin(bin, sizeof bin, tmpdir, s); unlink(s); unlink(bin); unlink(errf); rmdir(tmpdir); if (rc == 0) { fprintf(stderr, "dupf[%s][%s]: built ok, expected a reject\n", driver, label); return -1; } if (!hasmsg) { fprintf(stderr, "dupf[%s][%s]: nonzero exit but missing " "diagnostic \"%s\" (a crash, not a clean reject)\n", driver, label, diag); return -1; } return 0; } static int run_build(const char *driver, const char *label, const char *src, int i) { char s[64], tmpdir[64], cmd[1024], bin[128]; snprintf(s, sizeof s, "/tmp/dupf_ok_%d_%d.ww", getpid(), i); snprintf(tmpdir, sizeof tmpdir, "/tmp/dupf_ok_%d_d_%d", getpid(), i); FILE *f = fopen(s, "wb"); if (!f) return -1; fputs(src, f); fclose(f); mkdir(tmpdir, 0755); snprintf(cmd, sizeof cmd, "cd %s && %s build %s 2>/dev/null", tmpdir, driver, s); if (runwait(cmd) != 0) { fprintf(stderr, "dupf[%s][%s]: build failed (distinct fields " "must compile)\n", driver, label); unlink(s); rmdir(tmpdir); return -1; } outbin(bin, sizeof bin, tmpdir, s); int got = runwait(bin); unlink(s); unlink(bin); rmdir(tmpdir); return got; } struct rejrow { const char *label; const char *src; const char *diag; }; static const struct rejrow reject_rows[] = { { "adj_dup", "package main;\n" "type d = struct { a: i32, a: i32 };\n" "fn main() i32 = { let p: *d = nil; return 0; };\n", "duplicate field" }, { "nonadj_dup", "package main;\n" "type d = struct { a: i32, b: i32, a: i32 };\n" "fn main() i32 = { let p: *d = nil; return 0; };\n", "duplicate field" }, { "dup_difftype", "package main;\n" "type d = struct { a: i32, a: bool };\n" "fn main() i32 = { let p: *d = nil; return 0; };\n", "duplicate field" }, }; struct okrow { const char *label; const char *src; int want; }; static const struct okrow ok_rows[] = { { "distinct", "package main;\n" "type pt = struct { x: i32, y: i32 };\n" "fn main() i32 = { let p: pt = pt{x=3, y=4}; return p.x + p.y; };\n", 7 }, }; int main(void) { const char *bin = getenv("BIN"); if (!bin) bin = "out/bin"; char absbin[1024]; if (bin[0] != '/') { char cwd[1024]; if (getcwd(cwd, sizeof cwd) == NULL) return 1; snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin); bin = absbin; } char cdrv[1024], wdrv[1024]; snprintf(cdrv, sizeof cdrv, "%s/ww", bin); snprintf(wdrv, sizeof wdrv, "%s/ww_ww", bin); struct { const char *name; const char *path; int gated; } drivers[] = { { "cstage", cdrv, 0 }, { "wwstage", wdrv, 1 }, { NULL, NULL, 0 }, }; int nrej = (int)(sizeof reject_rows / sizeof reject_rows[0]); int nok = (int)(sizeof ok_rows / sizeof ok_rows[0]); int total = 0, fail = 0; for (int d = 0; drivers[d].name; d++) { if (drivers[d].gated && access(drivers[d].path, X_OK) != 0) { fprintf(stderr, "dupf: skip %s (no %s)\n", drivers[d].name, drivers[d].path); continue; } for (int i = 0; i < nrej; i++) { total++; if (build_should_fail(drivers[d].path, reject_rows[i].label, reject_rows[i].src, reject_rows[i].diag, d * 100 + i) != 0) fail++; } for (int i = 0; i < nok; i++) { total++; int got = run_build(drivers[d].path, ok_rows[i].label, ok_rows[i].src, d * 100 + i); if (got != ok_rows[i].want) { fprintf(stderr, "dupf[%s][%s]: exit=%d want=%d\n", drivers[d].name, ok_rows[i].label, got, ok_rows[i].want); fail++; } } } if (fail) { fprintf(stderr, "dupf: %d/%d fixtures failed\n", fail, total); return 1; } printf("dupf: %d/%d ok\n", total, total); return 0; }