coolguyandClaude Opus 5
94e28d427b
이 단계가 답하는 질문은 하나다 — 이 모듈 하나만 보고 무엇을 결정할 수 있는가.
그 경계를 산출물로 만들었다.
결정할 수 있는 것은 오류로 보고한다: 중복 정의, 중복 파라미터·제네릭,
선언되지 않은 effect 변수, 같은 블록의 재바인딩, 불변 바인딩에 대한 대입,
모듈에 없는 reexport 대상, 지역 바인딩이 아닌 scope 이름, variant 인자 개수.
결정할 수 없는 것은 외부 참조로 기록하고 오류로 만들지 않는다. 모듈 로딩이
아직 없으므로 해소할 방법이 없고, 이 목록이 곧 모듈의 의존 표면이자
interface hash가 소비할 입력이다. cool deps로 볼 수 있다.
이름 해소가 아니면 못 하는 판정 하나를 구현했다: match의 맨 이름이 바인딩인지
인자 없는 생성자인지는 구문으로 갈리지 않는다. enum 선언에서 만든 생성자
표로 판정하고, 같은 표로 인자 개수도 검사한다.
샘플에서 실제 오류 둘을 잡았다:
- 03의 scope inner가 어디서도 오지 않는다. scope X { }의 X가 "이미 가진
TaskScope를 쓴다"인지 "새 자식 스코프를 만들어 X로 묶는다"인지가 정해지지
않은 탓이다. 후자라면 자식의 부모가 구문에 없어 ambient authority가 된다.
결정 전까지 해당 예제를 주석으로 두고 이유를 적었다.
- 03이 List를 import 없이 쓰고 있었다. 외부 참조 목록에 드러나 채웠다.
TaskScope가 use 값이라는 사실에서 검사 하나가 따라 나온다: scope의 머리는
모듈 수준 이름일 수 없고 반드시 지역 바인딩이어야 한다.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019ZVDeU6KLuUVL3gs18Hm3E
471 lines
16 KiB
OCaml
471 lines
16 KiB
OCaml
open Coollang
|
|
|
|
let failures = ref 0
|
|
|
|
let check name cond =
|
|
if not cond then (
|
|
incr failures;
|
|
Printf.printf "FAIL %s\n" name)
|
|
|
|
let kinds src =
|
|
match Lexer.lex_result src with
|
|
| Ok ts -> List.map (fun t -> t.Token.kind) ts
|
|
| Error e ->
|
|
failwith
|
|
(Printf.sprintf "예상치 못한 렉서 오류 %d:%d %s" e.pos.line e.pos.col e.msg)
|
|
|
|
let lex_error src =
|
|
match Lexer.lex_result src with Ok _ -> None | Error e -> Some e.msg
|
|
|
|
(* --- 키워드와 이름 --- *)
|
|
|
|
let () =
|
|
check "키워드 인식"
|
|
(kinds "fn own affine"
|
|
= [ Token.Kw_fn; Token.Kw_own; Token.Kw_affine; Token.Eof ]);
|
|
check "이름은 키워드가 아니다"
|
|
(kinds "own_er" = [ Token.Ident "own_er"; Token.Newline; Token.Eof ])
|
|
|
|
(* --- 두 글자 연산자를 먼저 본다 --- *)
|
|
|
|
let () =
|
|
check "화살표"
|
|
(kinds "-> => == != <= >= && ||"
|
|
= [
|
|
Token.Arrow;
|
|
Token.FatArrow;
|
|
Token.EqEq;
|
|
Token.BangEq;
|
|
Token.Le;
|
|
Token.Ge;
|
|
Token.AmpAmp;
|
|
Token.PipePipe;
|
|
Token.Eof;
|
|
]);
|
|
check "한 글자로 갈리는 자리"
|
|
(kinds "- = ! < > |"
|
|
= [
|
|
Token.Minus;
|
|
Token.Eq;
|
|
Token.Bang;
|
|
Token.Lt;
|
|
Token.Gt;
|
|
Token.Pipe;
|
|
Token.Eof;
|
|
])
|
|
|
|
(* --- NEWLINE 삽입 (grammar.ebnf 어휘 절) --- *)
|
|
|
|
let () =
|
|
check "값으로 끝난 줄 뒤에 삽입"
|
|
(kinds "a\nb"
|
|
= [
|
|
Token.Ident "a";
|
|
Token.Newline;
|
|
Token.Ident "b";
|
|
Token.Newline;
|
|
Token.Eof;
|
|
]);
|
|
check "여는 괄호로 끝난 줄은 이어진다"
|
|
(kinds "f(\na)"
|
|
= [
|
|
Token.Ident "f";
|
|
Token.LParen;
|
|
Token.Ident "a";
|
|
Token.RParen;
|
|
Token.Newline;
|
|
Token.Eof;
|
|
]);
|
|
check "연산자로 끝난 줄은 이어진다"
|
|
(kinds "a +\nb"
|
|
= [ Token.Ident "a"; Token.Plus; Token.Ident "b"; Token.Newline; Token.Eof ]
|
|
);
|
|
check "빈 줄은 구분자를 만들지 않는다"
|
|
(kinds "a\n\n\nb"
|
|
= [
|
|
Token.Ident "a";
|
|
Token.Newline;
|
|
Token.Ident "b";
|
|
Token.Newline;
|
|
Token.Eof;
|
|
]);
|
|
check "주석만 있는 줄도 마찬가지"
|
|
(kinds "a\n// 설명\nb"
|
|
= [
|
|
Token.Ident "a";
|
|
Token.Newline;
|
|
Token.Ident "b";
|
|
Token.Newline;
|
|
Token.Eof;
|
|
]);
|
|
check "닫는 괄호 뒤에는 삽입"
|
|
(kinds "f()\ng()"
|
|
= [
|
|
Token.Ident "f";
|
|
Token.LParen;
|
|
Token.RParen;
|
|
Token.Newline;
|
|
Token.Ident "g";
|
|
Token.LParen;
|
|
Token.RParen;
|
|
Token.Newline;
|
|
Token.Eof;
|
|
]);
|
|
check "? 뒤에는 삽입"
|
|
(kinds "f()?\ng"
|
|
= [
|
|
Token.Ident "f";
|
|
Token.LParen;
|
|
Token.RParen;
|
|
Token.Question;
|
|
Token.Newline;
|
|
Token.Ident "g";
|
|
Token.Newline;
|
|
Token.Eof;
|
|
]);
|
|
check "빈 입력" (kinds "" = [ Token.Eof ])
|
|
|
|
(* --- 리터럴 --- *)
|
|
|
|
let () =
|
|
check "정수와 밑줄"
|
|
(kinds "1_000" = [ Token.Int "1_000"; Token.Newline; Token.Eof ]);
|
|
check "문자열 이스케이프"
|
|
(kinds "\"a\\nb\"" = [ Token.Str "a\nb"; Token.Newline; Token.Eof ]);
|
|
check "밑줄 단독" (kinds "_" = [ Token.Underscore; Token.Eof ])
|
|
|
|
(* --- 오류 --- *)
|
|
|
|
let () =
|
|
check "닫히지 않은 문자열" (lex_error "\"abc" <> None);
|
|
check "줄바꿈 전에 닫지 않은 문자열" (lex_error "\"abc\ndef\"" <> None);
|
|
check "알 수 없는 이스케이프" (lex_error "\"a\\qb\"" <> None);
|
|
check "이름은 문자로 시작" (lex_error "_foo" <> None);
|
|
check "단독 &" (lex_error "a & b" <> None);
|
|
check "정수 뒤 글자" (lex_error "12abc" <> None);
|
|
check "예상치 못한 문자" (lex_error "a @ b" <> None)
|
|
|
|
(* --- 오류 위치 --- *)
|
|
|
|
let () =
|
|
match Lexer.lex_result "a\nb @ c" with
|
|
| Ok _ -> check "위치 보고" false
|
|
| Error e -> check "위치 보고" (e.pos.line = 2 && e.pos.col = 3)
|
|
|
|
(* --- 샘플 전체가 어휘 분석을 통과해야 한다 --- *)
|
|
|
|
let () =
|
|
let dir = "../samples" in
|
|
let files =
|
|
Sys.readdir dir |> Array.to_list
|
|
|> List.filter (fun f -> Filename.check_suffix f ".cool")
|
|
|> List.sort compare
|
|
in
|
|
check "샘플이 존재한다" (List.length files >= 7);
|
|
List.iter
|
|
(fun f ->
|
|
let path = Filename.concat dir f in
|
|
match Driver.tokens path with
|
|
| Ok ts -> check (f ^ " 어휘 분석") (List.length ts > 10)
|
|
| Error errors ->
|
|
List.iter
|
|
(fun e -> Printf.printf " %s\n" (Driver.string_of_error e))
|
|
errors;
|
|
check (f ^ " 어휘 분석") false)
|
|
files
|
|
|
|
(* --- 기존 계약 --- *)
|
|
|
|
let () =
|
|
check "버전 비어있지 않음" (String.length Version.string > 0);
|
|
match Driver.check [] with Error [ _ ] -> () | _ -> check "빈 입력에는 오류" false
|
|
|
|
let () =
|
|
if !failures = 0 then print_endline "ok"
|
|
else (
|
|
Printf.printf "%d개 실패\n" !failures;
|
|
exit 1)
|
|
|
|
(* --- ASI 함정: effects 절이 줄 끝에 오면 } 뒤에 NEWLINE이 삽입된다.
|
|
렉서는 이대로 두고 문법이 { NEWLINE }으로 흡수한다 (grammar.ebnf). --- *)
|
|
|
|
let () =
|
|
check "닫는 중괄호 뒤 줄바꿈은 삽입된다"
|
|
(kinds "effects {A.b}\n-> Int"
|
|
= [
|
|
Token.Kw_effects;
|
|
Token.LBrace;
|
|
Token.Ident "A";
|
|
Token.Dot;
|
|
Token.Ident "b";
|
|
Token.RBrace;
|
|
Token.Newline;
|
|
Token.Arrow;
|
|
Token.Ident "Int";
|
|
Token.Newline;
|
|
Token.Eof;
|
|
]);
|
|
check "후행 콤마가 있으면 목록이 이어진다"
|
|
(kinds "f(\na,\nb,\n)"
|
|
= [
|
|
Token.Ident "f";
|
|
Token.LParen;
|
|
Token.Ident "a";
|
|
Token.Comma;
|
|
Token.Ident "b";
|
|
Token.Comma;
|
|
Token.RParen;
|
|
Token.Newline;
|
|
Token.Eof;
|
|
])
|
|
|
|
(* ================================================================== *)
|
|
(* 파서 *)
|
|
(* ================================================================== *)
|
|
|
|
let parse_ok src =
|
|
match Lexer.lex_result src with
|
|
| Error e ->
|
|
failwith (Printf.sprintf "렉서 오류 %d:%d %s" e.pos.line e.pos.col e.msg)
|
|
| Ok ts -> (
|
|
match Parser.parse_result ts with
|
|
| Ok m -> m
|
|
| Error e ->
|
|
failwith (Printf.sprintf "파서 오류 %d:%d %s" e.pos.line e.pos.col e.msg))
|
|
|
|
let parse_err src =
|
|
match Lexer.lex_result src with
|
|
| Error e -> Some e.msg
|
|
| Ok ts -> (
|
|
match Parser.parse_result ts with Ok _ -> None | Error e -> Some e.msg)
|
|
|
|
let one src =
|
|
match (parse_ok src).Ast.items with
|
|
| [ it ] -> Ast.show_item it
|
|
| items -> Printf.sprintf "<항목 %d개>" (List.length items)
|
|
|
|
(* --- 어순: effects 절은 파라미터 뒤, 화살표 앞 --- *)
|
|
|
|
let () =
|
|
check "함수 선언 어순"
|
|
(one "pub fn f(a: Int) effects {A.b} -> Int {\n a\n}"
|
|
= "pub (fn f (a:Int) [eset A.b] -> Int (block a))");
|
|
check "결과 위치의 effect 합집합"
|
|
(one "fn f() effects e1 | e2" = "(fn f () [evar e1 | evar e2] decl)");
|
|
check "함수 타입의 어순과 중첩"
|
|
(one "fn f(g: fn(Int) effects e -> Bool) -> fn(Int) -> Int"
|
|
= "(fn f (g:(fn (Int) [evar e] -> Bool)) -> (fn (Int) -> Int) decl)")
|
|
|
|
(* --- 대괄호 제네릭: 전위는 리터럴, 후위는 인스턴스화 --- *)
|
|
|
|
let () =
|
|
check "타입 위치의 대괄호"
|
|
(one "fn f(xs: List[Int]) -> Result[a, Error]"
|
|
= "(fn f (xs:(List Int)) -> (Result a Error) decl)");
|
|
check "식 위치의 후위 대괄호는 인스턴스화"
|
|
(one "fn f() {\n map[Path, Int, {A.b}](xs, g)\n}"
|
|
= "(fn f () (block (call (inst map Path Int [eset A.b]) xs g)))");
|
|
check "전위 대괄호는 리스트 리터럴"
|
|
(one "fn f() {\n let xs = [1, 2, 3]\n xs\n}"
|
|
= "(fn f () (block (let xs (list 1 2 3)) xs))")
|
|
|
|
(* --- 파라미터 수식어 순서 --- *)
|
|
|
|
let () =
|
|
check "own은 이름 앞, affine은 타입 안"
|
|
(one "fn f(own a: affine fn() effects {F.c}, mut b: Int)"
|
|
= "(fn f (own a:(affine-fn () [eset F.c]) mut b:Int) decl)")
|
|
|
|
(* --- 선언 --- *)
|
|
|
|
let () =
|
|
check "copyable struct"
|
|
(one "pub copyable struct R {\n id: Id,\n n: Int,\n}"
|
|
= "pub copyable (struct R (id Id) (n Int))");
|
|
check "enum variant"
|
|
(one "pub enum E {\n A(Code),\n B,\n}" = "pub (enum E (A Code) (B))");
|
|
check "capability"
|
|
(one "pub capability C {\n fn m(id: Id) effects {C.m} -> R\n}"
|
|
= "pub (capability C (fn m (id:Id) [eset C.m] -> R decl))");
|
|
check "import와 reexport"
|
|
(List.length (parse_ok "import \"d/p\" as P\nreexport N\n").Ast.items = 2);
|
|
check "const" (one "pub const N: Int = 3" = "pub (const N:Int 3)")
|
|
|
|
(* --- 식 --- *)
|
|
|
|
let () =
|
|
check "우선순위"
|
|
(one "fn f() {\n a + b * c == d && e\n}"
|
|
= "(fn f () (block (&& (== (+ a (* b c)) d) e)))");
|
|
check "postfix 연쇄"
|
|
(one "fn f() {\n p.q(r)?.s\n}"
|
|
= "(fn f () (block (. (? (call (. p q) r)) s)))");
|
|
check "if는 식"
|
|
(one "fn f() {\n let x = if c {\n a\n } else {\n b\n }\n x\n}"
|
|
= "(fn f () (block (let x (if c (block a) (block b))) x))");
|
|
check "match"
|
|
(one "fn f() {\n match e {\n A(_) => 1,\n _ => 2,\n }\n}"
|
|
= "(fn f () (block (match e ((A _) => 1) (_ => 2))))");
|
|
check "scope"
|
|
(one "fn f() {\n scope sc {\n sc.spawn(g)\n }\n}"
|
|
= "(fn f () (block (scope sc (block (call (. sc spawn) g)))))");
|
|
check "struct 리터럴"
|
|
(one "fn f() {\n H { a: 1 }\n}" = "(fn f () (block (struct H (a 1))))")
|
|
|
|
(* --- 파서가 거부해야 하는 것 --- *)
|
|
|
|
let () =
|
|
check "파라미터 위치의 effect 합집합"
|
|
(parse_err "fn f(g: fn(a) effects e | {A.b})"
|
|
= Some "파라미터 위치의 effects 절에는 합집합을 쓸 수 없습니다 (변수 단독 또는 리터럴 집합만 가능)");
|
|
check "match 가드"
|
|
(parse_err
|
|
"fn f() {\n match e {\n A(r) if r.x => 1,\n _ => 2,\n }\n}"
|
|
= Some "match 가드는 v0에 없습니다 (분기 본문에서 if를 쓰십시오)");
|
|
check "후행 콤마 누락"
|
|
(parse_err "fn f(\n a: Int\n)" = Some "다중 줄 목록에는 후행 콤마가 필요합니다");
|
|
check "if 머리의 struct 리터럴"
|
|
(parse_err "fn f() {\n if H { a: 1 } {\n b\n }\n}" <> None);
|
|
check "대입 왼쪽 검사"
|
|
(parse_err "fn f() {\n g() = 1\n}" = Some "대입 왼쪽에는 변수나 필드만 올 수 있습니다");
|
|
check "한 줄에 문 두 개" (parse_err "fn f() {\n a b\n}" = Some "문 끝에 줄바꿈이 필요합니다")
|
|
|
|
(* --- 괄호 안에서는 struct 리터럴이 다시 허용된다 --- *)
|
|
|
|
let () =
|
|
check "괄호로 감싸면 if 머리에서도 가능"
|
|
(one "fn f() {\n if (H { a: 1 }).b {\n c\n }\n}"
|
|
= "(fn f () (block (if (. (struct H (a 1)) b) (block c))))")
|
|
|
|
(* --- 샘플: 01~07은 파싱되고 08은 거부되어야 한다 --- *)
|
|
|
|
let () =
|
|
let dir = "../samples" in
|
|
let files =
|
|
Sys.readdir dir |> Array.to_list
|
|
|> List.filter (fun f -> Filename.check_suffix f ".cool")
|
|
|> List.sort compare
|
|
in
|
|
List.iter
|
|
(fun f ->
|
|
let path = Filename.concat dir f in
|
|
let is_syntax_error_file = f = "08_syntax_errors.cool" in
|
|
match Driver.ast path with
|
|
| Ok m ->
|
|
if is_syntax_error_file then check (f ^ " 는 파서가 거부해야 한다") false
|
|
else check (f ^ " 구문 분석") (List.length m.Ast.items > 0)
|
|
| Error errors ->
|
|
if is_syntax_error_file then ()
|
|
else (
|
|
List.iter
|
|
(fun e -> Printf.printf " %s\n" (Driver.string_of_error e))
|
|
errors;
|
|
check (f ^ " 구문 분석") false))
|
|
files
|
|
|
|
(* ================================================================== *)
|
|
(* 이름 해소 *)
|
|
(* ================================================================== *)
|
|
|
|
let resolve_errs src =
|
|
let m = parse_ok src in
|
|
let _, errors = Resolve.resolve m in
|
|
List.map (fun (e : Resolve.error) -> e.msg) errors
|
|
|
|
let resolve_ext src =
|
|
let m = parse_ok src in
|
|
let info, _ = Resolve.resolve m in
|
|
List.map fst info.Resolve.externals
|
|
|
|
let has_err src frag =
|
|
List.exists
|
|
(fun m ->
|
|
let n = String.length frag in
|
|
let rec go i =
|
|
i + n <= String.length m && (String.sub m i n = frag || go (i + 1))
|
|
in
|
|
go 0)
|
|
(resolve_errs src)
|
|
|
|
(* --- 모듈 하나로 결정할 수 있는 것 = 오류 --- *)
|
|
|
|
let () =
|
|
check "중복 정의" (has_err "fn f()\nfn f()" "두 번 정의");
|
|
check "중복 파라미터" (has_err "fn f(a: Int, a: Int)" "파라미터 a");
|
|
check "중복 제네릭" (has_err "fn f[a, a]()" "제네릭 파라미터 a");
|
|
check "선언되지 않은 effect 변수" (has_err "fn f() effects e" "선언되지 않은 effect 변수 e");
|
|
check "선언된 effect 변수는 통과" (resolve_errs "fn f[e: effects]() effects e" = []);
|
|
check "파라미터 타입 안의 effect 변수도 본다"
|
|
(has_err "fn f(g: fn() effects e)" "선언되지 않은 effect 변수 e");
|
|
check "같은 블록의 재바인딩"
|
|
(has_err "fn f() {\n let a = 1\n let a = 2\n a\n}" "다시 묶을 수 없습니다");
|
|
check "중첩 블록의 가림은 허용"
|
|
(resolve_errs
|
|
"fn f() {\n let a = 1\n if a {\n let a = 2\n a\n }\n}"
|
|
= []);
|
|
check "불변 바인딩에 대입" (has_err "fn f() {\n let a = 1\n a = 2\n}" "불변 바인딩");
|
|
check "mut이면 통과" (resolve_errs "fn f() {\n let mut a = 1\n a = 2\n}" = []);
|
|
check "모듈에 없는 reexport" (has_err "reexport N" "이 모듈에 없습니다");
|
|
check "모듈에 있는 reexport는 통과" (resolve_errs "enum N {\n A,\n}\nreexport N" = [])
|
|
|
|
(* --- scope 머리는 지역 바인딩이어야 한다 --- *)
|
|
|
|
let () =
|
|
check "지역 바인딩이 아닌 scope 이름"
|
|
(has_err "fn f() {\n scope sc {\n sc\n }\n}" "지역 바인딩이 아닙니다");
|
|
check "파라미터로 온 scope는 통과"
|
|
(resolve_errs "fn f(sc: TaskScope) {\n scope sc {\n sc\n }\n}" = [])
|
|
|
|
(* --- variant는 구문이 아니라 이름 해소가 판정한다 --- *)
|
|
|
|
let () =
|
|
let enum = "enum E {\n A(Code),\n B,\n}\n" in
|
|
check "인자 없는 variant는 바인딩이 아니라 생성자"
|
|
(resolve_errs
|
|
(enum ^ "fn f(e: E) {\n match e {\n B => 1,\n _ => 2,\n }\n}")
|
|
= []);
|
|
check "variant 인자 개수"
|
|
(has_err
|
|
(enum ^ "fn f(e: E) {\n match e {\n A => 1,\n _ => 2,\n }\n}")
|
|
"인자 1개가 필요합니다");
|
|
check "패턴의 중복 바인딩"
|
|
(has_err
|
|
(enum ^ "fn f(e: E) {\n match e {\n A(x) => x,\n _ => 0,\n }\n}"
|
|
^ "\nfn g(e: E) {\n match e {\n A(x) => x,\n _ => 0,\n }\n}")
|
|
"두 번 나옵니다"
|
|
= false)
|
|
|
|
(* --- 결정할 수 없는 것 = 외부 참조 --- *)
|
|
|
|
let () =
|
|
check "모르는 타입은 외부 참조" (resolve_ext "fn f(a: Widget)" = [ "Widget" ]);
|
|
check "import한 이름은 외부 참조가 아니다"
|
|
(resolve_ext "import \"d/p\" as P\nfn f() {\n P.go()\n}" = []);
|
|
check "지역 이름은 외부 참조가 아니다" (resolve_ext "fn f(a: Int) {\n a\n}" = []);
|
|
check "builtin은 외부 참조가 아니다"
|
|
(resolve_ext "fn f(a: Int) -> Result[Int, Int] {\n Ok(a)\n}" = []);
|
|
check "effect 집합의 capability도 표면에 든다"
|
|
(resolve_ext "fn f() effects {Gw.pay}" = [ "Gw" ])
|
|
|
|
(* --- 샘플: 01~07은 이름 해소를 통과해야 한다 --- *)
|
|
|
|
let () =
|
|
let dir = "../samples" in
|
|
let files =
|
|
Sys.readdir dir |> Array.to_list
|
|
|> List.filter (fun f -> Filename.check_suffix f ".cool")
|
|
|> List.filter (fun f -> f <> "08_syntax_errors.cool")
|
|
|> List.sort compare
|
|
in
|
|
List.iter
|
|
(fun f ->
|
|
let path = Filename.concat dir f in
|
|
match Driver.resolve path with
|
|
| Ok _ -> ()
|
|
| Error errors ->
|
|
List.iter
|
|
(fun e -> Printf.printf " %s\n" (Driver.string_of_error e))
|
|
errors;
|
|
check (f ^ " 이름 해소") false)
|
|
files
|