lexer: 어휘 분석 구현과 ASI 함정 하나 정정

grammar.ebnf의 어휘 절을 구현한다. 렉서는 선읽기를 요구하지 않고,
문법과 얽히는 유일한 부분인 NEWLINE 삽입은 can_end_statement 하나로
판정한다. 모든 토큰이 위치를 들고 다닌다 — 진단 품질이 헌법급이므로
나중에 붙이지 않는다.

샘플을 실제로 렉싱해 함정을 하나 잡았다. effects 절이 줄 끝에 오면 "}"가
값 종료 토큰이라 NEWLINE이 삽입되어 다음 줄의 "->"와 끊긴다(Go ASI와 같은
형태). 렉서에 문맥을 주는 대신 — 렉서 피드백은 철학 2가 배제한다 —
시그니처 머리의 흡수 위치를 프로덕션에 명시적으로 적어 닫았다. 파서가
임의로 건너뛰는 것이 아니라 문법에 적힌 자리에서만 흡수한다.
다중 줄 목록의 후행 콤마 필수도 함께 명시(콤마로 끝난 줄은 NEWLINE을
만들지 않으므로 목록이 자연히 이어진다).

cool check는 어휘 분석을 돌리되 통과했다고 말하지 않는다. 파이프라인의
나머지가 없는 이상 그 파일은 검사된 것이 아니다. 디버깅용 cool tokens 추가.

