Самоприменение: парсер flang, написанный на flang

Третий и самый крупный слой: 3887 строк, 372 функции, 147 тотальных.

Побайтовое совпадение AST с эталонным src/parser.mjs: 38 файлов .flang из 38
(включая собственный исходник) и 51 файл .fts из 51. Второе не довесок:
утилит, морфизмов, теорем, файлов-функторов и скобочной поверхности нет ни в
одном .flang, а разбирает их тот же парсер, и отдельный тест требует, чтобы в
корпусе встретились все семь видов legacy-узлов. Плюс 98 краевых случаев,
200 случайных склеек и 93 обрезки реальных исходников по случайной строке.
Диагностики сверяются по коду, тексту, строке и столбцу. Расхождений нет.

Рекурсивный спуск выбран сознательно, вопреки приёму ядра FTS. Поверхность
flang не построчная: «если» живёт и в строку, и блоком, «пусть» вкладывает
остаток блока, скобочный диалект отступов не видит вовсе. Свёртка в дерево
заставила бы сверять не с эталоном, а с собственным представлением о том, как
эталон группирует токены. Здесь порядок вызовов повторяет parser.mjs функция в
функцию, и расхождение всегда локально. Цена — 225 обычных функций, и она
названа честно, а не спрятана.

Поток идёт пачками по 32 токена: «хвост» копирует список целиком, и поедание
по одному дало бы порядка 4·10^8 копий на 28 000 токенах.

AST строится как «Значение» из core/json.flang, а не своим типом: иначе не
выразить разницу между «ключа нет» и «ключ со значением ничто», которой
пользуется эталон, и порядок вставки ключей, на который он опирается при
связывании вызовов без аргументов.

1224 теста flang, 0 падений.

Author: the-homeless-god

flang/self/SPEC.md

@@ -213,3 +213,125 @@ newer», потому что компилятор языка написан на
 интерпретатора; тест поднимает лимит до ста миллионов. Это не формальность:
 лимит ловит превращение печати в перебор. Компилятору такое разрешено
 (см. начало этого файла), факт-чекеру — нет.
