freelang-v4 4.3.0

package/src/ast.ts

@@ -0,0 +1,158 @@
+// FreeLang v4 — AST 노드 정의
+
+// ============================================================
+// 타입 표기 (Type Annotations)
+// ============================================================
+
+export type TypeAnnotation =
+  | { kind: "i32" }
+  | { kind: "i64" }
+  | { kind: "f64" }
+  | { kind: "bool" }
+  | { kind: "string" }
+  | { kind: "void" }
+  | { kind: "array"; element: TypeAnnotation }
+  | { kind: "channel"; element: TypeAnnotation }
+  | { kind: "option"; element: TypeAnnotation }
+  | { kind: "result"; ok: TypeAnnotation; err: TypeAnnotation }
+  | { kind: "promise"; element: TypeAnnotation }
+  | { kind: "struct_ref"; name: string }
+  | { kind: "fn"; params: TypeAnnotation[]; returnType: TypeAnnotation }
+  | { kind: "type_param"; name: string }                                  // Generic 타입 파라미터 (T, K, V)
+  | { kind: "generic_ref"; name: string; typeArgs: TypeAnnotation[] }   // 제네릭 타입 참조 (List<T>, Map<K,V>)
+  | { kind: "trait_ref"; name: string }                                  // Trait 참조 (Drawable)
+  | { kind: "self_type" };                                               // Self 타입
+
+// ============================================================
+// 패턴 (Match Patterns) — SPEC_05 Q8: 7종
+// ============================================================
+
+export type Pattern =
+  | { kind: "ident"; name: string }         // x → 바인딩
+  | { kind: "literal"; value: Expr }         // 42, "hello", true
+  | { kind: "ok"; inner: Pattern }           // Ok(v)
+  | { kind: "err"; inner: Pattern }          // Err(e)
+  | { kind: "some"; inner: Pattern }         // Some(v)
+  | { kind: "none" }                         // None
+  | { kind: "wildcard" }                     // _
+  | { kind: "struct"; name: string; fields: { name: string; pattern: Pattern; alias?: string }[]; rest: boolean }  // Point { x, y }
+  | { kind: "array"; elements: Pattern[]; rest: boolean; restIndex?: number }  // [a, b, c]
+  | { kind: "tuple"; elements: Pattern[]; rest: boolean; restIndex?: number }; // (a, b, c)
+
+export type MatchArm = {
+  pattern: Pattern;
+  guard?: Expr;  // if 조건절
+  body: Expr;
+};
+
+// ============================================================
+// 식 (Expressions) — 값을 만든다
+// ============================================================
+
+export type FnParam = {
+  name: string;
+  type?: TypeAnnotation;
+};
+
+export type Expr =
+  | { kind: "int_lit"; value: number; line: number; col: number }
+  | { kind: "float_lit"; value: number; line: number; col: number }
+  | { kind: "string_lit"; value: string; line: number; col: number }
+  | { kind: "bool_lit"; value: boolean; line: number; col: number }
+  | { kind: "ident"; name: string; line: number; col: number }
+  | { kind: "binary"; op: string; left: Expr; right: Expr; line: number; col: number }
+  | { kind: "unary"; op: string; operand: Expr; line: number; col: number }
+  | { kind: "await"; expr: Expr; line: number; col: number }
+  | { kind: "call"; callee: Expr; args: Expr[]; typeArgs?: TypeAnnotation[]; line: number; col: number }
+  | { kind: "index"; object: Expr; index: Expr; line: number; col: number }
+  | { kind: "field_access"; object: Expr; field: string; line: number; col: number }
+  | { kind: "assign"; target: Expr; value: Expr; line: number; col: number }
+  | { kind: "try"; operand: Expr; line: number; col: number }
+  | { kind: "if_expr"; condition: Expr; then: Expr[]; else_: Expr[]; line: number; col: number }
+  | { kind: "match_expr"; subject: Expr; arms: MatchArm[]; line: number; col: number }
+  | { kind: "array_lit"; elements: Expr[]; line: number; col: number }
+  | { kind: "struct_lit"; structName: string; fields: { name: string; value: Expr }[]; line: number; col: number }
+  | { kind: "fn_lit"; params: FnParam[]; returnType?: TypeAnnotation; body: Expr; line: number; col: number }
+  | { kind: "block_expr"; stmts: Stmt[]; expr: Expr | null; line: number; col: number }
+  | { kind: "chan_new"; element: TypeAnnotation; line: number; col: number }
+  | { kind: "chan_send"; chan: Expr; value: Expr; line: number; col: number }
+  | { kind: "chan_recv"; chan: Expr; line: number; col: number };
+
+// ============================================================
+// 문 (Statements) — 값을 만들지 않는다
+// ============================================================
+
+export type Param = {
+  name: string;
+  type: TypeAnnotation;
+};
+
+export type StructField = {
+  name: string;
+  type: TypeAnnotation;
+};
+
+export type TraitMethod = {
+  name: string;
+  params: Param[];
+  returnType: TypeAnnotation;
+  line: number;
+  col: number;
+};
+
+export type ImplMethod = {
+  name: string;
+  params: Param[];
+  returnType: TypeAnnotation;
+  body: Stmt[];
+  line: number;
+  col: number;
+};
+
+export type ImportItem = {
+  name: string;
+  alias?: string;
+};
+
+export type ImportDecl = {
+  kind: "import_decl";
+  source: string;
+  items: ImportItem[];
+  default?: boolean;
+  line: number;
+  col: number;
+};
+
+export type ExportDecl = {
+  kind: "export_decl";
+  target: Stmt | string[];
+  line: number;
+  col: number;
+};
+
+export type Stmt =
+  | { kind: "var_decl"; name: string; mutable: boolean; type: TypeAnnotation | null; init: Expr; line: number; col: number }
+  | { kind: "fn_decl"; name: string; isAsync: boolean; typeParams: string[]; params: Param[]; returnType: TypeAnnotation; body: Stmt[]; line: number; col: number }
+  | { kind: "struct_decl"; name: string; typeParams: string[]; fields: StructField[]; line: number; col: number }
+  | { kind: "trait_decl"; name: string; typeParams: string[]; methods: TraitMethod[]; line: number; col: number }
+  | { kind: "impl_decl"; trait: string | null; forType: TypeAnnotation; typeParams: string[]; methods: ImplMethod[]; line: number; col: number }
+  | { kind: "if_stmt"; condition: Expr; then: Stmt[]; else_: Stmt[] | null; line: number; col: number }
+  | { kind: "match_stmt"; subject: Expr; arms: MatchArm[]; line: number; col: number }
+  | { kind: "for_stmt"; variable: string; iterable: Expr; body: Stmt[]; line: number; col: number }
+  | { kind: "for_of_stmt"; variable: string; iterable: Expr; body: Stmt[]; line: number; col: number }
+  | { kind: "while_stmt"; condition: Expr; body: Stmt[]; line: number; col: number }
+  | { kind: "break_stmt"; line: number; col: number }
+  | { kind: "continue_stmt"; line: number; col: number }
+  | { kind: "spawn_stmt"; body: Stmt[]; line: number; col: number }
+  | { kind: "return_stmt"; value: Expr | null; line: number; col: number }
+  | { kind: "expr_stmt"; expr: Expr; line: number; col: number }
+  | ImportDecl
+  | ExportDecl;
+
+// ============================================================
+// 프로그램 (최상위)
+// ============================================================
+
+export type Program = {
+  stmts: Stmt[];
+};

