Ядро FTS на flang: все четыре слоя связались в одну программу

Вычислитель объявлял типы контракта у себя, и связывание давало десять
конфликтов FLANG_DUPLICATE_NAME — слои по отдельности работали, а вместе не
собирались. Теперь он берёт «Скаляр», «Операнд», «Условие», «Правило» и
остальные из слоя печати, как это уже делал парсер.

Ещё один конфликт был содержательным: «Итог примера» в парсере — это
разобранный пример со списком ошибок, а в вычислителе — результат сверки
примера с ожиданием. Одно имя на два разных понятия; в парсере переименовано
в «Разбор примера» по образцу соседних «Итог утилиты» и «Итог структуры».

Тесты вычислителя разделены: форма модуля проверяется по разбору своего файла,
вычисления — по связанной программе. Смешивать их нельзя, иначе требование
«функция без примера обязана иметь сумму типов в сигнатуре» распространилось бы
на чужой слой, у которого своё правило и свой тест.

Итог: `использует «Парсер FTS»` + `использует «Вычислитель утилит»` даёт
217 функций и 66 типов, все функции тотальные, ноль диагностик. Это полное
ядро FTS, написанное на самом flang.

Проверено: 1051 тест flang, 0 падений.

Author: the-homeless-god

flang/core/evaluate.flang

@@ -1,4 +1,5 @@
 модуль «Вычислитель утилит»
+  использует «Печать JSON» из "json.flang"
 
 // Вычислитель утилит ядра FTS, написанный на flang.
 //
@@ -35,64 +36,17 @@
 // Скаляр FTS: `type FtsScalar = string | number | boolean | null`. Сумма типов
 // вместо объединения TypeScript — единственный способ выразить это в языке,
 // где значение имеет ровно один тип.
-тип «Скаляр»
-  вариант «Скаляр строка» содержит «значение»: строка
-  вариант «Скаляр число» содержит «значение»: число
-  вариант «Скаляр признак» содержит «значение»: признак
-  вариант «Скаляр ничто»
-
-тип «Сравнение»
-  вариант «Равно»
-  вариант «Не равно»
-  вариант «Не меньше»
-  вариант «Не больше»
-  вариант «Больше»
-  вариант «Меньше»
-
-тип «Операнд»
-  вариант «Значение операнда» содержит «скаляр»: «Скаляр»
-  вариант «Поле операнда» содержит «поле»: строка
-  вариант «Процент операнда» содержит «процент»: число, «поле»: строка
-  вариант «Результат операнда»
-
-объект «Условие»
-  «поле»: строка
-  «сравнение»: «Сравнение»
-  «операнд»: «Операнд»
-
-тип «Действие»
-  вариант «Присвоить» содержит «операнд»: «Операнд»
-  вариант «Добавить» содержит «операнд»: «Операнд»
-
-объект «Правило»
-  «имя»: строка
-  «условия»: список «Условие»
-  «действие»: «Действие»
-
-объект «Свойство»
-  «имя»: строка
-  «сравнение»: «Сравнение»
-  «операнд»: «Операнд»
+
+
+
+
+
+
 
 // Привязка «имя поля → скаляр». Записи flang тотальны и имеют заранее
 // известные поля, поэтому входная запись утилиты — список пар, а не запись.
-объект «Привязка»
-  «имя»: строка
-  «значение»: «Скаляр»
-
-объект «Пример»
-  «имя»: строка
-  «вход»: список «Привязка»
-  «ожидается»: «Скаляр»
-
-объект «Утилита»
-  «имя»: строка
-  «принимает»: строка
-  «возвращает»: строка
-  «начальное»: «Скаляр»
-  «правила»: список «Правило»
-  «свойства»: список «Свойство»
-  «примеры»: список «Пример»
+
+
 
 // ────────────────────────────── итоги ──────────────────────────────
 

flang/core/parser.flang

@@ -103,7 +103,7 @@
   «свойство»: «Свойство»
   «ошибки»: список «Диагностика разбора»
 
-объект «Итог примера»
+объект «Разбор примера»
   «пример»: «Пример»
   «ошибки»: список «Диагностика разбора»
 
@@ -1053,11 +1053,11 @@
 
 тотальная функция «Разобрать пример»
   принимает «группа»: «Группа»
