Hojun-Cho
594a2bad62
A type prefixed with `!` is flagged as an error variant. When any variant in a tagged union carries the flag, `?` propagation uses those (and only those) as the error subset; the unflagged variant is the success type. The legacy "first variant = success" rule still applies when no `!`-flag is present, so existing code keeps working. - TK_NOT in parsetype → N_TBANG wrapper (lhs = inner type expr). Appended to Nkind tail for wwdump-diff byte stability. - resolve_type N_TBANG: wraps primitives in a fresh Type copy so the iserror bit doesn't taint shared globals like ty_str/ty_i32; flips the bit in place on NAMED (already unique per alias decl). - Type.iserror; type_named and typedecl inherit it from under. - New check.c helpers: tagged_has_errflag, tagged_is_error_variant, tagged_success_type. N_TRYPROP uses them to find the error subset and verify each error variant is propagatable to the enclosing return. - cgen mirrors with cg_tagged_success_tag + cg_variant_is_error. `?` compares AX against the success tag (no longer always 0) and remaps each error variant's tag for the enclosing fn. `!` aborts on any non-success tag. strconv.invalid and strconv.overflow now use `!`-flagged shape (`!i32` and `!void`) — visible signal in the API surface that they are error types, matching Hare. The (i64 | invalid | overflow) return shape and behavior are unchanged for callers; their match arms still bind the same way. Selfhost: lib/ww/parse/parse.ww recognises `!T` and emits N_TBANG. The selfhost typechecker and cgen ignore the flag — none of the selfhost sources use `!`, so byte-identity gates are unaffected. The selfhost mirror catches up when there's a source using it.
167 lines
6.3 KiB
C
167 lines
6.3 KiB
C
/*
|
|
* 300_check — type-checker tests.
|
|
*
|
|
* Each row is (src, expect) where expect is "ok" (no errors) or a
|
|
* substring that must appear in the captured stderr.
|
|
*/
|
|
#include "ww.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
|
|
static int
|
|
runrow(const char *src, const char *expect)
|
|
{
|
|
Arena *a = newarena();
|
|
Lex l;
|
|
Parser p;
|
|
Checker c;
|
|
lexinit(&l, a, "<test>", src, strlen(src));
|
|
parserinit(&p, a, &l);
|
|
Node *file = parsefile(&p);
|
|
|
|
char *errbuf = NULL;
|
|
size_t errlen = 0;
|
|
FILE *prev = errout;
|
|
errout = open_memstream(&errbuf, &errlen);
|
|
|
|
check_init(&c, a);
|
|
check_file(&c, file);
|
|
|
|
fclose(errout);
|
|
errout = prev;
|
|
|
|
int ok = 0;
|
|
if (strcmp(expect, "ok") == 0) {
|
|
ok = (c.errs == 0 && p.errs == 0 && l.errs == 0);
|
|
if (!ok)
|
|
fprintf(stderr, "expected ok but got %d errors:\n%s"
|
|
" src: %s\n", c.errs + p.errs + l.errs, errbuf, src);
|
|
} else {
|
|
ok = (errbuf && strstr(errbuf, expect) != NULL);
|
|
if (!ok)
|
|
fprintf(stderr, "expected substring '%s' in errs:\n%s"
|
|
" src: %s\n", expect, errbuf, src);
|
|
}
|
|
free(errbuf);
|
|
freearena(a);
|
|
return ok;
|
|
}
|
|
|
|
struct row { const char *src, *expect; };
|
|
|
|
static const struct row rows[] = {
|
|
/* OK cases */
|
|
{ "fn main() void = {};", "ok" },
|
|
{ "fn id(x: i32) i32 = { return x; };", "ok" },
|
|
{ "fn add(a: i32, b: i32) i32 = { return a + b; };", "ok" },
|
|
{ "def MAX: i32 = 4096;", "ok" },
|
|
{ "type point = struct { x: i32, y: i32 };", "ok" },
|
|
{ "type point = struct { x: i32, y: i32 };\n"
|
|
"fn move(p: *point, dx: i32) void = { p.x += dx; };", "ok" },
|
|
{ "fn nums() void = { let x: i32 = 1; let y: i64 = 2; };", "ok" },
|
|
{ "fn cond(x: i32) i32 = { if (x > 0) { return 1; }; return 0; };", "ok" },
|
|
{ "fn lo() void = { for (let i: i32 = 0; i < 10; i += 1) { }; };", "ok" },
|
|
{ "fn ptr(p: *i32) i32 = { return *p; };", "ok" },
|
|
{ "fn addr(x: i32) *i32 = { return &x; };", "ok" },
|
|
{ "fn cmp(a: i32, b: i32) bool = { return a == b; };", "ok" },
|
|
{ "fn b() bool = { return true && false || !true; };", "ok" },
|
|
{ "fn cast() void = { let x = (5 + 1): i64; };", "ok" },
|
|
{ "fn slc(s: []u8) []u8 = { return s; };", "ok" },
|
|
{ "fn arr() void = { let a: [16]u8; };", "ok" },
|
|
{ "fn lit() void = { let p = point { x = 1, y = 2 }; };\n"
|
|
"type point = struct { x: i32, y: i32 };", "ok" },
|
|
{ "fn idx(a: []i32) i32 = { return a[0]; };", "ok" },
|
|
{ "fn nilptr(p: *i32) bool = { return p == nil; };", "ok" },
|
|
{ "fn untyped() void = { let x: i64 = 42; };", "ok" },
|
|
{ "fn fld(p: *point) i32 = { return p.x; };\n"
|
|
"type point = struct { x: i32 };", "ok" },
|
|
{ "fn loops() void = { for () { break; }; for () { continue; }; };", "ok" },
|
|
|
|
/* multi-return tuples */
|
|
{ "fn divmod(a: i64, b: i64) (i64, i64) = { return a / b, a % b; };", "ok" },
|
|
{ "fn dm(a: i64, b: i64) (i64, i64) = { return a, b; };\n"
|
|
"fn caller() i64 = { let q, r = dm(10, 3); return q + r; };", "ok" },
|
|
{ "fn dm() (i64, i64) = { return 1, 2; };\n"
|
|
"fn ass() void = { let q: i64 = 0; let r: i64 = 0; q, r = dm(); };", "ok" },
|
|
|
|
/* error cases */
|
|
{ "fn f() void = { return 1; };", "return value in void" },
|
|
{ "fn f() i32 = { return; };", "not assignable" },
|
|
{ "fn f() void = { x = 1; };", "undefined" },
|
|
{ "fn f() void = { let x: nope = 1; };", "unknown type" },
|
|
{ "fn f() void = { let x: bool = 1; };", "not assignable" },
|
|
{ "fn f() i32 = { return \"hi\"; };", "not assignable" },
|
|
{ "fn f() void = { 1 + true; };", "non-numeric" },
|
|
{ "fn f() void = { -true; };", "non-numeric" },
|
|
{ "fn f() void = { *5; };", "deref non-pointer" },
|
|
{ "fn f() void = { let x: i32 = 1; let x: i32 = 2; };",
|
|
"ok" }, /* shadowing in inner scope; same scope flagged */
|
|
{ "fn f() void = { break; };", "break outside loop" },
|
|
{ "fn f() void = { continue; };", "continue outside loop" },
|
|
{ "fn f(x: i32) void = { x[0]; };", "indexing non-indexable" },
|
|
{ "fn f() i32 = { return 1; }; fn g() i32 = { return f(1); };",
|
|
"too many arguments" },
|
|
{ "fn f(a: i32) i32 = { return a; }; fn g() i32 = { return f(); };",
|
|
"not enough arguments" },
|
|
{ "fn f() void = { if (1) { }; };", "if condition" },
|
|
|
|
/* tagged-union normalization & exhaustiveness */
|
|
{ "fn f() (i32 | never) = { return 7; }; "
|
|
"fn g() i32 = { return f(); };", "ok" }, /* (T|never) → T */
|
|
{ "fn f() (i32 | i32) = { return 5; }; "
|
|
"fn g() i32 = { return f(); };", "ok" }, /* dedup → i32 */
|
|
{ "fn f() (i32 | void) = { return; };", "ok" }, /* bare return → void variant */
|
|
{ "fn f(b: bool) (i32 | void) = { if (b) { return 1; }; return; };",
|
|
"ok" },
|
|
{ "fn f() (i32 | str | bool) = { return 1; }; "
|
|
"fn g() void = { let v: (i32 | str | bool) = f(); "
|
|
"match (v) { case let x: i32 => { }; case let x: str => { }; }; };",
|
|
"variant bool not handled" },
|
|
{ "fn f() (i32 | str | bool) = { return 1; }; "
|
|
"fn g() void = { let v: (i32 | str | bool) = f(); "
|
|
"match (v) { case let x: i32 => { }; case => { }; }; };",
|
|
"ok" }, /* default arm absorbs missing variants */
|
|
{ "fn die() never = { for (true) { let _: i32 = 1; }; }; "
|
|
"fn f() i32 = { die(); };", "ok" }, /* never assignable to anything */
|
|
|
|
/* ? error-subset propagation typecheck */
|
|
{ "fn inner() (i32 | str) = { return 1; }; "
|
|
"fn outer() i32 = { let v: i32 = inner()?; return v; };",
|
|
"enclosing function must return a tagged union" },
|
|
{ "fn inner() (i32 | str | bool) = { return 1; }; "
|
|
"fn outer() (i64 | str) = { let v: i32 = inner()?; return v: i64; };",
|
|
"error variant bool not in enclosing return" },
|
|
{ "fn inner() (i32 | str | bool) = { return 1; }; "
|
|
"fn outer() (i64 | bool | str) = { let v: i32 = inner()?; return v: i64; };",
|
|
"ok" }, /* reversed-order error subset is OK */
|
|
|
|
/* `!`-flagged error variants (Hare's explicit error marker) */
|
|
{ "type invalid = !i32; "
|
|
"fn parse() (i64 | invalid) = { return 5: invalid; }; "
|
|
"fn caller() (i64 | invalid) = { let v: i64 = parse()?; return v + 1; };",
|
|
"ok" },
|
|
{ "type invalid = !i32; type overflow = !void; "
|
|
"fn parse() (invalid | i64 | overflow) = { return 0i64; }; "
|
|
"fn caller() i32 = { let v: i64 = parse()?; return v: i32; };",
|
|
"enclosing function must return a tagged union" },
|
|
};
|
|
|
|
int
|
|
main(void)
|
|
{
|
|
int n = sizeof rows / sizeof rows[0];
|
|
int fail = 0;
|
|
for (int i = 0; i < n; i++)
|
|
if (!runrow(rows[i].src, rows[i].expect)) {
|
|
fprintf(stderr, "row %d failed\n", i);
|
|
fail++;
|
|
}
|
|
if (fail) {
|
|
fprintf(stderr, "%d/%d check tests failed\n", fail, n);
|
|
return 1;
|
|
}
|
|
printf("check: %d/%d ok\n", n, n);
|
|
return 0;
|
|
}
|