package/src/async-basic.test.ts

@@ -0,0 +1,94 @@
+// FreeLang v4 — Async/Await 기본 기능 테스트
+// 최소 3/5 테스트 통과를 목표로 함
+
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { TypeChecker } from "./checker";
+import { Compiler } from "./compiler";
+
+describe("Async/Await Basic Implementation", () => {
+  function testParse(source: string) {
+    const lexer = new Lexer(source);
+    const { tokens, errors: lexErrors } = lexer.tokenize();
+    if (lexErrors.length > 0) {
+      throw new Error(`Lex: ${lexErrors[0].message}`);
+    }
+    const parser = new Parser(tokens);
+    const { program, errors: parseErrors } = parser.parse();
+    if (parseErrors.length > 0) {
+      throw new Error(`Parse: ${parseErrors[0].message}`);
+    }
+    return program;
+  }
+
+  function testTypeCheck(program: any) {
+    const checker = new TypeChecker();
+    const errors = checker.check(program);
+    return errors;
+  }
+
+  function testCompile(program: any) {
+    const compiler = new Compiler();
+    const chunk = compiler.compile(program);
+    return chunk;
+  }
+
+  // Test 1: async fn 선언 파싱
+  it("T1: Parse async fn declaration", () => {
+    const source = `async fn getValue(): Promise<i32> { return 42 }`;
+    const program = testParse(source);
+    expect(program.stmts.length).toBe(1);
+    const fnStmt = program.stmts[0];
+    expect(fnStmt.kind).toBe("fn_decl");
+    expect((fnStmt as any).isAsync).toBe(true);
+    expect((fnStmt as any).name).toBe("getValue");
+  });
+
+  // Test 2: Promise<T> 타입 파싱
+  it("T2: Parse Promise<T> type annotation", () => {
+    const source = `async fn getStr(): Promise<string> { return "ok" }`;
+    const program = testParse(source);
+    const fnStmt = program.stmts[0] as any;
+    expect(fnStmt.returnType.kind).toBe("promise");
+    expect(fnStmt.returnType.element.kind).toBe("string");
+  });
+
+  // Test 3: await 식 파싱
+  it("T3: Parse await expression", () => {
+    const source = `async fn caller(): Promise<i32> { let x = await getValue(); return x }`;
+    const program = testParse(source);
+    const fnStmt = program.stmts[0] as any;
+    const bodyHasAwait = fnStmt.body.some((stmt: any) => {
+      if (stmt.kind === "var_decl") {
+        return stmt.init.kind === "await";
+      }
+      return false;
+    });
+    expect(bodyHasAwait).toBe(true);
+  });
+
+  // Test 4: async fn 타입 검사 (Promise 자동 변환)
+  it("T4: Type check async fn returns Promise<T>", () => {
+    const source = `async fn getValue(): i32 { return 42 }`;
+    const program = testParse(source);
+    // 타입 체커는 async fn의 반환 타입을 Promise<T>로 자동 변환
+    const errors = testTypeCheck(program);
+    expect(errors.length).toBe(0);
+  });
+
+  // Test 5: await에 Promise 요구
+  it("T5: Type check await requires Promise", () => {
+    const source = `
+      async fn caller(): Promise<i32> {
+        let x = await getValue()
+        return x
+      }
+      fn getValue(): i32 { return 42 }
+    `;
+    const program = testParse(source);
+    const errors = testTypeCheck(program);
+    // await getValue()에서 getValue()는 i32를 반환하므로 에러
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors[0].message).toContain("await");
+  });
+});