+
+### `self/parser.flang`
+
+Состояние: 372 функции, 147 тотальных, 225 обычных. AST совпадает с эталоном
+(`src/parser.mjs`) **побайтово** — то есть `«Печать значения»` от построенного
+узла и `JSON.stringify(parse(исходник))` дают одну и ту же строку — на 38
+исходниках `.flang` репозитория (`flang/stdlib`, `flang/core`,
+`flang/examples/leetcode`, `flang/self`, включая собственный исходник) и на 51
+модели `.fts` (`examples`, `tools`, `web`, `editors`). Плюс 98 краевых случаев,
+200 случайных склеек и 93 обрезанных по случайной строке исходника
+репозитория — с зафиксированными сидами. Отказы сверяются так же: код, текст
+сообщения и место. Проверка: `flang/test/self-parser.test.mjs`.
+
+Корпус `.fts` здесь не украшение: конструкций наследия FTS — утилита, морфизм,
+теорема, файл-функтор и старая скобочная поверхность `категория X { … }` — нет
+ни в одном `.flang` репозитория, а разбирает их тот же `parser.mjs`. Без `.fts`
+половина эталона осталась бы непроверенной; тест отдельно требует, чтобы в
+корпусе встретились все семь видов узла `ftsLegacy`.
+
+**Почему рекурсивный спуск, а не свёртка потока в дерево.** Ядро FTS
+(`flang/core/parser.flang`) целиком тотально: поверхность `.fts` построчная, и
+разбор там сведён к свёртке по строкам и группам. Здесь этот путь выбран не
+был, и это решение, а не упущение. Поверхность flang не построчная: `если`
+живёт и в строку, и блоком; тело ветки бывает выражением на той же строке и
+отступным блоком; `пусть` вкладывает в себя весь остаток блока; скобочная
+поверхность отступов не замечает вовсе. Свести это к дереву отступов можно, но
+тогда сверять пришлось бы не с образцом, а с собственным представлением о том,
+как образец группирует токены, и каждое расхождение становилось бы отладкой
+двух разных разборов сразу. Здесь порядок вызовов повторяет `parser.mjs`
+функция в функцию, поэтому расхождение всегда локально — видно, в какой именно
+функции оно возникло. Цена решения названа прямо: нетотальность.
+
+**Поток токенов лежит пачками.** Список flang — массив, и `хвост` копирует его
+целиком (`builtins.mjs`). Съедать токены по одному из плоского списка значило
+бы копировать хвост на каждом шаге: на самом большом исходнике репозитория
+(28 000 токенов) это 4·10⁸ копий указателей. Поэтому поток разложен пачками по
+32 токена, а три токена заглядывания (`peek(0..2)` образца) лежат отдельными
+полями. Снятие токена стоит копирования пачки, переход к следующей пачке —
+копирования списка пачек; итог линеен.
+
+**Нетотальные функции (225) — три причины.**
+
+| Что | Почему не доказывается |
+|---|---|
+| рекурсивный спуск: «Разобрать выражение», «Разобрать строки», «Разобрать если», «Разобрать разбор», «Разобрать образец», «Разобрать постфикс», «Разобрать первичное», «Разобрать тип», «Разобрать функцию», «Разобрать запись», «Разобрать утилиту», «Разобрать скобочный документ» и их спутники (около 200 функций) | убывает остаток потока токенов, а поток лежит внутри записи «Разборщик» и меняется целиком: анализ (`src/totality.mjs`) считает частью значения хвост списка, голову, поле записи и поле варианта, но не «состояние стало меньше». Взаимная рекурсия идёт через «Разобрать выражение» и охватывает почти весь файл, поэтому нетотальна вся компонента сразу |
+| циклы по потоку: «Пропустить переводы», «Пропустить разделители», «Войти в блок», «Выйти из блока», «Собрать домен», «Собрать кодомен», «Собрать части типа» | то же самое в чистом виде: рекурсия по остатку потока |
+| обход строки по символам и по подстрокам: «Основа имени» (через «Нижний регистр» лексера), «Повторная замена», «Обрезать слева», «Обрезать справа», «Собрать тип» и связывание имён, которое их зовёт («Подобрать основу», «Разрешить среди локальных», «Разрешить локальное», «Связать узел», «Разрешить узел», «Отказ имени») | убывает разность «длина минус позиция», то есть число. Та же нехватка «символов строки», что названа в долгах `self/lexer.flang`, `self/emit-c.flang` и `stdlib/strings.flang` |
+
+Разложение потока пачками, поиск ключа в узле, подстановка ключа, связывание
+вызовов без аргументов и все таблицы ключевых слов — тотальны: там убывание
+структурное. Отсюда 147 доказанных функций из 372.
+
+**AST — обобщённое значение, а не свой типизированный узел.** Узел AST здесь —
+это «Значение» из `flang/core/json.flang`, та же сумма «скаляр | список |
+запись», что читает `self/emit-c.flang`. Причины три, и все три обязательные,
+а не удобные:
+
+1. печать в JSON берётся готовой и уже доказанной побайтово. Побайтовое
+   совпадение — единственный критерий верности, а вторая печать означала бы
+   второй набор решений про порядок ключей и экранирование;
+2. эталон различает «ключа нет» и «ключ со значением ничто»: `optional` поля,
+   `legacy` программы, `arg` утверждения, `only` импорта. Запись flang этого
+   различить не может — поле записи есть всегда;
+3. порядок ключей в JSON задаётся порядком вставки, и эталон им пользуется:
+   `bindNullaryCalls` переписывает `var` в `call`, снимая и заново кладя `name`
+   и `span`, чтобы получить порядок обычного вызова. Список пар ключ-значение
+   это воспроизводит, запись — нет.
+
+**Пометка узла вместо `WeakSet`.** Эталон помечает узлы `var`, ожидающие
+разрешения, слабым множеством, а связывание вызовов без аргументов переписывает
+их на месте. Здесь пометка живёт ключом самого узла — `?ждёт` и `?свободное`, —
+а «Связать вызовы» обходит готовый AST и снимает её. Ключи начинаются со знака
+вопроса, которого в AST быть не может, и до печати не доживают ни в одном из
+проверенных исходников.
+
+**Расхождения с эталоном.** Первые три — те же, что уже записаны у лексера, и
+здесь они лишь наследуются; четвёртое своё.
+
+1. **Нормализация NFC не выполняется.** Эталон приводит к NFC имя
+   (`expectName`), имя поля записи, имя параметра, строку типа скобочной
+   поверхности (`formatType`) и имена функторов композиции. Встроенной формы для
+   этого в языке нет. Расхождение: имя, записанное разложенной формой, эталон
+   отдаёт составленным, парсер на flang — разложенным.
+2. **`/^\p{Lu}/u` заменено явным алфавитом заглавных** — латиница и кириллица,
+   таблица лексера. Этой проверкой различаются «тип, вариант или функция»
+   (пишутся с прописной, не склоняются) и «локальное имя» — и в разрешении
+   падежей, и в образце. Расхождение: имя, начинающееся с греческой или
+   армянской прописной, эталон не склоняет, а парсер на flang попытается
+   подобрать ему основу.
+3. **`toLowerCase()` в поиске основы сделан по той же таблице.** Окончания
+   снимаются с имени, приведённого к нижнему регистру «Нижним регистром»
+   лексера, а он знает латиницу и кириллицу. Расхождение видно только вместе с
+   пунктом 2.
+4. **Регулярные выражения `formatType` выражены заменами.** Эталон приводит
+   строку типа скобочной поверхности четырьмя `replace` с `\s+` и `\s*`;
+   регулярных выражений в языке нет. Части склеены через `join(" ")`, поэтому
+   пробельный пробег — это всегда пробелы, и повторная замена даёт то же самое.
+   Остаётся один край: две вертикальные черты подряд (`A||B`) эталон разведёт
+   как `A | | B`, а эта печать оставит два пробела между ними. В типах моделей
+   репозитория такого нет, и `Map<string, number>[]`, `string | null`,
+   `A & B` совпадают побайтово.
+
+Столбцы токенов, таблица `\uXXXX` и алфавиты `ID_Start`/`ID_Continue` — долги
+лексера, парсер их только передаёт дальше: место диагностики он берёт из токена
+и сам ничего про символы не решает.
+
+**Отказ теряет программу целиком.** Эталон бросает `flangError` из середины
+спуска и наружу не отдаёт ничего. Здесь беда едет значением, первая записанная
+побеждает, а все предикаты потока после неё отвечают так, чтобы любой цикл
+немедленно закончился: «Это вид», «Это слово» и «Знак сейчас» — «нет»,
+«В конце блока» — «да». Разбор после отказа доходит до конца вхолостую, и
+`«Разбор исходника»` отдаёт `ничто` вместо наполовину собранного AST: половина
+AST означала бы, что из неё можно что-то построить.
+
+**Лимит шагов.** Разбор самого большого исходника репозитория (собственный,
+3300 строк, 28 000 токенов) вместе с лексером укладывается между 50 и 100
+миллионами шагов интерпретатора; тест поднимает лимит до ста пятидесяти
+миллионов, а глубину вызовов — до двадцати тысяч. Лимит здесь не формальность:
+он проверяет, что разбор остался линейным по числу токенов, а не свалился в
+квадрат — ради этого поток и разложен пачками. Глубина нужна потому, что спуск
+вкладывается на каждое `пусть` и на каждую ветку, а хвостовые вызовы (обходы
+объявлений, строк блока, аргументов) глубины не занимают.