stage1 新的ast结构 使用pest描述语法

gramma.pest

@@ -0,0 +1,384 @@
+// 顶层容器
+Root             = { SOI ~ ContainerMembers ~ EOI }
+ContainerMembers = { ExternalHeaderList ~ (ContainerDeclaration ~ (COMMA | SEMICOLON)*)* }
+
+HeaderItem         = { (AT | SHARP) ~ IDENTIFIER ~ (LPAREN ~ ExprList? ~ RPAREN)? }
+HeaderList         = { HeaderItem* }
+DeclHeader         = { HeaderList? ~ KEYWORD_pub? }
+ExternalHeaderItem = { (AT | SHARP) ~ BANG ~ IDENTIFIER ~ (LPAREN ~ ExprList? ~ RPAREN)? }
+ExternalHeaderList = { ExternalHeaderItem* }
+
+BindingIdent = { IDENTIFIER | UNDERSCORE }
+
+ContainerDeclaration = {
+    FnDecl
+  | VarDecl
+  | ConstDecl
+  | TypeDecl
+  | MemberDecl
+  | ComptimeDecl
+  | HeaderList ~ Block
+}
+
+ComptimeDecl = { KEYWORD_comptime ~ (Block | Expr) }
+
+// 函数声明（可带 comptime 前缀，支持修饰符）
+FnDecl = {
+    DeclHeader ~ KEYWORD_comptime? ~ KEYWORD_fn ~ IDENTIFIER ~ LPAREN ~ ParamDeclList ~ RPAREN ~ (COLON ~ TypeExpr)? ~ (SEMICOLON | Block)
+}
+
+ParamDeclList = { (ParamDecl ~ COMMA)* ~ (ParamDecl | DOT3)? }
+ParamDecl     = { HeaderList? ~ BindingIdent ~ COLON ~ TypeExpr }
+
+// 变量声明（支持修饰符、元组解构与类型推导）
+VarDecl   = { DeclHeader ~ KEYWORD_var ~ VarBody }
+ConstDecl = { DeclHeader ~ KEYWORD_const ~ VarBody }
+VarBody   = { VarPattern ~ (COLON ~ TypeExpr)? ~ (EQUAL ~ Expr)? }
+
+// 类型声明（支持修饰符）
+TypeDecl = { DeclHeader ~ KEYWORD_type ~ IDENTIFIER ~ EQUAL ~ TypeExpr }
+
+// 容器成员（支持修饰符）
+MemberDecl = { DeclHeader ~ IDENTIFIER ~ (COLON ~ TypeExpr)? ~ (EQUAL ~ Expr)? }
+
+// 变量声明左值模式（允许单独标识符）
+VarPattern     = { VarPatternAtom ~ (COMMA ~ VarPatternAtom)* }
+VarPatternAtom = {
+    BindingIdent
+  | DOT ~ IDENTIFIER ~ (LBRACKET ~ VarPattern ~ RBRACKET)?
+  | LPAREN ~ VarPattern ~ RPAREN
+}
+
+// 匹配模式（不允许单独标识符）
+MatchPattern     = { MatchPatternAtom ~ (COMMA ~ MatchPatternAtom)* }
+MatchPatternAtom = {
+    UNDERSCORE
+  | Expr
+  | DOT ~ IDENTIFIER ~ (LBRACKET ~ MatchPattern ~ RBRACKET)?
+  | LPAREN ~ MatchPattern ~ RPAREN
+}
+
+// 块内语句
+Block     = { LBRACE ~ Statement* ~ Expr? ~ RBRACE }
+Statement = {
+    RetStatement
+  | BreakStatement
+  | ContinueStatement
+  | DeferStatement
+  | DeclStatement
+  | ExprStatement
+  | ComptimeStatement
+}
+
+// 声明语句（内部声明已包含 HeaderList）
+DeclStatement     = { (VarDecl | ConstDecl | TypeDecl) ~ (COMMA | SEMICOLON)? }
+ExprStatement     = { Expr ~ (COMMA | SEMICOLON)? }
+ComptimeStatement = { ComptimeDecl ~ (COMMA | SEMICOLON)? }
+
+RetStatement      = { KEYWORD_ret ~ Expr? ~ (COMMA | SEMICOLON)? }
+BreakStatement    = { KEYWORD_break ~ Label? ~ Expr? ~ (COMMA | SEMICOLON)? }
+ContinueStatement = { KEYWORD_continue ~ Label? ~ (COMMA | SEMICOLON)? }
+DeferStatement    = { KEYWORD_defer ~ (Block | Statement) ~ (COMMA | SEMICOLON)? }
+
+// 标签定义（$ 前缀）
+Label = { DOLLAR ~ IDENTIFIER }
+
+// ============ 表达式 ============
+
+Expr = { AssignExpr }
+
+AssignExpr  = { BoolOrExpr ~ (AssignOp ~ AssignExpr)? }
+BoolOrExpr  = { BoolAndExpr ~ (BOOL_OR ~ BoolAndExpr)* }
+BoolAndExpr = { BitOrExpr ~ (BOOL_AND ~ BitOrExpr)* }
+BitOrExpr   = { BitXorExpr ~ (PIPE ~ BitXorExpr)* }
+BitXorExpr  = { BitAndExpr ~ (CARET ~ BitAndExpr)* }
+BitAndExpr  = { CmpEqExpr ~ (AMPERSAND ~ CmpEqExpr)* }
+CmpEqExpr   = { CmpExpr ~ ((EQ_EQ | BANG_EQUAL) ~ CmpExpr)* }
+CmpExpr     = { ArrowExpr ~ ((L_ARROW_EQ | L_ARROW | R_ARROW_EQ | R_ARROW) ~ ArrowExpr)* }
+
+ArrowExpr = { RangeExpr ~ ((THIN_R_ARROW | THIN_L_ARROW | FAT_D_ARROW | THIN_D_ARROW) ~ RangeExpr)* }
+
+RangeExpr  = { ShiftExpr ~ (DOT2 ~ ShiftExpr?)? }
+ShiftExpr  = { AddExpr ~ ((L_ARROW2_EQ | L_ARROW2 | R_ARROW2_EQ | R_ARROW2) ~ AddExpr)* }
+AddExpr    = { MulExpr ~ ((PLUS | MINUS) ~ MulExpr)* }
+MulExpr    = { PrefixExpr ~ ((ASTERISK | SLASH | PERCENT) ~ PrefixExpr)* }
+PrefixExpr = { PrefixOp* ~ PostfixExpr }
+PrefixOp   = { MINUS | BANG | TILDE | AMPERSAND }
+
+PostfixExpr = {
+    PrimaryExpr ~ (LPAREN ~ ExprList ~ RPAREN | DOT ~ IDENTIFIER | DOT ~ ASTERISK | LBRACKET ~ Expr ~ RBRACKET | LBRACKET ~ Expr ~ DOT2 ~ Expr? ~ RBRACKET | KEYWORD_as ~ TypeExpr)*
+}
+
+ExprList = { (Expr ~ COMMA)* ~ Expr? }
+
+PrimaryExpr = {
+    FLOAT_LITERAL
+  | INTEGER_LITERAL
+  | CHAR_LITERAL
+  | STRING_LITERAL
+  | KEYWORD_true
+  | KEYWORD_false
+  | KEYWORD_null
+  | TupleLiteral
+  | AggregateLiteral
+  | AnonymousAggregateLiteral
+  | ArrayLiteral
+  | AnonymousArrayLiteral
+  | ComptimeCallExpr // @name(args)
+
+  | IDENTIFIER
+  | Block
+  | IfExpr
+  | IfVarExpr
+  | WhileExpr
+  | LoopExpr
+  | ForExpr
+  | MatchExpr
+  | FnTypeExpr
+}
+
+TupleLiteral = { ParenExpr }
+
+// ============ 聚合字面量 ============
+
+AggregateLiteral          = { IDENTIFIER ~ LBRACE ~ StructInitList? ~ RBRACE }
+AnonymousAggregateLiteral = { DOT ~ LBRACE ~ StructInitList? ~ RBRACE }
+
+StructInitList = { StructInit ~ ((COMMA | SEMICOLON) ~ StructInit)* ~ (COMMA | SEMICOLON)? }
+StructInit     = { DOT ~ IDENTIFIER ~ (EQUAL ~ Expr)? }
+
+// ============ 数组/切片字面量 ============
+ArrayLiteral = {
+    // 切片字面量: []T[1,2,3]
+    // 数组字面量: [N]T[1,2,3] 或 [_]T[1,2,3]
+    LBRACKET ~ (INTEGER_LITERAL | UNDERSCORE)? ~ RBRACKET ~ TypeExpr ~ LBRACKET ~ ExprList? ~ RBRACKET
+}
+
+AnonymousArrayLiteral = {
+    DOT ~ LBRACKET ~ ExprList? ~ RBRACKET
+}
+
+// ============ 类型表达式（独立，限制语法） ============
+TypeExpr = { HeaderList? ~ TypePrefixExpr }
+
+TypePrefixExpr = { ASTERISK* ~ TypePostfixExpr }
+
+TypePostfixExpr = {
+    TypePrimary ~ (LPAREN ~ TypeExprList ~ RPAREN | DOT ~ IDENTIFIER | LBRACKET ~ TypeExpr ~ RBRACKET | KEYWORD_as ~ TypeExpr)*
+}
+
+TypePrimary = {
+    IDENTIFIER
+  | KEYWORD_i8
+  | KEYWORD_u8
+  | KEYWORD_i16
+  | KEYWORD_u16
+  | KEYWORD_i32
+  | KEYWORD_u32
+  | KEYWORD_i64
+  | KEYWORD_u64
+  | KEYWORD_f32
+  | KEYWORD_f64
+  | KEYWORD_isize
+  | KEYWORD_usize
+  | KEYWORD_bool
+  | KEYWORD_void
+  | KEYWORD_ptr
+  | FnTypeExpr
+  | AggregateTypeExpr
+  | TypeParenExpr
+  | ArrayTypeExpr
+}
+
+ArrayTypeExpr = {
+    LBRACKET ~ RBRACKET ~ TypeExpr
+  | LBRACKET ~ (INTEGER_LITERAL | UNDERSCORE) ~ RBRACKET ~ TypeExpr
+}
+
+TypeParenExpr = {
+    LPAREN ~ RPAREN
+  | LPAREN ~ TypeExpr ~ COMMA ~ (TypeExpr ~ COMMA)* ~ TypeExpr? ~ RPAREN
+  | LPAREN ~ TypeExpr ~ RPAREN
+}
+
+TypeExprList = { (TypeExpr ~ COMMA)* ~ TypeExpr? }
+
+FnTypeExpr = { KEYWORD_comptime? ~ KEYWORD_fn ~ LPAREN ~ TypeExprList? ~ RPAREN ~ (COLON ~ TypeExpr)? }
+
+AggregateTypeExpr = { (KEYWORD_struct | KEYWORD_union | KEYWORD_enum | KEYWORD_shape) ~ LBRACE ~ ContainerMembers ~ RBRACE }
+
+// ============ 控制流 ============
+IfExpr    = { KEYWORD_if ~ Expr ~ Block ~ (KEYWORD_else ~ (Block | IfExpr | IfVarExpr))? }
+IfVarExpr = { KEYWORD_if ~ VarBody ~ Block ~ (KEYWORD_else ~ (Block | IfExpr | IfVarExpr))? }
+
+WhileExpr = { Label? ~ KEYWORD_while ~ Expr ~ Block ~ (KEYWORD_else ~ (Block | Expr))? }
+LoopExpr  = { Label? ~ KEYWORD_loop ~ Block }
+ForExpr   = { Label? ~ KEYWORD_for ~ Expr ~ (COMMA ~ Expr)* ~ KEYWORD_as ~ BindingIdent ~ (COMMA ~ BindingIdent)* ~ Block ~ (KEYWORD_else ~ (Block | Expr))? }
+
+MatchExpr = { KEYWORD_match ~ Expr ~ LBRACE ~ MatchArm* ~ RBRACE }
+MatchArm  = { MatchPattern ~ (COMMA ~ MatchPattern)* ~ FAT_R_ARROW ~ Block }
+
+// ============ 其他表达式 ============
+ComptimeCallExpr = { AT ~ IDENTIFIER ~ LPAREN ~ ExprList? ~ RPAREN }
+ParenExpr        = {
+  
+  | LPAREN ~ Expr ~ COMMA ~ (Expr ~ COMMA)* ~ Expr? ~ RPAREN
+  | LPAREN ~ Expr ~ RPAREN
+}
+
+// ============ Token 定义 ============
+AssignOp   = { EQUAL | PLUS_EQ | MINUS_EQ | ASTERISK_EQ | SLASH_EQ | PERCENT_EQ | AMPERSAND_EQ | PIPE_EQ | CARET_EQ | L_ARROW2_EQ | R_ARROW2_EQ }
+BOOL_OR    = { PIPE ~ PIPE }
+BOOL_AND   = { AMPERSAND ~ AMPERSAND }
+EQ_EQ      = { EQUAL ~ EQUAL }
+BANG_EQUAL = { BANG ~ EQUAL }
+
+keyword_suffix    = _{ !(ASCII_ALPHANUMERIC | "_") }
+KEYWORD_fn        = @{ "fn" ~ keyword_suffix }
+KEYWORD_type      = @{ "type" ~ keyword_suffix }
+KEYWORD_pub       = @{ "pub" ~ keyword_suffix }
+KEYWORD_var       = @{ "var" ~ keyword_suffix }
+KEYWORD_const     = @{ "const" ~ keyword_suffix }
+KEYWORD_if        = @{ "if" ~ keyword_suffix }
+KEYWORD_else      = @{ "else" ~ keyword_suffix }
+KEYWORD_while     = @{ "while" ~ keyword_suffix }
+KEYWORD_loop      = @{ "loop" ~ keyword_suffix }
+KEYWORD_for       = @{ "for" ~ keyword_suffix }
+KEYWORD_as        = @{ "as" ~ keyword_suffix }
+KEYWORD_match     = @{ "match" ~ keyword_suffix }
+KEYWORD_ret       = @{ "ret" ~ keyword_suffix }
+KEYWORD_break     = @{ "break" ~ keyword_suffix }
+KEYWORD_continue  = @{ "continue" ~ keyword_suffix }
+KEYWORD_defer     = @{ "defer" ~ keyword_suffix }
+KEYWORD_shape     = @{ "shape" ~ keyword_suffix }
+KEYWORD_struct    = @{ "struct" ~ keyword_suffix }
+KEYWORD_union     = @{ "union" ~ keyword_suffix }
+KEYWORD_enum      = @{ "enum" ~ keyword_suffix }
+KEYWORD_comptime  = @{ "comptime" ~ keyword_suffix }
+KEYWORD_void      = @{ "void" ~ keyword_suffix }
+KEYWORD_bool      = @{ "bool" ~ keyword_suffix }
+KEYWORD_isize     = @{ "isize" ~ keyword_suffix }
+KEYWORD_usize     = @{ "usize" ~ keyword_suffix }
+KEYWORD_ptr       = @{ "ptr" ~ keyword_suffix }
+KEYWORD_true      = @{ "true" ~ keyword_suffix }
+KEYWORD_false     = @{ "false" ~ keyword_suffix }
+KEYWORD_null      = @{ "null" ~ keyword_suffix }
+KEYWORD_undefined = @{ "undefined" ~ keyword_suffix }
+KEYWORD_i8        = @{ "i8" ~ keyword_suffix }
+KEYWORD_u8        = @{ "u8" ~ keyword_suffix }
+KEYWORD_i16       = @{ "i16" ~ keyword_suffix }
+KEYWORD_u16       = @{ "u16" ~ keyword_suffix }
+KEYWORD_i32       = @{ "i32" ~ keyword_suffix }
+KEYWORD_u32       = @{ "u32" ~ keyword_suffix }
+KEYWORD_i64       = @{ "i64" ~ keyword_suffix }
+KEYWORD_u64       = @{ "u64" ~ keyword_suffix }
+KEYWORD_f32       = @{ "f32" ~ keyword_suffix }
+KEYWORD_f64       = @{ "f64" ~ keyword_suffix }
+
+FAT_D_ARROW  = { "<=>" }
+THIN_D_ARROW = { "<->" }
+L_ARROW2_EQ  = { "<<=" }
+R_ARROW2_EQ  = { ">>=" }
+DOT3         = { "..." }
+THIN_R_ARROW = { "<-" }
+THIN_L_ARROW = { "->" }
+L_ARROW_EQ   = { "<=" }
+R_ARROW_EQ   = { ">=" }
+L_ARROW2     = { "<<" }
+R_ARROW2     = { ">>" }
+FAT_R_ARROW  = { "=>" }
+PLUS_EQ      = { "+=" }
+MINUS_EQ     = { "-=" }
+ASTERISK_EQ  = { "*=" }
+SLASH_EQ     = { "/=" }
+PERCENT_EQ   = { "%=" }
+AMPERSAND_EQ = { "&=" }
+PIPE_EQ      = { "|=" }
+CARET_EQ     = { "^=" }
+DOT2         = { ".." }
+LPAREN       = { "(" }
+RPAREN       = { ")" }
+LBRACKET     = { "[" }
+RBRACKET     = { "]" }
+LBRACE       = { "{" }
+RBRACE       = { "}" }
+COMMA        = { "," }
+SEMICOLON    = { ";" }
+COLON        = { ":" }
+DOT          = { "." }
+AT           = { "@" }
+SHARP        = { "#" }
+DOLLAR       = { "$" }
+EQUAL        = { "=" }
+PLUS         = { "+" }
+MINUS        = { "-" }
+ASTERISK     = { "*" }
+SLASH        = { "/" }
+PERCENT      = { "%" }
+AMPERSAND    = { "&" }
+PIPE         = { "|" }
+CARET        = { "^" }
+TILDE        = { "~" }
+BANG         = { "!" }
+L_ARROW      = { "<" }
+R_ARROW      = { ">" }
+UNDERSCORE   = { "_" }
+
+keyword    = _{
+    KEYWORD_fn
+  | KEYWORD_type
+  | KEYWORD_var
+  | KEYWORD_const
+  | KEYWORD_if
+  | KEYWORD_else
+  | KEYWORD_while
+  | KEYWORD_loop
+  | KEYWORD_for
+  | KEYWORD_as
+  | KEYWORD_match
+  | KEYWORD_ret
+  | KEYWORD_break
+  | KEYWORD_continue
+  | KEYWORD_defer
+  | KEYWORD_shape
+  | KEYWORD_struct
+  | KEYWORD_union
+  | KEYWORD_enum
+  | KEYWORD_comptime
+  | KEYWORD_void
+  | KEYWORD_bool
+  | KEYWORD_true
+  | KEYWORD_false
+  | KEYWORD_null
+  | KEYWORD_undefined
+  | KEYWORD_i8
+  | KEYWORD_u8
+  | KEYWORD_i16
+  | KEYWORD_u16
+  | KEYWORD_i32
+  | KEYWORD_u32
+  | KEYWORD_i64
+  | KEYWORD_u64
+  | KEYWORD_f32
+  | KEYWORD_f64
+  | KEYWORD_isize
+  | KEYWORD_usize
+  | KEYWORD_ptr
+}
+IDENTIFIER = @{
+    !(keyword ~ !(ASCII_ALPHANUMERIC | "_")) ~ (ASCII_ALPHA | "_" ~ (ASCII_ALPHANUMERIC | "_")) ~ (ASCII_ALPHANUMERIC | "_")*
+}
+
+INTEGER_LITERAL = { DECIMAL | HEX | BINARY | OCTAL | "0" }
+DECIMAL         = { ASCII_NONZERO_DIGIT ~ (ASCII_DIGIT | "_")* }
+HEX             = { "0" ~ ("x" | "X") ~ ASCII_HEX_DIGIT ~ (ASCII_HEX_DIGIT | "_")* }
+BINARY          = { "0" ~ ("b" | "B") ~ ASCII_BIN_DIGIT ~ (ASCII_BIN_DIGIT | "_")* }
+OCTAL           = { "0" ~ ("o" | "O") ~ ASCII_OCT_DIGIT ~ (ASCII_OCT_DIGIT | "_")* }
+FLOAT_LITERAL   = { ASCII_DIGIT ~ "." ~ ASCII_DIGIT ~ (ASCII_DIGIT | "_")* }
+CHAR_LITERAL    = { "'" ~ (!"'" ~ ANY) ~ "'" }
+STRING_LITERAL  = { "\"" ~ ANY* ~ "\"" }
+
+COMMENT       = _{ LINE_COMMENT | BLOCK_COMMENT }
+LINE_COMMENT  =  { "//" ~ (!"\n" ~ ANY)* }
+BLOCK_COMMENT =  { "/*" ~ ANY* ~ "*/" }
+WHITESPACE    = _{ " " | "\t" | "\r" | "\n" }