package/src/async-jest.test.ts

@@ -0,0 +1,107 @@
+// FreeLang v4 — Async/Await 기본 테스트
+// Promise 기반 구현
+
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { TypeChecker } from "./checker";
+import { Compiler } from "./compiler";
+
+describe("Async/Await Basic Support", () => {
+  function compile(source: string) {
+    const lexer = new Lexer(source);
+    const { tokens, errors: lexErrors } = lexer.tokenize();
+    if (lexErrors.length > 0) {
+      throw new Error(`Lex errors: ${lexErrors.map(e => e.message).join(", ")}`);
+    }
+
+    const parser = new Parser(tokens);
+    const { program, errors: parseErrors } = parser.parse();
+    if (parseErrors.length > 0) {
+      throw new Error(`Parse errors: ${parseErrors.map(e => e.message).join(", ")}`);
+    }
+
+    const checker = new TypeChecker();
+    const checkErrors = checker.check(program);
+    if (checkErrors.length > 0) {
+      throw new Error(`Type errors: ${checkErrors.map(e => e.message).join(", ")}`);
+    }
+
+    const compiler = new Compiler();
+    const chunk = compiler.compile(program);
+    return chunk;
+  }
+
+  // T1: 기본 async 함수 선언
+  test("T1: Basic async function declaration", () => {
+    const source = `
+      async fn simple(): Promise<i32> {
+        return 42
+      }
+    `;
+    expect(() => compile(source)).not.toThrow();
+  });
+
+  // T2: async 함수에서 값 반환
+  test("T2: Async function with return value", () => {
+    const source = `
+      async fn getValue(): Promise<string> {
+        return "hello"
+      }
+    `;
+    expect(() => compile(source)).not.toThrow();
+  });
+
+  // T3: await 식 파싱
+  test("T3: Await expression parsing", () => {
+    const source = `
+      async fn delayed(): Promise<i32> {
+        let x = await getValue()
+        return x
+      }
+
+      fn getValue(): i32 {
+        return 42
+      }
+    `;
+    // 이 테스트는 타입 체크 에러가 발생할 것으로 예상
+    // getValue는 Promise를 반환하지 않으므로
+    const lexer = new Lexer(source);
+    const { tokens } = lexer.tokenize();
+    const parser = new Parser(tokens);
+    const { program } = parser.parse();
+
+    const checker = new TypeChecker();
+    const errors = checker.check(program);
+    // await는 Promise 타입을 요구하므로 에러가 나야 함
+    expect(errors.length).toBeGreaterThan(0);
+  });
+
+  // T4: Promise 타입 호환성
+  test("T4: Promise type compatibility", () => {
+    const source = `
+      async fn asyncFunc(): Promise<i32> {
+        return 42
+      }
+
+      fn caller(): Promise<i32> {
+        return asyncFunc()
+      }
+    `;
+    expect(() => compile(source)).not.toThrow();
+  });
+
+  // T5: await로 Promise 언래핑
+  test("T5: Await unwraps Promise type", () => {
+    const source = `
+      async fn getValue(): Promise<i32> {
+        return 42
+      }
+
+      async fn caller(): Promise<i32> {
+        let result = await getValue()
+        return result
+      }
+    `;
+    expect(() => compile(source)).not.toThrow();
+  });
+});

