202 lines
8.2 KiB
C
202 lines
8.2 KiB
C
#include "ww.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include "wwtestpkg.h"
|
|
|
|
static int
|
|
runrow(const char *src, const char *expect)
|
|
{
|
|
Arena *a = newarena();
|
|
Lex l;
|
|
Parser p;
|
|
Checker c;
|
|
char *ws = wwtest_wrap(src);
|
|
lexinit(&l, a, "<test>", ws, strlen(ws));
|
|
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);
|
|
free(ws);
|
|
freearena(a);
|
|
return ok;
|
|
}
|
|
|
|
struct row { const char *src, *expect; };
|
|
|
|
static const struct row rows[] = {
|
|
{ "fn main() void = {};", "ok" },
|
|
{ "fn init() void = {}; fn init() void = {};", "ok" },
|
|
{ "fn init(x: i32) void = {};", "func init must have no arguments and no return values" },
|
|
{ "fn init() i32 = { return 1; };", "func init must have no arguments and no return values" },
|
|
{ "fn init() void;", "func init must have a body" },
|
|
{ "export fn init() void = {};", "func init cannot be exported" },
|
|
{ "fn init() void = {}; fn f() void = { init(); };", "undefined: init" },
|
|
{ "fn make() i32 = { return 7; }; let state: i32 = make();", "ok" },
|
|
{ "fn left() i32 = { return right; }; let first: i32 = left(); let right: i32 = 3;", "ok" },
|
|
{ "fn readb() i32 = { return b; }; let a: i32 = readb(); let b: i32 = a;", "initialization cycle for a" },
|
|
{ "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" },
|
|
|
|
{ "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" },
|
|
|
|
{ "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; };",
|
|
"redeclared" }, /* same-scope let-redecl rejected (#32). */
|
|
{ "fn f() void = { let x: i32 = 1; { let x: i32 = 2; }; };",
|
|
"ok" }, /* nested-block shadow stays legal. */
|
|
{ "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" },
|
|
|
|
{ "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 */
|
|
|
|
{ "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" },
|
|
|
|
/* nullable pointer folding accepts `(*T | void)` */
|
|
{ "fn lookup(p: *i32) (*i32 | void) = { return p; };", "ok" },
|
|
{ "fn lookup() (*i32 | void) = { return; };", "ok" }, /* bare return → null */
|
|
|
|
{ "fn pick() (i32 | str) = { return 1; }; "
|
|
"fn caller() void = { let v: (i32 | str) = pick(); "
|
|
"match (v) { case let n: i32 => { }; case let s: str => { }; "
|
|
"case let f: f64 => { }; }; };",
|
|
"case: f64 is not a variant" },
|
|
{ "fn pick() (i32 | str | bool) = { return 1; }; "
|
|
"fn caller() i32 = { let v: (i32 | str | bool) = pick(); "
|
|
"match (v) { case let n: i32 => return n; "
|
|
"case str | f64 => return 9; case let b: bool => return 1; }; "
|
|
"return 0; };",
|
|
"case: f64 is not a variant" },
|
|
|
|
{ "type color = enum { RED, GREEN, BLUE };\n"
|
|
"fn f() i32 = { return color.GREEN as i32; };", "ok" },
|
|
{ "type mode = enum u8 { R = 1, W = 2, RW = R | W };\n"
|
|
"fn f() i32 = { let m: mode = mode.RW; return m as i32; };", "ok" },
|
|
{ "type mode = enum u8 { R = 1, W = 2 };\n"
|
|
"fn f() i32 = { return (mode.R | mode.W) as i32; };", "ok" },
|
|
{ "type c = enum { A, B };\n"
|
|
"fn f() i32 = { return c.NOPE as i32; };",
|
|
"no enum member 'NOPE'" },
|
|
{ "type c = enum { A, A };\n"
|
|
"fn f() i32 = { return c.A as i32; };",
|
|
"duplicate enum member" },
|
|
{ "type c = enum bool { A };\n"
|
|
"fn f() i32 = { return c.A as i32; };",
|
|
"enum storage type must be integer" },
|
|
};
|
|
|
|
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;
|
|
}
|