nob.c

@@ -1,67 +1,54 @@
-#undef UNICODE
+
-#define NOB_IMPLEMENTATION
-// Redefine nob_cc_flags() to carry the project's debug flags. Keep in sync
-// with CFLAGS_STR below.
 #define SPL_CFLAGS "-Wall", "-Wextra", "-O0", "-g", "-D_CRT_SECURE_NO_WARNINGS"
 #define nob_cc_flags(cmd) nob_cmd_append(cmd, SPL_CFLAGS)
+#undef UNICODE
+#define NOB_IMPLEMENTATION
 #include "nob.h"
+#undef NOB_IMPLEMENTATION
+#include "nob_popen.h"
 #ifdef _WIN32
 #include <consoleapi2.h>
 #endif
-
-// C-side bootstrap build script. Builds the stage0 VM tools and the splc0
-// compiler from their C sources. The SPL self-hosting chain (splc1, ...) is
-// out of scope and is driven by a different mechanism.
-//
-// Usage:
-//     cc -o nob nob.c          # bootstrap once
-//     ./nob                    # build all targets
-//     ./nob build <targets...> # build specific targets
-//     ./nob run <target> [..]  # build and run
-//     ./nob test               # build and run VM unit tests
-//     ./nob clean              # remove build artifacts
-//     ./nob list               # list all targets
-//     ./nob help               # print this help
-
 #define BUILD_FOLDER "build/"
 
-#ifdef _WIN32
-#define EXE_SUFFIX ".exe"
-#else
-#define EXE_SUFFIX ""
-#endif
-
 // Content of the .cflags stamp file; must match SPL_CFLAGS above.
 #define CFLAGS_STR "-Wall -Wextra -O0 -g"
 // Stamp file whose mtime is refreshed whenever the flags change so that all
 // object files get rebuilt.
 static const char *CFLAGS_STAMP = BUILD_FOLDER ".cflags";
 
-// Target descriptions
+/* clang-format off */
 #define VM_SRCS "stage0/spl_mcode.c", "stage0/spl_syscall.c", "stage0/spl_vm.c"
-#define SPLC0_PART_SRCS                                                                            \
-    "stage1/spl_ast.c", "stage1/spl_lexer.c", "stage1/spl_dumptree.c", "stage1/spl_type.c",        \
-        "stage1/spl_sema.c", "stage1/spl_ir.c", "stage1/spl_ast2ir.c"
-
 static const char *spl_cli_srcs[] = {"stage0/spl_cli.c", VM_SRCS};
-static const char *splc0_srcs[] = {"stage1/splc0.c", VM_SRCS, SPLC0_PART_SRCS};
 static const char *test_srcs[] = {"stage0/test_spl_vm.c", VM_SRCS};
-static const char *spl_disasm_srcs[] = {"stage0/spl_disasm.c", VM_SRCS};
+static const char *splc0_srcs[] = {
+    "stage1/splc0.c",
+    "stage1/spl_lexer.c",
+    "stage1/spl_ast.c",
+    "stage1/spl_dumptree.c",
+    "stage1/spl_type.c",
+    "stage1/spl_sema.c",
+    // "stage1/spl_ir.c",
+    // "stage1/spl_ast2ir.c",
+    // "stage1/spl_ir2vm.c",
+    // "stage0/spl_mcode.c",
+};
+
+/* clang-format on */
 
 typedef struct {
     const char *name;
     const char **srcs;
     size_t srcs_count;
-} Exe_Target;
+} target_t;
 
