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

lib: canonicalize syntax tests to package syntax_test

Browse Source
This commit is contained in:
Hojun-Cho
2026-08-08 13:52:09 +09:00
parent dc93bcee76
commit d19845abd7
3 changed files with 166 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

@@ -9,7 +9,7 @@
// survive, as in-language rows. `package main` + bare `import syntax`
// mirrors toktest/asttest.
package main;
package syntax_test;
import syntax;

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

@@ -19,123 +19,123 @@
// `package main` + bare `import tok/lex` mirrors wwdump (the only other
// external lex consumer).
package main;
package syntax_test;
import os;
import syntax;
import temp;
fn checkname(k: tkind, want: str) void = {
fn checktokname(k: tkind, want: str) void = {
assert(!(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 = {
checkname(tkind.TK_NONE, "<none>");
checkname(tkind.TK_EOF, "EOF");
checkname(tkind.TK_ERR, "ERR");
checkname(tkind.TK_IDENT, "IDENT");
checkname(tkind.TK_INT, "INT");
checkname(tkind.TK_FLOAT, "FLOAT");
checkname(tkind.TK_RUNE, "RUNE");
checkname(tkind.TK_STR, "STR");
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");
checkname(tkind.TK_FN, "fn");
checkname(tkind.TK_LET, "let");
checkname(tkind.TK_DEF, "def");
checkname(tkind.TK_IF, "if");
checkname(tkind.TK_ELSE, "else");
checkname(tkind.TK_FOR, "for");
checkname(tkind.TK_SWITCH, "switch");
checkname(tkind.TK_CASE, "case");
checkname(tkind.TK_RETURN, "return");
checkname(tkind.TK_USE, "import");
checkname(tkind.TK_TYPE, "type");
checkname(tkind.TK_STRUCT, "struct");
checkname(tkind.TK_DEFER, "defer");
checkname(tkind.TK_BREAK, "break");
checkname(tkind.TK_CONTINUE, "continue");
checkname(tkind.TK_EXPORT, "export");
checkname(tkind.TK_PROC, "proc");
checkname(tkind.TK_CHAN, "chan");
checkname(tkind.TK_NIL, "nil");
checkname(tkind.TK_TRUE, "true");
checkname(tkind.TK_FALSE, "false");
checkname(tkind.TK_AS, "as");
checkname(tkind.TK_IS, "is");
checkname(tkind.TK_VOID, "void");
checkname(tkind.TK_YIELD, "yield");
checkname(tkind.TK_STATIC, "static");
checkname(tkind.TK_MATCH, "match");
checkname(tkind.TK_CONST, "const");
checkname(tkind.TK_UNDER, "_");
checkname(tkind.TK_ENUM, "enum");
checkname(tkind.TK_MODULE, "package");
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");
checkname(tkind.TK_LPAREN, "(");
checkname(tkind.TK_RPAREN, ")");
checkname(tkind.TK_LBRACE, "{");
checkname(tkind.TK_RBRACE, "}");
checkname(tkind.TK_LBRACK, "[");
checkname(tkind.TK_RBRACK, "]");
checkname(tkind.TK_COMMA, ",");
checkname(tkind.TK_SEMI, ";");
checkname(tkind.TK_COLON, ":");
checkname(tkind.TK_DOT, ".");
checkname(tkind.TK_ELLIPSIS, "...");
checkname(tkind.TK_DOTDOT, "..");
checkname(tkind.TK_AT, "@");
checkname(tkind.TK_QUESTION, "?");
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, "?");
checkname(tkind.TK_ASSIGN, "=");
checkname(tkind.TK_PLUSEQ, "+=");
checkname(tkind.TK_MINUSEQ, "-=");
checkname(tkind.TK_STAREQ, "*=");
checkname(tkind.TK_SLASHEQ, "/=");
checkname(tkind.TK_PERCENTEQ, "%=");
checkname(tkind.TK_AMPEQ, "&=");
checkname(tkind.TK_PIPEEQ, "|=");
checkname(tkind.TK_CARETEQ, "^=");
checkname(tkind.TK_LSHIFTEQ, "<<=");
checkname(tkind.TK_RSHIFTEQ, ">>=");
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, ">>=");
checkname(tkind.TK_PLUS, "+");
checkname(tkind.TK_MINUS, "-");
checkname(tkind.TK_STAR, "*");
checkname(tkind.TK_SLASH, "/");
checkname(tkind.TK_PERCENT, "%");
checkname(tkind.TK_AMP, "&");
checkname(tkind.TK_PIPE, "|");
checkname(tkind.TK_CARET, "^");
checkname(tkind.TK_TILDE, "~");
checkname(tkind.TK_LSHIFT, "<<");
checkname(tkind.TK_RSHIFT, ">>");
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, ">>");
checkname(tkind.TK_EQ, "==");
checkname(tkind.TK_NEQ, "!=");
checkname(tkind.TK_LT, "<");
checkname(tkind.TK_LE, "<=");
checkname(tkind.TK_GT, ">");
checkname(tkind.TK_GE, ">=");
checktokname(tkind.TK_EQ, "==");
checktokname(tkind.TK_NEQ, "!=");
checktokname(tkind.TK_LT, "<");
checktokname(tkind.TK_LE, "<=");
checktokname(tkind.TK_GT, ">");
checktokname(tkind.TK_GE, ">=");
checkname(tkind.TK_AND, "&&");
checkname(tkind.TK_OR, "||");
checkname(tkind.TK_NOT, "!");
checktokname(tkind.TK_AND, "&&");
checktokname(tkind.TK_OR, "||");
checktokname(tkind.TK_NOT, "!");
checkname(tkind.TK_LARROW, "<-");
checkname(tkind.TK_ARROW, "->");
checkname(tkind.TK_FATARROW, "=>");
checktokname(tkind.TK_LARROW, "<-");
checktokname(tkind.TK_ARROW, "->");
checktokname(tkind.TK_FATARROW, "=>");
checkname(tkind.TK_MODRESET, "//ww:module-reset");
checkname(tkind.TK_MODPATH, "//ww:module");
checkname(tkind.TK_LAST, "<last>");
checktokname(tkind.TK_MODRESET, "//ww:module-reset");
checktokname(tkind.TK_MODPATH, "//ww:module");
checktokname(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.
checkname(90: tkind, "<?>");
checktokname(90: tkind, "<?>");
};
fn checkkw(s: str, want: tkind) void = {