@algosail/lang 0.2.11 → 0.5.0

package/test/parse/ast.test.js

@@ -0,0 +1,476 @@
+/**
+ * Контракт AST для публичного `parseSource` (RFC-0.1 п.12.2, `lang/lib/parse/ast-spec.js`).
+ *
+ * Ожидается: при успехе всегда есть объект `ast` (в т.ч. для пустого/пробельного файла);
+ * при ошибке `ast === undefined`. Следующий этап — реализация в `parse-source.js` / `index.js`.
+ */
+import test from 'brittle'
+import { parseSource } from '../../index.js'
+
+/** @param {import('brittle').Test} t */
+function assertPos (t, p, label) {
+  t.ok(p !== null && typeof p === 'object', `${label} is an object`)
+  t.ok(Number.isFinite(p.offset) && p.offset >= 0, `${label}.offset`)
+  t.ok(Number.isFinite(p.line) && p.line >= 1, `${label}.line`)
+  t.ok(Number.isFinite(p.column) && p.column >= 1, `${label}.column`)
+}
+
+/** @param {import('brittle').Test} t */
+function assertSpan (t, span) {
+  t.ok(span != null && typeof span === 'object', 'span is an object')
+  if (span == null || typeof span !== 'object') return
+  assertPos(t, span.start, 'span.start')
+  assertPos(t, span.end, 'span.end')
+}
+
+/**
+ * @param {import('brittle').Test} t
+ * @param {unknown} ast
+ * @returns {boolean}
+ */
+function assertSourceFileShell (t, ast) {
+  t.ok(ast !== null && ast !== undefined && typeof ast === 'object', 'ast is an object')
+  if (ast == null || typeof ast !== 'object') return false
+  t.is(ast.kind, 'source_file')
+  t.ok(Array.isArray(ast.items), 'ast.items is an array')
+  if (!Array.isArray(ast.items)) return false
+  assertSpan(t, ast.span)
+  return ast.span != null && ast.span.start != null && ast.span.end != null
+}
+
+test('parseSource: при ошибке ast отсутствует (undefined)', function (t) {
+  const r = parseSource('not_a_marker')
+  t.ok(r.ok === false)
+  t.is(r.ast, undefined)
+  t.end()
+})
+
+test('parseSource: при успехе ast — объект source_file с span и items', function (t) {
+  const r = parseSource('+Math ./math.sail')
+  t.ok(r.ok === true)
+  t.ok(r.ast !== undefined && r.ast !== null)
+  assertSourceFileShell(t, r.ast)
+  t.end()
+})
+
+test('AST: пустой файл и только пробелы дают source_file с пустыми items', function (t) {
+  for (const src of ['', '  \n\t  \n']) {
+    const r = parseSource(src)
+    t.ok(r.ok === true, `ok for ${JSON.stringify(src)}`)
+    t.ok(r.ast !== undefined && r.ast !== null, `ast present for ${JSON.stringify(src)}`)
+    if (!assertSourceFileShell(t, r.ast)) continue
+    t.alike(r.ast.items, [])
+  }
+  t.end()
+})
+
+test('AST: простой импорт +Module path', function (t) {
+  const r = parseSource('+Math ./math.sail\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  t.is(r.ast.items.length, 1)
+  const imp = r.ast.items[0]
+  t.is(imp.kind, 'import')
+  assertSpan(t, imp.span)
+  t.is(imp.module, 'Math')
+  t.is(imp.path, './math.sail')
+  t.alike(imp.doc, [])
+  t.is(imp.bracket, null)
+  t.end()
+})
+
+test('AST: скобочный импорт — bracket.words и bracket.types', function (t) {
+  const r = parseSource('+Lib ( @add &Point ) ./lib.sail')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const imp = r.ast.items[0]
+  t.is(imp.kind, 'import')
+  t.ok(imp.bracket !== null)
+  t.alike(imp.bracket.words, ['add'])
+  t.alike(imp.bracket.types, ['Point'])
+  t.end()
+})
+
+test('AST: doc перед импортом попадает в import.doc', function (t) {
+  const r = parseSource('-- hello --\n+Mod ./p.sail')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const imp = r.ast.items[0]
+  t.alike(imp.doc, [' hello '])
+  t.end()
+})
+
+test('AST: sum-тип с тегами и пустыми doc', function (t) {
+  const src = '&Bool\n| True\n| False'
+  const r = parseSource(src)
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const sum = r.ast.items[0]
+  t.is(sum.kind, 'sum_type')
+  assertSpan(t, sum.span)
+  t.is(sum.name, 'Bool')
+  t.alike(sum.typeParams, [])
+  t.alike(sum.doc, [])
+  t.is(sum.tags.length, 2)
+  t.is(sum.tags[0].name, 'True')
+  t.is(sum.tags[0].payload, null)
+  t.alike(sum.tags[0].doc, [])
+  assertSpan(t, sum.tags[0].span)
+  t.is(sum.tags[1].name, 'False')
+  t.end()
+})
+
+test('AST: sum-тип с параметром типа и полезной нагрузкой у тега', function (t) {
+  const src = '&Maybe a\n| None\n| Some a'
+  const r = parseSource(src)
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const sum = r.ast.items[0]
+  t.is(sum.name, 'Maybe')
+  t.alike(sum.typeParams, ['a'])
+  t.is(sum.tags[0].name, 'None')
+  t.is(sum.tags[0].payload, null)
+  t.is(sum.tags[1].name, 'Some')
+  t.ok(sum.tags[1].payload !== null)
+  t.is(sum.tags[1].payload.kind, 'type_var')
+  t.is(sum.tags[1].payload.name, 'a')
+  t.end()
+})
+
+test('AST: product-тип с полями', function (t) {
+  const src = '&Point\n:x Num\n:y Num'
+  const r = parseSource(src)
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const prod = r.ast.items[0]
+  t.is(prod.kind, 'product_type')
+  t.is(prod.name, 'Point')
+  t.alike(prod.typeParams, [])
+  t.alike(prod.doc, [])
+  t.is(prod.fields.length, 2)
+  t.is(prod.fields[0].name, 'x')
+  t.is(prod.fields[0].type.kind, 'type_name')
+  t.is(prod.fields[0].type.name, 'Num')
+  t.alike(prod.fields[0].doc, [])
+  assertSpan(t, prod.fields[0].span)
+  t.is(prod.fields[1].name, 'y')
+  t.end()
+})
+
+test('AST: слово с пустой сигнатурой ( -> ) и пустым телом', function (t) {
+  const r = parseSource('@nop ( -> )\n\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  t.is(r.ast.items.length, 1)
+  const w = r.ast.items[0]
+  t.is(w.kind, 'word')
+  t.is(w.name, 'nop')
+  assertSpan(t, w.span)
+  t.alike(w.doc, [])
+  const sig = w.signature
+  t.is(sig.kind, 'signature')
+  assertSpan(t, sig.span)
+  t.alike(sig.left, [])
+  t.alike(sig.right, [])
+  t.alike(sig.effectsAdd, [])
+  t.alike(sig.effectsRemove, [])
+  t.alike(w.body, [])
+  t.end()
+})
+
+test('AST: сигнатура со stack_var ~s и типом Num с обеих сторон стрелки', function (t) {
+  const r = parseSource('@id ( ~s Num -> ~s Num )\n\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const w0 = r.ast.items[0]
+  t.ok(w0 && w0.signature, 'word has signature')
+  if (!w0 || !w0.signature) return t.end()
+  const sig = w0.signature
+  t.is(sig.left.length, 2)
+  t.is(sig.left[0].kind, 'stack_var')
+  t.is(sig.left[0].name, 's')
+  assertSpan(t, sig.left[0].span)
+  t.is(sig.left[1].kind, 'sig_type_expr')
+  t.is(sig.left[1].type.kind, 'type_name')
+  t.is(sig.left[1].type.name, 'Num')
+  assertSpan(t, sig.left[1].span)
+
+  t.is(sig.right.length, 2)
+  t.is(sig.right[0].kind, 'stack_var')
+  t.is(sig.right[0].name, 's')
+  t.is(sig.right[1].kind, 'sig_type_expr')
+  t.is(sig.right[1].type.kind, 'type_name')
+  t.is(sig.right[1].type.name, 'Num')
+  t.alike(sig.effectsAdd, [])
+  t.alike(sig.effectsRemove, [])
+  t.end()
+})
+
+test('AST: маркеры эффектов только в конце правой части (effectsAdd / effectsRemove, side right)', function (t) {
+  const r = parseSource('@run ( Num -> Str +Async +Fail -Async )\n\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const w0 = r.ast.items[0]
+  t.ok(w0 && w0.signature, 'word has signature')
+  if (!w0 || !w0.signature) return t.end()
+  const sig = w0.signature
+  t.is(sig.left.length, 1)
+  t.is(sig.left[0].kind, 'sig_type_expr')
+  t.is(sig.left[0].type.kind, 'type_name')
+  t.is(sig.left[0].type.name, 'Num')
+  t.is(sig.right.length, 1)
+  t.is(sig.right[0].kind, 'sig_type_expr')
+  t.is(sig.right[0].type.kind, 'type_name')
+  t.is(sig.right[0].type.name, 'Str')
+  t.is(sig.effectsAdd.length, 2)
+  t.is(sig.effectsAdd[0].kind, 'sig_effect_add')
+  t.is(sig.effectsAdd[0].name, 'Async')
+  t.is(sig.effectsAdd[0].side, 'right')
+  assertSpan(t, sig.effectsAdd[0].span)
+  t.is(sig.effectsAdd[1].kind, 'sig_effect_add')
+  t.is(sig.effectsAdd[1].name, 'Fail')
+  t.is(sig.effectsAdd[1].side, 'right')
+  t.is(sig.effectsRemove.length, 1)
+  t.is(sig.effectsRemove[0].kind, 'sig_effect_remove')
+  t.is(sig.effectsRemove[0].name, 'Async')
+  t.is(sig.effectsRemove[0].side, 'right')
+  t.end()
+})
+
+test('AST: сигнатура — type_app List Num на слоте', function (t) {
+  const r = parseSource('@f ( List Num -> )\n\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const sig = r.ast.items[0].signature
+  t.is(sig.left.length, 1)
+  t.is(sig.left[0].kind, 'sig_type_expr')
+  t.is(sig.left[0].type.kind, 'type_app')
+  t.is(sig.left[0].type.ctor, 'List')
+  t.is(sig.left[0].type.args.length, 1)
+  t.is(sig.left[0].type.args[0].kind, 'type_name')
+  t.is(sig.left[0].type.args[0].name, 'Num')
+  t.alike(sig.right, [])
+  t.end()
+})
+
+test('AST: сигнатура — paren_type вокруг Maybe Num', function (t) {
+  const r = parseSource('@f ( ( Maybe Num ) -> )\n\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const ty = r.ast.items[0].signature.left[0].type
+  t.is(ty.kind, 'paren_type')
+  t.is(ty.inner.kind, 'type_app')
+  t.is(ty.inner.ctor, 'Maybe')
+  t.is(ty.inner.args.length, 1)
+  t.is(ty.inner.args[0].kind, 'type_name')
+  t.is(ty.inner.args[0].name, 'Num')
+  t.end()
+})
+
+test('AST: сигнатура — module_type_ref ~Lib/Point (RFC-0.1 lit_type / module_type_ref)', function (t) {
+  const r = parseSource('@usePoint ( ~Lib/Point -> )\n\n')
+  t.ok(r.ok, 'парсер должен принимать ~Module/Type в sig_item (parseSigItem → parseSigTypeExpr)')
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const ty = r.ast.items[0].signature.left[0].type
+  t.is(ty.kind, 'module_type_ref')
+  t.is(ty.module, 'Lib')
+  t.is(ty.type, 'Point')
+  t.end()
+})
+
+test('AST: сигнатура — Quote ( Num -> Str ) как quotation_sig (RFC-0.1 §6.1)', function (t) {
+  const r = parseSource('@w ( Quote ( Num -> Str ) -> )\n\n')
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const sig = r.ast.items[0].signature
+  t.is(sig.left.length, 1)
+  t.is(sig.left[0].kind, 'quotation_sig')
+  const inner = sig.left[0].inner
+  t.is(inner.left.length, 1)
+  t.is(inner.left[0].type.kind, 'type_name')
+  t.is(inner.left[0].type.name, 'Num')
+  t.is(inner.right.length, 1)
+  t.is(inner.right[0].type.name, 'Str')
+  t.end()
+})
+
+test('AST: сигнатура — sugar ( ( Num -> Str ) -> ) вложенная цитата', function (t) {
+  const r = parseSource('@w ( ( Num -> Str ) -> )\n\n')
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const sig = r.ast.items[0].signature
+  t.is(sig.left.length, 1)
+  t.is(sig.left[0].kind, 'quotation_sig')
+  const inner = sig.left[0].inner
+  t.is(inner.left[0].type.name, 'Num')
+  t.is(inner.right[0].type.name, 'Str')
+  t.end()
+})
+
+test('AST: сигнатура — ( ( Num -> Str ) ) без внешней -> — ошибка', function (t) {
+  const r = parseSource('@bad ( ( Num -> Str ) )\n\n')
+  t.ok(r.ok === false)
+  t.is(r.diagnostics[0].code, 'E1001')
+  t.end()
+})
+
+test('AST: сигнатура — Maybe ( Num -> Str ) как type_app + quotation_type', function (t) {
+  const r = parseSource('@f ( Maybe ( Num -> Str ) -> )\n\n')
+  t.ok(r.ok, r.diagnostics?.map((d) => d.message).join('; '))
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const ty = r.ast.items[0].signature.left[0].type
+  t.is(ty.kind, 'type_app')
+  t.is(ty.ctor, 'Maybe')
+  t.is(ty.args.length, 1)
+  t.is(ty.args[0].kind, 'quotation_type')
+  t.is(ty.args[0].inner.left[0].type.name, 'Num')
+  t.is(ty.args[0].inner.right[0].type.name, 'Str')
+  t.end()
+})
+
+test('AST: сигнатура — named_quotation_sig (just: ( ~s a -> ~s a )) — stack_var и type_var', function (t) {
+  const r = parseSource('@withJust ( just: ( ~s a -> ~s a ) -> )\n\n  /id\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const sig = r.ast.items[0].signature
+  t.is(sig.left.length, 1)
+  const nq = sig.left[0]
+  t.is(nq.kind, 'named_quotation_sig')
+  t.is(nq.prefix, 'just')
+  assertSpan(t, nq.span)
+  t.is(nq.quotation.kind, 'quotation_sig')
+  assertSpan(t, nq.quotation.span)
+  const inner = nq.quotation.inner
+  t.is(inner.kind, 'signature')
+  t.is(inner.left.length, 2)
+  t.is(inner.left[0].kind, 'stack_var')
+  t.is(inner.left[0].name, 's')
+  t.is(inner.left[1].kind, 'sig_type_expr')
+  t.is(inner.left[1].type.kind, 'type_var')
+  t.is(inner.left[1].type.name, 'a')
+  t.is(inner.right.length, 2)
+  t.is(inner.right[0].kind, 'stack_var')
+  t.is(inner.right[0].name, 's')
+  t.is(inner.right[1].kind, 'sig_type_expr')
+  t.is(inner.right[1].type.kind, 'type_var')
+  t.is(inner.right[1].type.name, 'a')
+  t.alike(inner.effectsAdd, [])
+  t.alike(inner.effectsRemove, [])
+  t.end()
+})
+
+test('AST: тело слова — string и number литералы', function (t) {
+  const r = parseSource('@w ( -> )\n\n  "hi"\n  42\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const body = r.ast.items[0].body
+  t.is(body.length, 2)
+  t.is(body[0].kind, 'literal')
+  t.is(body[0].litKind, 'string')
+  t.is(body[0].raw, '"hi"')
+  assertSpan(t, body[0].span)
+  t.is(body[1].kind, 'literal')
+  t.is(body[1].litKind, 'number')
+  t.is(body[1].raw, '42')
+  t.end()
+})
+
+test('AST: тело слова — bool, nil', function (t) {
+  const r = parseSource('@w ( -> )\n\n  true\n  false\n  nil\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const b = r.ast.items[0].body
+  t.is(b.length, 3)
+  t.is(b[0].litKind, 'bool')
+  t.is(b[0].raw, 'true')
+  t.is(b[1].litKind, 'bool')
+  t.is(b[1].raw, 'false')
+  t.is(b[2].litKind, 'nil')
+  t.is(b[2].raw, 'nil')
+  t.end()
+})
+
+test('AST: тело слова — word_ref, builtin, module_word_ref', function (t) {
+  const r = parseSource('@w ( -> )\n\n  /swap\n  dup\n  ~Math/add\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const b = r.ast.items[0].body
+  t.is(b.length, 3)
+  t.is(b[0].kind, 'word_ref')
+  t.is(b[0].name, 'swap')
+  assertSpan(t, b[0].span)
+  t.is(b[1].kind, 'builtin')
+  t.is(b[1].name, 'dup')
+  t.is(b[2].kind, 'module_word_ref')
+  t.is(b[2].module, 'Math')
+  t.is(b[2].word, 'add')
+  t.end()
+})
+
+test('AST: неизвестное lower в теле — узел builtin (RFC-0.1 §13 E1206 на L2)', function (t) {
+  const r = parseSource('@w ( -> )\n\n  not_a_real_builtin_xyz\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const b = r.ast.items[0].body
+  t.is(b.length, 1)
+  t.is(b[0].kind, 'builtin')
+  t.is(b[0].name, 'not_a_real_builtin_xyz')
+  t.end()
+})
+
+test('AST: тело слова — list_literal и quotation', function (t) {
+  const r = parseSource('@w ( -> )\n\n  [ 1 2 ]\n  ( /drop )\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const b = r.ast.items[0].body
+  t.is(b.length, 2)
+  t.is(b[0].kind, 'list_literal')
+  assertSpan(t, b[0].span)
+  t.is(b[0].elements.length, 2)
+  t.is(b[0].elements[0].litKind, 'number')
+  t.is(b[0].elements[0].raw, '1')
+  t.is(b[0].elements[1].raw, '2')
+  t.is(b[1].kind, 'quotation')
+  assertSpan(t, b[1].span)
+  t.is(b[1].body.length, 1)
+  t.is(b[1].body[0].kind, 'word_ref')
+  t.is(b[1].body[0].name, 'drop')
+  t.end()
+})
+
+test('AST: тело слова — slot_write и slot_read', function (t) {
+  const r = parseSource('@w ( -> )\n\n  :acc\n  ;acc\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const b = r.ast.items[0].body
+  t.is(b.length, 2)
+  t.is(b[0].kind, 'slot_write')
+  t.is(b[0].name, 'acc')
+  t.is(b[1].kind, 'slot_read')
+  t.is(b[1].name, 'acc')
+  t.end()
+})
+
+test('AST: doc между сигнатурой и телом слова (word.doc)', function (t) {
+  const r = parseSource('@w ( -> )\n-- about --\n\n  /id\n')
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  const w = r.ast.items[0]
+  t.alike(w.doc, [' about '])
+  t.is(w.body.length, 1)
+  t.is(w.body[0].kind, 'word_ref')
+  t.is(w.body[0].name, 'id')
+  t.end()
+})
+
+test('AST: несколько top-level подряд сохраняют порядок в items', function (t) {
+  const src = '+M ./a.sail\n&Bool\n| True\n@nop ( -> )\n'
+  const r = parseSource(src)
+  t.ok(r.ok)
+  if (!assertSourceFileShell(t, r.ast)) return t.end()
+  t.is(r.ast.items.length, 3)
+  t.is(r.ast.items[0].kind, 'import')
+  t.is(r.ast.items[1].kind, 'sum_type')
+  t.is(r.ast.items[2].kind, 'word')
+  t.end()
+})

package/test/parse/contract.test.js

@@ -0,0 +1,37 @@
+/**
+ * Public parse API shape — plan + RFC-0.1 §11 (Parse step).
+ */
+import test from 'brittle'
+import { parseSource } from '../../index.js'
+import { expectAccept } from './helpers.js'
+
+test('parseSource returns { ok, diagnostics }', function (t) {
+  const r = parseSource('')
+  t.ok(typeof r === 'object' && r !== null)
+  t.ok('ok' in r && typeof r.ok === 'boolean')
+  t.ok(Array.isArray(r.diagnostics))
+  t.end()
+})
+
+test('parseSource: success has empty diagnostics', function (t) {
+  expectAccept(t, '')
+  t.end()
+})
+
+test('parseSource: each diagnostic has string code and message', function (t) {
+  const r = parseSource('@x')
+  t.ok(r.ok === false)
+  t.ok(r.diagnostics.length >= 1)
+  for (const d of r.diagnostics) {
+    t.is(typeof d.code, 'string')
+    t.is(typeof d.message, 'string')
+  }
+  t.end()
+})
+
+test('parseSource: non-string input is rejected', function (t) {
+  const r = parseSource(null)
+  t.ok(r.ok === false)
+  t.ok(r.diagnostics.some(d => d.code === 'E1001'))
+  t.end()
+})

package/test/parse/fixtures-full-syntax.test.js

@@ -0,0 +1,24 @@
+/**
+ * Золотой эталон: один большой .sail и ожидаемое AST в JSON (test/fixtures/).
+ * Обновить JSON после намеренного изменения парсера: `npm run regen:fixture-ast` (из каталога lang).
+ */
+import test from 'brittle'
+import { readFileSync } from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { parseSource } from '../../index.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const fixtureDir = path.join(__dirname, '..', 'fixtures')
+const fixtureSailPath = path.join(fixtureDir, 'demo-full-syntax.sail')
+const fixtureAstPath = path.join(fixtureDir, 'demo-full-syntax.ast.json')
+
+test('fixture demo-full-syntax: parse matches demo-full-syntax.ast.json', function (t) {
+  const sourceText = readFileSync(fixtureSailPath, 'utf8')
+  const expected = JSON.parse(readFileSync(fixtureAstPath, 'utf8'))
+  const r = parseSource(sourceText)
+  t.ok(r.ok, 'fixture must parse without diagnostics')
+  t.is(r.diagnostics.length, 0)
+  t.alike(r.ast, expected)
+  t.end()
+})

package/test/parse/helpers.js

@@ -0,0 +1,27 @@
+import { parseSource } from '../../lib/parse/index.js'
+
+export { parseSource }
+
+export function expectAccept (t, sourceText) {
+  const r = parseSource(sourceText)
+  t.ok(r.ok === true, 'expected ok')
+  t.ok(Array.isArray(r.diagnostics), 'diagnostics must be an array')
+  t.is(r.diagnostics.length, 0, 'expected no diagnostics on success')
+}
+
+export function expectReject (t, sourceText, code, messageIncludes) {
+  const r = parseSource(sourceText)
+  t.ok(r.ok === false, 'expected failure')
+  t.ok(Array.isArray(r.diagnostics), 'diagnostics must be an array')
+  const d = r.diagnostics.find(x => x.code === code)
+  t.ok(
+    d,
+    `expected a diagnostic with code ${code}, got ${r.diagnostics.map(x => x.code).join(', ')}`
+  )
+  if (d !== undefined && messageIncludes !== undefined) {
+    t.ok(
+      typeof d.message === 'string' && d.message.includes(messageIncludes),
+      `message should include ${JSON.stringify(messageIncludes)}, got ${JSON.stringify(d.message)}`
+    )
+  }
+}

package/test/parse/l0-lex-diagnostics-matrix.test.js

@@ -0,0 +1,59 @@
+/**
+ * Матрица L0 (лексер RFC-lex-0.1, RFC-conformance-0.1 §3): диагностики из [lexer.js](lang/lib/parse/lexer.js).
+ * Парсер (L1) добавляет E1003–E1007; см. l1-parse-diagnostics-matrix.test.js.
+ *
+ * | Код   | Место в lexer.js        | Смысл | Проверка |
+ * |-------|-------------------------|-------|----------|
+ * | E1002 | readCommentToken        | Незакрытый `-- … --` | **ниже** (nextToken), l0-lex.test.js (parseSource) |
+ * | E1001 | readString              | Незакрытая строка    | **ниже** (nextToken), l1-parse-diagnostics-matrix (parseSource) |
+ * | E1001 | `/` без regexp/word_ref | Недопустимый `/`      | l1-parse-diagnostics-matrix (parseSource) |
+ * | E1001 | fallback символ         | Неизвестный символ   | **ниже** (nextToken) |
+ *
+ * Путь импорта читается `readPathToken`, не как отдельный шаг `nextToken` для `./…` (см. l0-lex «import path» через parseSource).
+ * Интеграция через `parseSource` для путей, тел слов и т.д. — в l0-lex.test.js и l1-*.
+ */
+import test from 'brittle'
+import { createLexerState, nextToken } from '../../lib/parse/lexer.js'
+
+function firstTokenDiagnostics (sourceText, regexpOk = false) {
+  const state = createLexerState(sourceText)
+  const ctx = { diagnostics: [], regexpOk }
+  const tok = nextToken(state, ctx)
+  return { tok, diagnostics: ctx.diagnostics }
+}
+
+test('L0 E1002: незакрытый блочный комментарий (только лексер)', function (t) {
+  const { tok, diagnostics } = firstTokenDiagnostics('-- без закрытия')
+  t.is(tok.type, 'EOF')
+  const d = diagnostics.find(x => x.code === 'E1002')
+  t.ok(d, 'E1002')
+  t.ok(d.message.includes('комментарий'))
+  t.end()
+})
+
+test('L0 E1001: неизвестный символ (fallback nextToken)', function (t) {
+  const { tok, diagnostics } = firstTokenDiagnostics('§')
+  t.is(tok.type, 'EOF')
+  const d = diagnostics.find(x => x.code === 'E1001')
+  t.ok(d && d.message.includes('§'))
+  t.end()
+})
+
+test('L0 E1001: незакрытая строка (только лексер)', function (t) {
+  const { tok, diagnostics } = firstTokenDiagnostics('"unclosed')
+  t.is(tok.type, 'EOF')
+  const d = diagnostics.find(x => x.code === 'E1001')
+  t.ok(d && d.message.includes('"'))
+  t.end()
+})
+
+test('L0: базовая токенизация MODULE и число (без диагностик)', function (t) {
+  const state = createLexerState('+Lib 42')
+  const ctx = { diagnostics: [], regexpOk: false }
+  const a = nextToken(state, ctx)
+  const b = nextToken(state, ctx)
+  t.is(a.type, 'MODULE')
+  t.is(b.type, 'NUMBER')
+  t.is(ctx.diagnostics.length, 0)
+  t.end()
+})

package/test/parse/l0-lex.test.js

@@ -0,0 +1,40 @@
+/**
+ * L0 Lex — RFC-conformance-0.1 §3, RFC-lex-0.1 (ws, comments §3, literals §6, path §7, order §8).
+ * Diagnostics for lex/parse — RFC-0.1 §13 (E1001–E1007).
+ * Матрица диагностик лексера (E1001/E1002 из lexer.js): l0-lex-diagnostics-matrix.test.js
+ */
+import test from 'brittle'
+import { expectAccept, expectReject } from './helpers.js'
+
+test('L0: whitespace-only file is valid (RFC-0.1 §12.2 source_file)', function (t) {
+  expectAccept(t, '')
+  expectAccept(t, '   \n\t  \n')
+  t.end()
+})
+
+test('L0: unclosed Sail block comment → E1002 (RFC-0.1 §13, RFC-lex §3)', function (t) {
+  expectReject(
+    t,
+    '-- opens but never closes',
+    'E1002',
+    "Незакрытый комментарий"
+  )
+  t.end()
+})
+
+test('L0: `--` inside string literal is not comment (RFC-lex §3, §6)', function (t) {
+  const src = '@w ( -> )\n\n  "-- not a comment --"'
+  expectAccept(t, src)
+  t.end()
+})
+
+test('L0: import path is single token without internal whitespace (RFC-lex §7)', function (t) {
+  expectAccept(t, '+Lib ./relative/path.sail')
+  expectAccept(t, '+Npm @scope/pkg-name')
+  t.end()
+})
+
+test('L0: regexp vs division — regexp after token that allows InputElementRegExp (RFC-lex §6)', function (t) {
+  expectAccept(t, '@w ( -> )\n\n  /just[^/]*/ dup')
+  t.end()
+})