Hojun-Cho
e92708ecda
Hare admits an array with a defined length wherever its element slice is
expected (assign / return / call-arg / init) as a borrow; ww rejected it
everywhere (the #108(c) exclusion), so base64 worked around the gap with
explicit a[0:n] slices.
type_assignable / isassignable now admit array->slice on an exact element
match (mirror ref/harec/src/types.c:1080-1097, the SLICE-dst arm). The four
acceptance sites route through one shared helper (desugar_arrayslice /
desugararrayslice) that rewrites the array expr to the explicit full slice
arr[0:len(arr)] — an N_SLICE over the array base. cgen is untouched: the
existing slice lowering (#252/#257/#135 made array bases, incl struct-field
arrays, correct) materialises the borrow header {.ptr=&arr[0], .len=N,
.cap=N}, byte-identically in both stages.
wwstage runs no general call-arg / N_ASSIGN typecheck, so checkassign +
desugarcallargs are added solely to route those two contexts through the
shared desugar (rule-10). desugarcallargs additionally loud-rejects an
element-MISMATCH array into a []T param, scoped to that shape so wwstage's
broader call-arg leniency is untouched.
953_arraytoslice_run covers the four contexts + a borrow-alias proof + the
i32/u8 element axis (dual-stage run + cs==ww byte-id), plus mismatch-reject
rows asserting both stages refuse [4]i32 -> []u8. Regen'd w6c + wwdump
combined.ww (#110).
273 lines
8.4 KiB
C
273 lines
8.4 KiB
C
/*
|
|
* 953_arraytoslice_run — runtime + byte-id + reject net for #258: the
|
|
* implicit [N]T -> []T array-to-slice BORROW. Hare admits an array with a
|
|
* defined length wherever its element slice is expected (assign / return /
|
|
* call-arg / init), as a borrow — `.ptr = &arr[0], .len = N, .cap = N`
|
|
* (ref/harec/src/types.c:1080-1097, the SLICE-dst arm). ww previously
|
|
* REJECTED it everywhere (cmd/wcc/type.c:#108(c) exclusion); base64
|
|
* worked around the gap with explicit `a[0:n]` slices.
|
|
*
|
|
* Fix (DESUGAR, checker-only, ZERO new cgen): type_assignable /
|
|
* isassignable admit array→slice on an exact element match; the four
|
|
* acceptance sites (clet / N_ASSIGN / call-arg gather / N_RETURN) then
|
|
* rewrite the array expr to the explicit full slice `arr[0:len(arr)]` (an
|
|
* N_SLICE over the array base) via the shared desugar_arrayslice /
|
|
* desugararrayslice helper. cgen is untouched — the existing slice
|
|
* lowering (#252/#257/#135 made array bases, incl struct-field arrays,
|
|
* correct) materialises the borrow header, identically in both stages.
|
|
*
|
|
* Positive rows: cstage `ww build` + run for exit code (the four contexts
|
|
* + a BORROW proof — mutate through the slice, observe the change in the
|
|
* backing array, i.e. alias not copy), then w6c vs w6c_ww `.s` cmp for the
|
|
* rule-10 byte-id gate (all four contexts emit byte-identical asm).
|
|
* - let_i32 let-init borrow `let s: []i32 = a`, s[2] → 33
|
|
* - let_u8 let-init borrow, u8 element, s[3] → 66
|
|
* - assign_i32 assignment borrow `s = a` (s was a[0:1]), s[3] → 4
|
|
* - callarg_i32 call-arg borrow `sum(a)` (sums all elements) → 65
|
|
* - callarg_u8 call-arg borrow, u8 element → 70
|
|
* - return_i32 return borrow `return g` (g a global array) → 17
|
|
* - borrow_i32 mutate s[2]=55 through the slice, read a[2] → 55
|
|
*
|
|
* Reject rows (cs==ww symmetric loud-reject): an element-type MISMATCH
|
|
* ([4]i32 -> []u8) is NOT a borrow — both stages must refuse it. w6c and
|
|
* w6c_ww are each run directly and must exit non-zero (the desugar's
|
|
* element-exact gate; type_assignable / isassignable fall through to a
|
|
* confident reject).
|
|
* - mismatch_let let s: []u8 = a where a:[4]i32 → both reject
|
|
* - mismatch_callarg f(a) where f wants []u8, a:[4]i32 → both reject
|
|
*/
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.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 int
|
|
slurp_eq(const char *a, const char *b)
|
|
{
|
|
FILE *fa = fopen(a, "rb"), *fb = fopen(b, "rb");
|
|
if (fa == NULL || fb == NULL) {
|
|
if (fa) fclose(fa);
|
|
if (fb) fclose(fb);
|
|
return -1;
|
|
}
|
|
int ca, cb, eq = 0;
|
|
do {
|
|
ca = fgetc(fa);
|
|
cb = fgetc(fb);
|
|
if (ca != cb) { eq = -1; break; }
|
|
} while (ca != EOF);
|
|
fclose(fa);
|
|
fclose(fb);
|
|
return eq;
|
|
}
|
|
|
|
struct row { const char *label; const char *src; int want_exit; int reject; };
|
|
|
|
static const struct row rows[] = {
|
|
{ "let_i32",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [4]i32 = [11, 22, 33, 44];\n"
|
|
" let s: []i32 = a;\n"
|
|
" return s[2];\n"
|
|
"};\n", 33, 0 },
|
|
{ "let_u8",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [4]u8 = [11u8, 22u8, 33u8, 66u8];\n"
|
|
" let s: []u8 = a;\n"
|
|
" return s[3]: i32;\n"
|
|
"};\n", 66, 0 },
|
|
{ "assign_i32",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [4]i32 = [1, 2, 3, 4];\n"
|
|
" let s: []i32 = a[0:1];\n"
|
|
" s = a;\n"
|
|
" return s[3];\n"
|
|
"};\n", 4, 0 },
|
|
{ "callarg_i32",
|
|
"package main;\n"
|
|
"fn sum(s: []i32) i32 = {\n"
|
|
" let t: i32 = 0; let i: i32 = 0;\n"
|
|
" for (i < s.len) { t += s[i]; i += 1; };\n"
|
|
" return t;\n"
|
|
"};\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [4]i32 = [10, 20, 30, 5];\n"
|
|
" return sum(a);\n"
|
|
"};\n", 65, 0 },
|
|
{ "callarg_u8",
|
|
"package main;\n"
|
|
"fn sum(s: []u8) i32 = {\n"
|
|
" let t: i32 = 0; let i: i32 = 0;\n"
|
|
" for (i < s.len) { t += s[i]: i32; i += 1; };\n"
|
|
" return t;\n"
|
|
"};\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [3]u8 = [10u8, 20u8, 40u8];\n"
|
|
" return sum(a);\n"
|
|
"};\n", 70, 0 },
|
|
{ "return_i32",
|
|
"package main;\n"
|
|
"let g: [3]i32 = [7, 8, 9];\n"
|
|
"fn mk() []i32 = { return g; };\n"
|
|
"export fn main() i32 = {\n"
|
|
" let s: []i32 = mk();\n"
|
|
" return s[1] + s[2];\n"
|
|
"};\n", 17, 0 },
|
|
{ "borrow_i32",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [4]i32 = [1, 2, 3, 4];\n"
|
|
" let s: []i32 = a;\n"
|
|
" s[2] = 55;\n"
|
|
" return a[2];\n"
|
|
"};\n", 55, 0 },
|
|
/* Reject rows: element-type mismatch — both stages refuse. */
|
|
{ "mismatch_let",
|
|
"package main;\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [4]i32 = [1, 2, 3, 4];\n"
|
|
" let s: []u8 = a;\n"
|
|
" return 0;\n"
|
|
"};\n", 0, 1 },
|
|
{ "mismatch_callarg",
|
|
"package main;\n"
|
|
"fn f(s: []u8) i32 = { return 0; };\n"
|
|
"export fn main() i32 = {\n"
|
|
" let a: [4]i32 = [1, 2, 3, 4];\n"
|
|
" return f(a);\n"
|
|
"};\n", 0, 1 },
|
|
{ NULL, NULL, 0, 0 },
|
|
};
|
|
|
|
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 w6c[1100], w6c_ww[1100];
|
|
snprintf(w6c, sizeof w6c, "%s/w6c", bin);
|
|
snprintf(w6c_ww, sizeof w6c_ww, "%s/w6c_ww", bin);
|
|
if (access(w6c_ww, X_OK) != 0) {
|
|
fprintf(stderr, "arraytoslice: w6c_ww missing — cannot run the "
|
|
"cs==ww byte-id gate (the whole point of this test)\n");
|
|
return 1;
|
|
}
|
|
|
|
int n = 0, fail = 0;
|
|
for (int i = 0; rows[i].src; i++, n++) {
|
|
char src[64];
|
|
snprintf(src, sizeof src, "/tmp/wwa2s_%d_%d.ww", getpid(), i);
|
|
FILE *f = fopen(src, "wb");
|
|
if (f == NULL) { fail++; continue; }
|
|
fputs(rows[i].src, f);
|
|
fclose(f);
|
|
|
|
char cs_s[64], ws_s[64];
|
|
snprintf(cs_s, sizeof cs_s, "/tmp/wwa2s_%d_%d_cs.s", getpid(), i);
|
|
snprintf(ws_s, sizeof ws_s, "/tmp/wwa2s_%d_%d_ww.s", getpid(), i);
|
|
char cmd[2048];
|
|
|
|
if (rows[i].reject) {
|
|
/* Element mismatch — both stages must refuse (non-zero). */
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null",
|
|
w6c, cs_s, src);
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "row[%s]: w6c ACCEPTED a "
|
|
"type-mismatch array→slice (must reject)\n",
|
|
rows[i].label);
|
|
fail++;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null",
|
|
w6c_ww, ws_s, src);
|
|
if (runwait(cmd) == 0) {
|
|
fprintf(stderr, "row[%s]: w6c_ww ACCEPTED a "
|
|
"type-mismatch array→slice (must reject)\n",
|
|
rows[i].label);
|
|
fail++;
|
|
}
|
|
unlink(src); unlink(cs_s); unlink(ws_s);
|
|
continue;
|
|
}
|
|
|
|
/* Positive row: cstage build + run for exit code. */
|
|
char tmpdir[64];
|
|
snprintf(tmpdir, sizeof tmpdir, "/tmp/wwa2s_%d_d_%d",
|
|
getpid(), i);
|
|
mkdir(tmpdir, 0755);
|
|
snprintf(cmd, sizeof cmd, "cd %s && %s/ww build %s",
|
|
tmpdir, bin, src);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "row[%s]: cstage build failed\n",
|
|
rows[i].label);
|
|
fail++;
|
|
unlink(src); rmdir(tmpdir);
|
|
continue;
|
|
}
|
|
char outbin[128];
|
|
const char *base = strrchr(src, '/');
|
|
base = base ? base + 1 : src;
|
|
snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base);
|
|
char *dot = strrchr(outbin, '.');
|
|
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
|
|
int got = runwait(outbin);
|
|
if (got != rows[i].want_exit) {
|
|
fprintf(stderr, "row[%s]: cstage exit %d, want %d\n",
|
|
rows[i].label, got, rows[i].want_exit);
|
|
fail++;
|
|
}
|
|
unlink(outbin); rmdir(tmpdir);
|
|
|
|
/* rule-10 byte-id: w6c vs w6c_ww .s. */
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null",
|
|
w6c, cs_s, src);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "row[%s]: w6c failed\n", rows[i].label);
|
|
fail++; unlink(src); continue;
|
|
}
|
|
snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null",
|
|
w6c_ww, ws_s, src);
|
|
if (runwait(cmd) != 0) {
|
|
fprintf(stderr, "row[%s]: w6c_ww failed\n",
|
|
rows[i].label);
|
|
fail++; unlink(src); unlink(cs_s); continue;
|
|
}
|
|
if (slurp_eq(cs_s, ws_s) != 0) {
|
|
fprintf(stderr,
|
|
"row[%s]: cstage/wwstage .s DIFFER (rule-10 "
|
|
"byte-id violation)\n", rows[i].label);
|
|
fail++;
|
|
}
|
|
unlink(src); unlink(cs_s); unlink(ws_s);
|
|
}
|
|
|
|
if (fail) {
|
|
fprintf(stderr, "%d/%d array-to-slice tests failed\n", fail, n);
|
|
return 1;
|
|
}
|
|
printf("arraytoslice: %d/%d ok (cstage run + cs==ww byte-id + reject)\n",
|
|
n, n);
|
|
return 0;
|
|
}
|