package/src/channel-jest.test.ts

@@ -0,0 +1,158 @@
+// FreeLang v4 — 채널/Actor 통합 테스트
+
+import { Lexer } from "./lexer";
+import { Parser } from "./parser";
+import { TypeChecker } from "./checker";
+import { Compiler } from "./compiler";
+import { VM } from "./vm";
+
+async function runCode(code: string): Promise<string[]> {
+  const lexer = new Lexer(code);
+  const { tokens, errors: lexErrors } = lexer.tokenize();
+  if (lexErrors.length > 0) {
+    throw new Error(`Lex errors: ${lexErrors.map((e) => e.message).join(", ")}`);
+  }
+
+  const parser = new Parser(tokens);
+  const { program, errors: parseErrors } = parser.parse();
+  if (parseErrors.length > 0) {
+    throw new Error(`Parse errors: ${parseErrors.map((e) => e.message).join(", ")}`);
+  }
+
+  const checker = new TypeChecker();
+  const checkErrors = checker.check(program);
+  if (checkErrors.length > 0) {
+    throw new Error(`Type errors: ${checkErrors.map((e: any) => e.message).join(", ")}`);
+  }
+
+  const compiler = new Compiler();
+  const bytecode = compiler.compile(program);
+
+  const vm = new VM();
+  const { output, error } = await vm.run(bytecode);
+  if (error) {
+    throw new Error(`Runtime error: ${error}`);
+  }
+  return output;
+}
+
+describe("Channel/Actor 기본 테스트", () => {
+  // 테스트 1: 채널 생성
+  test("T1: 채널 생성 (chan_new)", async () => {
+    const code = `
+      var ch = channel<i32>();
+      println(str(1));
+    `;
+    const output = await runCode(code);
+    expect(output).toContain("1");
+  });
+
+  // 테스트 2: 채널 송수신 (기본)
+  test("T2: 채널 송수신 (spawn에서 송신, 메인에서 수신)", async () => {
+    const code = `
+      var ch = channel<i32>();
+
+      spawn {
+        ch <- 42;
+      }
+
+      var x = <- ch;
+      println(str(x));
+    `;
+    const output = await runCode(code);
+    expect(output).toContain("42");
+  });
+
+  // 테스트 3: 다중 메시지
+  test("T3: 채널을 통한 다중 메시지 송수신", async () => {
+    const code = `
+      var ch = channel<i32>();
+
+      spawn {
+        ch <- 10;
+        ch <- 20;
+        ch <- 30;
+      }
+
+      var a = <- ch;
+      var b = <- ch;
+      var c = <- ch;
+      println(str(a));
+      println(str(b));
+      println(str(c));
+    `;
+    const output = await runCode(code);
+    expect(output).toContain("10");
+    expect(output).toContain("20");
+    expect(output).toContain("30");
+  });
+
+  // 테스트 4: 다중 Actor (2개)
+  test("T4: 다중 Actor 간 통신 (2 spawns)", async () => {
+    const code = `
+      var ch1 = channel<i32>();
+
+      spawn {
+        ch1 <- 100;
+      }
+
+      var y = <- ch1;
+      println(str(y));
+    `;
+    const output = await runCode(code);
+    expect(output).toContain("100");
+  });
+
+  // 테스트 5: 채널 타입 체크 (mismatch 감지)
+  test("T5: 채널 타입 미스매치 감지", async () => {
+    const code = `
+      var ch = channel<i32>();
+      ch <- "hello";
+    `;
+    await expect(runCode(code)).rejects.toThrow();
+  });
+
+  // 테스트 6: Actor 스케줄링 (순서 검증)
+  test("T6: Actor 스케줄링 순서 검증", async () => {
+    const code = `
+      var ch = channel<i32>();
+
+      spawn {
+        ch <- 1;
+        ch <- 2;
+      }
+
+      var x = <- ch;
+      var y = <- ch;
+      println(str(x));
+      println(str(y));
+    `;
+    const output = await runCode(code);
+    expect(output[0]).toBe("1");
+    expect(output[1]).toBe("2");
+  });
+
+  // 테스트 7: 복잡한 채널 패턴
+  test("T7: 복잡한 채널 패턴 (2개 채널)", async () => {
+    const code = `
+      var ch_a = channel<i32>();
+      var ch_b = channel<i32>();
+
+      spawn {
+        ch_a <- 1;
+      }
+
+      spawn {
+        ch_b <- 2;
+      }
+
+      var a = <- ch_a;
+      var b = <- ch_b;
+      println(str(a));
+      println(str(b));
+    `;
+    const output = await runCode(code);
+    expect(output).toContain("1");
+    expect(output).toContain("2");
+  });
+});