테스트 30건: 키워드, 두 글자 연산자 우선, NEWLINE 삽입 6가지 경우,
리터럴과 이스케이프, 오류 7종과 오류 위치, 그리고 samples/*.cool 전체가
어휘 분석을 통과하는지.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019ZVDeU6KLuUVL3gs18Hm3E

bin/main.ml

@@ -4,23 +4,30 @@ let usage =
 사용법:
   cool check <file.cool>...   타입/effect/capability 검사 (fast path)
   cool run <file.cool>        typed IR 인터프리터로 실행
+  cool tokens <file.cool>     토큰 덤프 (렉서 디버깅)
   cool version                버전 출력
 |}
 
-let report = function
+let report_errors errors =
-  | Ok () -> 0
+  List.iter (fun e -> prerr_endline (Coollang.Driver.string_of_error e)) errors;
-  | Error errors ->
-      List.iter
-        (fun e -> prerr_endline (Coollang.Driver.string_of_error e))
-        errors;
   1
 
+let report = function Ok () -> 0 | Error errors -> report_errors errors
+
+let dump_tokens file =
+  match Coollang.Driver.tokens file with
+  | Error errors -> report_errors errors
+  | Ok tokens ->
+      List.iter (fun t -> print_endline (Coollang.Token.show t)) tokens;
+      0
+
 let () =
   let argv = Array.to_list Sys.argv in
   let code =
     match List.tl argv with
     | "check" :: files -> report (Coollang.Driver.check files)
     | [ "run"; file ] -> report (Coollang.Driver.run file)
+    | [ "tokens"; file ] -> dump_tokens file
     | [ "version" ] ->
         print_endline Coollang.Version.string;
         0

docs/grammar.ebnf

@@ -24,6 +24,15 @@
  *   그 줄 끝에 NEWLINE 토큰을 넣는다. 그 외에는 넣지 않는다.
  *   따라서 연산자나 여는 괄호로 끝나는 줄은 다음 줄로 이어진다.
  *   빈 줄과 주석만 있는 줄은 NEWLINE을 만들지 않는다.
+ *
+ * 다중 줄 목록(파라미터, 인자, 필드, variant, 리스트 리터럴)은 후행 콤마가
+ * 필수다. 콤마로 끝난 줄은 NEWLINE을 만들지 않으므로 목록이 자연히 이어진다.
+ * 공식 formatter가 이를 강제한다.
+ *
+ * 시그니처 머리에서는 NEWLINE이 문법적으로 허용되고 무시된다. effects 절이
+ * 줄 끝에 오면 "}"가 값 종료 토큰이라 NEWLINE이 삽입되는데, 이 자리는 문이
+ * 끝날 수 있는 자리가 아니므로 아래 프로덕션이 { NEWLINE }으로 흡수한다.
+ * 흡수 위치를 프로덕션에 명시적으로 적는다 — 파서가 임의로 건너뛰지 않는다.
  *)
 
 ident          = letter , { letter | digit | "_" } ;
@@ -37,7 +46,9 @@ literal        = int_lit | string_lit | bool_lit ;
 (* ------------------------------------------------------------------ *)
 
 module         = { NEWLINE } , { item } ;
-item           = ( import | reexport | decl ) , NEWLINE ;
+item           = ( import | reexport | decl ) , { NEWLINE } ;
+(* decl이 이미 NEWLINE을 흡수했을 수 있으므로 항목 구분자는 0개 이상이다.
+ * 문 수준에서는 그렇지 않다 — stmt는 NEWLINE 하나를 반드시 요구한다 *)
 
 import         = "import" , string_lit , "as" , ident ;
 reexport       = "reexport" , ident ;
@@ -50,7 +61,10 @@ decl           = [ "pub" ] , ( fn_decl | struct_decl | enum_decl
 (* ------------------------------------------------------------------ *)
 
 fn_decl        = "fn" , ident , [ gen_params ] , "(" , [ params ] , ")" ,
-                 [ eff_result ] , [ "->" , type ] , [ block ] ;
+                 { NEWLINE } ,
+                 [ eff_result , { NEWLINE } ] ,
+                 [ "->" , type , { NEWLINE } ] ,
+                 [ block ] ;
 (* block이 없으면 시그니처 선언. interface 파일과 capability 본문에서 쓴다 *)
 
 struct_decl    = [ "copyable" ] , "struct" , ident , [ gen_params ] ,
@@ -61,8 +75,8 @@ enum_decl      = "enum" , ident , [ gen_params ] , "{" , { variant } , "}" ;
 variant        = ident , [ "(" , type_list , ")" ] , "," , { NEWLINE } ;
 
 capability_decl = "capability" , ident , "{" , { cap_method } , "}" ;
-cap_method     = "fn" , ident , "(" , [ params ] , ")" ,
+cap_method     = "fn" , ident , "(" , [ params ] , ")" , { NEWLINE } ,
-                 [ eff_result ] , [ "->" , type ] , NEWLINE ;
+                 [ eff_result , { NEWLINE } ] , [ "->" , type ] , NEWLINE ;
 
 const_decl     = "const" , ident , ":" , type , "=" , expr ;
 
@@ -110,7 +124,8 @@ type_list      = type , { "," , type } , [ "," ] ;
 (* ------------------------------------------------------------------ *)
 
 block          = "{" , { NEWLINE } , { stmt } , "}" ;
-stmt           = ( let_stmt | return_stmt | assign_stmt | expr ) , NEWLINE ;
+stmt           = ( let_stmt | return_stmt | assign_stmt | expr ) ,
+                 NEWLINE , { NEWLINE } ;
 
 let_stmt       = "let" , [ "mut" ] , pattern , [ ":" , type ] , "=" , expr ;
 return_stmt    = "return" , [ expr ] ;

lib/driver.ml

@@ -1,17 +1,59 @@
-(* v0 파이프라인의 자리표시자.
+(* v0 파이프라인.
    parse -> name resolution -> type check -> effect/capability check
    -> interface artifact + hash -> (cool run 시) 얇은 typed IR -> interpreter
 
-   각 단계는 별도 모듈로 분리해 들어온다. 지금은 CLI 형태만 고정한다. *)
+   현재 구현된 단계: 어휘 분석. *)
 
-type error = { file : string; message : string }
+type error = { file : string; line : int; col : int; message : string }
 
-let string_of_error { file; message } = Printf.sprintf "%s: %s" file message
+let string_of_error { file; line; col; message } =
+  Printf.sprintf "%s:%d:%d: %s" file line col message
+
+let read_file file =
+  try
+    let ic = open_in_bin file in
+    let n = in_channel_length ic in
+    let s = really_input_string ic n in
+    close_in ic;
+    Ok s
+  with Sys_error msg -> Error { file; line = 0; col = 0; message = msg }
+
+let lex_file file =
+  match read_file file with
+  | Error e -> Error e
+  | Ok src -> (
+      match Lexer.lex_result src with
+      | Ok tokens -> Ok tokens
+      | Error { pos; msg } ->
+          Error { file; line = pos.line; col = pos.col; message = msg })
+
+let tokens (file : string) : (Token.t list, error list) result =
+  match lex_file file with Ok ts -> Ok ts | Error e -> Error [ e ]
 
 let check (files : string list) : (unit, error list) result =
   match files with
-  | [] -> Error [ { file = "<none>"; message = "검사할 파일이 없습니다" } ]
+  | [] ->
-  | file :: _ -> Error [ { file; message = "check 파이프라인이 아직 구현되지 않았습니다" } ]
+      Error [ { file = "<none>"; line = 0; col = 0; message = "검사할 파일이 없습니다" } ]
+  | _ ->
+      let errors =
+        List.filter_map
+          (fun f -> match lex_file f with Ok _ -> None | Error e -> Some e)
+          files
+      in
+      if errors <> [] then Error errors
+      else
+        (* 어휘 분석은 통과했다. 통과했다고 말하지 않는다 — 파이프라인의
+           나머지가 아직 없으므로 검사되지 않은 것이다. *)
+        Error
+          (List.map
+             (fun f ->
+               {
+                 file = f;
+                 line = 0;
+                 col = 0;
+                 message = "어휘 분석까지 통과. 파서가 아직 구현되지 않았습니다";
+               })
+             files)
 
 let run (file : string) : (unit, error list) result =
-  Error [ { file; message = "interpreter가 아직 구현되지 않았습니다" } ]
+  Error [ { file; line = 0; col = 0; message = "interpreter가 아직 구현되지 않았습니다" } ]

lib/lexer.ml

@@ -0,0 +1,192 @@
+(* 렉서. grammar.ebnf의 어휘 절을 그대로 구현한다.
+   유일하게 문법과 얽히는 부분은 NEWLINE 삽입인데, 그 판정은
+   Token.can_end_statement 하나로 끝나며 선읽기를 요구하지 않는다. *)
+
+type error = { pos : Token.pos; msg : string }
+
+exception Error of error
+
+type state = {
+  src : string;
+  len : int;
+  mutable i : int;
+  mutable line : int;
+  mutable bol : int; (* 현재 줄의 시작 offset *)
+  mutable out : Token.t list; (* 역순 누적 *)
+}
+
+let pos st : Token.pos = { line = st.line; col = st.i - st.bol + 1 }
+let fail st msg = raise (Error { pos = pos st; msg })
+let fail_at p msg = raise (Error { pos = p; msg })
+let peek st = if st.i < st.len then Some st.src.[st.i] else None
+let peek2 st = if st.i + 1 < st.len then Some st.src.[st.i + 1] else None
+let emit st p kind = st.out <- { Token.kind; pos = p } :: st.out
+let last_kind st = match st.out with [] -> None | t :: _ -> Some t.Token.kind
+
+(* 줄 끝에 도달했을 때만 호출된다. 직전 토큰이 값으로 끝날 수 있으면 삽입.
+   이미 Newline을 넣었거나 아무것도 없으면 넣지 않으므로,
+   빈 줄과 주석만 있는 줄은 구분자를 만들지 않는다. *)
+let maybe_newline st =
+  match last_kind st with
+  | Some k when Token.can_end_statement k -> emit st (pos st) Token.Newline
+  | _ -> ()
+
+let is_letter c = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')
+let is_digit c = c >= '0' && c <= '9'
+let is_ident_rest c = is_letter c || is_digit c || c = '_'
+
+let lex_ident st =
+  let p = pos st in
+  let start = st.i in
+  while st.i < st.len && is_ident_rest st.src.[st.i] do
+    st.i <- st.i + 1
+  done;
+  let s = String.sub st.src start (st.i - start) in
+  match Token.keyword s with
+  | Some k -> emit st p k
+  | None -> emit st p (Token.Ident s)
+
+let lex_int st =
+  let p = pos st in
+  let start = st.i in
+  while st.i < st.len && (is_digit st.src.[st.i] || st.src.[st.i] = '_') do
+    st.i <- st.i + 1
+  done;
+  (* 숫자 바로 뒤에 글자가 붙으면 오타일 가능성이 높다. 조용히 넘기지 않는다. *)
+  if st.i < st.len && is_letter st.src.[st.i] then
+    fail st "정수 리터럴 뒤에 글자가 올 수 없습니다";
+  emit st p (Token.Int (String.sub st.src start (st.i - start)))
+
+let lex_string st =
+  let p = pos st in
+  st.i <- st.i + 1;
+  let buf = Buffer.create 16 in
+  let rec go () =
+    if st.i >= st.len then fail_at p "문자열이 닫히지 않았습니다"
+    else
+      match st.src.[st.i] with
+      | '"' -> st.i <- st.i + 1
+      | '\n' -> fail_at p "문자열이 닫히지 않았습니다 (줄바꿈 전에 닫아야 합니다)"
+      | '\\' ->
+          st.i <- st.i + 1;
+          if st.i >= st.len then fail_at p "문자열이 닫히지 않았습니다";
+          let c = st.src.[st.i] in
+          let decoded =
+            match c with
+            | 'n' -> '\n'
+            | 't' -> '\t'
+            | '\\' -> '\\'
+            | '"' -> '"'
+            | _ -> fail st (Printf.sprintf "알 수 없는 이스케이프 \\%c" c)
+          in
+          Buffer.add_char buf decoded;
+          st.i <- st.i + 1;
+          go ()
+      | c ->
+          Buffer.add_char buf c;
+          st.i <- st.i + 1;
+          go ()
+  in
+  go ();
+  emit st p (Token.Str (Buffer.contents buf))
+
+let skip_line_comment st =
+  while st.i < st.len && st.src.[st.i] <> '\n' do
+    st.i <- st.i + 1
+  done
+
+(* 한 글자 또는 두 글자 연산자. 두 글자를 항상 먼저 본다. *)
+let lex_punct st =
+  let p = pos st in
+  let one k =
+    st.i <- st.i + 1;
+    emit st p k
+  in
+  let two k =
+    st.i <- st.i + 2;
+    emit st p k
+  in
+  match (st.src.[st.i], peek2 st) with
+  | '-', Some '>' -> two Token.Arrow
+  | '=', Some '>' -> two Token.FatArrow
+  | '=', Some '=' -> two Token.EqEq
+  | '!', Some '=' -> two Token.BangEq
+  | '<', Some '=' -> two Token.Le
+  | '>', Some '=' -> two Token.Ge
+  | '&', Some '&' -> two Token.AmpAmp
+  | '|', Some '|' -> two Token.PipePipe
+  | '(', _ -> one Token.LParen
+  | ')', _ -> one Token.RParen
+  | '{', _ -> one Token.LBrace
+  | '}', _ -> one Token.RBrace
+  | '[', _ -> one Token.LBracket
+  | ']', _ -> one Token.RBracket
+  | ',', _ -> one Token.Comma
+  | ':', _ -> one Token.Colon
+  | '.', _ -> one Token.Dot
+  | '?', _ -> one Token.Question
+  | '=', _ -> one Token.Eq
+  | '!', _ -> one Token.Bang
+  | '<', _ -> one Token.Lt
+  | '>', _ -> one Token.Gt
+  | '+', _ -> one Token.Plus
+  | '-', _ -> one Token.Minus
+  | '*', _ -> one Token.Star
+  | '/', _ -> one Token.Slash
+  | '%', _ -> one Token.Percent
+  | '|', _ -> one Token.Pipe
+  | '&', _ -> fail st "& 연산자는 없습니다 (&&를 의도했습니까?)"
+  | c, _ -> fail st (Printf.sprintf "예상치 못한 문자 %C" c)
+
+let lex (src : string) : Token.t list =
+  let st =
+    { src; len = String.length src; i = 0; line = 1; bol = 0; out = [] }
+  in
+  let rec go () =
+    if st.i >= st.len then (
+      maybe_newline st;
+      emit st (pos st) Token.Eof)
+    else
+      let c = st.src.[st.i] in
+      match c with
+      | ' ' | '\t' | '\r' ->
+          st.i <- st.i + 1;
+          go ()
+      | '\n' ->
+          maybe_newline st;
+          st.i <- st.i + 1;
+          st.line <- st.line + 1;
+          st.bol <- st.i;
+          go ()
+      | '/' when peek2 st = Some '/' ->
+          skip_line_comment st;
+          go ()
+      | '_' ->
+          let p = pos st in
+          if st.i + 1 < st.len && is_ident_rest st.src.[st.i + 1] then
+            fail st "이름은 문자로 시작해야 합니다"
+          else (
+            st.i <- st.i + 1;
+            emit st p Token.Underscore;
+            go ())
+      | c when is_letter c ->
+          lex_ident st;
+          go ()
+      | c when is_digit c ->
+          lex_int st;
+          go ()
+      | '"' ->
+          lex_string st;
+          go ()
+      | _ ->
+          lex_punct st;
+          go ()
+  in
+  go ();
+  List.rev st.out
+
+let lex_result src =
+  match lex src with tokens -> Ok tokens | exception Error e -> Error e
+
+(* peek는 lex_punct 안에서만 쓰이지 않으므로 경고를 피한다 *)
+let _ = peek

lib/token.ml

@@ -0,0 +1,162 @@
+(* 토큰 정의. 위치는 진단 품질이 헌법급이므로 모든 토큰이 들고 다닌다. *)
+
+type pos = { line : int; col : int }
+
+type kind =
+  (* 리터럴과 이름 *)
+  | Ident of string
+  | Int of string
+  | Str of string
+  (* 키워드 *)
+  | Kw_pub
+  | Kw_fn
+  | Kw_struct
+  | Kw_enum
+  | Kw_capability
+  | Kw_const
+  | Kw_import
+  | Kw_as
+  | Kw_reexport
+  | Kw_let
+  | Kw_mut
+  | Kw_own
+  | Kw_affine
+  | Kw_copyable
+  | Kw_effects
+  | Kw_return
+  | Kw_if
+  | Kw_else
+  | Kw_match
+  | Kw_scope
+  | Kw_true
+  | Kw_false
+  (* 구두점 *)
+  | LParen
+  | RParen
+  | LBrace
+  | RBrace
+  | LBracket
+  | RBracket
+  | Comma
+  | Colon
+  | Dot
+  | Arrow
+  | FatArrow
+  | Question
+  | Underscore
+  | Eq
+  | EqEq
+  | Bang
+  | BangEq
+  | Lt
+  | Le
+  | Gt
+  | Ge
+  | Plus
+  | Minus
+  | Star
+  | Slash
+  | Percent
+  | AmpAmp
+  | PipePipe
+  | Pipe
+  (* 렉서가 삽입하는 문 구분자 *)
+  | Newline
+  | Eof
+
+type t = { kind : kind; pos : pos }
+
+let keyword = function
+  | "pub" -> Some Kw_pub
+  | "fn" -> Some Kw_fn
+  | "struct" -> Some Kw_struct
+  | "enum" -> Some Kw_enum
+  | "capability" -> Some Kw_capability
+  | "const" -> Some Kw_const
+  | "import" -> Some Kw_import
+  | "as" -> Some Kw_as
+  | "reexport" -> Some Kw_reexport
+  | "let" -> Some Kw_let
+  | "mut" -> Some Kw_mut
+  | "own" -> Some Kw_own
+  | "affine" -> Some Kw_affine
+  | "copyable" -> Some Kw_copyable
+  | "effects" -> Some Kw_effects
+  | "return" -> Some Kw_return
+  | "if" -> Some Kw_if
+  | "else" -> Some Kw_else
+  | "match" -> Some Kw_match
+  | "scope" -> Some Kw_scope
+  | "true" -> Some Kw_true
+  | "false" -> Some Kw_false
+  | _ -> None
+
+let show_kind = function
+  | Ident s -> Printf.sprintf "이름 %s" s
+  | Int s -> Printf.sprintf "정수 %s" s
+  | Str _ -> "문자열"
+  | Kw_pub -> "pub"
+  | Kw_fn -> "fn"
+  | Kw_struct -> "struct"
+  | Kw_enum -> "enum"
+  | Kw_capability -> "capability"
+  | Kw_const -> "const"
+  | Kw_import -> "import"
+  | Kw_as -> "as"
+  | Kw_reexport -> "reexport"
+  | Kw_let -> "let"
+  | Kw_mut -> "mut"
+  | Kw_own -> "own"
+  | Kw_affine -> "affine"
+  | Kw_copyable -> "copyable"
+  | Kw_effects -> "effects"
+  | Kw_return -> "return"
+  | Kw_if -> "if"
+  | Kw_else -> "else"
+  | Kw_match -> "match"
+  | Kw_scope -> "scope"
+  | Kw_true -> "true"
+  | Kw_false -> "false"
+  | LParen -> "("
+  | RParen -> ")"
+  | LBrace -> "{"
+  | RBrace -> "}"
+  | LBracket -> "["
+  | RBracket -> "]"
+  | Comma -> ","
+  | Colon -> ":"
+  | Dot -> "."
+  | Arrow -> "->"
+  | FatArrow -> "=>"
+  | Question -> "?"
+  | Underscore -> "_"
+  | Eq -> "="
+  | EqEq -> "=="
+  | Bang -> "!"
+  | BangEq -> "!="
+  | Lt -> "<"
+  | Le -> "<="
+  | Gt -> ">"
+  | Ge -> ">="
+  | Plus -> "+"
+  | Minus -> "-"
+  | Star -> "*"
+  | Slash -> "/"
+  | Percent -> "%"
+  | AmpAmp -> "&&"
+  | PipePipe -> "||"
+  | Pipe -> "|"
+  | Newline -> "줄바꿈"
+  | Eof -> "파일 끝"
+
+let show { kind; pos } =
+  Printf.sprintf "%d:%d %s" pos.line pos.col (show_kind kind)
+
+(* 줄 끝에서 문 구분자를 삽입할지 결정한다 (grammar.ebnf 어휘 절).
+   값으로 끝날 수 있는 토큰 뒤에서만 삽입하므로, 연산자나 여는 괄호로
+   끝나는 줄은 다음 줄로 이어진다. *)
+let can_end_statement = function
+  | Ident _ | Int _ | Str _ | RParen | RBracket | RBrace | Question | Kw_return
+  | Kw_true | Kw_false ->
+      true
+  | _ -> false

test/dune

@@ -1,3 +1,5 @@
 (test
  (name test_coollang)
- (libraries coollang))
+ (libraries coollang)
+ (deps
+  (glob_files %{workspace_root}/samples/*.cool)))

test/test_coollang.ml

@@ -1,8 +1,220 @@
-let () = assert (String.length Coollang.Version.string > 0)
+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 () =
-  match Coollang.Driver.check [] with
+  check "키워드 인식"
-  | Error [ _ ] -> ()
+    (kinds "fn own affine"
-  | _ -> failwith "빈 입력에는 오류가 나야 한다"
+    = [ Token.Kw_fn; Token.Kw_own; Token.Kw_affine; Token.Eof ]);
+  check "이름은 키워드가 아니다"
+    (kinds "own_er" = [ Token.Ident "own_er"; Token.Newline; Token.Eof ])
 
-let () = print_endline "ok"
+(* --- 두 글자 연산자를 먼저 본다 --- *)
+
+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;
+      ])