-  возвращает «Итог примера»
+  возвращает «Разбор примера»
   пусть «имя» равно «Прочитать всё имя» от («Пропустить слова» от («группа».«заголовок».«слова») и 1)
   пусть «сбор» равно свёртка («группа».«тело») начиная с «Начальный сбор примера» как «акк» и «строка» → «Шаг примера» от «акк» и «строка»
   пусть «без ожидания» равно если «сбор».«есть ожидание» то «Без ошибок» иначе («Ошибка разбора» от "FTS_UTILITY_EXAMPLE" и (соединить ["пример ", («В ёлочках» от («имя».«имя»)), " требует строку 'ожидается'"] по ""))
-  запись «Итог примера» с «пример» равным (запись «Пример» с «имя» равным («имя».«имя») и «вход» равным («сбор».«вход») и «ожидается» равным («сбор».«ожидается»)) и «ошибки» равным («Слить ошибки» от («Слить ошибки» от («имя».«ошибки») и («сбор».«ошибки»)) и «без ожидания»)
+  запись «Разбор примера» с «пример» равным (запись «Пример» с «имя» равным («имя».«имя») и «вход» равным («сбор».«вход») и «ожидается» равным («сбор».«ожидается»)) и «ошибки» равным («Слить ошибки» от («Слить ошибки» от («имя».«ошибки») и («сбор».«ошибки»)) и «без ожидания»)
 
 // ──────────────────────────────── утилита ───────────────────────────────────
 

flang/test/core-evaluate.test.mjs

@@ -34,7 +34,15 @@ import { checkTypes } from "../src/types.mjs"
 const root = fileURLToPath(new URL("../../", import.meta.url))
 const файл = new URL("../core/evaluate.flang", import.meta.url)
 const исходник = readFileSync(файл, "utf8")
-const программа = parse(исходник, "core/evaluate.flang")
+/* Модуль берёт типы документа из соседнего слоя печати («использует «Печать
+   JSON»»), поэтому разбирается со связыванием: без него «Скаляр» и остальные
+   типы контракта остались бы необъявленными. */
+const { linkProgram } = await import("../src/link.mjs")
+const связано = await linkProgram(fileURLToPath(файл), исходник, parse)
+const { diagnostics: связывание, ...программа } = связано
+/* Отдельно — разбор одного файла: проверки формы модуля обязаны смотреть на
+   то, что написано здесь, а не на объявления, пришедшие из слоя печати. */
+const модуль = parse(исходник, "core/evaluate.flang")
 const типы = checkTypes(программа)
 const тотальность = checkTotality(программа)
 
@@ -122,12 +130,20 @@ const кодОшибки = (ошибка) =>
 /* ───────────────────────────── слои языка ───────────────────────────────── */
 
 test("evaluate.flang: разбор даёт контракт SPEC, раздел 5", () => {
-  assert.equal(программа.flang, 1)
-  assert.equal(программа.module, "Вычислитель утилит")
-  assert.ok(Array.isArray(программа.functions))
-  assert.ok(программа.functions.length > 0)
+  assert.equal(модуль.flang, 1)
+  assert.equal(модуль.module, "Вычислитель утилит")
+  assert.ok(Array.isArray(модуль.functions))
+  assert.ok(модуль.functions.length > 0)
   /* Детерминированность: повторный разбор даёт побайтово тот же AST. */
-  assert.equal(JSON.stringify(parse(исходник, "core/evaluate.flang")), JSON.stringify(программа))
+  assert.equal(JSON.stringify(parse(исходник, "core/evaluate.flang")), JSON.stringify(модуль))
+})
+
+test("evaluate.flang: связывание со слоем печати проходит без диагностик", () => {
+  assert.deepEqual(связывание, [], "типы контракта берутся из json.flang, и это обязано связываться молча")
+  assert.ok(
+    программа.functions.length > модуль.functions.length,
+    "связанная программа обязана содержать функции обоих слоёв",
+  )
 })
 
 test("evaluate.flang: типы без диагностик", () => {
@@ -165,8 +181,11 @@ test("evaluate.flang: без примера остаются только фун
      «ожидается» записывается, но у функций, которые тянут за собой состояние
      вычисления («Итог»), пример был бы длиннее самой функции. Всё остальное
      обязано быть показано примером. */
+  /* Проверяется свой модуль: за функции слоя печати отвечает его собственный
+     тест, и требовать от них примеров здесь значило бы дублировать чужое
+     правило. Суммы типов берутся из связанной программы — они объявлены там. */
   const суммы = new Set((программа.types ?? []).filter((тип) => тип.kind === "sum").map((тип) => тип.name))
-  for (const fn of программа.functions) {
+  for (const fn of модуль.functions) {
     if ((fn.examples ?? []).length > 0) continue
     const типыСигнатуры = [fn.returns, ...(fn.params ?? []).map((параметр) => параметр.type)]
     assert.ok(