Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

test: prove ordinary import binding modes

Browse Source
This commit is contained in:
Hojun-Cho
2026-08-14 10:56:54 +09:00
parent 792b6ecbe5
commit 10e02a00ee
20 changed files with 1284 additions and 672 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
lib/ww/syntax/ast_test.ww
View File

@@ -10,90 +10,90 @@ package syntax_test;
import ww.syntax;
fn checknkname(k: nkind, want: str) void = {
assert(!(nkname(k) != want));
fn checknkname(k: syntax.nkind, want: str) void = {
assert(!(syntax.nkname(k) != want));
};
// One row per nkind value — same string the if-ladder returned. The
// final row pins the unknown-kind fallback ("?").
@test fn nkname_cases() void = {
checknkname(nkind.N_NONE, "none");
checknkname(nkind.N_INTLIT, "int");
checknkname(nkind.N_FLOATLIT, "float");
checknkname(nkind.N_STRLIT, "str");
checknkname(nkind.N_RUNELIT, "rune");
checknkname(nkind.N_TRUE, "true");
checknkname(nkind.N_FALSE, "false");
checknkname(nkind.N_NIL, "nil");
checknkname(nkind.N_IDENT, "id");
checknkname(syntax.nkind.N_NONE, "none");
checknkname(syntax.nkind.N_INTLIT, "int");
checknkname(syntax.nkind.N_FLOATLIT, "float");
checknkname(syntax.nkind.N_STRLIT, "str");
checknkname(syntax.nkind.N_RUNELIT, "rune");
checknkname(syntax.nkind.N_TRUE, "true");
checknkname(syntax.nkind.N_FALSE, "false");
checknkname(syntax.nkind.N_NIL, "nil");
checknkname(syntax.nkind.N_IDENT, "id");
checknkname(nkind.N_BIN, "bin");
checknkname(nkind.N_UN, "un");
checknkname(nkind.N_CALL, "call");
checknkname(nkind.N_INDEX, "index");
checknkname(nkind.N_DOT, "dot");
checknkname(nkind.N_CAST, "cast");
checknkname(nkind.N_STRUCTLIT, "structlit");
checknkname(nkind.N_ARRLIT, "arrlit");
checknkname(nkind.N_FIELD, "field");
checknkname(nkind.N_ASSIGN, "assign");
checknkname(nkind.N_ALLOC, "alloc");
checknkname(nkind.N_FREE, "free");
checknkname(nkind.N_RECV, "recv");
checknkname(nkind.N_SLICE, "slice");
checknkname(nkind.N_SPREAD, "spread");
checknkname(syntax.nkind.N_BIN, "bin");
checknkname(syntax.nkind.N_UN, "un");
checknkname(syntax.nkind.N_CALL, "call");
checknkname(syntax.nkind.N_INDEX, "index");
checknkname(syntax.nkind.N_DOT, "dot");
checknkname(syntax.nkind.N_CAST, "cast");
checknkname(syntax.nkind.N_STRUCTLIT, "structlit");
checknkname(syntax.nkind.N_ARRLIT, "arrlit");
checknkname(syntax.nkind.N_FIELD, "field");
checknkname(syntax.nkind.N_ASSIGN, "assign");
checknkname(syntax.nkind.N_ALLOC, "alloc");
checknkname(syntax.nkind.N_FREE, "free");
checknkname(syntax.nkind.N_RECV, "recv");
checknkname(syntax.nkind.N_SLICE, "slice");
checknkname(syntax.nkind.N_SPREAD, "spread");
checknkname(nkind.N_BLOCK, "block");
checknkname(nkind.N_EXPRSTMT, "exprstmt");
checknkname(nkind.N_LET, "let");
checknkname(nkind.N_RETURN, "return");
checknkname(nkind.N_IF, "if");
checknkname(nkind.N_FOR, "for");
checknkname(nkind.N_FORRANGE, "forrange");
checknkname(nkind.N_DEFER, "defer");
checknkname(nkind.N_BREAK, "break");
checknkname(nkind.N_CONTINUE, "continue");
checknkname(nkind.N_SWITCH, "switch");
checknkname(nkind.N_CASE, "case");
checknkname(syntax.nkind.N_BLOCK, "block");
checknkname(syntax.nkind.N_EXPRSTMT, "exprstmt");
checknkname(syntax.nkind.N_LET, "let");
checknkname(syntax.nkind.N_RETURN, "return");
checknkname(syntax.nkind.N_IF, "if");
checknkname(syntax.nkind.N_FOR, "for");
checknkname(syntax.nkind.N_FORRANGE, "forrange");
checknkname(syntax.nkind.N_DEFER, "defer");
checknkname(syntax.nkind.N_BREAK, "break");
checknkname(syntax.nkind.N_CONTINUE, "continue");
checknkname(syntax.nkind.N_SWITCH, "switch");
checknkname(syntax.nkind.N_CASE, "case");
checknkname(nkind.N_FILE, "file");
checknkname(nkind.N_USE, "use");
checknkname(nkind.N_DEF, "def");
checknkname(nkind.N_TYPEDECL, "typedecl");
checknkname(nkind.N_FNDECL, "fn");
checknkname(nkind.N_PARAM, "param");
checknkname(syntax.nkind.N_FILE, "file");
checknkname(syntax.nkind.N_USE, "use");
checknkname(syntax.nkind.N_DEF, "def");
checknkname(syntax.nkind.N_TYPEDECL, "typedecl");
checknkname(syntax.nkind.N_FNDECL, "fn");
checknkname(syntax.nkind.N_PARAM, "param");
checknkname(nkind.N_TNAME, "tname");
checknkname(nkind.N_TPTR, "tptr");
checknkname(nkind.N_TSLICE, "tslice");
checknkname(nkind.N_TARRAY, "tarray");
checknkname(nkind.N_TFN, "tfn");
checknkname(nkind.N_TSTRUCT, "tstruct");
checknkname(nkind.N_TFIELD, "tfield");
checknkname(nkind.N_TCHAN, "tchan");
checknkname(syntax.nkind.N_TNAME, "tname");
checknkname(syntax.nkind.N_TPTR, "tptr");
checknkname(syntax.nkind.N_TSLICE, "tslice");
checknkname(syntax.nkind.N_TARRAY, "tarray");
checknkname(syntax.nkind.N_TFN, "tfn");
checknkname(syntax.nkind.N_TSTRUCT, "tstruct");
checknkname(syntax.nkind.N_TFIELD, "tfield");
checknkname(syntax.nkind.N_TCHAN, "tchan");
checknkname(nkind.N_ATTR, "attr");
checknkname(nkind.N_TTUPLE, "ttuple");
checknkname(nkind.N_TTAGGED, "ttagged");
checknkname(nkind.N_TUPLE, "tuple");
checknkname(nkind.N_MATCH, "match");
checknkname(nkind.N_MCASE, "mcase");
checknkname(nkind.N_TRYPROP, "tryprop");
checknkname(nkind.N_TRYUNW, "tryunw");
checknkname(nkind.N_MLET, "mlet");
checknkname(nkind.N_MASSIGN, "massign");
checknkname(syntax.nkind.N_ATTR, "attr");
checknkname(syntax.nkind.N_TTUPLE, "ttuple");
checknkname(syntax.nkind.N_TTAGGED, "ttagged");
checknkname(syntax.nkind.N_TUPLE, "tuple");
checknkname(syntax.nkind.N_MATCH, "match");
checknkname(syntax.nkind.N_MCASE, "mcase");
checknkname(syntax.nkind.N_TRYPROP, "tryprop");
checknkname(syntax.nkind.N_TRYUNW, "tryunw");
checknkname(syntax.nkind.N_MLET, "mlet");
checknkname(syntax.nkind.N_MASSIGN, "massign");
checknkname(nkind.N_TYPETEST, "typetest");
checknkname(nkind.N_TYPEASSERT, "typeassert");
checknkname(nkind.N_VOIDLIT, "voidlit");
checknkname(nkind.N_TBANG, "tbang");
checknkname(nkind.N_YIELD, "yield");
checknkname(nkind.N_TENUM, "tenum");
checknkname(nkind.N_TENUMMEMBER, "tenummember");
checknkname(nkind.N_TPARAM, "tparam");
checknkname(nkind.N_LAST, "last");
checknkname(syntax.nkind.N_TYPETEST, "typetest");
checknkname(syntax.nkind.N_TYPEASSERT, "typeassert");
checknkname(syntax.nkind.N_VOIDLIT, "voidlit");
checknkname(syntax.nkind.N_TBANG, "tbang");
checknkname(syntax.nkind.N_YIELD, "yield");
checknkname(syntax.nkind.N_TENUM, "tenum");
checknkname(syntax.nkind.N_TENUMMEMBER, "tenummember");
checknkname(syntax.nkind.N_TPARAM, "tparam");
checknkname(syntax.nkind.N_LAST, "last");
// Unknown kind → the post-switch fallback. N_LAST is the highest
// named value (68); 69 is out of band, exercising the "?" tail.
checknkname(69: nkind, "?");
checknkname(69: syntax.nkind, "?");
};

24
lib/ww/syntax/sym_test.ww
View File

@@ -12,34 +12,34 @@ package syntax_test;
import ww.syntax;
@test fn scope_define_lookup() void = {
let s: *scope = newscope(nil);
let s: *syntax.scope = syntax.newscope(nil);
assert(!(s == nil));
let r1: *sym = scopedefine(s, "foo", skind.SK_VAR, nil, nil);
let r1: *syntax.sym = syntax.scopedefine(s, "foo", syntax.skind.SK_VAR, nil, nil);
assert(!(r1 == nil));
let r2: *sym = scopedefine(s, "bar", skind.SK_TYPE, nil, nil);
let r2: *syntax.sym = syntax.scopedefine(s, "bar", syntax.skind.SK_TYPE, nil, nil);
assert(!(r2 == nil));
let l1: *sym = scopelookup(s, "foo");
let l1: *syntax.sym = syntax.scopelookup(s, "foo");
assert(!(l1 == nil));
assert(!(l1.skind != skind.SK_VAR));
let l2: *sym = scopelookup(s, "bar");
assert(!(l1.skind != syntax.skind.SK_VAR));
let l2: *syntax.sym = syntax.scopelookup(s, "bar");
assert(!(l2 == nil));
assert(!(l2.skind != skind.SK_TYPE));
assert(!(l2.skind != syntax.skind.SK_TYPE));
};
@test fn scope_duplicate_reject() void = {
let s: *scope = newscope(nil);
let s: *syntax.scope = syntax.newscope(nil);
assert(!(s == nil));
let r1: *sym = scopedefine(s, "foo", skind.SK_VAR, nil, nil);
let r1: *syntax.sym = syntax.scopedefine(s, "foo", syntax.skind.SK_VAR, nil, nil);
assert(!(r1 == nil));
let r3: *sym = scopedefine(s, "foo", skind.SK_VAR, nil, nil);
let r3: *syntax.sym = syntax.scopedefine(s, "foo", syntax.skind.SK_VAR, nil, nil);
assert(!(r3 != nil));
};
@test fn scope_notfound_nil() void = {
let s: *scope = newscope(nil);
let s: *syntax.scope = syntax.newscope(nil);
assert(!(s == nil));
let l3: *sym = scopelookup(s, "baz");
let l3: *syntax.sym = syntax.scopelookup(s, "baz");
assert(!(l3 != nil));
};

266
lib/ww/syntax/tok_test.ww
View File

@@ -23,120 +23,120 @@ import ww.syntax;
import temp;
fn checktokname(k: tkind, want: str) void = {
assert(!(tokname(k) != want));
fn checktokname(k: syntax.tkind, want: str) void = {
assert(!(syntax.tokname(k) != want));
};
// One row per tkind value — same string the if-ladder returned. The
// final row pins the unknown-kind fallback ("<?>").
@test fn tokname_cases() void = {
checktokname(tkind.TK_NONE, "<none>");
checktokname(tkind.TK_EOF, "EOF");
checktokname(tkind.TK_ERR, "ERR");
checktokname(tkind.TK_IDENT, "IDENT");
checktokname(tkind.TK_INT, "INT");
checktokname(tkind.TK_FLOAT, "FLOAT");
checktokname(tkind.TK_RUNE, "RUNE");
checktokname(tkind.TK_STR, "STR");
checktokname(syntax.tkind.TK_NONE, "<none>");
checktokname(syntax.tkind.TK_EOF, "EOF");
checktokname(syntax.tkind.TK_ERR, "ERR");
checktokname(syntax.tkind.TK_IDENT, "IDENT");
checktokname(syntax.tkind.TK_INT, "INT");
checktokname(syntax.tkind.TK_FLOAT, "FLOAT");
checktokname(syntax.tkind.TK_RUNE, "RUNE");
checktokname(syntax.tkind.TK_STR, "STR");
checktokname(tkind.TK_FN, "fn");
checktokname(tkind.TK_LET, "let");
checktokname(tkind.TK_DEF, "def");
checktokname(tkind.TK_IF, "if");
checktokname(tkind.TK_ELSE, "else");
checktokname(tkind.TK_FOR, "for");
checktokname(tkind.TK_SWITCH, "switch");
checktokname(tkind.TK_CASE, "case");
checktokname(tkind.TK_RETURN, "return");
checktokname(tkind.TK_USE, "import");
checktokname(tkind.TK_TYPE, "type");
checktokname(tkind.TK_STRUCT, "struct");
checktokname(tkind.TK_DEFER, "defer");
checktokname(tkind.TK_BREAK, "break");
checktokname(tkind.TK_CONTINUE, "continue");
checktokname(tkind.TK_EXPORT, "export");
checktokname(tkind.TK_PROC, "proc");
checktokname(tkind.TK_CHAN, "chan");
checktokname(tkind.TK_NIL, "nil");
checktokname(tkind.TK_TRUE, "true");
checktokname(tkind.TK_FALSE, "false");
checktokname(tkind.TK_AS, "as");
checktokname(tkind.TK_IS, "is");
checktokname(tkind.TK_VOID, "void");
checktokname(tkind.TK_YIELD, "yield");
checktokname(tkind.TK_STATIC, "static");
checktokname(tkind.TK_MATCH, "match");
checktokname(tkind.TK_CONST, "const");
checktokname(tkind.TK_UNDER, "_");
checktokname(tkind.TK_ENUM, "enum");
checktokname(tkind.TK_MODULE, "package");
checktokname(syntax.tkind.TK_FN, "fn");
checktokname(syntax.tkind.TK_LET, "let");
checktokname(syntax.tkind.TK_DEF, "def");
checktokname(syntax.tkind.TK_IF, "if");
checktokname(syntax.tkind.TK_ELSE, "else");
checktokname(syntax.tkind.TK_FOR, "for");
checktokname(syntax.tkind.TK_SWITCH, "switch");
checktokname(syntax.tkind.TK_CASE, "case");
checktokname(syntax.tkind.TK_RETURN, "return");
checktokname(syntax.tkind.TK_USE, "import");
checktokname(syntax.tkind.TK_TYPE, "type");
checktokname(syntax.tkind.TK_STRUCT, "struct");
checktokname(syntax.tkind.TK_DEFER, "defer");
checktokname(syntax.tkind.TK_BREAK, "break");
checktokname(syntax.tkind.TK_CONTINUE, "continue");
checktokname(syntax.tkind.TK_EXPORT, "export");
checktokname(syntax.tkind.TK_PROC, "proc");
checktokname(syntax.tkind.TK_CHAN, "chan");
checktokname(syntax.tkind.TK_NIL, "nil");
checktokname(syntax.tkind.TK_TRUE, "true");
checktokname(syntax.tkind.TK_FALSE, "false");
checktokname(syntax.tkind.TK_AS, "as");
checktokname(syntax.tkind.TK_IS, "is");
checktokname(syntax.tkind.TK_VOID, "void");
checktokname(syntax.tkind.TK_YIELD, "yield");
checktokname(syntax.tkind.TK_STATIC, "static");
checktokname(syntax.tkind.TK_MATCH, "match");
checktokname(syntax.tkind.TK_CONST, "const");
checktokname(syntax.tkind.TK_UNDER, "_");
checktokname(syntax.tkind.TK_ENUM, "enum");
checktokname(syntax.tkind.TK_MODULE, "package");
checktokname(tkind.TK_LPAREN, "(");
checktokname(tkind.TK_RPAREN, ")");
checktokname(tkind.TK_LBRACE, "{");
checktokname(tkind.TK_RBRACE, "}");
checktokname(tkind.TK_LBRACK, "[");
checktokname(tkind.TK_RBRACK, "]");
checktokname(tkind.TK_COMMA, ",");
checktokname(tkind.TK_SEMI, ";");
checktokname(tkind.TK_COLON, ":");
checktokname(tkind.TK_DOT, ".");
checktokname(tkind.TK_ELLIPSIS, "...");
checktokname(tkind.TK_DOTDOT, "..");
checktokname(tkind.TK_AT, "@");
checktokname(tkind.TK_QUESTION, "?");
checktokname(syntax.tkind.TK_LPAREN, "(");
checktokname(syntax.tkind.TK_RPAREN, ")");
checktokname(syntax.tkind.TK_LBRACE, "{");
checktokname(syntax.tkind.TK_RBRACE, "}");
checktokname(syntax.tkind.TK_LBRACK, "[");
checktokname(syntax.tkind.TK_RBRACK, "]");
checktokname(syntax.tkind.TK_COMMA, ",");
checktokname(syntax.tkind.TK_SEMI, ";");
checktokname(syntax.tkind.TK_COLON, ":");
checktokname(syntax.tkind.TK_DOT, ".");
checktokname(syntax.tkind.TK_ELLIPSIS, "...");
checktokname(syntax.tkind.TK_DOTDOT, "..");
checktokname(syntax.tkind.TK_AT, "@");
checktokname(syntax.tkind.TK_QUESTION, "?");
checktokname(tkind.TK_ASSIGN, "=");
checktokname(tkind.TK_PLUSEQ, "+=");
checktokname(tkind.TK_MINUSEQ, "-=");
checktokname(tkind.TK_STAREQ, "*=");
checktokname(tkind.TK_SLASHEQ, "/=");
checktokname(tkind.TK_PERCENTEQ, "%=");
checktokname(tkind.TK_AMPEQ, "&=");
checktokname(tkind.TK_PIPEEQ, "|=");
checktokname(tkind.TK_CARETEQ, "^=");
checktokname(tkind.TK_LSHIFTEQ, "<<=");
checktokname(tkind.TK_RSHIFTEQ, ">>=");
checktokname(syntax.tkind.TK_ASSIGN, "=");
checktokname(syntax.tkind.TK_PLUSEQ, "+=");
checktokname(syntax.tkind.TK_MINUSEQ, "-=");
checktokname(syntax.tkind.TK_STAREQ, "*=");
checktokname(syntax.tkind.TK_SLASHEQ, "/=");
checktokname(syntax.tkind.TK_PERCENTEQ, "%=");
checktokname(syntax.tkind.TK_AMPEQ, "&=");
checktokname(syntax.tkind.TK_PIPEEQ, "|=");
checktokname(syntax.tkind.TK_CARETEQ, "^=");
checktokname(syntax.tkind.TK_LSHIFTEQ, "<<=");
checktokname(syntax.tkind.TK_RSHIFTEQ, ">>=");
checktokname(tkind.TK_PLUS, "+");
checktokname(tkind.TK_MINUS, "-");
checktokname(tkind.TK_STAR, "*");
checktokname(tkind.TK_SLASH, "/");
checktokname(tkind.TK_PERCENT, "%");
checktokname(tkind.TK_AMP, "&");
checktokname(tkind.TK_PIPE, "|");
checktokname(tkind.TK_CARET, "^");
checktokname(tkind.TK_TILDE, "~");
checktokname(tkind.TK_LSHIFT, "<<");
checktokname(tkind.TK_RSHIFT, ">>");
checktokname(syntax.tkind.TK_PLUS, "+");
checktokname(syntax.tkind.TK_MINUS, "-");
checktokname(syntax.tkind.TK_STAR, "*");
checktokname(syntax.tkind.TK_SLASH, "/");
checktokname(syntax.tkind.TK_PERCENT, "%");
checktokname(syntax.tkind.TK_AMP, "&");
checktokname(syntax.tkind.TK_PIPE, "|");
checktokname(syntax.tkind.TK_CARET, "^");
checktokname(syntax.tkind.TK_TILDE, "~");
checktokname(syntax.tkind.TK_LSHIFT, "<<");
checktokname(syntax.tkind.TK_RSHIFT, ">>");
checktokname(tkind.TK_EQ, "==");
checktokname(tkind.TK_NEQ, "!=");
checktokname(tkind.TK_LT, "<");
checktokname(tkind.TK_LE, "<=");
checktokname(tkind.TK_GT, ">");
checktokname(tkind.TK_GE, ">=");
checktokname(syntax.tkind.TK_EQ, "==");
checktokname(syntax.tkind.TK_NEQ, "!=");
checktokname(syntax.tkind.TK_LT, "<");
checktokname(syntax.tkind.TK_LE, "<=");
checktokname(syntax.tkind.TK_GT, ">");
checktokname(syntax.tkind.TK_GE, ">=");
checktokname(tkind.TK_AND, "&&");
checktokname(tkind.TK_OR, "||");
checktokname(tkind.TK_NOT, "!");
checktokname(syntax.tkind.TK_AND, "&&");
checktokname(syntax.tkind.TK_OR, "||");
checktokname(syntax.tkind.TK_NOT, "!");
checktokname(tkind.TK_LARROW, "<-");
checktokname(tkind.TK_ARROW, "->");
checktokname(tkind.TK_FATARROW, "=>");
checktokname(syntax.tkind.TK_LARROW, "<-");
checktokname(syntax.tkind.TK_ARROW, "->");
checktokname(syntax.tkind.TK_FATARROW, "=>");
checktokname(tkind.TK_MODRESET, "//ww:module-reset");
checktokname(tkind.TK_MODPATH, "//ww:module");
checktokname(tkind.TK_LAST, "<last>");
checktokname(syntax.tkind.TK_MODRESET, "//ww:module-reset");
checktokname(syntax.tkind.TK_MODPATH, "//ww:module");
checktokname(syntax.tkind.TK_LAST, "<last>");
// Unknown kind → the post-switch fallback. TK_LAST is the highest
// named value (89, after TK_MODPATH=88 landed); 90 is out of band,
// exercising the "<?>" tail.
checktokname(90: tkind, "<?>");
checktokname(90: syntax.tkind, "<?>");
};
fn checkkw(s: str, want: tkind) void = {
assert(!(kwlookup(s.ptr, s.len) != want));
fn checkkw(s: str, want: syntax.tkind) void = {
assert(!(syntax.kwlookup(s.ptr, s.len) != want));
};
// Table-driven (parallel-array idiom; tuple rows blocked by #111). The
@@ -153,15 +153,15 @@ fn checkkw(s: str, want: tkind) void = {
"import", "let", "match", "nil", "package", "proc", "return",
"static", "struct", "switch", "true", "type", "void", "yield",
];
let kwexp: [30]tkind = [
tkind.TK_AS, tkind.TK_BREAK, tkind.TK_CASE, tkind.TK_CHAN,
tkind.TK_CONST, tkind.TK_CONTINUE, tkind.TK_DEF, tkind.TK_DEFER,
tkind.TK_ELSE, tkind.TK_ENUM, tkind.TK_EXPORT, tkind.TK_FALSE,
tkind.TK_FN, tkind.TK_FOR, tkind.TK_IF, tkind.TK_IS,
tkind.TK_USE, tkind.TK_LET, tkind.TK_MATCH, tkind.TK_NIL,
tkind.TK_MODULE, tkind.TK_PROC, tkind.TK_RETURN, tkind.TK_STATIC,
tkind.TK_STRUCT, tkind.TK_SWITCH, tkind.TK_TRUE, tkind.TK_TYPE,
tkind.TK_VOID, tkind.TK_YIELD,
let kwexp: [30]syntax.tkind = [
syntax.tkind.TK_AS, syntax.tkind.TK_BREAK, syntax.tkind.TK_CASE, syntax.tkind.TK_CHAN,
syntax.tkind.TK_CONST, syntax.tkind.TK_CONTINUE, syntax.tkind.TK_DEF, syntax.tkind.TK_DEFER,
syntax.tkind.TK_ELSE, syntax.tkind.TK_ENUM, syntax.tkind.TK_EXPORT, syntax.tkind.TK_FALSE,
syntax.tkind.TK_FN, syntax.tkind.TK_FOR, syntax.tkind.TK_IF, syntax.tkind.TK_IS,
syntax.tkind.TK_USE, syntax.tkind.TK_LET, syntax.tkind.TK_MATCH, syntax.tkind.TK_NIL,
syntax.tkind.TK_MODULE, syntax.tkind.TK_PROC, syntax.tkind.TK_RETURN, syntax.tkind.TK_STATIC,
syntax.tkind.TK_STRUCT, syntax.tkind.TK_SWITCH, syntax.tkind.TK_TRUE, syntax.tkind.TK_TYPE,
syntax.tkind.TK_VOID, syntax.tkind.TK_YIELD,
];
let i: i32 = 0;
for (i < len(kwin)) {
@@ -197,7 +197,7 @@ fn checkkw(s: str, want: tkind) void = {
];
let j: i32 = 0;
for (j < len(nk)) {
checkkw(nk[j], tkind.TK_NONE);
checkkw(nk[j], syntax.tkind.TK_NONE);
j += 1;
};
};
@@ -205,9 +205,9 @@ fn checkkw(s: str, want: tkind) void = {
// The fd is RDWR; we lseek to 0
// before each write so earlier (possibly longer) content past want.len
// is irrelevant — only want.len bytes from offset 0 are compared.
fn checkprint(fd: i32, t: *tok, want: str) void = {
fn checkprint(fd: i32, t: *syntax.tok, want: str) void = {
assert(!(os.lseek(fd, 0i64, os.whence.SET) != 0i64));
tokprint(fd, t);
syntax.tokprint(fd, t);
assert(!(os.lseek(fd, 0i64, os.whence.SET) != 0i64));
let rbuf: [256]u8;
let z: i32 = 0;
@@ -233,33 +233,33 @@ fn checkprint(fd: i32, t: *tok, want: str) void = {
};
assert(!(fd < 0));
let t: tok;
let t: syntax.tok;
t.file = "t";
t.line = 1;
t.col = 1;
t.kind = tkind.TK_STR;
t.kind = syntax.tkind.TK_STR;
t.text = "\\\"\n\t\r\x01\x7fA";
checkprint(fd, &t, "t:1:1 STR \"\\\\\\\"\\n\\t\\r\\x01\\x7fA\"\n");
t.kind = tkind.TK_IDENT;
t.kind = syntax.tkind.TK_IDENT;
t.text = "name";
checkprint(fd, &t, "t:1:1 IDENT \"name\"\n");
t.kind = tkind.TK_ERR;
t.kind = syntax.tkind.TK_ERR;
t.text = "oops";
checkprint(fd, &t, "t:1:1 ERR \"oops\"\n");
t.kind = tkind.TK_INT;
t.kind = syntax.tkind.TK_INT;
t.uval = 42u64;
checkprint(fd, &t, "t:1:1 INT 42\n");
t.kind = tkind.TK_RUNE;
t.kind = syntax.tkind.TK_RUNE;
t.uval = 65u64;
checkprint(fd, &t, "t:1:1 RUNE 65\n");
// Default arm: a kind outside the switch appends no value.
t.kind = tkind.TK_NONE;
t.kind = syntax.tkind.TK_NONE;
checkprint(fd, &t, "t:1:1 <none>\n");
assert(!(os.close(fd) != 0));
@@ -267,11 +267,11 @@ fn checkprint(fd: i32, t: *tok, want: str) void = {
};
fn checkfloat(src: str, want: u64) void = {
let l: lex;
lexinit(&l, "t", src.ptr, src.len: u64);
let t: tok;
lexnext(&l, &t);
assert(!(t.kind != tkind.TK_FLOAT));
let l: syntax.lex;
syntax.lexinit(&l, "t", src.ptr, src.len: u64);
let t: syntax.tok;
syntax.lexnext(&l, &t);
assert(!(t.kind != syntax.tkind.TK_FLOAT));
assert(!(t.uval != want));
};
@@ -312,29 +312,29 @@ fn checkfloat(src: str, want: u64) void = {
@test fn intfinalband() void = {
let src: str = "18446744073709551616";
let l: lex;
lexinit(&l, "t", src.ptr, src.len: u64);
let t: tok;
lexnext(&l, &t);
assert(!(t.kind != tkind.TK_ERR));
let l: syntax.lex;
syntax.lexinit(&l, "t", src.ptr, src.len: u64);
let t: syntax.tok;
syntax.lexnext(&l, &t);
assert(!(t.kind != syntax.tkind.TK_ERR));
assert(!(l.errs != 1));
};
@test fn suffixrewindcols() void = {
let src: str = "1foo bar";
let l: lex;
lexinit(&l, "t", src.ptr, src.len: u64);
let t: tok;
lexnext(&l, &t);
assert(!(t.kind != tkind.TK_INT));
let l: syntax.lex;
syntax.lexinit(&l, "t", src.ptr, src.len: u64);
let t: syntax.tok;
syntax.lexnext(&l, &t);
assert(!(t.kind != syntax.tkind.TK_INT));
assert(!(t.col != 1));
assert(!(t.uval != 1u64));
lexnext(&l, &t);
assert(!(t.kind != tkind.TK_IDENT));
syntax.lexnext(&l, &t);
assert(!(t.kind != syntax.tkind.TK_IDENT));
assert(!(t.col != 2));
assert(!(t.text != "foo"));
lexnext(&l, &t);
assert(!(t.kind != tkind.TK_IDENT));
syntax.lexnext(&l, &t);
assert(!(t.kind != syntax.tkind.TK_IDENT));
assert(!(t.col != 6));
assert(!(t.text != "bar"));
};