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 // `package main` + bare `import ast` mirrors wwdump (the external
// astprint consumer). // astprint consumer).
package main; package syntax_test;
import syntax; import syntax;
fn checkname(k: nkind, want: str) void = { fn checknkname(k: nkind, want: str) void = {
assert(!(nkname(k) != want)); assert(!(nkname(k) != want));
}; };
// One row per nkind value — same string the if-ladder returned. The // One row per nkind value — same string the if-ladder returned. The
// final row pins the unknown-kind fallback ("?"). // final row pins the unknown-kind fallback ("?").
@test fn nkname_cases() void = { @test fn nkname_cases() void = {
checkname(nkind.N_NONE, "none"); checknkname(nkind.N_NONE, "none");
checkname(nkind.N_INTLIT, "int"); checknkname(nkind.N_INTLIT, "int");
checkname(nkind.N_FLOATLIT, "float"); checknkname(nkind.N_FLOATLIT, "float");
checkname(nkind.N_STRLIT, "str"); checknkname(nkind.N_STRLIT, "str");
checkname(nkind.N_RUNELIT, "rune"); checknkname(nkind.N_RUNELIT, "rune");
checkname(nkind.N_TRUE, "true"); checknkname(nkind.N_TRUE, "true");
checkname(nkind.N_FALSE, "false"); checknkname(nkind.N_FALSE, "false");
checkname(nkind.N_NIL, "nil"); checknkname(nkind.N_NIL, "nil");
checkname(nkind.N_IDENT, "id"); checknkname(nkind.N_IDENT, "id");
checkname(nkind.N_BIN, "bin"); checknkname(nkind.N_BIN, "bin");
checkname(nkind.N_UN, "un"); checknkname(nkind.N_UN, "un");
checkname(nkind.N_CALL, "call"); checknkname(nkind.N_CALL, "call");
checkname(nkind.N_INDEX, "index"); checknkname(nkind.N_INDEX, "index");
checkname(nkind.N_DOT, "dot"); checknkname(nkind.N_DOT, "dot");
checkname(nkind.N_CAST, "cast"); checknkname(nkind.N_CAST, "cast");
checkname(nkind.N_STRUCTLIT, "structlit"); checknkname(nkind.N_STRUCTLIT, "structlit");
checkname(nkind.N_ARRLIT, "arrlit"); checknkname(nkind.N_ARRLIT, "arrlit");
checkname(nkind.N_FIELD, "field"); checknkname(nkind.N_FIELD, "field");
checkname(nkind.N_ASSIGN, "assign"); checknkname(nkind.N_ASSIGN, "assign");
checkname(nkind.N_ALLOC, "alloc"); checknkname(nkind.N_ALLOC, "alloc");
checkname(nkind.N_FREE, "free"); checknkname(nkind.N_FREE, "free");
checkname(nkind.N_RECV, "recv"); checknkname(nkind.N_RECV, "recv");
checkname(nkind.N_SLICE, "slice"); checknkname(nkind.N_SLICE, "slice");
checkname(nkind.N_SPREAD, "spread"); checknkname(nkind.N_SPREAD, "spread");
checkname(nkind.N_BLOCK, "block"); checknkname(nkind.N_BLOCK, "block");
checkname(nkind.N_EXPRSTMT, "exprstmt"); checknkname(nkind.N_EXPRSTMT, "exprstmt");
checkname(nkind.N_LET, "let"); checknkname(nkind.N_LET, "let");
checkname(nkind.N_RETURN, "return"); checknkname(nkind.N_RETURN, "return");
checkname(nkind.N_IF, "if"); checknkname(nkind.N_IF, "if");
checkname(nkind.N_FOR, "for"); checknkname(nkind.N_FOR, "for");
checkname(nkind.N_FORRANGE, "forrange"); checknkname(nkind.N_FORRANGE, "forrange");
checkname(nkind.N_DEFER, "defer"); checknkname(nkind.N_DEFER, "defer");
checkname(nkind.N_BREAK, "break"); checknkname(nkind.N_BREAK, "break");
checkname(nkind.N_CONTINUE, "continue"); checknkname(nkind.N_CONTINUE, "continue");
checkname(nkind.N_SWITCH, "switch"); checknkname(nkind.N_SWITCH, "switch");
checkname(nkind.N_CASE, "case"); checknkname(nkind.N_CASE, "case");
checkname(nkind.N_FILE, "file"); checknkname(nkind.N_FILE, "file");
checkname(nkind.N_USE, "use"); checknkname(nkind.N_USE, "use");
checkname(nkind.N_DEF, "def"); checknkname(nkind.N_DEF, "def");
checkname(nkind.N_TYPEDECL, "typedecl"); checknkname(nkind.N_TYPEDECL, "typedecl");
checkname(nkind.N_FNDECL, "fn"); checknkname(nkind.N_FNDECL, "fn");
checkname(nkind.N_PARAM, "param"); checknkname(nkind.N_PARAM, "param");
checkname(nkind.N_TNAME, "tname"); checknkname(nkind.N_TNAME, "tname");
checkname(nkind.N_TPTR, "tptr"); checknkname(nkind.N_TPTR, "tptr");
checkname(nkind.N_TSLICE, "tslice"); checknkname(nkind.N_TSLICE, "tslice");
checkname(nkind.N_TARRAY, "tarray"); checknkname(nkind.N_TARRAY, "tarray");
checkname(nkind.N_TFN, "tfn"); checknkname(nkind.N_TFN, "tfn");
checkname(nkind.N_TSTRUCT, "tstruct"); checknkname(nkind.N_TSTRUCT, "tstruct");
checkname(nkind.N_TFIELD, "tfield"); checknkname(nkind.N_TFIELD, "tfield");
checkname(nkind.N_TCHAN, "tchan"); checknkname(nkind.N_TCHAN, "tchan");
checkname(nkind.N_ATTR, "attr"); checknkname(nkind.N_ATTR, "attr");
checkname(nkind.N_TTUPLE, "ttuple"); checknkname(nkind.N_TTUPLE, "ttuple");
checkname(nkind.N_TTAGGED, "ttagged"); checknkname(nkind.N_TTAGGED, "ttagged");
checkname(nkind.N_TUPLE, "tuple"); checknkname(nkind.N_TUPLE, "tuple");
checkname(nkind.N_MATCH, "match"); checknkname(nkind.N_MATCH, "match");
checkname(nkind.N_MCASE, "mcase"); checknkname(nkind.N_MCASE, "mcase");
checkname(nkind.N_TRYPROP, "tryprop"); checknkname(nkind.N_TRYPROP, "tryprop");
checkname(nkind.N_TRYUNW, "tryunw"); checknkname(nkind.N_TRYUNW, "tryunw");
checkname(nkind.N_MLET, "mlet"); checknkname(nkind.N_MLET, "mlet");
checkname(nkind.N_MASSIGN, "massign"); checknkname(nkind.N_MASSIGN, "massign");
checkname(nkind.N_TYPETEST, "typetest"); checknkname(nkind.N_TYPETEST, "typetest");
checkname(nkind.N_TYPEASSERT, "typeassert"); checknkname(nkind.N_TYPEASSERT, "typeassert");
checkname(nkind.N_VOIDLIT, "voidlit"); checknkname(nkind.N_VOIDLIT, "voidlit");
checkname(nkind.N_TBANG, "tbang"); checknkname(nkind.N_TBANG, "tbang");
checkname(nkind.N_YIELD, "yield"); checknkname(nkind.N_YIELD, "yield");
checkname(nkind.N_TENUM, "tenum"); checknkname(nkind.N_TENUM, "tenum");
checkname(nkind.N_TENUMMEMBER, "tenummember"); checknkname(nkind.N_TENUMMEMBER, "tenummember");
checkname(nkind.N_TPARAM, "tparam"); checknkname(nkind.N_TPARAM, "tparam");
checkname(nkind.N_LAST, "last"); checknkname(nkind.N_LAST, "last");
// Unknown kind → the post-switch fallback. N_LAST is the highest // Unknown kind → the post-switch fallback. N_LAST is the highest
// named value (68); 69 is out of band, exercising the "?" tail. // 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` // survive, as in-language rows. `package main` + bare `import syntax`
// mirrors toktest/asttest. // mirrors toktest/asttest.
package main; package syntax_test;
import syntax; 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 // `package main` + bare `import tok/lex` mirrors wwdump (the only other
// external lex consumer). // external lex consumer).
package main; package syntax_test;
import os; import os;
import syntax; import syntax;
import temp; import temp;
fn checkname(k: tkind, want: str) void = { fn checktokname(k: tkind, want: str) void = {
assert(!(tokname(k) != want)); assert(!(tokname(k) != want));
}; };
// One row per tkind value — same string the if-ladder returned. The // One row per tkind value — same string the if-ladder returned. The
// final row pins the unknown-kind fallback ("<?>"). // final row pins the unknown-kind fallback ("<?>").
@test fn tokname_cases() void = { @test fn tokname_cases() void = {
checkname(tkind.TK_NONE, "<none>"); checktokname(tkind.TK_NONE, "<none>");
checkname(tkind.TK_EOF, "EOF"); checktokname(tkind.TK_EOF, "EOF");
checkname(tkind.TK_ERR, "ERR"); checktokname(tkind.TK_ERR, "ERR");
checkname(tkind.TK_IDENT, "IDENT"); checktokname(tkind.TK_IDENT, "IDENT");
checkname(tkind.TK_INT, "INT"); checktokname(tkind.TK_INT, "INT");
checkname(tkind.TK_FLOAT, "FLOAT"); checktokname(tkind.TK_FLOAT, "FLOAT");
checkname(tkind.TK_RUNE, "RUNE"); checktokname(tkind.TK_RUNE, "RUNE");
checkname(tkind.TK_STR, "STR"); checktokname(tkind.TK_STR, "STR");
checkname(tkind.TK_FN, "fn"); checktokname(tkind.TK_FN, "fn");
checkname(tkind.TK_LET, "let"); checktokname(tkind.TK_LET, "let");
checkname(tkind.TK_DEF, "def"); checktokname(tkind.TK_DEF, "def");
checkname(tkind.TK_IF, "if"); checktokname(tkind.TK_IF, "if");
checkname(tkind.TK_ELSE, "else"); checktokname(tkind.TK_ELSE, "else");
checkname(tkind.TK_FOR, "for"); checktokname(tkind.TK_FOR, "for");
checkname(tkind.TK_SWITCH, "switch"); checktokname(tkind.TK_SWITCH, "switch");
checkname(tkind.TK_CASE, "case"); checktokname(tkind.TK_CASE, "case");
checkname(tkind.TK_RETURN, "return"); checktokname(tkind.TK_RETURN, "return");
checkname(tkind.TK_USE, "import"); checktokname(tkind.TK_USE, "import");
checkname(tkind.TK_TYPE, "type"); checktokname(tkind.TK_TYPE, "type");
checkname(tkind.TK_STRUCT, "struct"); checktokname(tkind.TK_STRUCT, "struct");
checkname(tkind.TK_DEFER, "defer"); checktokname(tkind.TK_DEFER, "defer");
checkname(tkind.TK_BREAK, "break"); checktokname(tkind.TK_BREAK, "break");
checkname(tkind.TK_CONTINUE, "continue"); checktokname(tkind.TK_CONTINUE, "continue");
checkname(tkind.TK_EXPORT, "export"); checktokname(tkind.TK_EXPORT, "export");
checkname(tkind.TK_PROC, "proc"); checktokname(tkind.TK_PROC, "proc");
checkname(tkind.TK_CHAN, "chan"); checktokname(tkind.TK_CHAN, "chan");
checkname(tkind.TK_NIL, "nil"); checktokname(tkind.TK_NIL, "nil");
checkname(tkind.TK_TRUE, "true"); checktokname(tkind.TK_TRUE, "true");
checkname(tkind.TK_FALSE, "false"); checktokname(tkind.TK_FALSE, "false");
checkname(tkind.TK_AS, "as"); checktokname(tkind.TK_AS, "as");
checkname(tkind.TK_IS, "is"); checktokname(tkind.TK_IS, "is");
checkname(tkind.TK_VOID, "void"); checktokname(tkind.TK_VOID, "void");
checkname(tkind.TK_YIELD, "yield"); checktokname(tkind.TK_YIELD, "yield");
checkname(tkind.TK_STATIC, "static"); checktokname(tkind.TK_STATIC, "static");
checkname(tkind.TK_MATCH, "match"); checktokname(tkind.TK_MATCH, "match");
checkname(tkind.TK_CONST, "const"); checktokname(tkind.TK_CONST, "const");
checkname(tkind.TK_UNDER, "_"); checktokname(tkind.TK_UNDER, "_");
checkname(tkind.TK_ENUM, "enum"); checktokname(tkind.TK_ENUM, "enum");
checkname(tkind.TK_MODULE, "package"); checktokname(tkind.TK_MODULE, "package");
checkname(tkind.TK_LPAREN, "("); checktokname(tkind.TK_LPAREN, "(");
checkname(tkind.TK_RPAREN, ")"); checktokname(tkind.TK_RPAREN, ")");
checkname(tkind.TK_LBRACE, "{"); checktokname(tkind.TK_LBRACE, "{");
checkname(tkind.TK_RBRACE, "}"); checktokname(tkind.TK_RBRACE, "}");
checkname(tkind.TK_LBRACK, "["); checktokname(tkind.TK_LBRACK, "[");
checkname(tkind.TK_RBRACK, "]"); checktokname(tkind.TK_RBRACK, "]");
checkname(tkind.TK_COMMA, ","); checktokname(tkind.TK_COMMA, ",");
checkname(tkind.TK_SEMI, ";"); checktokname(tkind.TK_SEMI, ";");
checkname(tkind.TK_COLON, ":"); checktokname(tkind.TK_COLON, ":");
checkname(tkind.TK_DOT, "."); checktokname(tkind.TK_DOT, ".");
checkname(tkind.TK_ELLIPSIS, "..."); checktokname(tkind.TK_ELLIPSIS, "...");
checkname(tkind.TK_DOTDOT, ".."); checktokname(tkind.TK_DOTDOT, "..");
checkname(tkind.TK_AT, "@"); checktokname(tkind.TK_AT, "@");
checkname(tkind.TK_QUESTION, "?"); checktokname(tkind.TK_QUESTION, "?");
checkname(tkind.TK_ASSIGN, "="); checktokname(tkind.TK_ASSIGN, "=");
checkname(tkind.TK_PLUSEQ, "+="); checktokname(tkind.TK_PLUSEQ, "+=");
checkname(tkind.TK_MINUSEQ, "-="); checktokname(tkind.TK_MINUSEQ, "-=");
checkname(tkind.TK_STAREQ, "*="); checktokname(tkind.TK_STAREQ, "*=");
checkname(tkind.TK_SLASHEQ, "/="); checktokname(tkind.TK_SLASHEQ, "/=");
checkname(tkind.TK_PERCENTEQ, "%="); checktokname(tkind.TK_PERCENTEQ, "%=");
checkname(tkind.TK_AMPEQ, "&="); checktokname(tkind.TK_AMPEQ, "&=");
checkname(tkind.TK_PIPEEQ, "|="); checktokname(tkind.TK_PIPEEQ, "|=");
checkname(tkind.TK_CARETEQ, "^="); checktokname(tkind.TK_CARETEQ, "^=");
checkname(tkind.TK_LSHIFTEQ, "<<="); checktokname(tkind.TK_LSHIFTEQ, "<<=");
checkname(tkind.TK_RSHIFTEQ, ">>="); checktokname(tkind.TK_RSHIFTEQ, ">>=");
checkname(tkind.TK_PLUS, "+"); checktokname(tkind.TK_PLUS, "+");
checkname(tkind.TK_MINUS, "-"); checktokname(tkind.TK_MINUS, "-");
checkname(tkind.TK_STAR, "*"); checktokname(tkind.TK_STAR, "*");
checkname(tkind.TK_SLASH, "/"); checktokname(tkind.TK_SLASH, "/");
checkname(tkind.TK_PERCENT, "%"); checktokname(tkind.TK_PERCENT, "%");
checkname(tkind.TK_AMP, "&"); checktokname(tkind.TK_AMP, "&");
checkname(tkind.TK_PIPE, "|"); checktokname(tkind.TK_PIPE, "|");
checkname(tkind.TK_CARET, "^"); checktokname(tkind.TK_CARET, "^");
checkname(tkind.TK_TILDE, "~"); checktokname(tkind.TK_TILDE, "~");
checkname(tkind.TK_LSHIFT, "<<"); checktokname(tkind.TK_LSHIFT, "<<");
checkname(tkind.TK_RSHIFT, ">>"); checktokname(tkind.TK_RSHIFT, ">>");
checkname(tkind.TK_EQ, "=="); checktokname(tkind.TK_EQ, "==");
checkname(tkind.TK_NEQ, "!="); checktokname(tkind.TK_NEQ, "!=");
checkname(tkind.TK_LT, "<"); checktokname(tkind.TK_LT, "<");
checkname(tkind.TK_LE, "<="); checktokname(tkind.TK_LE, "<=");
checkname(tkind.TK_GT, ">"); checktokname(tkind.TK_GT, ">");
checkname(tkind.TK_GE, ">="); checktokname(tkind.TK_GE, ">=");
checkname(tkind.TK_AND, "&&"); checktokname(tkind.TK_AND, "&&");
checkname(tkind.TK_OR, "||"); checktokname(tkind.TK_OR, "||");
checkname(tkind.TK_NOT, "!"); checktokname(tkind.TK_NOT, "!");
checkname(tkind.TK_LARROW, "<-"); checktokname(tkind.TK_LARROW, "<-");
checkname(tkind.TK_ARROW, "->"); checktokname(tkind.TK_ARROW, "->");
checkname(tkind.TK_FATARROW, "=>"); checktokname(tkind.TK_FATARROW, "=>");
checkname(tkind.TK_MODRESET, "//ww:module-reset"); checktokname(tkind.TK_MODRESET, "//ww:module-reset");
checkname(tkind.TK_MODPATH, "//ww:module"); checktokname(tkind.TK_MODPATH, "//ww:module");
checkname(tkind.TK_LAST, "<last>"); checktokname(tkind.TK_LAST, "<last>");
// Unknown kind → the post-switch fallback. TK_LAST is the highest // Unknown kind → the post-switch fallback. TK_LAST is the highest
// named value (89, after TK_MODPATH=88 landed); 90 is out of band, // named value (89, after TK_MODPATH=88 landed); 90 is out of band,
// exercising the "<?>" tail. // exercising the "<?>" tail.
checkname(90: tkind, "<?>"); checktokname(90: tkind, "<?>");
}; };
fn checkkw(s: str, want: tkind) void = { fn checkkw(s: str, want: tkind) void = {