feat: L Language v0.1 编译器完整实现

5 阶段编译流水线: 词法分析 → 语法分析(Pratt) → 语义分析(类型推断) → LLVM IR → .exe 模块: - lexer: 手写状态机, 40 种 Token, // 和 /* */ 注释 - parser: Pratt 表达式解析(9 级优先级) + 递归下降语句/函数 - ast: 14 种节点类型 + 工厂函数 - sema: 作用域链符号表 + 类型推断 + 类型检查 - codegen: AST → LLVM-C API, print_i64/f64/bool 内建 - driver: 命令行 + 流水线串联 + 错误报告 - util: Arena bump allocator (8MB) 测试: 65 单元测试(词法41+语法15+语义9) + 5 集成测试全部通过语言特性: i64/f64/bool/void, let不可变变量, if/else, while, 递归函数
2026-06-05 00:26:59 +08:00
commit 3b7bab1e1b
40 changed files with 5804 additions and 0 deletions
@@ -0,0 +1,5 @@
+fn main() -> i64 {
+    let x: i64 = 1 + 2 * 3;
+    print_i64(x);
+    return 0;
+}
@@ -0,0 +1,9 @@
+fn main() -> i64 {
+    let x: i64 = 10;
+    if x > 5 {
+        print_i64(1);
+    } else {
+        print_i64(0);
+    }
+    return 0;
+}
@@ -0,0 +1,11 @@
+fn countdown(n: i64) -> i64 {
+    if n > 0 {
+        print_i64(n);
+        return countdown(n - 1);
+    }
+    return 0;
+}
+
+fn main() -> i64 {
+    return countdown(5);
+}
@@ -0,0 +1,12 @@
+fn fib(n: i64) -> i64 {
+    if n < 2 {
+        return n;
+    }
+    return fib(n - 1) + fib(n - 2);
+}
+
+fn main() -> i64 {
+    let result: i64 = fib(10);
+    print_i64(result);
+    return 0;
+}
@@ -0,0 +1,14 @@
+fn square(x: f64) -> f64 {
+    return x * x;
+}
+
+fn add_floats(a: f64, b: f64) -> f64 {
+    return a + b;
+}
+
+fn main() -> i64 {
+    let s: f64 = square(3.0);
+    let sum: f64 = add_floats(s, 4.0);
+    print_f64(sum);
+    return 0;
+}
@@ -0,0 +1,53 @@
+#include "test_utils.h"
+#include "lexer.h"
+#include "arena.h"
+
+void test_simple_tokens() {
+    Arena a = arena_create(1);
+    const char* src = "fn main() { return 42; }";
+    size_t count; ErrorInfo error = {0};
+    Token* tokens = lex(&a, src, "test", &count, &error);
+    ASSERT(tokens != NULL);
+    ASSERT(count >= 8);
+    ASSERT(tokens[0].kind == TOK_FN);
+    ASSERT(tokens[1].kind == TOK_IDENT);
+    ASSERT(tokens[2].kind == TOK_LPAREN);
+    ASSERT(tokens[3].kind == TOK_RPAREN);
+    ASSERT(tokens[4].kind == TOK_LBRACE);
+    ASSERT(tokens[5].kind == TOK_RETURN);
+    ASSERT(tokens[6].kind == TOK_INT_LIT);
+    ASSERT(tok_int_value(&tokens[6]) == 42);
+    arena_destroy(&a);
+}
+
+void test_keywords() {
+    Arena a = arena_create(1);
+    const char* src = "fn let if else while return i64 f64 bool void true false";
+    TokenKind expected[] = {TOK_FN, TOK_LET, TOK_IF, TOK_ELSE, TOK_WHILE,
+        TOK_RETURN, TOK_I64, TOK_F64, TOK_BOOL, TOK_VOID, TOK_TRUE, TOK_FALSE, TOK_EOF};
+    size_t count; ErrorInfo error = {0};
+    Token* tokens = lex(&a, src, "test", &count, &error);
+    ASSERT(tokens != NULL);
+    for (int i = 0; i < 13; i++) ASSERT(tokens[i].kind == expected[i]);
+    arena_destroy(&a);
+}
+
+void test_operators() {
+    Arena a = arena_create(1);
+    const char* src = "+ - * / % == != < > <= >= && || ! ->";
+    TokenKind expected[] = {TOK_PLUS, TOK_MINUS, TOK_STAR, TOK_SLASH, TOK_PERCENT,
+        TOK_EQ_EQ, TOK_BANG_EQ, TOK_LT, TOK_GT, TOK_LT_EQ, TOK_GT_EQ,
+        TOK_AND_AND, TOK_PIPE_PIPE, TOK_BANG, TOK_ARROW, TOK_EOF};
+    size_t count; ErrorInfo error = {0};
+    Token* tokens = lex(&a, src, "test", &count, &error);
+    ASSERT(tokens != NULL);
+    for (int i = 0; i < 16; i++) ASSERT(tokens[i].kind == expected[i]);
+    arena_destroy(&a);
+}
+
+int main(void) {
+    TEST_RUN(test_simple_tokens);
+    TEST_RUN(test_keywords);
+    TEST_RUN(test_operators);
+    return test_summary();
+}
@@ -0,0 +1,68 @@
+#include "test_utils.h"
+#include "parser.h"
+#include "lexer.h"
+#include "arena.h"
+
+static AstNode* parse_string(const char* src) {
+    Arena* a = malloc(sizeof(Arena));
+    *a = arena_create(1);
+    size_t tcount;
+    ErrorInfo lex_err = {0};
+    Token* tokens = lex(a, src, "test", &tcount, &lex_err);
+    if (!tokens) { arena_destroy(a); free(a); return NULL; }
+    ErrorInfo parse_err = {0};
+    AstNode* ast = parse(a, tokens, tcount, "test", &parse_err);
+    if (!ast) { arena_destroy(a); free(a); return NULL; }
+    // NOTE: arena and tokens must stay alive for AST - leak intentionally in test
+    return ast;
+}
+
+void test_simple_function() {
+    AstNode* ast = parse_string("fn main() { return 42; }");
+    ASSERT(ast != NULL);
+    ASSERT(ast->kind == AST_PROGRAM);
+    ASSERT(ast->as.program.fn_count == 1);
+    AstNode* fn = ast->as.program.functions[0];
+    ASSERT(fn->kind == AST_FUNCTION);
+}
+
+void test_arithmetic_expr() {
+    AstNode* ast = parse_string("fn main() { return 1 + 2 * 3; }");
+    ASSERT(ast != NULL);
+    AstNode* body = ast->as.program.functions[0]->as.function.body;
+    AstNode* ret = body->as.block.stmts[0];
+    ASSERT(ret->kind == AST_RETURN_STMT);
+    AstNode* expr = ret->as.return_stmt.expr;
+    ASSERT(expr->kind == AST_BINARY_EXPR);
+    ASSERT(expr->as.binary.op == OP_ADD);
+    // 1 + (2 * 3): right should be *, left should be 1
+    ASSERT(expr->as.binary.right->kind == AST_BINARY_EXPR);
+    ASSERT(expr->as.binary.right->as.binary.op == OP_MUL);
+}
+
+void test_if_statement() {
+    AstNode* ast = parse_string("fn main() { if true { return 1; } else { return 0; } }");
+    ASSERT(ast != NULL);
+}
+
+void test_while_loop() {
+    AstNode* ast = parse_string("fn main() { while true { return; } }");
+    ASSERT(ast != NULL);
+}
+
+void test_function_with_params() {
+    AstNode* ast = parse_string("fn add(a: i64, b: i64) -> i64 { return a + b; }");
+    ASSERT(ast != NULL);
+    AstNode* fn = ast->as.program.functions[0];
+    ASSERT(fn->as.function.param_count == 2);
+    ASSERT(fn->as.function.return_type == TYPE_I64);
+}
+
+int main(void) {
+    TEST_RUN(test_simple_function);
+    TEST_RUN(test_arithmetic_expr);
+    TEST_RUN(test_if_statement);
+    TEST_RUN(test_while_loop);
+    TEST_RUN(test_function_with_params);
+    return test_summary();
+}
@@ -0,0 +1,59 @@
+#include "test_utils.h"
+#include "parser.h"
+#include "lexer.h"
+#include "sema.h"
+#include "arena.h"
+
+void test_type_error() {
+    Arena a = arena_create(1);
+    size_t tc; ErrorInfo lex_err = {0};
+    Token* toks = lex(&a, "fn main() { let x: i64 = 1; let y: i64 = x + true; return; }",
+                      "test", &tc, &lex_err);
+    ASSERT(toks != NULL);
+    ErrorInfo parse_err = {0};
+    AstNode* ast = parse(&a, toks, tc, "test", &parse_err);
+    ASSERT(ast != NULL);
+
+    ErrorList errors; error_init(&errors);
+    sema_analyze(ast, &errors, &a);
+    ASSERT(errors.count > 0);
+    arena_destroy(&a);
+}
+
+void test_undefined_var() {
+    Arena a = arena_create(1);
+    size_t tc; ErrorInfo lex_err = {0};
+    Token* toks = lex(&a, "fn main() { let x: i64 = y; return; }", "test", &tc, &lex_err);
+    ASSERT(toks != NULL);
+    ErrorInfo parse_err = {0};
+    AstNode* ast = parse(&a, toks, tc, "test", &parse_err);
+    ASSERT(ast != NULL);
+
+    ErrorList errors; error_init(&errors);
+    sema_analyze(ast, &errors, &a);
+    ASSERT(errors.count > 0);
+    arena_destroy(&a);
+}
+
+void test_simple_ok() {
+    Arena a = arena_create(1);
+    size_t tc; ErrorInfo lex_err = {0};
+    Token* toks = lex(&a, "fn main() { let x: i64 = 42; print_i64(x); return; }",
+                      "test", &tc, &lex_err);
+    ASSERT(toks != NULL);
+    ErrorInfo parse_err = {0};
+    AstNode* ast = parse(&a, toks, tc, "test", &parse_err);
+    ASSERT(ast != NULL);
+
+    ErrorList errors; error_init(&errors);
+    sema_analyze(ast, &errors, &a);
+    ASSERT(errors.count == 0);
+    arena_destroy(&a);
+}
+
+int main(void) {
+    TEST_RUN(test_type_error);
+    TEST_RUN(test_undefined_var);
+    TEST_RUN(test_simple_ok);
+    return test_summary();
+}
@@ -0,0 +1,27 @@
+#ifndef TEST_UTILS_H
+#define TEST_UTILS_H
+#include <stdio.h>
+#include <stdlib.h>
+
+static int _tests_run = 0;
+static int _tests_failed = 0;
+
+#define ASSERT(expr) do { \
+    _tests_run++; \
+    if (!(expr)) { \
+        fprintf(stderr, "\033[1;31mFAIL\033[0m %s:%d: %s\n", __FILE__, __LINE__, #expr); \
+        _tests_failed++; \
+    } \
+} while(0)
+
+#define TEST_RUN(func) do { \
+    fprintf(stderr, "  RUN  %s\n", #func); \
+    func(); \
+} while(0)
+
+static inline int test_summary(void) {
+    fprintf(stderr, "\n%d tests, %d passed, %d failed\n",
+            _tests_run, _tests_run - _tests_failed, _tests_failed);
+    return _tests_failed > 0 ? 1 : 0;
+}
+#endif