-static Exe_Target exe_targets[] = {
+static target_t exe_targets[] = {
     {"spl_cli", spl_cli_srcs, NOB_ARRAY_LEN(spl_cli_srcs)},
-    {"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
     {"test", test_srcs, NOB_ARRAY_LEN(test_srcs)},
-    {"spl_disasm", spl_disasm_srcs, NOB_ARRAY_LEN(spl_disasm_srcs)},
+    {"splc0", splc0_srcs, NOB_ARRAY_LEN(splc0_srcs)},
 };
 
-static const Exe_Target *find_exe_target(const char *name) {
+static const target_t *find_exe_target(const char *name) {
     for (size_t i = 0; i < NOB_ARRAY_LEN(exe_targets); ++i) {
         if (strcmp(exe_targets[i].name, name) == 0) {
             return &exe_targets[i];
@@ -84,10 +71,6 @@ static const char *obj_path(const char *src) {
     return out;
 }
 
-static const char *exe_path(const char *name) {
-    return nob_temp_sprintf(BUILD_FOLDER "%s" EXE_SUFFIX, name);
-}
-
 static bool sync_cflags_stamp(void) {
     Nob_String_View cflags = nob_sv_from_cstr(CFLAGS_STR);
     Nob_String_Builder old = {0};
@@ -134,8 +117,8 @@ static bool build_object(const char *src) {
     return nob_cmd_run(&cmd);
 }
 
-static bool link_exe(const Exe_Target *target) {
+static bool link_exe(const target_t *target) {
-    const char *exe = exe_path(target->name);
+    const char *exe = nob_temp_sprintf(BUILD_FOLDER "%s", target->name);
     const char **objs = (const char **)nob_temp_alloc(sizeof(const char *) * target->srcs_count);
     for (size_t i = 0; i < target->srcs_count; ++i) {
         objs[i] = obj_path(target->srcs[i]);
@@ -158,7 +141,7 @@ static bool link_exe(const Exe_Target *target) {
 }
 
 static bool build_target(const char *name) {
-    const Exe_Target *target = find_exe_target(name);
+    const target_t *target = find_exe_target(name);
     if (target == NULL) {
         nob_log(NOB_ERROR, "unknown target `%s`", name);
         return false;
@@ -181,6 +164,143 @@ static bool build_all(void) {
     return true;
 }
 
+static void parse_expect(const char *name, Nob_Cmd_Result *expect) {
+    Nob_String_Builder sb = {0};
+    nob_read_entire_file(name, &sb);
+    Nob_String_View sv = nob_sb_to_sv(sb);
+    while (sv.count > 0) {
+        Nob_String_View line = nob_sv_chop_by_delim(&sv, '\n');
+        line = nob_sv_trim_left(line); // 去掉前导空格
+
+        if (!nob_sv_starts_with(line, nob_sv_from_cstr("//"))) {
+            break;
+        }
+
+        Nob_String_View rest = nob_sv_from_parts(line.data + 2, line.count - 2);
+        rest = nob_sv_trim_left(rest);
+
+        if (rest.count == 0)
+            continue;
+
+        if (nob_sv_starts_with(rest, nob_sv_from_cstr("Expect"))) {
+            break;
+        }
+        rest = nob_sv_from_parts(rest.data + 6, rest.count - 6);
+        rest = nob_sv_trim_left(rest);
+
+        // 按 '=' 分割
+        Nob_String_View key = nob_sv_chop_by_delim(&rest, '=');
+        key = nob_sv_trim(key);
+        Nob_String_View value = nob_sv_trim(rest);
+
+        if (nob_sv_eq(key, nob_sv_from_cstr("retcode"))) {
+            int val = 0;
+            for (size_t i = 0; i < value.count && isdigit(value.data[i]); ++i) {
+                val = val * 10 + (value.data[i] - '0');
+            }
+            expect->exit_code = val;
+        } else if (nob_sv_eq(key, nob_sv_from_cstr("stdout"))) {
+        }
+    }
+}
+
+static bool test_once(const char *fname) {
+    const char *compiler_path = "splc0";
+    const char *cli_path = "spl_cli";
+    const char *target_sir = BUILD_FOLDER "test.sir";
+
+    Nob_Cmd cmd = {0};
+    if (!build_target(compiler_path)) {
+        return 1;
+    }
+    cmd.count = 0;
+
+    nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", compiler_path));
+    nob_cmd_append(&cmd, fname, target_sir);
+    if (!nob_cmd_run(&cmd)) {
+        return false;
+    }
+
+    if (!build_target(cli_path)) {
+        return 1;
+    }
+    cmd.count = 0;
+    nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", cli_path));
+    nob_cmd_append(&cmd, target_sir);
+    nob_cmd_run(&cmd);
+
+    Nob_Cmd_Result result = {0};
+
+    Nob_String_Builder cmd_str = {0};
+    nob_cmd_render(cmd, &cmd_str);
+    nob_sb_append_null(&cmd_str);
+    nob_cmd_capture_popen(cmd_str.items, &result);
+    // Expect retcode = number
+
+    Nob_Cmd_Result expect = {0};
+    parse_expect(fname, &expect);
+
+    if (expect.exit_code != result.exit_code) {
+        nob_log(NOB_ERROR, "Expect code `%d`, Result code `%d`\n", expect.exit_code,
+                result.exit_code);
+        return false;
+    }
+
+    nob_cmd_result_free(result);
+    return true;
+}
+
+static bool test_once_ast(const char *fname) {
+    const char *target_name = "splc0";
+    if (!prepare_build())
+        return 1;
+    if (!build_target(target_name))
+        return 1;
+    Nob_Cmd cmd = {0};
+    nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", target_name));
+    nob_cmd_append(&cmd, "--dump", "ast", fname, BUILD_FOLDER "t.sir");
+    return nob_cmd_run(&cmd);
+}
+
+static bool test_once_sema(const char *fname) {
+    const char *target_name = "splc0";
+    if (!prepare_build())
+        return 1;
+    if (!build_target(target_name))
+        return 1;
+    Nob_Cmd cmd = {0};
+    nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", target_name));
+    nob_cmd_append(&cmd, "--dump", "sema", fname, BUILD_FOLDER "t.sir");
+    return nob_cmd_run(&cmd);
+}
+
+typedef bool (*test_fn_t)(const char *fname);
+static bool run_test(Nob_Files *files, test_fn_t test_once) {
+    const char *test_folder = "./tests/stage1/";
+
+    Nob_File_Paths paths = {0};
+    nob_read_entire_dir(test_folder, &paths);
+    for (int i = 0; i < files->count; i += 1) {
+        for (int j = 0; j < paths.count; j += 1) {
+            String_View sv = sv_from_cstr(paths.items[j]);
+            // printf("--- test " SV_Fmt " ---\n", SV_Arg(sv));
+            if (!strstr(paths.items[j], files->items[i])) {
+                continue;
+            }
+            const char *tname = nob_temp_sprintf("%s%s", test_folder, paths.items[j]);
+            printf("--- test %s ---\n", tname);
+            if (test_once(tname) == false)
+                return false;
+        }
+    }
+
+    if (!prepare_build()) {
+        return 1;
+    }
+
+    return true;
+}
+
 static bool delete_walk_entry(Nob_Walk_Entry entry) { return nob_delete_file(entry.path); }
 
 static bool delete_directory_recursively(const char *dir_path) {
@@ -246,7 +366,7 @@ int main(int argc, char **argv) {
         if (!build_target(target_name))
             return 1;
         Nob_Cmd cmd = {0};
-        nob_cmd_append(&cmd, exe_path(target_name));
+        nob_cmd_append(&cmd, nob_temp_sprintf(BUILD_FOLDER "%s", target_name));
         while (argc > 0) {
             nob_cmd_append(&cmd, nob_shift(argv, argc));
         }
@@ -254,13 +374,24 @@ int main(int argc, char **argv) {
     }
 
     if (strcmp(command_name, "test") == 0) {
-        if (!prepare_build())
+        Nob_Files files = {0};
-            return 1;
+        test_fn_t tfn = test_once;
-        if (!build_target("test"))
+        if (argc > 0) {
-            return 1;
+            const char *mode_name = nob_shift(argv, argc);
-        Nob_Cmd cmd = {0};
+            if (strcmp(mode_name, "ast") == 0) {
-        nob_cmd_append(&cmd, exe_path("test"));
+                tfn = test_once_ast;
-        return nob_cmd_run(&cmd) ? 0 : 1;
+            } else if (strcmp(mode_name, "sema") == 0) {
+                tfn = test_once_sema;
+            } else {
+                da_append(&files, mode_name);
+            }
+        }
+
+        while (argc > 0) {
+            da_append(&files, nob_shift(argv, argc));
+        }
+
+        return run_test(&files, tfn) ? 0 : 1;
     }
 
     if (strcmp(command_name, "clean") == 0) {

nob.h

@@ -1,3 +1,4 @@
+// clang-format off
 /* nob - v3.10.0 - Public Domain - https://github.com/tsoding/nob.h
 
    This library is the next generation of the [NoBuild](https://github.com/tsoding/nobuild) idea.

nob_popen.h

@@ -0,0 +1,54 @@
+#ifndef __NOB_POPEN_H__
+#define __NOB_POPEN_H__
+
+#include "nob.h"
+
+typedef struct {
+    Nob_String_Builder out; // stdout 内容
+    int exit_code;          // 实际退出码
+    bool ok;                // 是否成功启动
+} Nob_Cmd_Result;
+
+typedef struct {
+    const char **items;
+    int capacity;
+    int count;
+} Nob_Files;
+
+// 运行命令，捕获 stdout 和退出码（不支持 stdin 和 stderr）
+bool nob_cmd_capture_popen(const char *tname, Nob_Cmd_Result *res) {
+    memset(res, 0, sizeof(*res));
+
+#ifdef _WIN32
+    FILE *fp = _popen(tname, "r");
+#else
+    FILE *fp = popen(tname, "r");
+#endif
+
+    if (!fp) {
+        nob_log(NOB_ERROR, "popen failed");
+        return false;
+    }
+
+    // 读取输出到 String_Builder
+    char buffer[4096];
+    while (fgets(buffer, sizeof(buffer), fp)) {
+        nob_sb_append_cstr(&res->out, buffer);
+    }
+
+    // 获取退出码
+#ifdef _WIN32
+    res->exit_code = _pclose(fp);
+#else
+    res->exit_code = pclose(fp);
+    if (WIFEXITED(res->exit_code))
+        res->exit_code = WEXITSTATUS(res->exit_code);
+#endif
+
+    res->ok = true;
+    return true;
+}
+
+#define nob_cmd_result_free(res) nob_sb_free((res).out)
+
+#endif /* __NOB_POPEN_H__ */

stage0/spl_cli.c

@@ -29,6 +29,7 @@ typedef struct {
     int debug;
     int debug_cli;
     int trace;
+    int disasm;
     const char *entry;
     const char *path;  /* file.sir */
     const char **args; /* spl 程序参数（file.sir 之后） */
@@ -39,6 +40,7 @@ static void usage(void) {
     fprintf(stderr, "Usage: spl_cli [options] <file.sir> [args...]\n"
                     "  -d, --debug       stack-canary checks\n"
                     "  -g, --debug-cli   interactive debugger (REPL)\n"
+                    "  --disasm          disasm dump sir\n"
                     "  --entry <name>    entry function (default: main)\n"
                     "  --trace           print every instruction\n"
                     "  -h, --help        show help\n");
@@ -63,6 +65,8 @@ static int parse_args(int argc, const char **argv, cli_opts_t *o) {
                 o->debug_cli = 1;
             } else if (strcmp(a, "--trace") == 0) {
                 o->trace = 1;
+            } else if (strcmp(a, "--disasm") == 0) {
+                o->disasm = 1;
             } else if (strcmp(a, "--entry") == 0) {
                 if (i + 1 >= argc) {
                     fprintf(stderr, "spl_cli: --entry needs a name\n");
@@ -624,6 +628,11 @@ int main(int argc, const char **argv) {
         fprintf(stderr, "spl_cli: cannot load '%s'\n", o.path);
         return 1;
     }
+
+    if (o.disasm) {
+        spl_prog_dump(&prog);
+        return 0;
+    }
     spl_syscall_register(&prog);
 
     spl_vm_t vm;

stage0/spl_disasm.c

@@ -1,76 +0,0 @@
-/* spl_disasm.c - SIR bytecode disassembler
- *
- * Usage: spl_disasm <file.sir>
- */
-
-#include "spl_mcode.h"
-#include <stdio.h>
-
-int main(int argc, const char **argv) {
-    if (argc < 2) {
-        fprintf(stderr, "Usage: spl_disasm <file.sir>\n");
-        return 1;
-    }
-
-    spl_prog_t prog;
-    if (spl_prog_load_from_file(argv[1], &prog) != 0) {
-        fprintf(stderr, "spl_disasm: cannot load '%s'\n", argv[1]);
-        return 1;
-    }
-
-    printf(";; SPL bytecode dump: %s\n", argv[1]);
-    printf(";; ninsns=%zu nfuncs=%zu nnatives=%zu nstrs=%zu\n\n", vec_size(prog.insns),
-           vec_size(prog.funcs), vec_size(prog.natives), vec_size(prog.strtab));
-
-    if (vec_size(prog.funcs) > 0) {
-        printf(";; --- functions ---\n");
-        for (usize i = 0; i < vec_size(prog.funcs); i++) {
-            spl_vm_func_t *f = &vec_at(prog.funcs, i);
-            printf("  %s  nargs=%zu ninsns=%zu addr=%zu\n", f->name ? f->name : "(anon)", f->nargs,
-                   f->ninsns, f->address);
-        }
-        printf("\n");
-    }
-
-    if (vec_size(prog.natives) > 0) {
-        printf(";; --- natives ---\n");
-        for (int i = 0; i < (int)vec_size(prog.natives); i++) {
-            spl_vm_native_t *n = &vec_at(prog.natives, i);
-            printf("  %s\n", n->name ? n->name : "(anon)");
-        }
-        printf("\n");
-    }
-
-    if (vec_size(prog.strtab) > 0) {
-        printf(";; --- string table ---\n");
-        for (int i = 0; i < (int)vec_size(prog.strtab); i++) {
-            printf("  %d: \"%s\"\n", i, vec_at(prog.strtab, i));
-        }
-        printf("\n");
-    }
-
-    printf(";; --- instructions ---\n");
-    for (usize i = 0; i < vec_size(prog.insns); i++) {
-        spl_vm_ins_t *ins = &vec_at(prog.insns, i);
-        printf("%4zd: %s", i, spl_vm_opcode_name((spl_vm_opcode_t)ins->opcode));
-        if (ins->type != SPL_VOID)
-            printf(" %s", spl_vm_type_kind_name((spl_vm_kind_t)ins->type));
-        printf(" %zd", ins->imm);
-
-        /* annotate jumps / calls */
-        if (ins->opcode == SPL_JMP || ins->opcode == SPL_BZ || ins->opcode == SPL_BNZ) {
-            spl_vm_val_t target = i + 1 + ins->imm;
-            printf("  ; -> %zu", target);
-        } else if (ins->opcode == SPL_CALL) {
-            printf("  ; nargs=%zu, from stack", ins->imm);
-        } else if (ins->opcode == SPL_CALLI) {
-            printf("  ; indirect call");
-        } else if (ins->opcode == SPL_GADDR) {
-            printf("  ; gdata[%zu]", ins->imm);
-        }
-        printf("\n");
-    }
-
-    spl_prog_drop(&prog);
-    return 0;
-}

stage0/spl_mcode.c

@@ -43,6 +43,61 @@ void spl_prog_drop(spl_prog_t *prog) {
     prog->debug = NULL;
 }
 
+void spl_prog_dump(spl_prog_t *prog) {
+    printf(";; SPL bytecode dump: \n");
+    printf(";; ninsns=%zu nfuncs=%zu nnatives=%zu nstrs=%zu\n\n", vec_size(prog->insns),
+           vec_size(prog->funcs), vec_size(prog->natives), vec_size(prog->strtab));
+
+    if (vec_size(prog->funcs) > 0) {
+        printf(";; --- functions ---\n");
+        for (usize i = 0; i < vec_size(prog->funcs); i++) {
+            spl_vm_func_t *f = &vec_at(prog->funcs, i);
+            printf("  %s  nargs=%zu ninsns=%zu addr=%zu\n", f->name ? f->name : "(anon)", f->nargs,
+                   f->ninsns, f->address);
+        }
+        printf("\n");
+    }
+
+    if (vec_size(prog->natives) > 0) {
+        printf(";; --- natives ---\n");
+        for (int i = 0; i < (int)vec_size(prog->natives); i++) {
+            spl_vm_native_t *n = &vec_at(prog->natives, i);
+            printf("  %s\n", n->name ? n->name : "(anon)");
+        }
+        printf("\n");
+    }
+
+    if (vec_size(prog->strtab) > 0) {
+        printf(";; --- string table ---\n");
+        for (int i = 0; i < (int)vec_size(prog->strtab); i++) {
+            printf("  %d: \"%s\"\n", i, vec_at(prog->strtab, i));
+        }
+        printf("\n");
+    }
+
+    printf(";; --- instructions ---\n");
+    for (usize i = 0; i < vec_size(prog->insns); i++) {
+        spl_vm_ins_t *ins = &vec_at(prog->insns, i);
+        printf("%4zd: %s", i, spl_vm_opcode_name((spl_vm_opcode_t)ins->opcode));
+        if (ins->type != SPL_VOID)
+            printf(" %s", spl_vm_type_kind_name((spl_vm_kind_t)ins->type));
+        printf(" %zd", ins->imm);
+
+        /* annotate jumps / calls */
+        if (ins->opcode == SPL_JMP || ins->opcode == SPL_BZ || ins->opcode == SPL_BNZ) {
+            spl_vm_val_t target = i + 1 + ins->imm;
+            printf("  ; -> %zu", target);
+        } else if (ins->opcode == SPL_CALL) {
+            printf("  ; nargs=%zu, from stack", ins->imm);
+        } else if (ins->opcode == SPL_CALLI) {
+            printf("  ; indirect call");
+        } else if (ins->opcode == SPL_GADDR) {
+            printf("  ; gdata[%zu]", ins->imm);
+        }
+        printf("\n");
+    }
+}
+
 /* ---- LE read/write helpers ---- */
 
 static inline spl_vm_val_t rd64(const unsigned char **p) {

stage0/spl_mcode.h

@@ -199,6 +199,7 @@ typedef struct spl_prog {
 
 void spl_prog_init(spl_prog_t *prog);
 void spl_prog_drop(spl_prog_t *prog);
+void spl_prog_dump(spl_prog_t *prog);
 
 int spl_prog_load_from_file(const char *fname, spl_prog_t *prog);
 int spl_prog_store_to_file(const char *fname, spl_prog_t *prog);

stage1/spl_ast.h

@@ -7,134 +7,147 @@
 #include "spl_tok.h"
 
 /* clang-format off */
-#define SPL_AST_KIND_TABLE            \
+#define SPL_AST_KIND_TABLE                                            \
-    X(SPL_AST_NONE,                 V0, none) \
+    X(SPL_AST_NONE,                 V0, none)                         \
-    X(SPL_AST_CONTAINER_MEMBERS,    V0, container_members) \
+    X(SPL_AST_ROOT,                 V0, root)                         \
-    X(SPL_AST_FN_DECL,              V0, fn_decl) \
+    X(SPL_AST_CONTAINER_MEMBERS,    V0, container_members)            \
-    X(SPL_AST_FN_DEFINE,            V0, fn_define) \
+    X(SPL_AST_EXTERNAL_TAG_ITEM,    V0, external_tag_item)            \
-    X(SPL_AST_TYPE_DECL,            V0, type_decl) \
+    X(SPL_AST_TAG_ITEM,             V0, tag_item)                     \
-    X(SPL_AST_VAR_DECL,             V0, var_decl) \
+    X(SPL_AST_COMPTIME_DECL,        V0, comptime_decl)                \
-    X(SPL_AST_CONST_DECL,           V0, const_decl) \
+    X(SPL_AST_TOP_LEVEL_BLOCK,      V0, top_level_block)              \
-    X(SPL_AST_MEMBER_DECL,          V0, member_decl) \
+    X(SPL_AST_FN_DECL,              V0, fn_decl)                      \
-    X(SPL_AST__COMPTIME_STMT,       V0, comptime_stmt) \
+    X(SPL_AST_VAR_DECL,             V0, var_decl)                     \
-    X(SPL_AST__DIRECTIVE_BLOCK,     V0, directive_block) \
+    X(SPL_AST_CONST_DECL,           V0, const_decl)                   \
-    X(SPL_AST_PARAM_DECL,           V0, param_decl) \
+    X(SPL_AST_TYPE_DECL,            V0, type_decl)                    \
-    X(SPL_AST_ATTR_ITEM,            V0, attr_item) \
+    X(SPL_AST_MEMBER_DECL,          V0, member_decl)                  \
-    X(SPL_AST_ARGG_INIT_ITEM,       V0, argg_init_item) \
+    X(SPL_AST_PARAM_DECL,           V0, param_decl)                   \
-    X(SPL_AST_IF_STATEMENT,         V0, if_statement) \
+    X(SPL_AST_STATEMENT_RET,        V0, statement_ret)                \
-    X(SPL_AST_IFVAR_STATEMENT,      V0, ifvar_statement) \
+    X(SPL_AST_STATEMENT_BREAK,      V0, statement_break)              \
-    X(SPL_AST_WHILE_STATEMENT,      V0, while_statement) \
+    X(SPL_AST_STATEMENT_CONTINUE,   V0, statement_continue)           \
-    X(SPL_AST_LOOP_STATEMENT,       V0, loop_statement) \
+    X(SPL_AST_STATEMENT_DEFER,      V0, statement_defer)              \
-    X(SPL_AST_FOR_STATEMENT,        V0, for_statement) \
+    X(SPL_AST_STATEMENT_COMPTIME,   V0, statement_comptime)           \
-    X(SPL_AST_MATCH_STATEMENT,      V0, match_statement) \
+    X(SPL_AST_STATEMENT_DECL,       V0, statement_decl)               \
-    X(SPL_AST_RET_STATEMENT,        V0, ret_statement) \
+    X(SPL_AST_STATEMENT_EXPR,       V0, statement_expr)               \
-    X(SPL_AST_BREAK_STATEMENT,      V0, break_statement) \
+    X(SPL_AST_AGGREGATE_MEMBER,     V0, aggregate_member)             \
-    X(SPL_AST_CONTINUE_STATEMENT,   V0, continue_statement) \
+    X(SPL_AST_STRUCT_INIT_ITEM,     V0, struct_init_item)             \
-    X(SPL_AST_DEFER_STATEMENT,      V0, defer_statement) \
+    X(SPL_AST_MATCH_ARM,            V0, match_arm)                    \
-    X(SPL_AST_TRY_STATEMENT,        V0, try_statement) \
+    X(SPL_AST_LABEL,                V0, label)                        \
-    X(SPL_AST_CATCH_STATEMENT,      V0, catch_statement) \
+    X(SPL_AST_EXPR_INT_LIT,         V0, int_lit)                      \
-    X(SPL_AST_ERRDEFER_STATEMEMT,   V0, errdefer_statement) \
+    X(SPL_AST_EXPR_FLOAT_LIT,       V0, float_lit)                    \
-    X(SPL_AST_EXPR_STATEMENT,       V0, expr_statement) \
+    X(SPL_AST_EXPR_CHAR_LIT,        V0, char_lit)                     \
-    X(SPL_AST_PACKED_EXPR,          V0, packed_expr) \
+    X(SPL_AST_EXPR_STRING_LIT,      V0, string_lit)                   \
-    X(SPL_AST_ASSIGN_EXPR,          V0, assign_expr) \
+    X(SPL_AST_EXPR_BOOL_LIT,        V0, bool_lit)                     \
-    X(SPL_AST_ASSIGN_ADD_EXPR,      V0, assign_add_expr) \
+    X(SPL_AST_EXPR_NULL_LIT,        V0, null_lit)                     \
-    X(SPL_AST_ASSIGN_SUB_EXPR,      V0, assign_sub_expr) \
+    X(SPL_AST_EXPR_UNDEFINED_LIT,   V0, undefined_lit)                \
-    X(SPL_AST_ASSIGN_MUL_EXPR,      V0, assign_mul_expr) \
+    X(SPL_AST_EXPR_IDENT,           V0, ident)                        \
-    X(SPL_AST_ASSIGN_DIV_EXPR,      V0, assign_div_expr) \
+    X(SPL_AST_EXPR_UNARY,           V0, unary)                        \
-    X(SPL_AST_ASSIGN_MOD_EXPR,      V0, assign_mod_expr) \
+    X(SPL_AST_EXPR_BINARY,          V0, binary)                       \
-    X(SPL_AST_ASSIGN_AND_EXPR,      V0, assign_and_expr) \
+    X(SPL_AST_EXPR_CALL,            V0, call)                         \
-    X(SPL_AST_ASSIGN_OR_EXPR,       V0, assign_or_expr) \
+    X(SPL_AST_EXPR_FIELD,           V0, field)                        \
-    X(SPL_AST_ASSIGN_XOR_EXPR,      V0, assign_xor_expr) \
+    X(SPL_AST_EXPR_INDEX,           V0, index)                        \
-    X(SPL_AST_ASSIGN_LSHIFT_EXPR,   V0, assign_lshift_expr) \
+    X(SPL_AST_EXPR_SLICE,           V0, slice)                        \
-    X(SPL_AST_ASSIGN_USHIFT_EXPR,   V0, assign_ushift_expr) \
+    X(SPL_AST_EXPR_CAST,            V0, cast)                         \
-    X(SPL_AST_BOOL_OR_EXPR,         V0, bool_or_expr) \
+    X(SPL_AST_EXPR_TUPLE,           V0, tuple)                        \
-    X(SPL_AST_BOOL_AND_EXPR,        V0, bool_and_expr) \
+    X(SPL_AST_EXPR_ARRAY_LIT,       V0, array_literal)                \
-    X(SPL_AST_BIT_OR_EXPR,          V0, bit_or_expr) \
+    X(SPL_AST_EXPR_ANON_ARRAY_LIT,  V0, anon_array_literal)           \
-    X(SPL_AST_BIT_XOR_EXPR,         V0, bit_xor_expr) \
+    X(SPL_AST_EXPR_AGGREGATE_LIT,   V0, aggregate_literal)            \
-    X(SPL_AST_BIT_AND_EXPR,         V0, bit_and_expr) \
+    X(SPL_AST_EXPR_COMPTIME_CALL,   V0, comptime_call)                \
-    X(SPL_AST_CMP_EQ_EXPR,          V0, cmp_eq_expr) \
+    X(SPL_AST_EXPR_BLOCK,           V0, block)                        \
-    X(SPL_AST_CMP_NE_EXPR,          V0, cmp_ne_expr) \
+    X(SPL_AST_EXPR_IF,              V0, if_expr)                      \
-    X(SPL_AST_CMP_LE_EXPR,          V0, cmp_le_expr) \
+    X(SPL_AST_EXPR_IFVAR,           V0, ifvar_expr)                   \
-    X(SPL_AST_CMP_GE_EXPR,          V0, cmp_ge_expr) \
+    X(SPL_AST_EXPR_WHILE,           V0, while_expr)                   \
-    X(SPL_AST_CMP_LT_EXPR,          V0, cmp_lt_expr) \
+    X(SPL_AST_EXPR_LOOP,            V0, loop_expr)                    \
-    X(SPL_AST_CMP_GT_EXPR,          V0, cmp_gt_expr) \
+    X(SPL_AST_EXPR_FOR,             V0, for_expr)                     \
-    X(SPL_AST_RANGE_EXPR,           V0, range_expr) \
+    X(SPL_AST_EXPR_MATCH,           V0, match_expr)                   \
-    X(SPL_AST_LSHIFT_EXPR,          V0, lshift_expr) \
+    X(SPL_AST_EXPR_FN_TYPE,         V0, fn_type)                      \
-    X(SPL_AST_RSHIFT_EXPR,          V0, rshift_expr) \
+    X(SPL_AST_TYPE_PATH,            V0, type_path)                    \
-    X(SPL_AST_ADD_EXPR,             V0, add_expr) \
+    X(SPL_AST_TYPE_POINTER,         V0, type_pointer)                 \
-    X(SPL_AST_SUB_EXPR,             V0, sub_expr) \
+    X(SPL_AST_TYPE_ARRAY,           V0, type_array)                   \
-    X(SPL_AST_MUL_EXPR,             V0, mul_expr) \
+    X(SPL_AST_TYPE_SLICE,           V0, type_slice)                   \
-    X(SPL_AST_DIV_EXPR,             V0, div_expr) \
+    X(SPL_AST_TYPE_FN,              V0, type_fn)                      \
-    X(SPL_AST_MOD_EXPR,             V0, mod_expr) \
+    X(SPL_AST_TYPE_PAREN,           V0, type_paren)                   \
-    X(SPL_AST_MINUS_EXPR,           V0, minus_expr) \
+    X(SPL_AST_TYPE_AGGREGATE,       V0, type_aggregate)               \
-    X(SPL_AST_NOT_EXPR,             V0, not_expr) \
+    X(SPL_AST_TYPE_COMPTIME_CALL,   V0, type_comptime_call)           \
-    X(SPL_AST_BIT_NOT_EXPR,         V0, bit_not_expr) \
+    X(SPL_AST_PATTERN_IDENT,        V0, pattern_ident)                \
-    X(SPL_AST_ADDRESS_EXPR,         V0, address_expr) \
+    X(SPL_AST_PATTERN_UNDERSCORE,   V0, pattern_underscore)           \
-    X(SPL_AST_CALL_EXPR,            V0, call_expr) \
+    X(SPL_AST_PATTERN_DOT,          V0, pattern_dot)                  \
-    X(SPL_AST_FIELD_EXPR,           V0, field_expr) \
+    X(SPL_AST_PATTERN_TUPLE,        V0, pattern_tuple)                \
-    X(SPL_AST_DEREF_EXPR,           V0, deref_expr) \
+    X(SPL_AST_PATTERN_LIST,         V0, pattern_list)
-    X(SPL_AST_INDEX_EXPR,           V0, index_expr) \
+/* clang-format on */
-    X(SPL_AST_SLICE_EXPR,           V0, slice_expr) \
-    X(SPL_AST_AS_EXPR,              V0, as_expr) \
-    X(SPL_AST_EXPR_INTEGER_LIT,     V0, integer_lit) \
-    X(SPL_AST_EXPR_FLOAT_LIT,       V0, float_lit) \
-    X(SPL_AST_EXPR_CHAR_LIT,        V0, char_lit) \
-    X(SPL_AST_EXPR_STRING_LIT,      V0, string_lit) \
-    X(SPL_AST_EXPR_TRUE,            V0, true_lit) \
-    X(SPL_AST_EXPR_FALSE,           V0, false_lit) \
-    X(SPL_AST_EXPR_NULL,            V0, null_lit) \
-    X(SPL_AST_EXPR_UNDEFINED,       V0, undefined_lit) \
-    X(SPL_AST_EXPR_IDENT,           V0, ident_expr) \
-    X(SPL_AST_ARGGREGATE_INIT,      V0, aggregate_init) \
-    X(SPL_AST_EXPR_EXPR,            V0, expr_expr) \
-    X(SPL_AST_ARRAY_LIT,            V0, array_lit) \
-    X(SPL_AST_BUILTIN_EXPR,         V0, builtin_expr) \
-    X(SPL_AST_BLOCK_EXPR,           V0, block_expr) \
-    X(SPL_AST_BASE_TYPE_FN,         V0, base_type_fn) \
-    X(SPL_AST_BASE_TYPE_PATH,       V0, base_type_path) \
-    X(SPL_AST_TYPE_POINTER,         V0, type_pointer) \
-    X(SPL_AST_TYPE_ARRAY,           V0, type_array) \
-    X(SPL_AST_TYPE_SLICE,           V0, type_slice) \
-    X(SPL_AST_TYPE_STRUCT,          V0, type_struct) \
-    X(SPL_AST_TYPE_UNION,           V0, type_union) \
-    X(SPL_AST_TYPE_SHAPE,           V0, type_shape) \
-    X(SPL_AST_TYPE_ENUM,            V0, type_enum) \
-    X(SPL_AST_TYPE_VOID,            V0, type_void) \
-    X(SPL_AST_TYPE_BOOL,            V0, type_bool) \
-    X(SPL_AST_TYPE_OPAQUE,          V0, type_opaque) \
-    X(SPL_AST_TYPE_I8,              V0, type_i8) \
-    X(SPL_AST_TYPE_U8,              V0, type_u8) \
-    X(SPL_AST_TYPE_I16,             V0, type_i16) \
-    X(SPL_AST_TYPE_U16,             V0, type_u16) \
-    X(SPL_AST_TYPE_I32,             V0, type_i32) \
-    X(SPL_AST_TYPE_U32,             V0, type_u32) \
-    X(SPL_AST_TYPE_I64,             V0, type_i64) \
-    X(SPL_AST_TYPE_U64,             V0, type_u64) \
-    X(SPL_AST_TYPE_ISIZE,           V0, type_isize) \
-    X(SPL_AST_TYPE_USIZE,           V0, type_usize) \
-    X(SPL_AST_TYPE__F32,            V0, type_f32) \
-    X(SPL_AST_TYPE__F64,            V0, type_f64) \
-    X(SPL_AST_TYPE_ANY,             V0, type_any) \
-    X(SPL_AST_TYPE_IDENT,           V0, type_ident) \
-
-/* clang-format on*/
 
 typedef enum {
 #ifdef X
 #undef X
 #endif
-    #define X(name, ...) name,
+#define X(name, ...) name,
     SPL_AST_KIND_TABLE
 #undef X
-    SPL_AST_COUNT,
+        SPL_AST_COUNT,
 } spl_ast_node_kind_t;
 
-const char *spl_ast_kind_name(spl_ast_node_kind_t kind);
+/* clang-format off */
+#define SPL_BINARY_OP_TABLE                                            \
+    X(SPL_OP_ASSIGN,                1,  'R', =)                          \
+    X(SPL_OP_ASSIGN_ADD,            1,  'R', +=)                         \
+    X(SPL_OP_ASSIGN_SUB,            1,  'R', -=)                         \
+    X(SPL_OP_ASSIGN_MUL,            1,  'R', *=)                         \
+    X(SPL_OP_ASSIGN_DIV,            1,  'R', /=)                         \
+    X(SPL_OP_ASSIGN_MOD,            1,  'R', %=)                         \
+    X(SPL_OP_ASSIGN_AND,            1,  'R', &=)                         \
+    X(SPL_OP_ASSIGN_OR,             1,  'R', |=)                         \
+    X(SPL_OP_ASSIGN_XOR,            1,  'R', ^=)                         \
+    X(SPL_OP_ASSIGN_LSHIFT,         1,  'R', <<=)                        \
+    X(SPL_OP_ASSIGN_RSHIFT,         1,  'R', >>=)                        \
+    X(SPL_OP_BOOL_OR,               2,  'L', ||)                         \
+    X(SPL_OP_BOOL_AND,              3,  'L', &&)                         \
+    X(SPL_OP_BIT_OR,                4,  'L', |)                          \
+    X(SPL_OP_BIT_XOR,               5,  'L', ^)                          \
+    X(SPL_OP_BIT_AND,               6,  'L', &)                          \
+    X(SPL_OP_CMP_EQ,                7,  'L', ==)                         \
+    X(SPL_OP_CMP_NE,                7,  'L', !=)                         \
+    X(SPL_OP_CMP_LE,                8,  'L', <=)                         \
+    X(SPL_OP_CMP_GE,                8,  'L', >=)                         \
+    X(SPL_OP_CMP_LT,                8,  'L', <)                          \
+    X(SPL_OP_CMP_GT,                8,  'L', >)                          \
+    X(SPL_OP_ARROW_LEFT,            9,  'L', <-)                         \
+    X(SPL_OP_ARROW_RIGHT,           9,  'L', ->)                         \
+    X(SPL_OP_ARROW_FAT_BOTH,        9,  'L', <=>)                        \
+    X(SPL_OP_ARROW_THIN_BOTH,       9,  'L', <->)                        \
+    X(SPL_OP_ARROW_FAT_RIGHT,       9,  'L', =>)                         \
+    X(SPL_OP_RANGE,                 10, 'L', ..)                         \
+    X(SPL_OP_LSHIFT,                11, 'L', <<)                         \
+    X(SPL_OP_RSHIFT,                11, 'L', >>)                         \
+    X(SPL_OP_ADD,                   12, 'L', +)                          \
+    X(SPL_OP_SUB,                   12, 'L', -)                          \
+    X(SPL_OP_MUL,                   13, 'L', *)                          \
+    X(SPL_OP_DIV,                   13, 'L', /)                          \
+    X(SPL_OP_MOD,                   13, 'L', %)
+/* clang-format on */
+
+typedef enum {
+#ifdef X
+#undef X
+#endif
+#define X(name, ...) name,
+    SPL_BINARY_OP_TABLE
+#undef X
+} spl_binary_op_t;
+
+typedef enum {
+    SPL_UNARY_OP_MINUS,
+    SPL_UNARY_OP_NOT,
+    SPL_UNARY_OP_BIT_NOT,
+    SPL_UNARY_OP_ADDRESS,
+} spl_unary_op_t;
+
+const char *spl_binary_op_name(spl_binary_op_t op);
+const char *spl_unary_op_name(spl_unary_op_t op);
 
 struct spl_ast_node;
 typedef struct spl_ast_node spl_ast_node_t;
 typedef usize spl_ast_node_ref_t;
 typedef VEC(spl_ast_node_ref_t) spl_ast_node_ref_vec_t;
+
 struct spl_ast_node {
     spl_ast_node_kind_t kind;
     spl_dbg_node_t dbg;
@@ -143,167 +156,337 @@ struct spl_ast_node {
         usize resolved_def_id;
         usize resolved_type_id;
     };
+
     union {
-        spl_ast_node_ref_vec_t container_members; /* container_decl */
+        /* SPL_AST_ROOT */
-
         struct {
-            const char *ident;
+            spl_ast_node_ref_t members; /* container_members 节点 */
-            spl_ast_node_ref_vec_t expr_list;
+        } root;
-        } attr_item;
 
+        /* SPL_AST_CONTAINER_MEMBERS */
         struct {
-            spl_ast_node_ref_vec_t attr_list; /* attr_item */
+            spl_ast_node_ref_vec_t external_tags; /* external_tag_item 节点列表 */
+            spl_ast_node_ref_vec_t declarations;
+        } container_members;
+
+        /* SPL_AST_FN_DECL */
+        struct {
+            spl_ast_node_ref_vec_t tag_list; /* tag_item 节点 */
+            bool is_comptime;
             const char *name;
-            spl_ast_node_ref_vec_t param_list; /* param_decl */
+            spl_ast_node_ref_vec_t params; /* param_decl 节点 */
-            spl_ast_node_ref_t type_expr; /* ret type expr */
+            spl_ast_node_ref_t ret_type;   /* 类型节点，可空 */
-            spl_ast_node_ref_vec_t block; /* 语句/尾表达式 */
+            spl_ast_node_ref_t body;       /* 表达式节点，可空表示仅声明 */
         } fn_decl;
+
+        /* SPL_AST_VAR_DECL / SPL_AST_CONST_DECL */
         struct {
-            spl_ast_node_ref_vec_t attr_list; /* attr_item */
+            spl_ast_node_ref_vec_t attr_list;
+            spl_ast_node_ref_t pattern;   /* 模式节点 */
+            spl_ast_node_ref_t type;      /* 类型节点，可空 */
+            spl_ast_node_ref_t init_expr; /* 表达式节点，可空 */
+        } var_const_decl;
+
+        /* SPL_AST_TYPE_DECL */
+        struct {
+            spl_ast_node_ref_vec_t attr_list;
+            const char *name;
+            spl_ast_node_ref_t type_expr; /* 类型节点 */
+        } type_decl;
+
+        /* SPL_AST_MEMBER_DECL */
+        struct {
+            spl_ast_node_ref_vec_t attr_list;
+            const char *name;
+            spl_ast_node_ref_t type_expr; /* 可空 */
+            spl_ast_node_ref_t init_expr; /* 可空 */
+        } member_decl;
+
+        /* SPL_AST_PARAM_DECL */
+        struct {
+            spl_ast_node_ref_vec_t attr_list;
             const char *name;
             spl_ast_node_ref_t type_expr;
         } param_decl;
 
+        /* SPL_AST_TAG_ITEM / SPL_AST_EXTERNAL_TAG_ITEM */
+        struct {
+            bool is_at;       /* true: @, false: # */
+            bool is_external; /* true: @!或#! */
+            const char *name;
+            spl_ast_node_ref_vec_t args;
+        } tag_item;
+
+        /* SPL_AST_COMPTIME_DECL */
+        struct {
+            spl_ast_node_ref_t body; /* block 或 expr 节点 */
+        } comptime_decl;
+
+        /* SPL_AST_TOP_LEVEL_BLOCK */
+        struct {
+            spl_ast_node_ref_vec_t tag_list; /* tag_item 节点列表 */
+            spl_ast_node_ref_t block;        /* 表达式节点block */
+        } top_level_block;
+
+        /* SPL_AST_STATEMENT_RET */
+        struct {
+            spl_ast_node_ref_t expr; /* 可空 */
+        } statement_ret;
+
+        /* SPL_AST_STATEMENT_BREAK */
+        struct {
+            spl_ast_node_ref_t label; /* 可空 */
+            spl_ast_node_ref_t expr;  /* 可空 */
+        } statement_break;
+
+        /* SPL_AST_STATEMENT_CONTINUE */
+        struct {
+            spl_ast_node_ref_t label; /* 可空 */
+        } statement_continue;
+
+        /* SPL_AST_STATEMENT_DEFER */
+        struct {
+            spl_ast_node_ref_t body; /* block 或 statement 节点 */
+        } statement_defer;
+
+        /* SPL_AST_STATEMENT_COMPTIME */
+        struct {
+            spl_ast_node_ref_t body; /* block 或 expr 节点 */
+        } statement_comptime;
+
+        /* SPL_AST_STATEMENT_DECL */
+        struct {
+            spl_ast_node_ref_t decl; /* var/const/type 声明节点 */
+        } statement_decl;
+
+        /* SPL_AST_STATEMENT_EXPR */
+        struct {
+            spl_ast_node_ref_t expr;
+        } statement_expr;
+
+        /* SPL_AST_AGGREGATE_MEMBER */
+        struct {
+            spl_ast_node_ref_vec_t attr_list;
+            const char *name;
+            spl_ast_node_ref_t type_expr; /* 可空 */
+            spl_ast_node_ref_t init_expr; /* 可空 */
+        } aggregate_member;
+
+        /* SPL_AST_STRUCT_INIT_ITEM */
         struct {
             const char *name;
-            spl_ast_node_ref_t type_expr;
+            spl_ast_node_ref_t expr; /* 可空 */
-        } type_decl;
+        } struct_init_item;
+
+        /* SPL_AST_MATCH_ARM */
+        struct {
+            spl_ast_node_ref_t pattern; /* 模式节点 */
+            spl_ast_node_ref_t body;    /* block 或 expr 节点 */
+        } match_arm;
+
+        /* SPL_AST_LABEL */
         struct {
-            spl_ast_node_ref_vec_t attr_list; /* attr_item */
             const char *name;
-            spl_ast_node_ref_t type_expr;
+        } label;
-        } member_decl;
+
+        /* ---- 表达式子类型 ---- */
+        struct {
+            isize val;
+        } int_lit;
+        struct {
+            double val;
+        } float_lit;
+        struct {
+            char val;
+        } char_lit;
+        struct {
+            const char *data;
+        } string_lit;
+        struct {
+            bool val;
+        } bool_lit;
+        /* null_lit, undefined_lit 无数据 */
 
         struct {
-            spl_ast_node_ref_vec_t attr_list; /* attr_item */
             const char *name;
-            spl_ast_node_ref_t type_expr;
+        } ident;
-            spl_ast_node_ref_t expr;
-        } var_const_decl;
-
-        /* 语句数据：kind 决定解释哪个成员 */
-        struct {
-            spl_ast_node_ref_t expr;
-            spl_ast_node_ref_vec_t if_block;   /* 语句 */
-            spl_ast_node_ref_vec_t else_block; /* 语句 */
-        } if_statement;
-        struct {
-            spl_ast_node_ref_t packed_expr;
-            spl_ast_node_ref_vec_t if_block;   /* 语句 */
-            spl_ast_node_ref_vec_t else_block; /* 语句 */
-        } ifvar_statement;
-        struct {
-            spl_ast_node_ref_t expr;
-            spl_ast_node_ref_vec_t while_block; /* 语句 */
-        } while_statement;
-        struct {
-            spl_ast_node_ref_vec_t loop_block; /* 语句 */
-        } loop_statement;
-        struct {
-            spl_ast_node_ref_vec_t expr_vec;
-            VEC(char *) ident_vec;
-            spl_ast_node_ref_vec_t block; /* 语句 */
-        } for_statement;
-        struct {
-            spl_ast_node_ref_t expr;
-            spl_ast_node_ref_vec_t paced_exprs; /* packed_expr */
-            spl_ast_node_ref_vec_t match_block; /* 语句 */
-        } match_statement;
-        struct {
-            spl_ast_node_ref_t expr;
-        } ret_statement;
-        struct {
-        } break_statement;
-        struct {
-        } continue_statement;
-        struct {
-            spl_ast_node_ref_vec_t block_or_statement; /* 语句 */
-        } defer_statement;
 
         struct {
-            const char *ident;
+            spl_unary_op_t op;
-            const char *bind_ident;
+            spl_ast_node_ref_t operand;
-            spl_ast_node_ref_t expr;
+        } unary;
-        } packed_expr;
+
         struct {
+            spl_binary_op_t op;
             spl_ast_node_ref_t left;
             spl_ast_node_ref_t right;
-        } op_expr;
+        } binary;
-        struct {
-            spl_ast_node_ref_t postfix_expr;
-        } prefix_expr;
-        struct {
-            spl_ast_node_ref_t primary_expr;
-            union {
-                spl_ast_node_ref_vec_t call_expr;
-                const char *field_expr; /* field/method */
-                spl_ast_node_ref_t index_expr;
-                struct {
-                    spl_ast_node_ref_t begin;
-                    spl_ast_node_ref_t end;
-                } slice_expr;
-                spl_ast_node_ref_t type_expr;
-            };
-        } postfix_expr;
 
         struct {
-            isize integer_expr;
+            spl_ast_node_ref_t callee;
-            double float_expr;
+            spl_ast_node_ref_vec_t args;
-            char char_lit_expr;
+        } call;
-            const char *string_lit_expr; /* parsed c string */
-            const char *ident;
 
-            struct {
+        struct {
-                const char *name;
+            spl_ast_node_ref_t obj;
-                spl_ast_node_ref_vec_t expr; /* aggregate_init_item */
+            const char *field;
-            } aggregate_init;
+        } field;
 
+        struct {
+            spl_ast_node_ref_t obj;
+            spl_ast_node_ref_t index;
+        } index;
+
+        struct {
+            spl_ast_node_ref_t obj;
+            spl_ast_node_ref_t begin;
+            spl_ast_node_ref_t end;
+        } slice;
+
+        struct {
             spl_ast_node_ref_t expr;
-            struct {
+            spl_ast_node_ref_t type;
-                isize integer;
+        } cast;
-                spl_ast_node_ref_t type_expr;
-                spl_ast_node_ref_vec_t expr_list;
-            } array_lit_expr;
-            struct {
-                const char *ident;
-                spl_ast_node_ref_vec_t expr_list;
-            } builtin_expr;
-            spl_ast_node_ref_vec_t block_expr; /* 语句 */
-        } primary_expr;
 
         struct {
-            const char *ident;
+            spl_ast_node_ref_vec_t elems;
-            spl_ast_node_ref_t expr;
+        } tuple;
-        } aggregate_init_item;
 
         struct {
-            spl_ast_node_ref_vec_t attr_list; /* attr_item */
+            bool has_len;
-            union {
+            isize len;
-                struct {
+            bool is_underscore_len;
-                    VEC(const char *) ident_vec;
+            spl_ast_node_ref_t elem_type;
-                } type_path;
+            spl_ast_node_ref_vec_t elems;
-                struct {
+        } array_literal;
-                    spl_ast_node_ref_t element;
+
-                    spl_ast_node_ref_t size;
+        struct {
-                } array_type;
+            spl_ast_node_ref_vec_t elems;
-                struct {
+        } anon_array_literal;
-                    spl_ast_node_ref_t element;
+
-                } slice_type;
+        struct {
-                struct {
+            const char *name;              /* 可空，匿名时为 NULL */
-                    spl_ast_node_ref_t pointee;
+            spl_ast_node_ref_vec_t fields; /* struct_init_item 节点列表 */
-                } pointer_type;
+        } aggregate_literal;
-                struct {
+
-                    spl_ast_node_ref_vec_t param_list; /* param_decl */
+        struct {
-                    spl_ast_node_ref_t type_expr;
+            const char *name;
-                } fn_type;
+            spl_ast_node_ref_vec_t args;
-                spl_ast_node_ref_vec_t aggregate_list; /* container_decl */
+        } comptime_call;
-            };
+
-        } type_expr;
+        struct {
+            spl_ast_node_ref_vec_t stmts;
+            spl_ast_node_ref_t tail_expr;
+        } block;
+
+        struct {
+            spl_ast_node_ref_t cond;
+            spl_ast_node_ref_t then_block;
+            spl_ast_node_ref_t else_branch;
+        } if_expr;
+
+        struct {
+            spl_ast_node_ref_t var_decl;
+            spl_ast_node_ref_t then_block;
+            spl_ast_node_ref_t else_branch;
+        } ifvar_expr;
+
+        struct {
+            spl_ast_node_ref_t label;
+            spl_ast_node_ref_t cond;
+            spl_ast_node_ref_t body;
+            spl_ast_node_ref_t else_branch;
+        } while_expr;
+
+        struct {
+            spl_ast_node_ref_t label;
+            spl_ast_node_ref_t body;
+        } loop_expr;
+
+        struct {
+            spl_ast_node_ref_t label;
+            spl_ast_node_ref_vec_t iter_exprs;
+            spl_ast_node_ref_vec_t idents;
+            spl_ast_node_ref_t body;
+            spl_ast_node_ref_t else_branch;
+        } for_expr;
+
+        struct {
+            spl_ast_node_ref_t matched_expr;
+            spl_ast_node_ref_vec_t arms; /* match_arm 节点 */
+        } match_expr;
+
+        struct {
+            bool is_comptime;
+            spl_ast_node_ref_vec_t params;
+            spl_ast_node_ref_t ret_type;
+        } fn_type;
+
+        /* ---- 类型子类型 ---- */
+        struct {
+            const char *name;
+            spl_ast_node_ref_vec_t generic_args;
+        } type_path;
+
+        struct {
+            spl_ast_node_ref_t pointee;
+        } type_pointer;
+
+        struct {
+            bool has_len;
+            isize len;
+            bool is_underscore_len;
+            spl_ast_node_ref_t elem_type;
+        } type_array;
+
+        struct {
+            spl_ast_node_ref_t elem_type;
+        } type_slice;
+
+        struct {
+            bool is_comptime;
+            spl_ast_node_ref_vec_t params;
+            spl_ast_node_ref_t ret_type;
+        } type_fn;
+
+        struct {
+            spl_ast_node_ref_vec_t types;
+        } type_paren;
+
+        struct {
+            const char *kind_name;
+            spl_ast_node_ref_vec_t members; /* aggregate_member 节点 */
+        } type_aggregate;
+
+        struct {
+            const char *name;
+            spl_ast_node_ref_vec_t args;
+        } type_comptime_call;
+
+        /* ---- 模式子类型 ---- */
+        struct {
+            const char *name;
+        } pattern_ident;
+
+        /* pattern_underscore 无数据 */
+
+        struct {
+            const char *name;
+            spl_ast_node_ref_t sub_pattern;
+        } pattern_dot;
+
+        struct {
+            spl_ast_node_ref_vec_t patterns;
+        } pattern_tuple;
+
+        struct {
+            spl_ast_node_ref_vec_t patterns;
+        } pattern_list;
     };
 };
 
 typedef VEC(spl_ast_node_t) spl_ast_node_vec_t;
-typedef VEC(char*)spl_ast_cstr_ref_vec_t;
+typedef VEC(char *) spl_ast_cstr_ref_vec_t;
 typedef struct {
     int parsed;
     spl_tok_vec_t input;
@@ -315,9 +498,10 @@ typedef struct {
 void spl_ast_init(spl_ast_t *ast, const spl_tok_vec_t *tok_vec /*move*/);
 void spl_ast_drop(spl_ast_t *ast);
 
-spl_ast_node_t* spl_ast_node(spl_ast_t *ast, spl_ast_node_ref_t node);
+spl_ast_node_t *spl_ast_node(spl_ast_t *ast, spl_ast_node_ref_t node);
+const char *spl_ast_node_name(spl_ast_node_t *node);
 
-void spl_ast_prase(spl_ast_t *ast);
+void spl_ast_parse(spl_ast_t *ast);
 void spl_ast_valid(spl_ast_t *ast);
 void spl_ast_dump(spl_ast_t *ast, spl_ast_node_ref_t node);
 

stage1/spl_ast2ir.c

@@ -10,8 +10,259 @@ static spl_type_id_t tid_from_def(const spl_sema_t *sema, spl_def_id_t def) {
     return d ? d->type_id : 0;
 }
 
-static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
+static spl_ir_node_ref_t transit(spl_ast2ir_t *ctx, spl_ast_node_ref_t ref);
-                                 spl_ast_node_ref_t ref) {
+
+static spl_ir_node_ref_t transit_op(spl_ir_builder_t *ir, spl_ast_node_kind_t kind,
+                                    spl_type_id_t tid, spl_ir_node_ref_t lref,
+                                    spl_ir_node_ref_t rref) {
+    spl_ir_node_ref_t ret = 0;
+    switch (kind) {
+    case SPL_AST_CMP_EQ_EXPR: {
+        ret = spl_ir_builder_cmp_eq(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_CMP_NE_EXPR: {
+        ret = spl_ir_builder_cmp_ne(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_CMP_LE_EXPR: {
+        ret = spl_ir_builder_cmp_le(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_CMP_GE_EXPR: {
+        ret = spl_ir_builder_cmp_ge(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_CMP_LT_EXPR: {
+        ret = spl_ir_builder_cmp_lt(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_CMP_GT_EXPR: {
+        ret = spl_ir_builder_cmp_gt(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_EXPR: {
+        ret = rref;
+    } break;
+    case SPL_AST_ASSIGN_LSHIFT_EXPR:
+    case SPL_AST_LSHIFT_EXPR: {
+        ret = spl_ir_builder_arith_shl(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_RSHIFT_EXPR:
+    case SPL_AST_RSHIFT_EXPR: {
+        ret = spl_ir_builder_arith_shr(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_ADD_EXPR:
+    case SPL_AST_ADD_EXPR: {
+        ret = spl_ir_builder_arith_add(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_SUB_EXPR:
+    case SPL_AST_ASSIGN_SUB_EXPR: {
+        ret = spl_ir_builder_arith_sub(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_MUL_EXPR:
+    case SPL_AST_MUL_EXPR: {
+        ret = spl_ir_builder_arith_mul(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_DIV_EXPR:
+    case SPL_AST_ASSIGN_DIV_EXPR: {
+        ret = spl_ir_builder_arith_div(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_MOD_EXPR:
+    case SPL_AST_MOD_EXPR: {
+        ret = spl_ir_builder_arith_rem(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_AND_EXPR:
+    case SPL_AST_BIT_AND_EXPR: {
+        ret = spl_ir_builder_arith_and(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_OR_EXPR:
+    case SPL_AST_BIT_OR_EXPR: {
+        ret = spl_ir_builder_arith_or(ir, tid, lref, rref);
+    } break;
+    case SPL_AST_ASSIGN_XOR_EXPR:
+    case SPL_AST_BIT_XOR_EXPR: {
+        ret = spl_ir_builder_arith_xor(ir, tid, lref, rref);
+    } break;
+    default:
+        UNREACHABLE();
+        break;
+    }
+    return ret;
+}
+
+static spl_ir_node_ref_t transit_expr(spl_ast2ir_t *ctx, spl_ast_node_ref_t ref, bool is_lval) {
+    spl_ir_builder_t *ir = ctx->ir;
+    const spl_sema_t *sema = ctx->sema;
+    if (ref == 0)
+        return 0;
+    Assert(sema != NULL);
+    spl_ast_node_t *n = spl_ast_node(sema->ast, ref);
+    spl_ir_node_ref_t ret = 0;
+    Assert(n != NULL);
+
+    switch (n->kind) {
+    case SPL_AST_PACKED_EXPR: {
+        TODO();
+    } break;
+    case SPL_AST_ASSIGN_EXPR: {
+        spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
+        spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, true);
+        ret = spl_ir_builder_mem_store(ir, n->resolved_type_id, lval, rval);
+    } break;
+    case SPL_AST_ASSIGN_ADD_EXPR:
+    case SPL_AST_ASSIGN_SUB_EXPR:
+    case SPL_AST_ASSIGN_MUL_EXPR:
+    case SPL_AST_ASSIGN_DIV_EXPR:
+    case SPL_AST_ASSIGN_MOD_EXPR:
+    case SPL_AST_ASSIGN_AND_EXPR:
+    case SPL_AST_ASSIGN_OR_EXPR:
+    case SPL_AST_ASSIGN_XOR_EXPR:
+    case SPL_AST_ASSIGN_LSHIFT_EXPR:
+    case SPL_AST_ASSIGN_RSHIFT_EXPR: {
+        spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
+        spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, false);
+        rval = transit_op(ir, n->kind, n->resolved_type_id, lval, rval);
+        lval = transit_expr(ctx, n->op_expr.left, true);
+        ret = spl_ir_builder_mem_store(ir, n->resolved_type_id, lval, rval);
+    } break;
+    case SPL_AST_CMP_EQ_EXPR:
+    case SPL_AST_CMP_NE_EXPR:
+    case SPL_AST_CMP_LE_EXPR:
+    case SPL_AST_CMP_GE_EXPR:
+    case SPL_AST_CMP_LT_EXPR:
+    case SPL_AST_CMP_GT_EXPR: {
+        spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
+        spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, false);
+        ret = transit_op(ir, n->kind, n->resolved_type_id, lval, rval);
+    } break;
+    case SPL_AST_RANGE_EXPR: {
+        TODO();
+    } break;
+    case SPL_AST_BOOL_OR_EXPR:
+    case SPL_AST_BOOL_AND_EXPR: {
+        TODO();
+    } break;
+    case SPL_AST_BIT_OR_EXPR:
+    case SPL_AST_BIT_XOR_EXPR:
+    case SPL_AST_BIT_AND_EXPR:
+    case SPL_AST_LSHIFT_EXPR:
+    case SPL_AST_RSHIFT_EXPR:
+    case SPL_AST_ADD_EXPR:
+    case SPL_AST_SUB_EXPR:
+    case SPL_AST_MUL_EXPR:
+    case SPL_AST_DIV_EXPR:
+    case SPL_AST_MOD_EXPR: {
+        spl_ir_node_ref_t rval = transit_expr(ctx, n->op_expr.right, false);
+        spl_ir_node_ref_t lval = transit_expr(ctx, n->op_expr.left, false);
+        // TODO assert type is bool
+        ret = transit_op(ir, n->kind, n->resolved_type_id, lval, rval);
+    } break;
+    case SPL_AST_MINUS_EXPR: {
+        ret = transit_expr(ctx, n->prefix_expr.postfix_expr, false);
+        ret = spl_ir_builder_arith_neg(ir, n->resolved_type_id, ret);
+    } break;
+    case SPL_AST_NOT_EXPR: {
+        ret = transit_expr(ctx, n->prefix_expr.postfix_expr, false);
+        ret = spl_ir_builder_arith_not(ir, n->resolved_type_id, ret);
+        TODO(); // return bool type
+    } break;
+    case SPL_AST_BIT_NOT_EXPR: {
+        ret = transit_expr(ctx, n->prefix_expr.postfix_expr, false);
+        ret = spl_ir_builder_arith_not(ir, n->resolved_type_id, ret);
+    } break;
+    case SPL_AST_ADDRESS_EXPR: {
+        TODO();
+    } break;
+    case SPL_AST_CALL_EXPR: {
+        spl_ast_node_t *fn_sym = spl_ast_node(ctx->sema->ast, n->postfix_expr.primary_expr);
+        Assert(fn_sym != NULL);
+        spl_def_node_t *dn = spl_def_node(sema->type, fn_sym->resolved_def_id);
+        Assert(dn != NULL);
+        spl_ir_node_ref_t ir_ref = 0;
+        if (!map_get(ctx->def2ir_map, fn_sym->resolved_def_id, &ir_ref)) {
+            Panic("can't resolved ir map in def2ir");
+        }
+        Assert(ir_ref != 0);
+
+        VEC(spl_ir_node_ref_t) params;
+        vec_init(params);
+        vec_for(n->postfix_expr.call_expr, i) {
+            spl_ast_node_ref_t param_node = vec_at(n->postfix_expr.call_expr, i);
+            spl_ir_node_ref_t ref = transit_expr(ctx, param_node, false);
+            vec_push(params, ref);
+        }
+        spl_ir_node_ref_t call_ref = spl_ir_builder_control_call(ir, n->resolved_type_id, ir_ref);
+        vec_for(params, i) { spl_ir_builder_control_call_param(ir, call_ref, vec_at(params, i)); }
+        vec_free(params);
+        ret = call_ref;
+    } break;
+    case SPL_AST_FIELD_EXPR:
+    case SPL_AST_DEREF_EXPR:
+    case SPL_AST_INDEX_EXPR:
+    case SPL_AST_SLICE_EXPR:
+    case SPL_AST_AS_EXPR:
+        TODO();
+        break;
+    case SPL_AST_EXPR_INTEGER_LIT: {
+        ret = spl_ir_builder_type_const_int(ir, n->resolved_type_id, n->primary_expr.integer_expr);
+        break;
+    }
+    case SPL_AST_EXPR_FLOAT_LIT:
+    case SPL_AST_EXPR_CHAR_LIT:
+    case SPL_AST_EXPR_STRING_LIT: {
+        TODO();
+    } break;
+    case SPL_AST_EXPR_TRUE: {
+        return spl_ir_builder_type_const_bool(
+            ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), true);
+    } break;
+    case SPL_AST_EXPR_FALSE: {
+        return spl_ir_builder_type_const_bool(
+            ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), false);
+    }
+    case SPL_AST_EXPR_NULL: {
+        return spl_ir_builder_type_const_bool(ir, n->resolved_type_id, 0);
+    } break;
+    case SPL_AST_EXPR_UNDEFINED:
+        return 0;
+    case SPL_AST_EXPR_IDENT: {
+        spl_def_node_t *dn = spl_def_node(sema->type, n->resolved_def_id);
+        Assert(dn != NULL);
+        spl_ir_node_ref_t ir_ref = 0;
+        if (!map_get(ctx->def2ir_map, n->resolved_def_id, &ir_ref)) {
+            Panic("can't resolved ir map in def2ir");
+        }
+        Assert(ir_ref != 0);
+        if (is_lval) {
+            return ir_ref;
+        } else {
+            return spl_ir_builder_mem_load(ir, dn->type_id, ir_ref);
+        }
+    } break;
+    case SPL_AST_ARGGREGATE_INIT: {
+        vec_for(n->primary_expr.aggregate_init.expr, i) {
+            transit_expr(ctx, vec_at(n->primary_expr.aggregate_init.expr, i), false);
+        }
+    } break;
+    case SPL_AST_EXPR_EXPR: {
+        transit_expr(ctx, n->primary_expr.expr, is_lval);
+    } break;
+    case SPL_AST_ARRAY_LIT: {
+        TODO();
+    } break;
+    case SPL_AST_BUILTIN_EXPR: {
+        TODO();
+    } break;
+    case SPL_AST_BLOCK_EXPR: {
+        vec_for(n->primary_expr.block_expr, i) {
+            transit(ctx, vec_at(n->primary_expr.block_expr, i));
+        }
+    } break;
+    default:
+        UNREACHABLE();
+        break;
+    }
+    return ret;
+}
+
+static spl_ir_node_ref_t transit(spl_ast2ir_t *ctx, spl_ast_node_ref_t ref) {
+    spl_ir_builder_t *ir = ctx->ir;
+    const spl_sema_t *sema = ctx->sema;
     if (ref == 0)
         return 0;
     Assert(sema != NULL);
@@ -24,7 +275,7 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
         UNREACHABLE();
         break;
     case SPL_AST_CONTAINER_MEMBERS: {
-        vec_for(n->container_members, i) { transit(ir, sema, vec_at(n->container_members, i)); }
+        vec_for(n->container_members, i) { transit(ctx, vec_at(n->container_members, i)); }
     } break;
     case SPL_AST_FN_DECL:
         TODO();
@@ -34,26 +285,43 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
         spl_type_node_t *fn_type = spl_type_node(sema->type, tid);
         Assert(fn_type && fn_type->kind == SPL_TYPE_FN);
         // n->fn_decl.attr_list; TODO @extern(vm) using extern attribute
-        spl_ir_builder_fn_begin(ir, n->fn_decl.name, tid, (spl_ir_attr_t){0} /*TODO*/);
+        spl_ir_func_ref_t fn_ref =
-
+            spl_ir_builder_fn_begin(ir, n->fn_decl.name, tid, (spl_ir_attr_t){0} /*TODO*/);
+        Assert(fn_ref != 0);
         spl_ir_builder_block_begin(ir);
-        vec_for(n->fn_decl.block, i) { transit(ir, sema, vec_at(n->fn_decl.block, i)); }
+
+        map_put(ctx->def2ir_map, n->resolved_def_id, fn_ref);
+        vec_for(n->fn_decl.param_list, i) {
+            spl_ast_node_ref_t nref = vec_at(n->fn_decl.param_list, i);
+            spl_ast_node_t *n = spl_ast_node(sema->ast, nref);
+            spl_type_id_t tid = tid_from_def(sema, n->resolved_def_id);
+            spl_ir_node_ref_t idx_ref = spl_ir_const_comptime_int(ir, sema, i);
+            spl_ir_node_ref_t var_ref = spl_ir_builder_control_param(ir, tid, idx_ref);
+            map_put(ctx->def2ir_map, n->resolved_def_id, var_ref);
+        }
+
+        transit(ctx, n->fn_decl.block);
         if (!ir->terminated) {
+            // FIXME
             spl_ir_builder_control_ret(ir, n->fn_decl.type_expr, 0);
         }
         spl_ir_builder_block_end(ir);
         spl_ir_builder_fn_end(ir);
 
     } break;
-    case SPL_AST_TYPE_DECL:
+    case SPL_AST_TYPE_DECL: {
-        TODO();
+        transit(ctx, n->type_decl.type_expr);
-        break;
+    } break;
     case SPL_AST_VAR_DECL: {
         spl_type_id_t tid = tid_from_def(sema, n->resolved_def_id);
         spl_ir_node_ref_t var_ref =
             spl_ir_builder_mem_alloca(ir, tid, spl_ir_const_comptime_int(ir, sema, 1));
+        map_put(ctx->def2ir_map, n->resolved_def_id, var_ref);
         if (n->var_const_decl.expr) {
-            spl_ir_builder_mem_store(ir, tid, var_ref, transit(ir, sema, n->var_const_decl.expr));
+            spl_ir_node_ref_t expr_ref = transit_expr(ctx, n->var_const_decl.expr, false);
+            if (expr_ref != 0) { // 0 means undefined
+                spl_ir_builder_mem_store(ir, tid, var_ref, expr_ref);
+            }
         }
     } break;
     case SPL_AST_CONST_DECL: {
@@ -64,31 +332,74 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
         break;
     case SPL_AST__COMPTIME_STMT:
     case SPL_AST__DIRECTIVE_BLOCK:
-    case SPL_AST_PARAM_DECL:
+    case SPL_AST_PARAM_DECL: {
-        break;
+        UNREACHABLE();
+    } break;
     case SPL_AST_ATTR_ITEM:
     case SPL_AST_ARGG_INIT_ITEM: {
         TODO();
     } break;
     case SPL_AST_IF_STATEMENT: {
-        spl_ir_node_ref_t ref = transit(ir, sema, n->if_statement.expr);
+        spl_ir_node_ref_t ref = transit_expr(ctx, n->if_statement.expr, false);
         ref = spl_ir_builder_control_br(ir, ref);
         spl_ir_builder_block_end(ir);
+
         usize true_block = spl_ir_builder_block_begin(ir);
+        transit_expr(ctx, n->if_statement.if_block, false);
+        usize true_ref = spl_ir_builder_control_jmp(ir);
+        spl_ir_builder_block_end(ir);
 
         usize false_block = spl_ir_builder_block_begin(ir);
+        transit_expr(ctx, n->if_statement.else_block, false);
+        usize false_ref = spl_ir_builder_control_jmp(ir);
+        spl_ir_builder_block_end(ir);
+
+        usize end_block = spl_ir_builder_block_begin(ir);
+        spl_ir_builder_control_jmp_fixup(ir, true_ref, end_block);
+        spl_ir_builder_control_jmp_fixup(ir, false_ref, end_block);
         spl_ir_builder_control_br_fixup(ir, ref, true_block, false_block);
     } break;
-    case SPL_AST_IFVAR_STATEMENT:
+    case SPL_AST_IFVAR_STATEMENT: {
-    case SPL_AST_WHILE_STATEMENT:
+        TODO();
-    case SPL_AST_LOOP_STATEMENT:
+    } break;
+    case SPL_AST_WHILE_STATEMENT: {
+        spl_ir_node_ref_t end_ref = spl_ir_builder_control_jmp(ir);
+        spl_ir_builder_block_end(ir);
+
+        usize cond_block = spl_ir_builder_block_begin(ir);
+        spl_ir_node_ref_t cond_expr_ref = transit_expr(ctx, n->while_statement.expr, false);
+        spl_ir_node_ref_t cond_ref = spl_ir_builder_control_br(ir, cond_expr_ref);
+        spl_ir_builder_block_end(ir);
+
+        usize true_block = spl_ir_builder_block_begin(ir);
+        transit_expr(ctx, n->while_statement.while_block, false);
+        usize true_ref = spl_ir_builder_control_jmp(ir);
+        spl_ir_builder_block_end(ir);
+
+        usize end_block = spl_ir_builder_block_begin(ir);
+        spl_ir_builder_control_jmp_fixup(ir, true_ref, cond_block);
+        spl_ir_builder_control_br_fixup(ir, cond_ref, true_block, end_block);
+    } break;
+    case SPL_AST_LOOP_STATEMENT: {
+        usize end_ref = spl_ir_builder_control_jmp(ir);
+        spl_ir_builder_block_end(ir);
+
+        usize loop_block = spl_ir_builder_block_begin(ir);
+        spl_ir_node_ref_t loop_expr_ref = transit_expr(ctx, n->loop_statement.loop_block, false);
+        usize loop_ref = spl_ir_builder_control_jmp(ir);
+        spl_ir_builder_block_end(ir);
+
+        usize end_block = spl_ir_builder_block_begin(ir);
+        spl_ir_builder_control_jmp_fixup(ir, end_ref, loop_block);
+        spl_ir_builder_control_jmp_fixup(ir, loop_ref, loop_block);
+    } break;
     case SPL_AST_FOR_STATEMENT:
     case SPL_AST_MATCH_STATEMENT:
         TODO();
         break;
     case SPL_AST_RET_STATEMENT: {
         if (n->ret_statement.expr) {
-            ret = transit(ir, sema, n->ret_statement.expr);
+            ret = transit(ctx, n->ret_statement.expr);
         }
         ret = spl_ir_builder_control_ret(ir, n->resolved_type_id, ret);
     } break;
@@ -99,6 +410,8 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
     case SPL_AST_CATCH_STATEMENT:
     case SPL_AST_ERRDEFER_STATEMEMT:
     case SPL_AST_EXPR_STATEMENT:
+        TODO();
+        break;
     case SPL_AST_PACKED_EXPR:
     case SPL_AST_ASSIGN_EXPR:
     case SPL_AST_ASSIGN_ADD_EXPR:
@@ -110,7 +423,7 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
     case SPL_AST_ASSIGN_OR_EXPR:
     case SPL_AST_ASSIGN_XOR_EXPR:
     case SPL_AST_ASSIGN_LSHIFT_EXPR:
-    case SPL_AST_ASSIGN_USHIFT_EXPR:
+    case SPL_AST_ASSIGN_RSHIFT_EXPR:
     case SPL_AST_BOOL_OR_EXPR:
     case SPL_AST_BOOL_AND_EXPR:
     case SPL_AST_BIT_OR_EXPR:
@@ -140,55 +453,24 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
     case SPL_AST_INDEX_EXPR:
     case SPL_AST_SLICE_EXPR:
     case SPL_AST_AS_EXPR:
-        TODO();
+    case SPL_AST_EXPR_INTEGER_LIT:
-        break;
-    case SPL_AST_EXPR_INTEGER_LIT: {
-        ret = spl_ir_builder_type_const_int(ir, n->resolved_type_id, n->primary_expr.integer_expr);
-        break;
-    }
     case SPL_AST_EXPR_FLOAT_LIT:
     case SPL_AST_EXPR_CHAR_LIT:
-    case SPL_AST_EXPR_STRING_LIT: {
+    case SPL_AST_EXPR_STRING_LIT:
-        TODO();
+    case SPL_AST_EXPR_TRUE:
-    } break;
+    case SPL_AST_EXPR_FALSE:
-    case SPL_AST_EXPR_TRUE: {
+    case SPL_AST_EXPR_NULL:
-        return spl_ir_builder_type_const_bool(
-            ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), true);
-    } break;
-    case SPL_AST_EXPR_FALSE: {
-        return spl_ir_builder_type_const_bool(
-            ir, spl_type_builder_simple(sema->type, SPL_TYPE_BOOL), false);
-    }
-    case SPL_AST_EXPR_NULL: {
-        return spl_ir_builder_type_const_bool(ir, n->resolved_type_id, 0);
-    } break;
     case SPL_AST_EXPR_UNDEFINED:
-        break;
+    case SPL_AST_EXPR_IDENT:
-    case SPL_AST_EXPR_IDENT: {
+    case SPL_AST_ARGGREGATE_INIT:
-    } break;
+    case SPL_AST_EXPR_EXPR:
-    case SPL_AST_ARGGREGATE_INIT: {
+    case SPL_AST_ARRAY_LIT:
-        vec_for(n->primary_expr.aggregate_init.expr, i) {
+    case SPL_AST_BUILTIN_EXPR:
-            transit(ir, sema, vec_at(n->primary_expr.aggregate_init.expr, i));
-        }
-    } break;
-    case SPL_AST_EXPR_EXPR: {
-        transit(ir, sema, n->primary_expr.expr);
-    } break;
-    case SPL_AST_ARRAY_LIT: {
-        TODO();
-    } break;
-    case SPL_AST_BUILTIN_EXPR: {
-        TODO();
-    } break;
     case SPL_AST_BLOCK_EXPR: {
-        vec_for(n->primary_expr.block_expr, i) {
+        return transit_expr(ctx, ref, false);
-            transit(ir, sema, vec_at(n->primary_expr.block_expr, i));
+    }
-        }
-    } break;
     case SPL_AST_BASE_TYPE_FN:
     case SPL_AST_BASE_TYPE_PATH:
-        TODO();
-        break;
     case SPL_AST_TYPE_POINTER:
     case SPL_AST_TYPE_ARRAY:
     case SPL_AST_TYPE_SLICE:
@@ -213,20 +495,24 @@ static spl_ir_node_ref_t transit(spl_ir_builder_t *ir, const spl_sema_t *sema,
     case SPL_AST_TYPE__F64:
     case SPL_AST_TYPE_ANY:
     case SPL_AST_TYPE_IDENT:
-        break;
+    case SPL_AST_COUNT: {
-    case SPL_AST_COUNT:
         UNREACHABLE();
         break;
     }
+    }
     return ret;
 }
 
-void spl_ast2ir_init(spl_ast2ir_t *ast2ir, spl_ir_builder_t *ir, const spl_sema_t *sema) {
+static usize hash_int(spl_def_id_t k) { return MAP_HASH_INT(k); }
-    ast2ir->sema = sema;
+static int cmp_int(spl_def_id_t k1, spl_def_id_t k2) { return MAP_CMP_INT(k1, k2); }
-    ast2ir->ir = ir;
+
-    ast2ir->err_count = 0;
+void spl_ast2ir_init(spl_ast2ir_t *ctx, spl_ir_builder_t *ir, const spl_sema_t *sema) {
+    ctx->sema = sema;
+    ctx->ir = ir;
+    map_init(ctx->def2ir_map, hash_int, cmp_int);
+    ctx->err_count = 0;
 }
 
-void spl_ast2ir_drop(spl_ast2ir_t *ast2ir) {}
+void spl_ast2ir_drop(spl_ast2ir_t *ctx) { map_free(ctx->def2ir_map); }
 
-void spl_ast2ir_run(spl_ast2ir_t *ctx) { transit(ctx->ir, ctx->sema, ctx->sema->ast->root); }
+void spl_ast2ir_run(spl_ast2ir_t *ctx) { transit(ctx, ctx->sema->ast->root); }

stage1/spl_ast2ir.h

@@ -4,9 +4,11 @@
 #include "spl_ir.h"
 #include "spl_sema.h"
 
+typedef MAP(spl_def_id_t, spl_ir_node_ref_t) spl_def2ir_map_t;
 typedef struct {
     const spl_sema_t *sema;
     spl_ir_builder_t *ir;
+    spl_def2ir_map_t def2ir_map;
     int err_count;
 } spl_ast2ir_t;
 

stage1/spl_dbg.h

@@ -11,15 +11,15 @@ typedef struct {
 } spl_dbg_node_t;
 
 #define SPL_FATAL(dbg, fmt, ...)                                                                   \
-    LOG_FATAL("fatal at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"),       \
+    LOG_FATAL("fatal at %s:%d:%d " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"),         \
               ((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
 
 #define SPL_ERROR(dbg, fmt, ...)                                                                   \
-    LOG_ERROR("error at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"),       \
+    LOG_ERROR("error at %s:%d:%d " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"),         \
               ((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
 
 #define SPL_WARN(dbg, fmt, ...)                                                                    \
-    LOG_ERROR("warn at %s:%zd:%zd " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"),        \
+    LOG_ERROR("warn at %s:%d:%d " fmt, ((dbg) && (dbg)->fname ? (dbg)->fname : "<null>"),          \
               ((dbg) ? (dbg)->line : 0), ((dbg) ? (dbg)->col : 0), ##__VA_ARGS__)
 
 #endif /* __SPL_DBG_H__ */

stage1/spl_ir.c

@@ -113,12 +113,15 @@ static void ir_dump_node(const spl_type_t *ty, spl_ir_node_t *n) {
     case SPL_IR_ARITH_XOR:
     case SPL_IR_ARITH_SHL:
     case SPL_IR_ARITH_SHR:
+        ir_dump_type(ty, n->arith.tid);
+        ir_dump_ref(n->arith.left);
+        ir_dump_ref(n->arith.right);
+        break;
     case SPL_IR_ARITH_NEG:
     case SPL_IR_ARITH_ABS:
     case SPL_IR_ARITH_NOT:
         ir_dump_type(ty, n->arith.tid);
         ir_dump_ref(n->arith.left);
-        ir_dump_ref(n->arith.right);
         break;
     case SPL_IR_CMP_EQ:
     case SPL_IR_CMP_NE:
@@ -272,7 +275,7 @@ void spl_ir_dump(spl_ir_t *ir, const spl_type_t *ty) {
         if (i == 0)
             continue;
         spl_ir_func_t *func = &vec_at(ir->funcs, i);
-        printf("func %s", func->name ? func->name : "?");
+        printf("func %s %%%zu", func->name ? func->name : "?", i);
         printf(" tid=");
         spl_type_pure_dump((spl_type_t *)ty, func->fn_tid);
         printf("\n");
@@ -739,9 +742,9 @@ spl_ir_node_ref_t spl_ir_builder_control_call(spl_ir_builder_t *b, spl_type_id_t
     return ref;
 }
 
-void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t node,
+void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t call_node,
                                        spl_ir_node_ref_t arg) {
-    spl_ir_node_t *n = spl_ir_node(&b->ir, b->current_fn, node);
+    spl_ir_node_t *n = spl_ir_node(&b->ir, b->current_fn, call_node);
     Assert(n != NULL);
     vec_push(n->control_call.params, arg);
 }

stage1/spl_ir.h

@@ -409,7 +409,7 @@ void spl_ir_builder_control_jmp_fixup(spl_ir_builder_t *b, spl_ir_node_ref_t ref
                                       usize target_block);
 spl_ir_node_ref_t spl_ir_builder_control_call(spl_ir_builder_t *b, spl_type_id_t tid,
                                               spl_ir_node_ref_t func);
-void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t node,
+void spl_ir_builder_control_call_param(spl_ir_builder_t *b, spl_ir_node_ref_t call_node,
                                        spl_ir_node_ref_t arg);
 spl_ir_node_ref_t spl_ir_builder_control_param(spl_ir_builder_t *b, spl_type_id_t tid,
                                                spl_ir_node_ref_t idx);

stage1/spl_ir2vm.h

@@ -4,98 +4,27 @@
 #include "spl_ir.h"
 #include "spl_type.h"
 
-/*
+#include "../stage0/spl_mcode.h"
- * ================================================================
- * SPL VM ABI (ir2vm 的正式约定；布局知识唯一来源)
- * ================================================================
- *
- * 栈值槽 spl_val_t = sizeof(usize) = 8 字节。
- * SIR 指令 type 只表达标量 tag（SPL_I8..SPL_PTR），聚合无 tag——
- * 聚合值在 vreg 中是字节块，整体搬运用 NCALL vm_memcpy。
- *
- * ── 函数栈帧（字节坐标系，基址 = (char*)&stacks[fp]）─────────────
- *
- *   [canary]                       fp-8 .. 0     （VM CALL 自动插入，ir2vm 不触碰）
- *   [params 区]                    fp+0 .. fp+Na （Na = C ABI 参数区字节数）
- *   [locals / vreg]                fp+Na .. fp+Na+L
- *
- *   ALLOC ceil((Na+L)/8) 一条 prologue；epilogue 走 RET。
- *   LADDR(imm) 的 imm 是字节偏移；canary 在 fp-1 槽，编译码不可见。
- *
- * ── 参数区 = C ABI（聚合值按值） ─────────────────────────────────
- *   标量参数：align_up(off,8) 后占 8 字节（一槽）。
- *   聚合参数：按聚合 size 排布跨多槽（align8 + size）。
- *   调用方：标量 ld/PUSH 一槽；聚合逐 8 字节块压栈（聚合 vreg 强制 8 对齐）。
- *   被调方：标量参数映射参数槽；聚合参数在 prologue memcpy 参数区 → param vreg，
- *           emit_value(param) 取 vreg 地址。参数槽数 = ceil(param_bytes/8) = CALL nargs。
- *
- * ── locals = 虚拟寄存器区 ────────────────────────────────────────
- *   每个产生值的 IR 节点 = 一个 vreg（locals 区按类型对齐的字节块）。
- *   纯值节点（type.const / mem.global_alloc / mem.alloca / 折叠 sizeof 等）不落 vreg，
- *   引用处重算（PUSH / GADDR / LADDR）；其余产生值节点落 vreg，引用处 LOAD。
- *   聚合 vreg 引用处返回其地址（LADDR），搬运经 vm_memcpy。
- *   mem.alloca(tid)(cnt) 的 vreg 槽即缓冲区本体，节点值 = LADDR(vreg_off)。
- *   所有运算走 load/store：ld A; ld B; op; st Dst；立即数直接 PUSH。
- *
- * ── 调用 ──────────────────────────────────────────────────────────
- *   调用方：逐参数压栈（标量一槽；聚合按 C ABI 逐 8 字节块）→ push fn_addr(或
- *           native_idx) → CALL n / NCALL n。返回值落 call 节点 vreg。
- *   原生函数：IR 中 nodes 为空的函数（@extern 声明）→ 注册进 prog.natives，
- *             加载时由 spl_syscall_register 填 impl；调用改 PUSH nat_idx + NCALL。
- *             变参 nargs = 实际参数槽数。
- *
- * ── enum（不展开，直接保留）─────────────────────────────────────
- *   IR 层保留 enum 类型（不再展开为 struct）。enum 布局 = tag(usize, offset 0)
- *   + payload(offset 8，最大变体）。构造：agg.construct(enum)(tag, payload)；
- *   match：先取 tag 判定变体，再 extract(enum, 1) 一跳取 payload，
- *   field_tid = 变体具体类型（由 ast2ir 传入）。
- *
- * ── 返回 ──────────────────────────────────────────────────────────
- *   标量：ld vreg(val); RET(tag)（RET 的 type 决定 VM 是否弹出返回值）。
- *   聚合返回 = sret（自展开，不改 VM）：
- *     被调函数签名尾部追加隐藏 *T 参数（最后一个）；返回时把聚合 vreg
- *     memcpy 到 sret 地址，RET(void)。
- *     调用方在 locals 预留聚合槽（= call 节点 vreg），压其地址为最后实参；
- *     call 完成后聚合值已在该槽。
- *   返回 void：RET(SPL_VOID)。
- *
- * ── 全局数据 ──────────────────────────────────────────────────────
- *   任何聚合类型下（含 $root 顶层）的 var/const 属全局数据区。gdata 是
- *   spl_ir_node_vec_t，每条 = 一个 value 节点（type.const：标量折叠值，
- *   聚合/无 init 零）。ir2vm 遍历求值 → SIR gdata 条目（字节 blob）。
- *   mem.global_alloc(tid, const_node) 的 const_node = gdata 向量索引，
- *   降级为 GADDR(idx)。符号(def) → gdata 索引的解析在 ast2ir 收集期
- *   （gdata_ref 表），ir2vm 按索引直接用。
- *
- * ── 类型布局（C ABI，唯一实现处）────────────────────────────────
- *   type_align / type_size / field_offset：标量按 bits/8 对齐；
- *   struct 顺序对齐 + 尾填充；union 取最大字段；enum = tag(8) + 最大 payload；
- *   slice/range = [ptr, len] 各 8 字节；array = len * elem。
- *
- * ── 分支 ──────────────────────────────────────────────────────────
- *   control.br/jmp/select 的 label 是 IR node ref（基本块首指令）。两遍发射：
- *   第一遍逐节点发指令并记录 label 节点 → 指令地址；第二遍回填
- *   JMP/BZ/BNZ 相对偏移 imm = target_addr - (jmp_addr + 1)。
- * ================================================================
- */
 
-/* 调试映射：每函数 IR 节点 → 首条指令 ip（调试器显示当前 IR 节点用） */
 typedef struct {
     spl_ir_func_ref_t fid;
-    VEC(usize) node_first_ip; /* 索引 = IR 节点 ref，值 = 该节点首指令绝对 ip */
+    VEC(usize) node_first_ip;
 } spl_ir2vm_fdbg_t;
 typedef VEC(spl_ir2vm_fdbg_t) spl_ir2vm_fdbg_vec_t;
 
+// MAP()
 typedef struct {
     const spl_ir_t *ir;
     const spl_type_t *type;
-    spl_ir2vm_fdbg_vec_t fdbg; /* ir2vm_run 后填充；splc0 -g 读取生成 debug 段 */
+    spl_prog_t prog;
+
+    // spl_ir2vm_fdbg_vec_t fdbg; /* ir2vm_run 后填充；splc0 -g 读取生成 debug 段 */
 } spl_ir2vm_t;
 
 void spl_ir2vm_init(spl_ir2vm_t *ctx, const spl_ir_t *ir, const spl_type_t *type);
 void spl_ir2vm_drop(spl_ir2vm_t *ctx);
 
-int spl_ir2vm_run(spl_ir2vm_t *ctx, const char *outpath); /* 返回错误数 */
+int spl_ir2vm_run(spl_ir2vm_t *ctx);
 void spl_ir2vm_dump(spl_ir2vm_t *ctx);
 
 #endif /* __SPL_IR2VM_H__ */

stage1/spl_lexer.c

@@ -349,6 +349,22 @@ spl_tok_vec_t spl_lex(const char *source, const char *fname) {
         }
 
         /* Multi-character operators (longest match) */
+#define TRY_OP1(c1, tok1)                                                                          \
+    if (c == (c1)) {                                                                               \
+        spl_tok_t tok;                                                                             \
+        memset(&tok, 0, sizeof(tok));                                                              \
+        tok.type = (tok1);                                                                         \
+        tok.lexeme = start;                                                                        \
+        tok.len = 1;                                                                               \
+        tok.fname = fname;                                                                         \
+        tok.offset = offset;                                                                       \
+        tok.line = line;                                                                           \
+        tok.col = col;                                                                             \
+        vec_push(toks, tok);                                                                       \
+        offset++;                                                                                  \
+        col++;                                                                                     \
+        continue;                                                                                  \
+    }
 
 /* Helper: try to match a two-char operator */
 #define TRY_OP2(c1, c2, tok2, tok1)                                                                \
@@ -394,13 +410,15 @@ spl_tok_vec_t spl_lex(const char *source, const char *fname) {
     }
 
         /* Three-char operators first */
+        TRY_OP3('<', '-', '>', TOK_ARROW_BOTH, TOK_RIGHT_ARROW, TOK_LT)
+        TRY_OP3('<', '=', '>', TOK_FAT_ARROW_BOTH, TOK_RIGHT_FAT_ARROW, TOK_LT)
         TRY_OP3('<', '<', '=', TOK_ASSIGN_L_SH, TOK_L_SH, TOK_LT)
         TRY_OP3('>', '>', '=', TOK_ASSIGN_R_SH, TOK_R_SH, TOK_GT)
         TRY_OP3('.', '.', '.', TOK_ELLIPSIS, TOK_RANGE, TOK_DOT)
 
         /* Two-char operators */
         TRY_OP2('=', '=', TOK_EQ, TOK_ASSIGN)
-        TRY_OP2('=', '>', TOK_FAT_ARROW, TOK_ASSIGN)
+        TRY_OP2('=', '>', TOK_RIGHT_FAT_ARROW, TOK_ASSIGN)
         TRY_OP2('!', '=', TOK_NEQ, TOK_NOT)
         TRY_OP2('<', '=', TOK_LE, TOK_LT)
         TRY_OP2('>', '=', TOK_GE, TOK_GT)
@@ -414,110 +432,53 @@ spl_tok_vec_t spl_lex(const char *source, const char *fname) {
         TRY_OP2('&', '=', TOK_ASSIGN_AND, TOK_AND)
         TRY_OP2('|', '=', TOK_ASSIGN_OR, TOK_OR)
         TRY_OP2('^', '=', TOK_ASSIGN_XOR, TOK_XOR)
-        TRY_OP2('<', '-', TOK_LEFT_ARRAY, TOK_LT)
+        TRY_OP2('<', '-', TOK_LEFT_ARROW, TOK_LT)
-        TRY_OP2('-', '>', TOK_RIGHT_ARRAY, TOK_SUB)
+        TRY_OP2('-', '>', TOK_RIGHT_ARROW, TOK_SUB)
         TRY_OP2(':', '=', TOK_COLON_ASSIGN, TOK_COLON)
 
         /* Single-character operators */
-        {
+        TRY_OP1('+', TOK_ADD);
-            spl_tok_type_t tt = TOK_UNKNOWN;
+        TRY_OP1('-', TOK_SUB);
-            switch (c) {
+        TRY_OP1('*', TOK_MUL);
-            case '+':
+        TRY_OP1('/', TOK_DIV);
-                tt = TOK_ADD;
+        TRY_OP1('%', TOK_MOD);
-                break;
+        TRY_OP1('&', TOK_AND);
-            case '-':
+        TRY_OP1('|', TOK_OR);
-                tt = TOK_SUB;
+        TRY_OP1('^', TOK_XOR);
-                break;
+        TRY_OP1('~', TOK_BIT_NOT);
-            case '*':
+        TRY_OP1('!', TOK_NOT);
-                tt = TOK_MUL;
+        TRY_OP1('<', TOK_LT);
-                break;
+        TRY_OP1('>', TOK_GT);
-            case '/':
+        TRY_OP1('=', TOK_ASSIGN);
-                tt = TOK_DIV;
+        TRY_OP1('.', TOK_DOT);
-                break;
+        TRY_OP1(',', TOK_COMMA);
-            case '%':
+        TRY_OP1(';', TOK_SEMICOLON);
-                tt = TOK_MOD;
+        TRY_OP1(':', TOK_COLON);
-                break;
+        TRY_OP1('(', TOK_L_PAREN);
-            case '&':
+        TRY_OP1(')', TOK_R_PAREN);
-                tt = TOK_AND;
+        TRY_OP1('[', TOK_L_BRACKET);
-                break;
+        TRY_OP1(']', TOK_R_BRACKET);
-            case '|':
+        TRY_OP1('{', TOK_L_BRACE);
-                tt = TOK_OR;
+        TRY_OP1('}', TOK_R_BRACE);
-                break;
+        TRY_OP1('#', TOK_SHARP);
-            case '^':
+        TRY_OP1('@', TOK_AT);
-                tt = TOK_XOR;
+        TRY_OP1('$', TOK_DOLLAR);
-                break;
+        TRY_OP1('?', TOK_COND);
-            case '~':
-                tt = TOK_BIT_NOT;
-                break;
-            case '!':
-                tt = TOK_NOT;
-                break;
-            case '<':
-                tt = TOK_LT;
-                break;
-            case '>':
-                tt = TOK_GT;
-                break;
-            case '=':
-                tt = TOK_ASSIGN;
-                break;
-            case '.':
-                tt = TOK_DOT;
-                break;
-            case ',':
-                tt = TOK_COMMA;
-                break;
-            case ';':
-                tt = TOK_SEMICOLON;
-                break;
-            case ':':
-                tt = TOK_COLON;
-                break;
-            case '(':
-                tt = TOK_L_PAREN;
-                break;
-            case ')':
-                tt = TOK_R_PAREN;
-                break;
-            case '[':
-                tt = TOK_L_BRACKET;
-                break;
-            case ']':
-                tt = TOK_R_BRACKET;
-                break;
-            case '{':
-                tt = TOK_L_BRACE;
-                break;
-            case '}':
-                tt = TOK_R_BRACE;
-                break;
-            case '#':
-                tt = TOK_SHARP;
-                break;
-            case '@':
-                tt = TOK_AT;
-                break;
-            case '?':
-                tt = TOK_COND;
-                break;
-            default:
-                tt = TOK_UNKNOWN;
-                break;
-            }
 
-            spl_tok_t tok;
+        // TODO
-            memset(&tok, 0, sizeof(tok));
+        spl_tok_t tok;
-            tok.type = tt;
+        memset(&tok, 0, sizeof(tok));
-            tok.lexeme = start;
+        tok.type = TOK_UNKNOWN;
-            tok.len = 1;
+        tok.lexeme = start;
-            tok.fname = fname;
+        tok.len = 1;
-            tok.offset = offset;
+        tok.fname = fname;
-            tok.line = line;
+        tok.offset = offset;
-            tok.col = col;
+        tok.line = line;
-            vec_push(toks, tok);
+        tok.col = col;
-            offset++;
+        vec_push(toks, tok);
-            col++;
+        offset++;
-        }
+        col++;
+        continue;
     }
 
     /* EOF token */

stage1/spl_sema.c

@@ -341,7 +341,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
 
         spl_type_id_t old_ret = sema->current_fn_ret_tid;
         sema->current_fn_ret_tid = ret_id;
-        vec_for(n->fn_decl.block, i) { sema_parse(sema, vec_at(n->fn_decl.block, i)); }
+        sema_parse(sema, n->fn_decl.block);
         sema->current_fn_ret_tid = old_ret;
         sema_pop_scope(sema);
     } break;
@@ -478,23 +478,15 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
             SPL_ERROR(&n->dbg, "if condition must be bool");
             sema->error_count++;
         }
-        vec_for(n->if_statement.if_block, i) {
+        sema_parse(sema, n->if_statement.if_block);
-            sema_parse(sema, vec_at(n->if_statement.if_block, i));
+        sema_parse(sema, n->if_statement.else_block);
-        }
-        vec_for(n->if_statement.else_block, i) {
-            sema_parse(sema, vec_at(n->if_statement.else_block, i));
-        }
     } break;
     case SPL_AST_IFVAR_STATEMENT: {
         if (n->ifvar_statement.packed_expr) {
             sema_parse(sema, n->ifvar_statement.packed_expr);
         }
-        vec_for(n->ifvar_statement.if_block, i) {
+        sema_parse(sema, n->ifvar_statement.if_block);
-            sema_parse(sema, vec_at(n->ifvar_statement.if_block, i));
+        sema_parse(sema, n->ifvar_statement.else_block);
-        }
-        vec_for(n->ifvar_statement.else_block, i) {
-            sema_parse(sema, vec_at(n->ifvar_statement.else_block, i));
-        }
     } break;
     case SPL_AST_WHILE_STATEMENT: {
         if (!n->while_statement.expr) {
@@ -506,14 +498,10 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
             SPL_ERROR(&n->dbg, "while condition must be bool");
             sema->error_count++;
         }
-        vec_for(n->while_statement.while_block, i) {
+        sema_parse(sema, n->while_statement.while_block);
-            sema_parse(sema, vec_at(n->while_statement.while_block, i));
-        }
     } break;
     case SPL_AST_LOOP_STATEMENT: {
-        vec_for(n->loop_statement.loop_block, i) {
+        sema_parse(sema, n->loop_statement.loop_block);
-            sema_parse(sema, vec_at(n->loop_statement.loop_block, i));
-        }
     } break;
     case SPL_AST_FOR_STATEMENT: {
         sema_push_scope(sema);
@@ -531,7 +519,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
                 spl_scope_insert(sema->scope, sema->scope->current_scope, symbol);
             }
         }
-        vec_for(n->for_statement.block, j) { sema_parse(sema, vec_at(n->for_statement.block, j)); }
+        sema_parse(sema, n->for_statement.block);
         sema_pop_scope(sema);
     } break;
     case SPL_AST_MATCH_STATEMENT: {
@@ -541,9 +529,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
         vec_for(n->match_statement.paced_exprs, i) {
             sema_parse(sema, vec_at(n->match_statement.paced_exprs, i));
         }
-        vec_for(n->match_statement.match_block, i) {
+        sema_parse(sema, n->match_statement.match_block);
-            sema_parse(sema, vec_at(n->match_statement.match_block, i));
-        }
     } break;
     case SPL_AST_RET_STATEMENT: {
         if (n->ret_statement.expr) {
@@ -596,7 +582,7 @@ static spl_type_id_t sema_parse(spl_sema_t *sema, spl_ast_node_ref_t ref) {
     case SPL_AST_ASSIGN_OR_EXPR:
     case SPL_AST_ASSIGN_XOR_EXPR:
     case SPL_AST_ASSIGN_LSHIFT_EXPR:
-    case SPL_AST_ASSIGN_USHIFT_EXPR: {
+    case SPL_AST_ASSIGN_RSHIFT_EXPR: {
         spl_type_id_t lt = sema_parse(sema, n->op_expr.left);
         spl_type_id_t rt = sema_parse(sema, n->op_expr.right);
         if (lt == 0) {

stage1/spl_tok.h

@@ -25,17 +25,17 @@
     X(match         , KW_MATCH          , SPL_V0) \
     X(null          , KW_NULL           , SPL_V0) \
     X(ret           , KW_RET            , SPL_V0) \
-    X(shape         , WK_SHAPE          , SPL_V0) \
+    X(shape         , KW_SHAPE          , SPL_V0) \
     X(struct        , KW_STRUCT         , SPL_V0) \
     X(true          , KW_TRUE           , SPL_V0) \
     X(try           , KW_TRY            , SPL_V0) \
     X(type          , KW_TYPE           , SPL_V0) \
-    X(undefined     , KW_UNDEFINDED     , SPL_V0) \
+    X(undefined     , KW_UNDEFINED      , SPL_V0) \
     X(union         , KW_UNION          , SPL_V0) \
     X(var           , KW_VAR            , SPL_V0) \
     X(void          , KW_VOID           , SPL_V0) \
     X(while         , KW_WHILE          , SPL_V0) \
-    X(_             , KW_ANY            , SPL_V0) \
+    X(_             , KW_UNDERSCORE     , SPL_V0) \
     // KEYWORD_TABLE
 
 #define TOKEN_TABLE \
@@ -45,13 +45,17 @@
     X(endline   , TOK_ENDLINE           , SPL_V0 ) \
     X("#"       , TOK_SHARP             , SPL_V0 ) \
     X("@"       , TOK_AT                , SPL_V0 ) \
+    X("$"       , TOK_DOLLAR            , SPL_V0 ) \
     X("=="      , TOK_EQ                , SPL_V0 ) \
     X("="       , TOK_ASSIGN            , SPL_V0 ) \
     X("+="      , TOK_ASSIGN_ADD        , SPL_V0 ) \
     X("+"       , TOK_ADD               , SPL_V0 ) \
     X("-="      , TOK_ASSIGN_SUB        , SPL_V0 ) \
-    X("->"      , TOK_RIGHT_ARRAY       , SPL_V0 ) \
+    X("->"      , TOK_RIGHT_ARROW       , SPL_V0 ) \
-    X("<-"      , TOK_LEFT_ARRAY        , SPL_V0 ) \
+    X("<-"      , TOK_LEFT_ARROW        , SPL_V0 ) \
+    X("<->"     , TOK_ARROW_BOTH        , SPL_V0 ) \
+    X("<=>"     , TOK_FAT_ARROW_BOTH    , SPL_V0 ) \
+    X("=>"      , TOK_RIGHT_FAT_ARROW   , SPL_V0 ) \
     X("-"       , TOK_SUB               , SPL_V0 ) \
     X("*="      , TOK_ASSIGN_MUL        , SPL_V0 ) \
     X("*"       , TOK_MUL               , SPL_V0 ) \
@@ -93,7 +97,6 @@
     X("."       , TOK_DOT               , SPL_V0 ) \
     X(".."      , TOK_RANGE             , SPL_V0 ) \
     X("..."     , TOK_ELLIPSIS          , SPL_V0 ) \
-    X("=>"      , TOK_FAT_ARROW         , SPL_V0 ) \
     X("?"       , TOK_COND              , SPL_V0 ) \
     X(ident     , TOK_IDENT             , SPL_V0 ) \
     X(int       , TOK_INT_LITERAL       , SPL_V0 ) \

stage1/spl_type.c

@@ -6,9 +6,6 @@ static usize spl_type_hash(spl_type_node_t n) {
     case SPL_TYPE_ERROR:
     case SPL_TYPE_VOID:
     case SPL_TYPE_BOOL:
-    case SPL_TYPE_UNDEFINED:
-    case SPL_TYPE_NULL:
-        break;
     case SPL_TYPE_INT:
         hash += n.int_type.bits + n.int_type.is_signed;
         break;
@@ -16,41 +13,28 @@ static usize spl_type_hash(spl_type_node_t n) {
         hash += n.float_type.bits;
         break;
     case SPL_TYPE_PTR:
-        hash += n.ptr_pointee;
+        hash += n.ptr_type.pointee;
-        break;
-    case SPL_TYPE_SLICE:
-        hash += n.slice_element;
-        break;
-    case SPL_TYPE_RANGE:
-        hash += n.range_element;
         break;
     case SPL_TYPE_ARRAY:
         hash += n.array_type.element + n.array_type.len;
         break;
     case SPL_TYPE_STRUCT:
     case SPL_TYPE_UNION:
-        hash += n.layout.mode * 31 + n.layout.fixed_align_bits;
-        vec_for(n.agg_members, i) {
-            hash += (n.agg_members.data[i].name ? map_hash_str(n.agg_members.data[i].name) : 0) +
-                    n.agg_members.data[i].type_id;
-        }
-        break;
     case SPL_TYPE_ENUM:
+    case SPL_TYPE_SHAPE:
         hash += n.layout.mode * 31 + n.layout.fixed_align_bits;
-        hash += n.adt_type.tag_type;
+        hash += n.agg_type.tag_type;
-        vec_for(n.adt_type.variants, i) {
+        vec_for(n.agg_type.variants, i) {
             hash +=
-                (n.adt_type.variants.data[i].name ? map_hash_str(n.adt_type.variants.data[i].name)
+                (n.agg_type.variants.data[i].name ? map_hash_str(n.agg_type.variants.data[i].name)
                                                   : 0) +
-                n.adt_type.variants.data[i].type_id;
+                n.agg_type.variants.data[i].type_id;
         }
         break;
     case SPL_TYPE_FN:
         hash += n.fn_type.ret;
         vec_for(n.fn_type.params, i) { hash += vec_at(n.fn_type.params, i); }
         break;
-    default: // TODO
-        break;
     }
     return hash;
 }
@@ -62,9 +46,6 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
     case SPL_TYPE_ERROR:
     case SPL_TYPE_VOID:
     case SPL_TYPE_BOOL:
-    case SPL_TYPE_UNDEFINED:
-    case SPL_TYPE_NULL:
-        break;
     case SPL_TYPE_INT:
         if (n1.int_type.bits != n2.int_type.bits)
             return 1;
@@ -76,15 +57,7 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
             return 1;
         break;
     case SPL_TYPE_PTR:
-        if (n1.ptr_pointee != n2.ptr_pointee)
+        if (n1.ptr_type.pointee != n2.ptr_type.pointee)
-            return 1;
-        break;
-    case SPL_TYPE_SLICE:
-        if (n1.slice_element != n2.slice_element)
-            return 1;
-        break;
-    case SPL_TYPE_RANGE:
-        if (n1.range_element != n2.range_element)
             return 1;
         break;
     case SPL_TYPE_ARRAY:
@@ -95,34 +68,21 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
         break;
     case SPL_TYPE_STRUCT:
     case SPL_TYPE_UNION:
-        if (n1.layout.mode != n2.layout.mode ||
-            n1.layout.fixed_align_bits != n2.layout.fixed_align_bits)
-            return 1;
-        if (vec_size(n1.agg_members) != vec_size(n2.agg_members))
-            return 1;
-        vec_for(n1.agg_members, i) {
-            const char *na = n1.agg_members.data[i].name;
-            const char *nb = n2.agg_members.data[i].name;
-            if (strcmp(na ? na : "", nb ? nb : "") != 0)
-                return 1;
-            if (n1.agg_members.data[i].type_id != n2.agg_members.data[i].type_id)
-                return 1;
-        }
-        break;
     case SPL_TYPE_ENUM:
+    case SPL_TYPE_SHAPE:
         if (n1.layout.mode != n2.layout.mode ||
             n1.layout.fixed_align_bits != n2.layout.fixed_align_bits)
             return 1;
-        if (n1.adt_type.tag_type != n2.adt_type.tag_type)
+        if (n1.agg_type.tag_type != n2.agg_type.tag_type)
             return 1;
-        if (vec_size(n1.adt_type.variants) != vec_size(n2.adt_type.variants))
+        if (vec_size(n1.agg_type.variants) != vec_size(n2.agg_type.variants))
             return 1;
-        vec_for(n1.adt_type.variants, i) {
+        vec_for(n1.agg_type.variants, i) {
-            const char *na = n1.adt_type.variants.data[i].name;
+            const char *na = n1.agg_type.variants.data[i].name;
-            const char *nb = n2.adt_type.variants.data[i].name;
+            const char *nb = n2.agg_type.variants.data[i].name;
             if (strcmp(na ? na : "", nb ? nb : "") != 0)
                 return 1;
-            if (n1.adt_type.variants.data[i].type_id != n2.adt_type.variants.data[i].type_id)
+            if (n1.agg_type.variants.data[i].type_id != n2.agg_type.variants.data[i].type_id)
                 return 1;
         }
         break;
@@ -136,8 +96,6 @@ static int spl_type_eq(spl_type_node_t n1, spl_type_node_t n2) {
                 return 1;
         }
         break;
-    default: // TODO
-        return 1;
     }
     return 0;
 }
@@ -150,10 +108,9 @@ static void spl_type_node_free_vecs(spl_type_node_t *tn) {
     switch (tn->kind) {
     case SPL_TYPE_STRUCT:
     case SPL_TYPE_UNION:
-        vec_free(tn->agg_members);
-        break;
     case SPL_TYPE_ENUM:
-        vec_free(tn->adt_type.variants);
+    case SPL_TYPE_SHAPE:
+        vec_free(tn->agg_type.variants);
         break;
     case SPL_TYPE_FN:
         vec_free(tn->fn_type.params);
@@ -187,24 +144,15 @@ static const spl_type_member_t *spl_type_agg_member_find(spl_type_t *type, spl_t
     if (!n || !name) {
         return NULL;
     }
-    if (n->kind == SPL_TYPE_STRUCT || n->kind == SPL_TYPE_UNION) {
+    if (n->kind == SPL_TYPE_STRUCT || n->kind == SPL_TYPE_UNION || n->kind == SPL_TYPE_ENUM ||
-        vec_for(n->agg_members, i) {
+        n->kind == SPL_TYPE_SHAPE) {
-            const char *mn = n->agg_members.data[i].name;
+        vec_for(n->agg_type.variants, i) {
+            const char *mn = vec_at(n->agg_type.variants, i).name;
             if (strcmp(mn ? mn : "", name) == 0) {
                 if (out_idx) {
                     *out_idx = i;
                 }
-                return &n->agg_members.data[i];
+                return &n->agg_type.variants.data[i];
-            }
-        }
-    } else if (n->kind == SPL_TYPE_ENUM) {
-        vec_for(n->adt_type.variants, i) {
-            const char *mn = n->adt_type.variants.data[i].name;
-            if (strcmp(mn ? mn : "", name) == 0) {
-                if (out_idx) {
-                    *out_idx = i;
-                }
-                return &n->adt_type.variants.data[i];
             }
         }
     }
@@ -245,21 +193,7 @@ spl_type_id_t spl_type_builder_float(spl_type_t *type, usize bits) {
 spl_type_id_t spl_type_builder_ptr(spl_type_t *type, spl_type_id_t pointee) {
     spl_type_node_t tn = {0};
     tn.kind = SPL_TYPE_PTR;
-    tn.ptr_pointee = pointee;
+    tn.ptr_type.pointee = pointee;
-    return spl_type_node_push(type, &tn);
-}
-
-spl_type_id_t spl_type_builder_slice(spl_type_t *type, spl_type_id_t element) {
-    spl_type_node_t tn = {0};
-    tn.kind = SPL_TYPE_SLICE;
-    tn.slice_element = element;
-    return spl_type_node_push(type, &tn);
-}
-
-spl_type_id_t spl_type_builder_range(spl_type_t *type, spl_type_id_t element) {
-    spl_type_node_t tn = {0};
-    tn.kind = SPL_TYPE_RANGE;
-    tn.range_element = element;
     return spl_type_node_push(type, &tn);
 }
 
@@ -284,24 +218,96 @@ spl_type_id_t spl_type_builder_fn(spl_type_t *type, spl_type_id_t ret, const spl
 }
 
 spl_type_id_t spl_type_builder_agg(spl_type_t *type, spl_type_node_kind_t tk,
-                                   const spl_type_member_t *members, usize nmembers,
+                                   spl_type_member_vec_t *variants, spl_type_id_t tag_type,
-                                   spl_type_id_t tag_type, spl_type_layout_t layout) {
+                                   spl_type_layout_t layout) {
     spl_type_node_t tn = {0};
     tn.kind = tk;
     tn.layout = layout;
+    tn.agg_type.variants = *variants;
     if (tk == SPL_TYPE_ENUM) {
-        vec_init(tn.adt_type.variants);
+        tn.agg_type.tag_type = tag_type;
-        for (usize i = 0; i < nmembers; i++) {
-            vec_push(tn.adt_type.variants, members[i]);
-        }
-        tn.adt_type.tag_type = tag_type;
     } else {
-        vec_init(tn.agg_members);
+        tn.agg_type.tag_type = 0;
-        for (usize i = 0; i < nmembers; i++) {
+    }
-            vec_push(tn.agg_members, members[i]);
+    vec_init(*variants);
+    return spl_type_node_push(type, &tn);
+}
+
+spl_type_id_t spl_type_lookup_builtin(spl_type_t *type, const char *name) {
+    if (!name || !*name)
+        return 0;
+
+    // 固定名称类型
+    if (strcmp(name, "bool") == 0)
+        return spl_type_builder_simple(type, SPL_TYPE_BOOL);
+    if (strcmp(name, "void") == 0)
+        return spl_type_builder_simple(type, SPL_TYPE_VOID);
+    if (strcmp(name, "isize") == 0)
+        return spl_type_builder_int(type, sizeof(void *) * 8, true);
+    if (strcmp(name, "usize") == 0)
+        return spl_type_builder_int(type, sizeof(void *) * 8, false);
+
+    // 动态模式：iN / uN / fN，N 为正整数
+    char prefix = name[0];
+    if (prefix == 'i' || prefix == 'u' || prefix == 'f') {
+        const char *rest = name + 1;
+        if (*rest == '\0')
+            return 0;
+        char *end;
+        long bits = strtol(rest, &end, 10);
+        if (end != rest && *end == '\0' && bits > 0) {
+            if (prefix == 'i')
+                return spl_type_builder_int(type, (int)bits, true);
+            if (prefix == 'u')
+                return spl_type_builder_int(type, (int)bits, false);
+            if (prefix == 'f')
+                return spl_type_builder_float(type, (int)bits);
         }
     }
-    return spl_type_node_push(type, &tn);
+    return 0;
+}
+
+spl_type_id_t spl_def_get_type_id(spl_type_t *type, spl_def_id_t def_id) {
+    spl_def_node_t *def_node = spl_def_node(type, def_id);
+    Assert(def_node != NULL);
+    return def_node->type_id;
+}
+
+spl_def_id_t spl_def_builder_void(spl_type_t *type) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_bool(spl_type_t *type) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_int(spl_type_t *type, usize bits, int is_signed) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_float(spl_type_t *type, usize bits) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_ptr(spl_type_t *type, spl_def_id_t pointee) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_array(spl_type_t *type, spl_def_id_t element, usize len) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_slice(spl_type_t *type, spl_type_id_t element) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_range(spl_type_t *type) {
+    TODO();
+    return 0;
+}
+spl_def_id_t spl_def_builder_fn(spl_type_t *type) {
+    TODO();
+    return 0;
 }
 
 spl_def_id_t spl_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
@@ -337,20 +343,18 @@ void spl_type_init(spl_type_t *type) {
     vec_init(type->def_table);
     vec_push(type->def_table, (spl_def_node_t){0});
 
-    spl_type_builder_simple(type, SPL_TYPE_VOID);
+    // spl_type_builder_simple(type, SPL_TYPE_VOID);
-    spl_type_builder_simple(type, SPL_TYPE_BOOL);
+    // spl_type_builder_simple(type, SPL_TYPE_BOOL);
-    spl_type_builder_simple(type, SPL_TYPE_UNDEFINED);
+    // spl_type_builder_int(type, 8, false);
-    spl_type_builder_simple(type, SPL_TYPE_NULL);
+    // spl_type_builder_int(type, 16, false);
-    spl_type_builder_int(type, 8, false);
+    // spl_type_builder_int(type, 32, false);
-    spl_type_builder_int(type, 16, false);
+    // spl_type_builder_int(type, 64, false);
-    spl_type_builder_int(type, 32, false);
+    // spl_type_builder_int(type, 8, true);
-    spl_type_builder_int(type, 64, false);
+    // spl_type_builder_int(type, 16, true);
-    spl_type_builder_int(type, 8, true);
+    // spl_type_builder_int(type, 32, true);
-    spl_type_builder_int(type, 16, true);
+    // spl_type_builder_int(type, 64, true);
-    spl_type_builder_int(type, 32, true);
+    // spl_type_builder_float(type, 32);
-    spl_type_builder_int(type, 64, true);
+    // spl_type_builder_float(type, 64);
-    spl_type_builder_float(type, 32);
-    spl_type_builder_float(type, 64);
 }
 
 void spl_type_drop(spl_type_t *type) {
@@ -359,10 +363,9 @@ void spl_type_drop(spl_type_t *type) {
         switch (n->kind) {
         case SPL_TYPE_STRUCT:
         case SPL_TYPE_UNION:
-            vec_free(n->agg_members);
-            break;
         case SPL_TYPE_ENUM:
-            vec_free(n->adt_type.variants);
+        case SPL_TYPE_SHAPE:
+            vec_free(n->agg_type.variants);
             break;
         case SPL_TYPE_FN:
             vec_free(n->fn_type.params);
@@ -377,13 +380,13 @@ void spl_type_drop(spl_type_t *type) {
     vec_free(type->def_table);
 }
 
-spl_type_node_t *spl_type_node(spl_type_t *type, spl_type_id_t id) {
+spl_type_node_t *spl_type_node(const spl_type_t *type, spl_type_id_t id) {
     if (!id || id >= vec_size(type->type_table))
         return NULL;
     return &vec_at(type->type_table, id);
 }
 
-spl_def_node_t *spl_def_node(spl_type_t *type, spl_def_id_t id) {
+spl_def_node_t *spl_def_node(const spl_type_t *type, spl_def_id_t id) {
     if (!id || id >= vec_size(type->def_table))
         return NULL;
     return &vec_at(type->def_table, id);
@@ -405,12 +408,6 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
     case SPL_TYPE_BOOL:
         printf("bool");
         break;
-    case SPL_TYPE_UNDEFINED:
-        printf("undefined");
-        break;
-    case SPL_TYPE_NULL:
-        printf("null");
-        break;
     case SPL_TYPE_INT:
         if (n->int_type.bits == 0) {
             printf("comptime_int");
@@ -427,52 +424,35 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
         break;
     case SPL_TYPE_PTR:
         printf("*");
-        spl_type_pure_dump(type, n->ptr_pointee);
+        spl_type_pure_dump(type, n->ptr_type.pointee);
-        break;
-    case SPL_TYPE_SLICE:
-        printf("[]");
-        spl_type_pure_dump(type, n->slice_element);
-        break;
-    case SPL_TYPE_RANGE:
-        printf("range[");
-        spl_type_pure_dump(type, n->range_element);
-        printf("]");
         break;
     case SPL_TYPE_ARRAY:
         printf("[%zu]", n->array_type.len);
         spl_type_pure_dump(type, n->array_type.element);
         break;
     case SPL_TYPE_STRUCT:
-        printf("struct{");
-        vec_for(n->agg_members, i) {
-            if (i) {
-                printf(", ");
-            }
-            spl_type_member_t *member = &vec_at(n->agg_members, i);
-            printf("%s:", member->name ? member->name : "?");
-            spl_type_pure_dump(type, member->type_id);
-        }
-        printf("}");
-        break;
     case SPL_TYPE_UNION:
-        printf("union{");
-        vec_for(n->agg_members, i) {
-            if (i) {
-                printf(", ");
-            }
-            spl_type_member_t *member = &vec_at(n->agg_members, i);
-            printf("%s:", member->name ? member->name : "?");
-            spl_type_pure_dump(type, member->type_id);
-        }
-        printf("}");
-        break;
     case SPL_TYPE_ENUM:
-        printf("enum{"); // TODO tag_type
+    case SPL_TYPE_SHAPE:
-        vec_for(n->adt_type.variants, i) {
+        switch (n->kind) {
+        case SPL_TYPE_STRUCT:
+            printf("struct{\n");
+        case SPL_TYPE_UNION:
+            printf("union{\n");
+        case SPL_TYPE_ENUM:
+            printf("enum{\n");
+        case SPL_TYPE_SHAPE:
+            printf("shape{\n");
+            break;
+        default:
+            UNREACHABLE();
+            break;
+        }
+        vec_for(n->agg_type.variants, i) {
             if (i) {
                 printf(", ");
             }
-            spl_type_member_t *member = &vec_at(n->adt_type.variants, i);
+            spl_type_member_t *member = &vec_at(n->agg_type.variants, i);
             printf("%s:", member->name ? member->name : "?");
             spl_type_pure_dump(type, member->type_id);
         }
@@ -486,13 +466,10 @@ void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id) {
             }
             spl_type_pure_dump(type, vec_at(n->fn_type.params, i));
         }
-        printf(") -> ");
+        printf(")");
         spl_type_pure_dump(type, n->fn_type.ret);
         break;
     }
-    case SPL_TYPE_ID:
-        printf("id#%zu", n->type_id);
-        break;
     }
 }
 
@@ -523,6 +500,19 @@ void spl_type_def_dump(spl_type_t *type, spl_def_id_t id) {
     case SPL_DEF_AGG:
         def_kind_name = "agg";
         break;
+    case SPL_DEF_BUILTIN:
+        switch (node->builtin_kind) {
+        case SPL_BUILTIN_RANGE:
+            def_kind_name = "builtin.range";
+            break;
+        case SPL_BUILTIN_SLICE:
+            def_kind_name = "builtin.slice";
+            break;
+        default:
+            def_kind_name = "builtin";
+            break;
+        }
+        break;
     case SPL_DEF_DISTINCT:
         def_kind_name = "newtype";
         break;

stage1/spl_type.h

@@ -15,17 +15,13 @@ typedef enum {
     SPL_TYPE_BOOL,
     SPL_TYPE_INT,
     SPL_TYPE_FLOAT,
-    SPL_TYPE_UNDEFINED, // 自动配对任意类型的字面量，值为 undefined
-    SPL_TYPE_NULL,      // 自动配对指针/切片的字面量，值为 0
     SPL_TYPE_PTR,
-    SPL_TYPE_SLICE, // 未来拥有泛型后删除
-    SPL_TYPE_RANGE, // 未来拥有泛型后删除
     SPL_TYPE_ARRAY,
     SPL_TYPE_STRUCT,
     SPL_TYPE_UNION,
     SPL_TYPE_ENUM,
+    SPL_TYPE_SHAPE,
     SPL_TYPE_FN,
-    SPL_TYPE_ID,
 } spl_type_node_kind_t;
 
 typedef enum {
@@ -48,7 +44,7 @@ typedef VEC(spl_type_member_t) spl_type_member_vec_t;
 
 typedef struct {
     spl_type_node_kind_t kind;
-    spl_type_layout_t layout;
+    spl_type_layout_t layout; // attribute
     union {
         struct {
             usize bits;
@@ -57,23 +53,21 @@ typedef struct {
         struct {
             usize bits;
         } float_type;
-        spl_type_id_t ptr_pointee;
+        struct {
-        spl_type_id_t slice_element;
+            spl_type_id_t pointee;
-        spl_type_id_t range_element;
+        } ptr_type;
         struct {
             spl_type_id_t element;
             usize len;
         } array_type;
-        spl_type_member_vec_t agg_members;
         struct {
             spl_type_member_vec_t variants;
             spl_type_id_t tag_type;
-        } adt_type; // ADT
+        } agg_type; // adt record aggregate
         struct {
             spl_type_id_vec_t params;
             spl_type_id_t ret;
         } fn_type;
-        spl_type_id_t type_id;
     };
 } spl_type_node_t;
 typedef VEC(spl_type_node_t) spl_type_node_vec_t;
@@ -84,13 +78,19 @@ typedef enum {
     SPL_DEF_MEMBER,
     SPL_DEF_VAR,
     SPL_DEF_FN,
-    SPL_DEF_AGG,      // include enum variants
+    SPL_DEF_AGG,
-    SPL_DEF_DISTINCT, // newtype
+    SPL_DEF_DISTINCT,
-    SPL_DEF_ALIAS,    // sametypes
+    SPL_DEF_ALIAS,
+    SPL_DEF_BUILTIN,
 } spl_def_node_kind_t;
 
 typedef struct {
     spl_def_node_kind_t kind;
+    enum {
+        SPL_BUILTIN_NONE,
+        SPL_BUILTIN_SLICE,
+        SPL_BUILTIN_RANGE,
+    } builtin_kind;
     const char *name;
     spl_dbg_node_t dbg_node;
     spl_type_id_t type_id;
@@ -111,8 +111,8 @@ void spl_type_drop(spl_type_t *type);
 void spl_type_def_dump(spl_type_t *type, spl_def_id_t id);
 void spl_type_pure_dump(spl_type_t *type, spl_type_id_t id);
 
-spl_type_node_t *spl_type_node(spl_type_t *type, spl_type_id_t id);
+spl_type_node_t *spl_type_node(const spl_type_t *type, spl_type_id_t id);
-spl_def_node_t *spl_def_node(spl_type_t *type, spl_def_id_t id);
+spl_def_node_t *spl_def_node(const spl_type_t *type, spl_def_id_t id);
 
 spl_type_id_t spl_def_alloc(spl_type_t *type, spl_def_node_kind_t kind, const char *name,
                             spl_dbg_node_t dbg, usize ast_node_ref);
@@ -127,12 +127,24 @@ spl_type_id_t spl_type_builder_simple(spl_type_t *type, spl_type_node_kind_t kin
 spl_type_id_t spl_type_builder_int(spl_type_t *type, usize bits, int is_signed);
 spl_type_id_t spl_type_builder_float(spl_type_t *type, usize bits);
 spl_type_id_t spl_type_builder_ptr(spl_type_t *type, spl_type_id_t pointee);
-spl_type_id_t spl_type_builder_slice(spl_type_t *type, spl_type_id_t element);
-spl_type_id_t spl_type_builder_range(spl_type_t *type, spl_type_id_t element);
 spl_type_id_t spl_type_builder_array(spl_type_t *type, spl_type_id_t element, usize len);
 spl_type_id_t spl_type_builder_fn(spl_type_t *type, spl_type_id_t ret, const spl_type_id_t *params,
                                   usize nparams);
 spl_type_id_t spl_type_builder_agg(spl_type_t *type, spl_type_node_kind_t tk,
-                                   const spl_type_member_t *members, usize nmembers,
+                                   spl_type_member_vec_t *variants, spl_type_id_t tag_type,
-                                   spl_type_id_t tag_type, spl_type_layout_t layout);
+                                   spl_type_layout_t layout);
+
+spl_type_id_t spl_type_lookup_builtin(spl_type_t *type, const char *name);
+
+spl_type_id_t spl_def_get_type_id(spl_type_t *type, spl_def_id_t def_id);
+spl_def_id_t spl_def_builder_void(spl_type_t *type);
+spl_def_id_t spl_def_builder_bool(spl_type_t *type);
+spl_def_id_t spl_def_builder_int(spl_type_t *type, usize bits, int is_signed);
+spl_def_id_t spl_def_builder_float(spl_type_t *type, usize bits);
+spl_def_id_t spl_def_builder_ptr(spl_type_t *type, spl_def_id_t pointee);
+spl_def_id_t spl_def_builder_array(spl_type_t *type, spl_def_id_t element, usize len);
+spl_def_id_t spl_def_builder_slice(spl_type_t *type, spl_type_id_t element);
+spl_def_id_t spl_def_builder_range(spl_type_t *type);
+spl_def_id_t spl_def_builder_fn(spl_type_t *type);
+
 #endif /* __SPL_TYPE_H__ */

stage1/splc0.c

@@ -12,7 +12,7 @@
 
 #include "spl_ast.h"
 #include "spl_ast2ir.h"
-// #include "spl_ir2vm.h"
+#include "spl_ir2vm.h"
 #include "spl_lexer.h"
 #include "spl_sema.h"
 #include "spl_tok.h"
@@ -23,6 +23,7 @@ typedef enum {
     DUMP_AST,
     DUMP_SEMA,
     DUMP_IR,
+    DUMP_VM,
 } dump_t;
 
 static char *read_file(const char *path, long *out_len) {
@@ -68,6 +69,8 @@ static void dump_tokens(spl_tok_vec_t toks) {
 
 static int compile_spl(const char *src, const char *fname, const char *outpath, int gen_debug,
                        dump_t dump) {
+    (void)gen_debug;
+
     spl_tok_vec_t toks = spl_lex(src, fname);
     if (dump == DUMP_TOKEN) {
         dump_tokens(toks);
@@ -76,7 +79,7 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
     }
     spl_ast_t ast;
     spl_ast_init(&ast, &toks);
-    spl_ast_prase(&ast);
+    spl_ast_parse(&ast);
     if (ast.parsed < 0) {
         printf("parse failed, no output\n");
         // memory leak
@@ -88,54 +91,63 @@ static int compile_spl(const char *src, const char *fname, const char *outpath,
         // memory leak
         return 0;
     }
-    spl_sema_t sema;
+    // spl_sema_t sema;
-    spl_type_t type;
+    // spl_type_t type;
-    spl_scope_t scope;
+    // spl_scope_t scope;
-    spl_type_init(&type);
+    // spl_type_init(&type);
-    spl_scope_init(&scope);
+    // spl_scope_init(&scope);
-    spl_sema_init(&sema, &ast, &type, &scope);
+    // spl_sema_init(&sema, &ast, &type, &scope);
-    sema.ast = &ast;
+    // sema.ast = &ast;
-    spl_sema_run(&sema);
+    // spl_sema_run(&sema);
-    if (sema.error_count) {
+    // if (sema.error_count) {
-        printf("sema errors=%d, no output\n", sema.error_count);
+    //     printf("sema errors=%d, no output\n", sema.error_count);
-        // memory leak
+    //     // memory leak
-        return 1;
+    //     return 1;
-    }
+    // }
-    if (dump == DUMP_SEMA) {
+    // if (dump == DUMP_SEMA) {
-        spl_sema_dump(&sema);
+    //     spl_sema_dump(&sema);
-        spl_ast_dump(&ast, ast.root);
+    //     spl_ast_dump(&ast, ast.root);
-        // memory leak
+    //     // memory leak
-        return 0;
+    //     return 0;
-    }
+    // }
 
-    spl_ast2ir_t a2ir;
+    // spl_ast2ir_t a2ir;
-    spl_ir_builder_t ir_builder;
+    // spl_ir_builder_t ir_builder;
-    spl_ir_builder_init(&ir_builder);
+    // spl_ir_builder_init(&ir_builder);
-    spl_ast2ir_init(&a2ir, &ir_builder, &sema);
+    // spl_ast2ir_init(&a2ir, &ir_builder, &sema);
-    spl_ast2ir_run(&a2ir);
+    // spl_ast2ir_run(&a2ir);
-    if (a2ir.err_count) {
+    // if (a2ir.err_count) {
-        printf("ast2ir errors=%d, no output\n", a2ir.err_count);
+    //     printf("ast2ir errors=%d, no output\n", a2ir.err_count);
-        spl_ast2ir_drop(&a2ir);
+    //     spl_ast2ir_drop(&a2ir);
-        spl_sema_drop(&sema);
+    //     spl_sema_drop(&sema);
-        spl_ast_drop(&ast);
+    //     spl_ast_drop(&ast);
-        return 1;
+    //     return 1;
-    }
+    // }
-    if (dump == DUMP_IR) {
+    // if (dump == DUMP_IR) {
-        spl_ir_dump(&ir_builder.ir, &type);
+    //     spl_ir_dump(&ir_builder.ir, &type);
-        // memory leak
+    //     // memory leak
-        return 0;
+    //     return 0;
-    }
+    // }
 
     // spl_ir2vm_t ir2vm;
-    // spl_ir2vm_init(&ir2vm, &a2ir.ir, &sema.type);
+    // spl_ir2vm_init(&ir2vm, &a2ir.ir->ir, sema.type);
-    // int rc = spl_ir2vm_run(&ir2vm, outpath);
+    // int rc = spl_ir2vm_run(&ir2vm);
-    // if (gen_debug && rc == 0)
+    // if (rc != 0) {
-    //     gen_debug_map(outpath, &ast, &a2ir.ir, &ir2vm);
+    //     printf("ir2vm error %d", rc);
+    //     return rc;
+    // }
+    // if (dump == DUMP_VM) {
+    //     spl_prog_dump(&ir2vm.prog);
+    //     // memory leak
+    //     return 0;
+    // }
+
+    // spl_prog_store_to_file(outpath, &ir2vm.prog);
+
     // spl_ir2vm_drop(&ir2vm);
     // spl_ast2ir_drop(&a2ir);
     // spl_sema_drop(&sema);
     // spl_ast_drop(&ast);
-    // return rc ? 1 : 0;
     return 0;
 }
 
@@ -146,7 +158,7 @@ int main(int argc, char **argv) {
     }
     if (strcmp(argv[1], "--help") == 0 || strcmp(argv[1], "-h") == 0) {
         LOG_INFO("splc0 <in> <out>              compile (.spl -> .sir, stage B)");
-        LOG_INFO("splc0 --dump <flags> <file>   dump: lex,ast,sema,ir");
+        LOG_INFO("splc0 --dump <flags> <file>   dump: lex,ast,sema,ir,vm,none");
         return 0;
     }
     int argi = 1;
@@ -165,15 +177,19 @@ int main(int argc, char **argv) {
         const char *flags = argv[argi + 1];
         if (strstr(flags, "lex") != NULL) {
             dump = DUMP_TOKEN;
-        }
+        } else if (strstr(flags, "ast") != NULL) {
-        if (strstr(flags, "ast") != NULL) {
             dump = DUMP_AST;
-        }
+        } else if (strstr(flags, "sema") != NULL) {
-        if (strstr(flags, "sema") != NULL) {
             dump = DUMP_SEMA;
-        }
+        } else if (strstr(flags, "ir") != NULL) {
-        if (strstr(flags, "ir") != NULL) {
             dump = DUMP_IR;
+        } else if (strstr(flags, "vm") != NULL) {
+            dump = DUMP_VM;
+        } else if (strstr(flags, "none") != NULL) {
+            dump = DUMP_NONE;
+        } else {
+            Panic("--dump unknown flags");
+            return 1;
         }
         argi += 2;
     }