/* * 712_redecl — check: refuse same-scope let/mlet/param/top-let * redeclarations (task #32). * * Pre-fix: cmd/wcc/check.c silently dropped the duplicate insert when * scope_define returned NULL. `let a: i32 = 1; let a: i32 = 2;` in * one block compiled cleanly and the second store last-write-wins; * `fn f(a: i32, a: i32)` accepted both params, body resolved to the * second. Surfaced post-#27 (which dropped the localoff name-dedup * shim that had been masking the issue at codegen) — see commit * 1292f98's follow-up note and worker-27's filed task. * * Post-fix: cstage check.c errors at every site where scope_define / * scope_define_in_module's NULL return was previously ignored: * * site | message * ---------------------------+-------------------------------------- * block-body N_LET | let '%s' redeclared in same scope * N_MLET (`let (a,b)=…`) | let '%s' redeclared in same scope * N_FORRANGE tuple-binding | binding '%s' redeclared in same scope * N_FNDECL param | param '%s' redeclared * top-level N_LET | duplicate let %s * * N_MCASE (case-binding) and N_FORRANGE single-binding already lived * in fresh per-arm / per-loop scopes with at most one bind, so they * weren't part of the bug class. Top-level N_TYPEDECL / N_DEF / * N_FNDECL already errored on NULL ("duplicate %s"). * * Cstage-only. Wwstage's check.ww is a single-pass resolve walk with * no per-block scoping (line 1015 comment), exercised only by * wwdump_ww as a diagnostic; adding the guard there today would * false-positive on legal cross-block shadow. Tracked under #11 * (wwstage checkfile pass with per-block scoping). Matches the * test/wcc/708 + test/wcc/696 cstage-only neg-case precedent. * * row | gate | what it pins * --------------------------+----------------+-------------------- * neg_let_same_block | build fails | site 1443 * neg_mlet_same_block | build fails | site 1562 * neg_mlet_tuple_dup | build fails | site 1562 (dup-in) * neg_forrange_tuple_dup | build fails | site 1505 * neg_param_dup | build fails | site 1914 * neg_toplet_dup | build fails | site 1880 * pos_nested_block_shadow | exit=1 | scope boundary * pos_nested_shadow_typed | exit=2 | (name,type) — bucket * | | keys by name only * pos_forrange_body_shadow | exit=99 | for body N_BLOCK * | | opens a fresh scope * pos_mcase_per_arm | exit=7 | match arm scope */ #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; } /* * kind == 0: negative — build must fail (any nonzero exit). * kind == 1: positive — build must succeed AND binary exits with `want`. */ struct row { const char *label; int kind; const char *src; int want; }; static const struct row rows[] = { /* neg: site 1443 — block-body let dup. */ { "neg_let_same_block", 0, "fn main() i32 = {\n" " let a: i32 = 1;\n" " let a: i32 = 2;\n" " return a;\n" "};\n", 0 }, /* neg: site 1562 — mlet shadows earlier same-block let. */ { "neg_mlet_same_block", 0, "fn pair() (i32, i32) = { return (10, 20); };\n" "fn main() i32 = {\n" " let a: i32 = 1;\n" " let (a, b) = pair();\n" " return a + b;\n" "};\n", 0 }, /* neg: site 1562 — mlet pattern lists the same name twice. */ { "neg_mlet_tuple_dup", 0, "fn pair() (i32, i32) = { return (10, 20); };\n" "fn main() i32 = {\n" " let (a, a) = pair();\n" " return a;\n" "};\n", 0 }, /* neg: site 1505 — forrange tuple-pattern lists same name twice. */ { "neg_forrange_tuple_dup", 0, "fn main() i32 = {\n" " let xs: [1](i32, i32) = [(10i32, 20i32)];\n" " for (let (a, a) .. xs) {\n" " return a;\n" " };\n" " return -1;\n" "};\n", 0 }, /* neg: site 1914 — two params with the same name. */ { "neg_param_dup", 0, "fn f(a: i32, a: i32) i32 = { return a; };\n" "fn main() i32 = { return f(1, 2); };\n", 0 }, /* neg: site 1880 — top-level let dup. */ { "neg_toplet_dup", 0, "let x: i32 = 1;\n" "let x: i32 = 2;\n" "fn main() i32 = { return x; };\n", 0 }, /* pos: nested-block shadow stays legal. Inner block opens a * fresh scope, scope_define's per-scope hash bucket isolates the * inner `a` from the outer one. Outer `a` untouched after the * inner block exits. */ { "pos_nested_block_shadow", 1, "fn main() i32 = {\n" " let a: i32 = 1;\n" " {\n" " let a: i32 = 99;\n" " };\n" " return a;\n" "};\n", 1 }, /* pos: nested-block shadow with a different type. Confirms the * scope-bucket key is the name alone, not (name, type) — the * inner `s: str` does NOT collide with the outer `s: i32`. */ { "pos_nested_shadow_typed", 1, "fn main() i32 = {\n" " let s: i32 = 2;\n" " {\n" " let s: str = \"hi\";\n" " let _ = s;\n" " };\n" " return s;\n" "};\n", 2 }, /* pos: for-loop body N_BLOCK opens a fresh scope, so a `let x` * inside the body doesn't collide with the for-range's binding * `x` (which lives in the per-loop scope, one level above). */ { "pos_forrange_body_shadow", 1, "fn main() i32 = {\n" " let arr: [1]i32 = [42i32];\n" " let r: i32 = 0;\n" " for (let x .. arr) {\n" " let x: i32 = 99;\n" " r = x;\n" " };\n" " return r;\n" "};\n", 99 }, /* pos: each match arm is its own scope, so two arms each * binding `v` don't collide. Pre-#32 this was already legal * (newscope wrapper at check.c:1186); pinned here so a future * scope-tightening can't quietly remove that wrapper. */ { "pos_mcase_per_arm", 1, "type T = (i32 | f64);\n" "fn main() i32 = {\n" " let t: T = 7i32;\n" " match (t) {\n" " case let v: i32 => { return v; };\n" " case let v: f64 => { return -1; };\n" " };\n" "};\n", 7 }, }; static int run_row(const char *driver, const struct row *r, int i) { char src[128], tmpdir[128], cmd[2048]; snprintf(src, sizeof src, "/tmp/wcredecl_%d_%d.ww", getpid(), i); snprintf(tmpdir, sizeof tmpdir, "/tmp/wcredecl_%d_d_%d", getpid(), i); FILE *f = fopen(src, "wb"); if (!f) return -1; fputs(r->src, f); fclose(f); mkdir(tmpdir, 0755); snprintf(cmd, sizeof cmd, "cd %s && %s build %s >/dev/null 2>&1", tmpdir, driver, src); int rc = runwait(cmd); const char *base = strrchr(src, '/'); base = base ? base + 1 : src; char outbin[256]; snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base); char *dot = strrchr(outbin, '.'); if (dot && strcmp(dot, ".ww") == 0) *dot = '\0'; if (r->kind == 0) { /* Negative — build must fail. */ if (rc == 0) { fprintf(stderr, "redecl[%s]: build unexpectedly succeeded\n", r->label); unlink(outbin); } unlink(src); /* combined.ww left next to src by the driver */ char combined[256]; snprintf(combined, sizeof combined, "%s.combined.ww", src); dot = strrchr(combined, '.'); (void)dot; snprintf(combined, sizeof combined, "/tmp/wcredecl_%d_%d.combined.ww", getpid(), i); unlink(combined); rmdir(tmpdir); return rc == 0 ? -1 : 0; } /* Positive — build then run. */ if (rc != 0) { fprintf(stderr, "redecl[%s]: build failed\n", r->label); unlink(src); rmdir(tmpdir); return -1; } int got = runwait(outbin); unlink(src); unlink(outbin); char combined[256]; snprintf(combined, sizeof combined, "/tmp/wcredecl_%d_%d.combined.ww", getpid(), i); unlink(combined); rmdir(tmpdir); if (got != r->want) { fprintf(stderr, "redecl[%s]: exit=%d want=%d\n", r->label, got, r->want); return -1; } return 0; } int main(void) { const char *bin = getenv("BIN"); if (!bin) bin = "out/bin"; char absbin[512]; if (bin[0] != '/') { char cwd[256]; if (getcwd(cwd, sizeof cwd) == NULL) return 1; snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin); bin = absbin; } char cdrv[640]; snprintf(cdrv, sizeof cdrv, "%s/ww", bin); int n = (int)(sizeof rows / sizeof rows[0]); int fail = 0; for (int i = 0; i < n; i++) { if (run_row(cdrv, &rows[i], i) != 0) fail++; } if (fail) { fprintf(stderr, "redecl: %d/%d row(s) failed\n", fail, n); return 1; } printf("redecl: %d/%d ok\n", n, n); return 0; }