| 5.20.0 | Публичный | 5.20.0 — первый публичный релиз этой линии. Самохостируемый компилятор становится маршрутом по умолчанию, а встроенный вычислитель Лиспекса переведён на Лиспекс 1.20.0. Исходный код открыт на github.com/studiohaze/topaz. |
| 5.19.815 | Внутренняя | Общий декодер манифеста корпуса принимает строку фикстуры только когда заполнены фаза, версии и результат, источник задан ровно одним файлом или каталогом, исходу соответствует код и записанные итоги сходятся. Неполные строки отклоняются, а не превращаются в пустые значения. |
| 5.19.814 | Внутренняя | Манифесты корпусов пакета, проверки и оценки производительности v5.4 читаются тем же декодером, что и topaz check-corpus. Некорректная или неизвестная строка манифеста отклоняется везде, а не пропускается молча отдельным разбором. |
| 5.19.813 | Внутренняя | Корпусы запуска и тестирования пакетов v5.4 выполняют строки, ожидающие ошибку рантайма, поэтому проверяются код ошибки, её сообщение и вывод, напечатанный до сбоя. Новая фикстура пакета печатает вывод, а затем падает с TPZ4002 при делении целого на ноль. |
| 5.19.812 | Внутренняя | Файлы ожидаемого вывода в корпусе сохраняют значащие пустые строки в конце. Завершителем файла считается только один последний перевод строки, поэтому вывод программы, оканчивающейся пустой строкой, сравнивается точно, а не с обрезанной записью. |
| 5.19.811 | Внутренняя | topaz run и нативная сборка принимают аргументы после -- только если программа экспортирует main(args, stdin). Программа без такой точки входа отклоняется до запуска, а не теряет аргументы молча. |
| 5.19.810 | Внутренняя | Компилятор на Топазе сохраняет переданный по каналу стандартный ввод при topaz test. Раньше режим тестирования заменял его пустой строкой, а теперь программа, читающая main(args, stdin) с --compiler self, получает тот же ввод, что и при topaz run. |
| 5.19.809 | Внутренняя | Сборка, запуск и документирование пакета используют один путь, который разбирает и проверяет пакет один раз, а не повторяет эту работу. Поведение команд, диагностика и вывод не изменились. |
| 5.19.808 | Внутренняя | topaz test передаёт программе, экспортирующей main(args, stdin), стандартный ввод из канала так же, как topaz run. Тесты пакетов в корпусе также воспроизводят внешние функции и применяют то же правило кода выхода, что и командная строка. |
| 5.19.807 | Внутренняя | Проверка, поддержка редактора и фазы корпуса строят входные модули для проверки через одно общее преобразование. Идентичность модулей, роли точки входа и внешних функций, фрагменты исходников и порядок модулей сохранены, а диагностика и поведение каждого вызова не изменились. |
| 5.19.806 | Внутренняя | Каталог импорта, который существует, но не читается, больше не считается отсутствующим. Нечитаемые каталоги и исходники, а также элементы с именами не в UTF-8 дают TPZ3003 вместо TPZ3001 и в компиляторе, и в сервере редактора. |
| 5.19.805 | Внутренняя | Побочные файлы корпуса вроде .stdin, .args и .defer считаются отсутствующими, только если их действительно нет. Нечитаемый или не UTF-8 файл приводит к ошибке с указанием пути, а не молча теряет ввод или ожидаемую проверку, и блоки виртуальных файлов требуют уникального пути и точного разделителя. |
| 5.19.804 | Внутренняя | Фикстуры корпуса в виде каталога читаются точно. Отсутствующий или нечитаемый файл фикстуры больше не может выдать ту самую диагностику, которую ждёт строка, и случайно пройти, а чтение отклоняет пути не в UTF-8, необычные элементы, повторяющиеся пути и метку входа, расходящуюся с манифестом. |
| 5.19.803 | Внутренняя | Чтение манифеста корпуса сообщает о некорректном вводе с указанием пути и номера строки. Отклоняются пропущенные или повторённые итоги, нечисловые счётчики, повторяющиеся ключи фикстур и ключи без кавычек, а также неверное значение часов, и пустой файл больше не принимается за манифест без строк. |
| 5.19.802 | Внутренняя | Проверка корпуса исполнения в интерпретаторе больше не сверяет сама с собой производную сумму количеств по областям. Проверка каждого количества, разбор и выполнение всех строк, точные записи вывода и сверка кода и сообщения остановки сохранены. |
| 5.19.801 | Внутренняя | Восемь печатающих программ из документа с примерами выполняются прямо из канонических исходников корпуса. Восемь побайтово совпадающих копий и проверка, сверявшая их с оригиналами, удалены, а файлы ожидаемого вывода по-прежнему проверяют тот же вывод программы. |
| 5.19.800 | Внутренняя | Интерпретатор сопоставляет внешнюю функцию с типом функции вроде (int) -> int, читая число параметров, значения по умолчанию и признак переменного числа так же, как это делает сгенерированный код. Пакет, воспроизводящий внешние функции, работает и с topaz run, и с topaz build --run. |
| 5.19.799 | Внутренняя | Виртуальные файлы детерминированного хоста хранят сырые байты, поэтому программа, записавшая байт вроде 0x80, читает ровно то, что записала. Чтение и запись текста остаются представлением в UTF-8, а список каталога сообщает размеры в сырых байтах. |
| 5.19.798 | Внутренняя | Сборка наблюдений компилятора завершается в одной процедуре, которая уже владела корневым дайджестом, записями манифеста и бюджетом размера. Порядок элементов, хеши, байты манифеста, текст ошибки бюджета и итоговый результат не изменились. |
| 5.19.797 | Внутренняя | Предпросмотр для редактора строит один индекс позиций на модуль и читает по нему области видимости, объявления, ссылки, экспорты и типовые факты вместо повторного обхода всего синтаксического дерева. Правило первого совпадения и сами факты не изменились. |
| 5.19.796 | Внутренняя | Десятичный целочисленный литерал, на единицу превышающий знаковый 64-битный максимум, сохраняет написанную запись в наблюдении вместо пустого значения. Stage 0 и компилятор на Топазе сообщают его одинаково, а наблюдение предельной длительности не изменилось. |
| 5.19.795 | Внутренняя | Одна проверка наблюдений больше не выполняет один и тот же запрос дважды и не сравнивает результат сам с собой. Компиляция и наблюдение проходят один раз, а проверка приёма, сравнение с намеренно другими наборами, точное содержимое проекций, отклонение испорченных проекций и ограничения ресурсов сохранены. |
| 5.19.794 | Внутренняя | Вызовы конструкторов вроде Html.Text("ready") и Command.Dispatch(Msg.Ready) получают точную цель вызова и специализированный тип результата из окружающего контекста. Четыре частных исключения для модуля std.dom, приводивших результат к неизвестному типу, удалены. |
| 5.19.793 | Внутренняя | Вызов метода получателя сообщает модуль, в котором метод определён, поэтому локальная цель читается как main::Point, а импортированная как model::Point и при прямом, и при конвейерном вызове. Экспорт 5.20 приводит параметры метода, тип возврата и эту идентичность к одной канонической форме. |
| 5.19.792 | Внутренняя | Наблюдения вызовов несут сведения о цели вызова от самой проверки для обычных, опциональных и членских вызовов, а этап конвейера регистрирует вызываемую цель только при единственной ссылке и совпадении имени члена. Оба компилятора сообщают одинаковые формы прямых, опциональных и конвейерных вызовов. |
| 5.19.791 | Внутренняя | Проверка в компиляторе на Топазе типизирует вызов у обобщённого опционального значения, например value?.run(41) для Option<T>, так же, как Stage 0. Аргументы выводятся один раз, каждая ветвь объединения проверяется по своей сигнатуре, а сообщения TPZ5006, TPZ5005 и TPZ5003 не изменились. |
| 5.19.790 | Внутренняя | Опциональные вызовы вроде Option<Array<int>>?.get(0) и runner?.run(41) сохраняют специализированный тип цели вызова после проверки, поэтому следующий этап видит то же представление вызова, что и компилятор на Топазе. Поведение рантайма и смысл языка не изменились. |
| 5.19.789 | Внутренняя | Вызов пользовательского метода получателя сохраняет специализированный тип функции в точке вызова, поэтому метод с именованным аргументом и значением по умолчанию получает одинаковое представление в Stage 0 и в компиляторе на Топазе. Поведение рантайма и смысл языка не изменились. |
| 5.19.788 | Внутренняя | Компилятор на Топазе размещает значения параметров по умолчанию рядом с параметрами в порядке их объявления, совпадая со Stage 0 для обычных функций и методов. Рантайм читает эту форму и по-прежнему принимает прежнюю вложенную форму из запечатанных образов компилятора. |
| 5.19.787 | Внутренняя | Опубликованное низкоуровневое представление компилятора на Топазе больше не выдаёт пустой вызов для каждой операции. Объект вызова восстанавливается из уже имевшихся сведений о цели, получателе, аргументах и порядке вычисления и охватывает вызовы значений, членов и конвейера. |
| 5.19.786 | Внутренняя | Понижение в Stage 0 согласуется с компилятором на Топазе в идентичности привязок обычных функций, в трактовке варианта перечисления без полезной нагрузки в образце как конструктора, а не локальной привязки, и в выдаваемых сведениях о представлении. Схемы, диагностика и исполнение не изменились. |
| 5.19.785 | Внутренняя | Опциональный вызов внутри конвейера, например lead |> absent?.get(sideEffect(_)), сохраняет короткое замыкание. Если получателя нет, этап возвращает None, не вычисляя записанные аргументы, а скомпилированный продукт несёт и проверяет этот охранник, а не теряет его. |
| 5.19.784 | Внутренняя | Шесть сравнений в наборе проверки типов ставили значение против самого себя или собственной копии. Теперь используются независимо построенные Array, Map, записи и внешние значения, поэтому наблюдается структурная эквивалентность и статическое отклонение несравнимых значений, а не тождество. |
| 5.19.783 | Внутренняя | Инициализатор верхнего уровня может ссылаться на более позднюю привязку из правой части &&, || или ?? либо из аргументов опционального вызова, ведь эти части выполняются только если это допускает левая часть или получатель. Если такая часть выполнится слишком рано, действует прежняя ошибка несвязанного значения. |
| 5.19.782 | Внутренняя | Исходный файл, который существует, но не читается или не является корректным UTF-8, больше не считается отсутствующим. Разрешение точки входа и импортов выдаёт для него диагностику загрузчика TPZ3003 вместо TPZ3001. |
| 5.19.781 | Внутренняя | Вспомогательная функция парсера, у которой не было потребителей кроме проверки, сравнивавшей её саму с собой, стала внутренней, а проверка удалена. Поэтапная поверхность разбора, применяемая для сохранения токенов и наблюдения, не изменилась, как и разбор, деревья и диагностика. |
| 5.19.780 | Внутренняя | Замороженные количества фикстур v5.1 и таблица областей v5.2 хранятся в одном месте, которое читают и проверки парсера, и topaz check-corpus. Проверка, доказывавшая лишь согласие двух копий одной таблицы, удалена, а сами количества не изменились. |
| 5.19.779 | Внутренняя | Повторяющееся имя в выборочном импорте даёт TPZ2011 ровно один раз для каждого последующего нарушающего элемента и в порядке исходника. Если имя сталкивается и как экспортируемое, и как локальная привязка, приоритет у экспортируемого, и оба компилятора совпадают. |
| 5.19.778 | Внутренняя | None является конструктором Option и не может служить именем привязки, поэтому объявление константы с именем None отклоняется с TPZ2012 прямо в позиции имени. Stage 0 и парсер компилятора на Топазе применяют одно правило. |
| 5.19.777 | Внутренняя | Четыре замечания к исходникам в средстве сравнения с Python устранены. Временные значения передаются прямо в построители, два условия упрощены, компилятор, рантайм и исходники языка не изменились, а средство по-прежнему сравнивает свои фикстуры без расхождений. |
| 5.19.776 | Внутренняя | Поле с именем-ключевым словом, доступное после . или ?. либо записанное в позиции имени поля записи, больше не переводит разбор блоков в конструкцию вроде match или concurrent. Блоки из нескольких операторов после такого доступа и вложенные образцы записей после такого поля разбираются верно. |
| 5.19.775 | Внутренняя | Этап конвейера находит подстановку _ в любом из своих аргументов и останавливается перед вложенным конвейером. Этап без подстановки по-прежнему получает переданное значение первым аргументом, а этап с ней сохраняет все записанные позиционные, именованные и раскрытые аргументы и вычисляет их в порядке исходника. |
| 5.19.774 | Внутренняя | Идентификаторы образов компилятора Stage 1 и Stage 2 записываются один раз при сборке инструментов, поэтому запрос значения больше не хеширует весь встроенный образ заново. Байты образов, их манифесты и отдельная проверка образа перед запуском не изменились. |
| 5.19.773 | Внутренняя | Требуемая версия инструментария Rust читается из метаданных пакета, а не записана отдельно в трёх местах. Запечатанные манифесты хранят ту же версию, а байты образов, поведение рантайма и смысл языка не изменились. |
| 5.19.772 | Внутренняя | При сборке компактного образа компилятора больше не создаются три временных списка, нужных только для получения длины и немедленной сериализации. Схема образа, порядок и байты те же, манифесты и поведение рантайма тоже. |
| 5.19.771 | Внутренняя | Инструмент неподвижной точки Stage 2 требует ровно один входной путь и отклоняет пропущенный или лишний аргумент до чтения данных. Имена путей принимаются в том виде, в каком их даёт операционная система, а форма отчёта не изменилась. |
| 5.19.770 | Внутренняя | Устаревший канареечный инструмент для образа компилятора Stage 1 удалён. У него не осталось вызывающих, а обработку ответа и происхождения уже ведут официальные пути генерации и сравнения. |
| 5.19.769 | Внутренняя | Генератор второго прохода Stage 2 читает свои опции за один проход и отклоняет пропущенное значение, повторную или неизвестную опцию до начала генерации. Обработка опций, вычисление хеша и атомарная запись теперь общие с генератором Stage 1. |
| 5.19.768 | Внутренняя | Генератор образа Stage 1 разбирает аргументы один раз и отклоняет опцию без значения, повторную или неизвестную опцию и входной манифест, который не будет использован. Интерпретируемый режим применяется только без явного указания, а связанный сначала читает свой манифест. |
| 5.19.767 | Внутренняя | Инструмент сравнения Stage 1 больше не создаёт один и тот же вывод дважды и не называет это устойчивостью. Генерация идёт один раз, связанный и интерпретируемый пути обязаны дать одинаковый исходник, а проверка компиляции и запуска, идентичность образа и отклонение порчи и чужого производителя сохранены. |
| 5.19.766 | Внутренняя | Две проверки, которые дважды создавали один и тот же вывод и сравнивали его сам с собой, удалены, а их имена теперь описывают наблюдаемое свойство. Статус завершения, типовые, пониженные, экспортные и сгенерированные поверхности, приём манифеста и компиляция с запуском до результата 42 сохранены. |
| 5.19.765 | Внутренняя | Хосты тестовых фикстур заимствуют текст исходника, а не требуют значение, живущее всю программу, поэтому три динамически собранных исходника больше не приходится оставлять в памяти навсегда. Текст фикстур и всё, что наблюдают проверки, не изменились. |
| 5.19.764 | Внутренняя | Числа в JSON, который выпускает компилятор, строятся напрямую, а не печатаются в текст и разбираются обратно общим чтением. Точная десятичная запись, порядок ключей, имена полей, количества, порядковые номера и позиции не изменились. |
| 5.19.763 | Внутренняя | Проекция адаптера цели строит один индекс на модуль, а не обходит одно и то же синтаксическое дерево для каждого поиска родителя, поля и имени. Количества имён, выбор первой экспортируемой функции и проекции членов, полезной нагрузки, значений по умолчанию и форм не изменились. |
| 5.19.762 | Внутренняя | Слой запросов компилятора на Топазе избавился от трёх типов записей, дублировавших канонические формы, и от двух преобразований, заново собиравших каждый факт хоста, элемент каталога и сгенерированный стандартный модуль. Имена полей, формы, порядок фактов и обработка дубликатов не изменились. |
| 5.19.761 | Внутренняя | Профилировщик компилятора на Топазе индексирует ссылки типизированными вложенными отображениями, а не склеивает идентичности в строки с разделителями при каждом поиске, и один каталог владеет исходными ссылками вместе с индексами целей и членов. Решения профиля, коды, заметки, позиции и порядок не изменились. |
| 5.19.760 | Внутренняя | Эмиттер компилятора на Топазе проходит список пониженных операций один раз и хранит один каталог с индексом первого вхождения и отсортированными листьями рантайма, а не строит отображение и не обходит тот же список снова. Предел операций, вычисление замкнутых целых и получаемые байты прежние. |
| 5.19.759 | Внутренняя | Модуль проверки в компиляторе на Топазе оставляет девятнадцать внутренних типов записей себе, и экспортируется только одна точка входа проверки. Поля, поиски, фазы, диагностика и позиции работают как прежде. |
| 5.19.758 | Внутренняя | Разрешение имён в компиляторе на Топазе ищет факты хоста по индексу путей для каждого вида, а не обходит весь список фактов при каждом чтении, проверке вложенности и перечислении каталога. Порядок запросов, первое совпадение при дубликатах, статусы, байты данных и диагностика не изменились. |
| 5.19.757 | Внутренняя | Запись состояния парсера в компиляторе на Топазе стала внутренней, как в Stage 0, где то же состояние скрыто за публичными точками входа. Экспортируемая функция разбора, деревья, диагностика, заметки, позиции и восстановление не изменились. |
| 5.19.756 | Внутренняя | Из сгенерированных таблиц удалена неиспользуемая константа версии Unicode. Единственным источником закреплённых данных Unicode 16.0.0 остаётся генератор, заголовок по-прежнему это записывает, а диапазоны символов и байты отображений не изменились. |
| 5.19.755 | Внутренняя | Три вспомогательные функции Unicode в компиляторе на Топазе, использовавшиеся только внутри своего модуля, стали внутренними, и экспортируемых функций осталось семь. Сигнатуры, тела, вызывающие места и таблицы Unicode 16.0 не изменились. |
| 5.19.754 | Внутренняя | Четыре вспомогательные функции лексера в компиляторе на Топазе сохраняли экспорт, ставший ненужным после перехода разрешения имён на обход графа токенов. Теперь они внутренние, экспортируются только точка входа лексера и поиск ключевых слов, а сигнатуры, тела и вызывающие места не изменились. |
| 5.19.753 | Внутренняя | Запись полезной нагрузки и три константы схем остаются внутри модуля эмиттера компилятора на Топазе, так что экспортируется только один шаг выпуска, а один модуль убрал ненужный импорт. Значения схем, получаемые байты и сведения о происхождении не изменились. |
| 5.19.752 | Внутренняя | Одна константа схемы происхождения, использовавшаяся только внутри своего модуля, больше не экспортируется. Само значение, производимые им байты и отдельная проверка на стороне чтения не изменились. |
| 5.19.751 | Внутренняя | Обменная запись, которой никто не пользовался, удалена вместе с неиспользуемым импортом. Приём запроса сохраняет собственную внутреннюю запись, а обработка пакетов, диагностика, позиции и формы вывода не изменились. |
| 5.19.750 | Внутренняя | Из обработки импорта в парсере компилятора на Топазе удалено оставшееся неиспользуемое локальное значение. Пути импорта, выборки, псевдонимы, позиция парсера, восстановление, диагностика и позиции работают в точности как раньше. |
| 5.19.749 | Внутренняя | Внутренний надзиратель исполнения на macOS пишет запрос и вычитывает вывод одновременно под уже имевшимся контролем времени и памяти, поэтому переставший читать дочерний процесс не может его застопорить. Файл результата, где удвоенные скобки ломали чтение JSON, снова выдаётся одним корректным объектом. |
| 5.19.748 | Внутренняя | Внутренний надзиратель песочницы на macOS пишет обрамлённый запрос дочернему процессу и одновременно вычитывает его вывод под действующим контролем реального времени. Дочерний процесс, который вовсе не читает ввод, больше не может застопорить надзирателя до срабатывания тайм-аута. |
| 5.19.747 | Внутренняя | Установка, подготовка и очистка управляемых артефактов требуют, чтобы каждый существующий родительский каталог был настоящим каталогом, а не символической ссылкой. Прежняя миграция Python оставляет связанный каталог кэша и байты, на которые он указывает, нетронутыми. |
| 5.19.746 | Внутренняя | Самоприменимый компилятор применяет проверку профиля к любому окончательному результату компиляции, а не только к успешному. Отклонённая программа сохраняет диагностику профиля вроде TPZ2001 вместе с синтаксической ошибкой, как и компилятор Stage 0. |
| 5.19.745 | Внутренняя | Командная строка больше не создаёт и не проверяет промежуточную запись о компиляции, которая всё равно отбрасывалась и не доходила до настоящего результата. Вывод проверки берётся прямо из реальной компиляции, а его содержимое не изменилось. |
| 5.19.744 | Внутренняя | Миграция каталога вывода веб из версий до 5.6.1 признаёт папку своей только тогда, когда загрузчик содержит все три подписи, которые Топаз порождает сам. Пользовательская сборка, где Топаз лишь упомянут, сохраняет свои файлы JavaScript, WASM и Cargo.toml и не подлежит очистке. |
| 5.19.743 | Внутренняя | Преобразование расширенных путей к дискам Windows и путей UNC в безопасную для команд форму собрано в одном месте вместо двух одинаковых копий. Поведение корня рабочего пространства, вывода сборки, исходников и журналов осталось прежним. |
| 5.19.742 | Внутренняя | При обнаружении установленного продукта Лиспекс четыре идентичности артефактов читаются из одной фиксированной упорядоченной таблицы, а порядок, состояние, хост, путь, размер и хеш проверяются одним общим правилом. Выводимые сведения и запросы на запуск прежние. |
| 5.19.741 | Внутренняя | Планирование приложения Лиспекс и допуск на хосте несут одну запись идентичности заблокированного правила вместо шести разрозненных полей, и ограниченный и полный профили строят её одинаково. Поведение приложения и проверка блокировок и артефактов не изменились. |
| 5.19.740 | Внутренняя | Отчёт о циклах импорта обходит отсортированный список соседей внутри каждой группы цикла вместо повторного просмотра всех рёбер на каждом шаге. Сообщение TPZ3006, его позиция и правило об одной диагностике на цикл прежние. |
| 5.19.739 | Внутренняя | При построении наблюдения предпросмотра запрос больше не сериализуется, чтобы затем быть разобранным ради исправления фазы и закодированным заново. Общие файлы собираются один раз для фактической фазы вызывающей стороны, а содержимое наблюдений, схемы и диагностика прежние. |
| 5.19.738 | Внутренняя | Проверка типов несёт одну запись о месте вызова через разрешение вызова, его завершение и применение схемы типов вместо семи отдельных полей. Проверка модуля возвращает именованную запись вместо глубоко вложенного кортежа, семантика языка и диагностика прежние. |
| 5.19.737 | Внутренняя | Сопоставление типов во время выполнения в интерпретаторе хранит стек циклов псевдонимов и позицию ошибки в одном значении состояния, а проверки перечислений, записей и новых типов читают определение рантайма напрямую. Поведение интерпретатора, коды и позиции ошибок прежние. |
| 5.19.736 | Внутренняя | Бэкенд Python строит таблицу экспорта рантайма каждого модуля один раз и разделяет её только для чтения с импортами пространств имён вместо глубокого копирования. Порождаемый код Python, его порядок и поведение при ошибках прежние. |
| 5.19.735 | Внутренняя | Скомпилированная программа, у которой тело выражения-генератора не соответствует виду коллекции, отклоняется с указанием места в исходнике ещё до выполнения тела. Раньше такое несоответствие накапливалось не туда и молча возвращало пустую коллекцию. |
| 5.19.734 | Внутренняя | Одна проверка во время сборки подтверждает весь порождённый манифест компилятора, отвергая повторяющиеся ключи JSON и неизвестные поля, и проверяет полезную нагрузку компилятора до её сжатия. Рантайм читает этот проверенный результат вместо повторного разбора байтов манифеста. |
| 5.19.733 | Внутренняя | Проверки продукта Лиспекс описывают выпуск, развёрнутый сейчас, где все размещённые возможности реализованы и нет ни одной неподдерживаемой. Материалы, относящиеся только к истории, переведены в необязательный режим, а сам архив свидетельств не тронут. |
| 5.19.732 | Внутренняя | При копировании пакета в каталог vendor имя, версия и хеш кандидата проверяются до изменения назначения, родительские символические ссылки отклоняются, а незавершённые замены откатываются при сбое. Файлы topaz.toml и .tpz должны быть обычными. |
| 5.19.731 | Внутренняя | Файл topaz.toml отклоняет неизвестные поля и зависимость, где указаны сразу версия и путь. Файл topaz.lock должен содержать ровно одну корневую строку и по одной строке на каждую прямую зависимость, а чтение манифеста и блокировки остаётся внутри пакета и отклоняет ссылки наружу. |
| 5.19.730 | Внутренняя | Фикстуры воспроизведения и необязательные артефакты пакета читаются строгим средством чтения файлов пакета, которое отклоняет символическую ссылку в любом сегменте пути, выход за корень пакета и всё, что не является обычным файлом. Проверка блокировки и воспроизведение берут одни байты. |
| 5.19.729 | Внутренняя | Экспортированные let и const распознаются самоприменимым путём, его документацией и списком экспорта, а не сообщаются как не имеющие типизированного объявления. Каждый модуль исполняет свой верхний уровень ровно один раз, поэтому экспортированный инициализатор не срабатывает дважды. |
| 5.19.728 | Внутренняя | Map.filter и Map.mapValues делают снимок пар в порядке вставки до вызова функции, поэтому изменение того же Map внутри неё больше не приводит к аварийному завершению порождённой программы на Rust. Изменения сохраняются в исходном Map, а число вызовов не растёт. |
| 5.19.727 | Внутренняя | При построении именованных и квалифицированных схем JSON восемь неизменных входов передаются одним значением, а отдельным остаётся только состояние обхода. Поиск схем, подстановка обобщённых параметров, рекурсия и поведение при ошибках прежние. |
| 5.19.726 | Внутренняя | Бэкенд порождаемого Rust даёт имя иерархии модулей, функций и позиций, объединяет неизменные входы построения образцов for в одно значение и больше не переносит каталог объявлений, который никто не читал. Порождаемый код и поведение при ошибках прежние. |
| 5.19.725 | Внутренняя | На границе нативного вызова байтовая запись определяется по идентичности модуля, который её объявил, а не по короткому имени. В Топаз 5.20 одноимённая запись из другого модуля там больше не принимается, а поведение по короткому имени в Топаз 5.19 сохранено. |
| 5.19.724 | Внутренняя | Правило, выбирающее явную идентичность объявления при её наличии и опубликованное имя в противном случае, собрано в одном месте для каждого рантайма. Сравнение, порядок, ключи Map и Set, распаковка записей и проверки образцов и типов читают его, поведение прежнее. |
| 5.19.723 | Внутренняя | Создание снимка множества выполняет одна процедура там, где рядом стояли две одинаковые. Обход, Set.toArray, union, intersection и difference сохраняют порядок, удаление дубликатов и результаты. |
| 5.19.722 | Внутренняя | Для Array.sortedBy, sortBy и retain рантайм читает вызываемую функцию и элемент только из состояния ожидания, а не из копий рядом с ним. Порядок вызовов, число аргументов, семантика сохранённых элементов и ошибки прежние. |
| 5.19.721 | Внутренняя | Обратные вызовы высшего порядка для массивов и Map используют один протокол шагов вместо двух одинаковых. map, filter, reduce, Map.filter и Map.mapValues сохраняют порядок вызовов, результаты и ошибки во всех рантаймах. |
| 5.19.720 | Внутренняя | Поиск псевдонимов, записей, перечислений и новых типов при построении типизированной схемы JSON использует одну общую форму вместо четырёх повторений. Результаты поиска, подстановка, пределы рекурсии и ошибки типизированного JSON прежние. |
| 5.19.719 | Внутренняя | Две проверки синтаксиса типов схемы используют один обход в порядке исходника вместо собственных перечислений всех видов узлов типа. Отклонение импортированной схемы до Топаз 5.20 и блочного локального псевдонима работает как прежде. |
| 5.19.718 | Внутренняя | Квалификация типа пространством имён использует общий структурный обход вместо ручной пересборки каждого вида типа и заменяет только узлы перечислений, записей и новых типов, названные в таблице пространства имён. Результаты типизации прежние. |
| 5.19.717 | Внутренняя | Ещё два вручную поддерживаемых перечня форм типов в проверке типов заменены общими обходами. Сбор идентичностей экспортированных именованных типов и запечатывание порождённых типов-носителей Лиспекс дают прежние результаты. |
| 5.19.716 | Внутренняя | Переименование именованных идентичностей в проверке типов выполняет одна процедура. Прежде она была написана дважды, для перепривязки выборочного импорта в Топаз 5.19 и для канонизации со стабильной привязкой к модулю в Топаз 5.20, результаты обеих сохранены. |
| 5.19.715 | Внутренняя | Обнаружение ссылки на ещё недоступную функцию или let верхнего уровня использует один поиск и одно правило отсечения и для выражений, и для блоков. Сообщение TPZ5002, позиция первого нарушения и исключение для const не изменились. |
| 5.19.714 | Внутренняя | Сбор переменных вывода типов в проверке типов записывает условие один раз вместо двух вложенных проверок. Порядок первого появления и подавление дубликатов прежние. |
| 5.19.713 | Внутренняя | Построение ключа схемы JSON принимает только те значения, которые действительно использует. Каталог объявлений прежде проходил через него нетронутым, а байты ключа, порядок, подстановка, пределы рекурсии и результаты типизированного JSON остались прежними. |
| 5.19.712 | Внутренняя | Опорная точка цикла передаётся напрямую при сообщении о цикле модулей, без лишнего слоя ссылки. Обнаружение циклов, сообщаемый путь и текст сообщения прежние. |
| 5.19.711 | Внутренняя | Экспорт модуля различается только как тип или значение. Функции, let и const учитывались раздельно, хотя эту разницу никто не читал, а пригодность к импорту, подсказки и вся диагностика экспорта работают как прежде. |
| 5.19.710 | Внутренняя | Разрешение ссылки на значение сообщает только те случаи, которым нужна последующая диагностика, а именно импортированную привязку и пространство имён. Обычная привязка модуля не сообщает ничего, чтение, запись и диагностика прежние. |
| 5.19.709 | Внутренняя | Решение о том, перекрывает ли локальное значение импортированное пространство имён, использует тот же лексический поиск, что и остальные локальные обращения. Второй почти такой же поиск удалён, перекрытие, приоритет и диагностика прежние. |
| 5.19.708 | Внутренняя | Разрешение именованного типа сначала просматривает лексические области и обращается к таблице модуля только при отсутствии локальной привязки, а не запрашивает обе всегда. Перекрытие, приоритет и сообщения о неразрешённых ссылках прежние. |
| 5.19.707 | Внутренняя | Проверка экспортированных сигнатур обходит каждый публичный тип там, где он встречается, вместо предварительного сбора в список. Сообщение TPZ3014 о приватном типе в публичной сигнатуре сохраняет позицию и порядок. |
| 5.19.706 | Внутренняя | Проверка поверхности импорта больше не получает таблицу текущего модуля, которую никогда не читала. Сообщения TPZ3010 и TPZ3009, их позиции, порядок и подсказки не изменились. |
| 5.19.705 | Внутренняя | Запись ссылки на значение сообщает, что было найдено, поэтому пути идентификатора и присваивания не повторяют просмотр областей и обращение к таблице. Сообщения TPZ3012 и TPZ3015 сохраняют позиции и порядок. |
| 5.19.704 | Внутренняя | Разрешение члена пространства имён обращается к экспорту один раз и повторно использует результат для классификации и для всех ветвей диагностики. Сообщения TPZ3013, TPZ3010 и TPZ0002 и исключение для значения по умолчанию приватной записи не изменились. |
| 5.19.703 | Внутренняя | Квалифицированное имя типа разрешает голову пространства имён один раз и повторно использует эту цель для обработки члена, экспорта и ссылки. Сообщение TPZ3013 о недопустимой голове сохраняет позицию и порядок. |
| 5.19.702 | Внутренняя | В самоприменимом компиляторе разрешение ссылки возвращает найденную привязку модуля, поэтому пути присваивания и значения не повторяют локальный поиск и обращение к таблице. Сообщения TPZ3013 и TPZ3005 не изменились. |
| 5.19.701 | Внутренняя | Псевдоним выборочного импорта в позиции типа записывает локальное имя псевдонима, поэтому самоприменимый компилятор и компилятор Stage 0 сообщают одну и ту же цель ссылки. В позиции значения по-прежнему записываются исходный модуль и экспортированное имя. |
| 5.19.700 | Внутренняя | При построении таблицы модуля отсутствующая привязка представляется отсутствием значения, а не отрицательным индексом, когда выбирается индекс экспорта и решается, коллизия это или вставка. Сообщение TPZ3008 и поведение при повторном экспорте прежние. |
| 5.19.699 | Внутренняя | Разрешение члена пространства имён сохраняет отсутствующий экспорт как отсутствие значения, а не сводит его к отрицательному индексу и пустой строке пространства имён. Семантика члена, исключение для значения по умолчанию приватной записи и вся диагностика прежние. |
| 5.19.698 | Внутренняя | Операции чтения в самоприменимом компиляторе получают запись таблицы модуля напрямую, а не запрашивают индекс, который мог быть отрицательным маркером, чтобы затем обратиться к массиву. Диагностика, порядок, поверхности импорта и экспорта прежние. |
| 5.19.697 | Внутренняя | Восемь путей, которые лишь читают привязку модуля, получают запись привязки напрямую вместо индекса, который мог быть отрицательным маркером. Цели ссылок, состояние пространства имён и экспорта и диагностика прежние. |
| 5.19.696 | Внутренняя | Объявление протокола записывается сразу как факт объявления, а не строится сначала как временная целая привязка. Порядок, позиции, состояние пространства имён и экспорта и диагностика прежние. |
| 5.19.695 | Внутренняя | Факты объявлений выводятся из существующей привязки модуля, а окончательное пространство имён и признак экспорта передаются явно, вместо пересборки целой привязки для каждого. Факты, порядок, позиции и диагностика прежние. |
| 5.19.694 | Внутренняя | Каждое экспортированное имя ищется один раз как единая запись, несущая и индекс привязки, и пространство имён, вместо двух отдельных поисков по одному имени. Факты экспорта, их порядок, подсказки и диагностика прежние. |
| 5.19.693 | Внутренняя | Каждый модуль хранит один отсортированный список своих уникальных экспортированных имён, который используют проверка отсутствия экспорта, подсказки и факты экспорта. Прежде при каждом обращении привязки просматривались заново и массив сортировался с нуля. |
| 5.19.692 | Внутренняя | Факты экспорта добавляются в порядке модулей, а имена внутри модуля уже отсортированы. Приём, который при каждом экспорте заново просматривал и сдвигал весь накопленный список, удалён, итоговый порядок и содержимое совпадают. |
| 5.19.691 | Внутренняя | Проверка сигнатур экспорта берёт таблицу текущего модуля по позиции, поскольку таблицы строятся в порядке модулей. Лишний поиск по идентичности, из-за которого проверка могла молча пропускаться, удалён. |
| 5.19.690 | Внутренняя | Текст исходника модуля кодируется в UTF-8 один раз при разборе модуля, и последующие проходы используют это представление. Прежде пять проходов кодировали один и тот же исходник заново. |
| 5.19.689 | Внутренняя | Список допущенных модулей остаётся единственной записью о том, какие модули разобраны успешно, тогда как рядом хранилось отдельное множество идентичностей. Обнаружение, отсечение рёбер, сообщения о циклах и порядок зависимостей прежние. |
| 5.19.688 | Внутренняя | Допуск импорта принимается один раз и сразу даёт путь, источник, физический псевдоним и происхождение стандартного модуля, тогда как шесть мест заново строили путь и просматривали те же факты. Порядок запросов, маршрутизация, коллизии псевдонимов и диагностика прежние. |
| 5.19.687 | Внутренняя | Модуль, отклонённый из-за совпадения физического псевдонима, больше не спрашивает у хоста о файлах, названных в его собственных импортах. Отдельный сканер, работавший до разбора, удалён, импорты находит только граф модулей от парсера, сообщение TPZ3004 прежнее. |
| 5.19.686 | Внутренняя | Фигурная скобка внутри комментария после импорта больше не скрывает следующий за ним импорт. Обнаружение модулей пропускает строчные и блочные комментарии до подсчёта скобок, поэтому такому исходнику не нужны дополнительные раунды запросов о файлах. |
| 5.19.685 | Внутренняя | Обнаружение модулей принимает как сегмент пути только настоящий идентификатор, поэтому import function, import *, import lib.function и import lib.sub"text" больше не заставляют компилятор запрашивать файлы у хоста. Ни одна из этих форм и раньше не давала ребра импорта. |
| 5.19.684 | Внутренняя | Пробелы, переводы строк и комментарии вокруг точки в составном импорте читаются так же, как их читает парсер, поэтому import lib . sub запрашивает у хоста файл вложенного модуля, а не родительского. Точка без следующего сегмента отбрасывает путь, а не оставляет его недостроенным. |
| 5.19.683 | Внутренняя | Разделитель инструкций после головы import завершает импорт и для обнаружения модулей, поэтому import с последующим переводом строки, точкой с запятой или строчным комментарием больше не заставляет компилятор запрашивать файл у хоста. Парсеры и не читали такие формы как импорт. |
| 5.19.682 | Внутренняя | Обнаружение модулей завершает строчный комментарий только по переводу строки и больше не считает подачу страницы пробелом, как и лексер. Закомментированный импорт, за которым идёт одиночный возврат каретки, больше не заставляет компилятор запрашивать этот файл у хоста. |
| 5.19.681 | Внутренняя | Обнаружение модулей завершает блочный комментарий на первом закрывающем маркере, как задано спецификацией языка, и не считает глубину вложенности. Результаты разрешения, диагностика и запросы к хосту прежние. |
| 5.19.680 | Внутренняя | Поиск конца идентификатора выполняет одна общая процедура, которую используют и лексер, и обнаружение модулей. Суффиксы длительности, метки, ключевые слова, строки с тегом и правила идентификаторов Unicode сохраняют поведение. |
| 5.19.679 | Внутренняя | Сканирование идентификаторов в самоприменимом лексере считает ширину символа одним общим путём вместо двух копий. Набор символов, которыми идентификатор начинается и продолжается, включая буквы, цифры и эмодзи Unicode, не изменился. |
| 5.19.678 | Внутренняя | Токены продолжения строки объявляются один раз в каждой реализации компоновки вместо двух длинных списков. Набор токенов, продолжающих строку до и после переноса, включая else только слева и запятую и толстую стрелку только справа, не изменился. |
| 5.19.677 | Внутренняя | Восстановление после переноса строки внутри однострочной интерполяции идёт в лексере Stage 0 по одному общему пути, встречен ли перенос напрямую или из вложенной строки. Токены, диагностика и проверка отступов не изменились. |
| 5.19.676 | Внутренняя | Сканирование строк в самоприменимом лексере выводит ширину разделителя из признака многострочности, а не хранит её вторым полем. Состояние, в котором эти два значения расходились, исчезло, а токены, диагностика и позиции не изменились. |
| 5.19.675 | Внутренняя | Когда многострочная строка находится внутри однострочной интерполяции, лексер Stage 0 находит охватывающую интерполяцию один раз, а не ищет её дважды. Восстановление после переноса, токены, диагностика и проверка отступов не изменились. |
| 5.19.674 | Внутренняя | Интерполяция в лексере Stage 0 берёт признак однострочности или многострочности из охватывающей строки, а не хранит его копию, поэтому эти два места больше не могут описывать разные виды строк. Поведение лексера не изменилось. |
| 5.19.673 | Внутренняя | Режимы строк в Stage 0 хранят данные об отступах многострочной строки сами, а не в параллельном стеке рядом, поэтому они больше не могут разойтись. Токены, диагностика, проверка отступов и восстановление не изменились. |
| 5.19.672 | Внутренняя | Сканирование тегированных строк в самоприменимом лексере передаёт результат сканирования строки напрямую, а не разбирает его на поля и собирает заново. Тегированные шаблоны разбираются на токены ровно как прежде. |
| 5.19.671 | Внутренняя | Сканирование обычного кода, строк и интерполяций в самоприменимом лексере возвращает одну форму результата вместо двух, которые несли то же содержимое под разными именами. Лексический вывод не изменился. |
| 5.19.670 | Внутренняя | Строчные и блочные комментарии попадают в самоприменимый лексер по одной общей ветке, а вид комментария определяется в одном месте. Токены комментариев, диагностика незакрытого комментария и токены / и /= не изменились. |
| 5.19.669 | Внутренняя | Сканирование строк и сканирование обычных токенов в самоприменимом лексере используют одну запись результата, поэтому у одного и того же содержимого больше нет двух определений типа. Токенизация, примыкание тегированных шаблонов и восстановление не изменились. |
| 5.19.668 | Внутренняя | Сканирование интерполяции в самоприменимом лексере возвращает только то, что использует вызывающая сторона, после передачи собранных токенов и диагностики. Уже переданное содержимое наружу не уходит, а токенизация строк и восстановление не изменились. |
| 5.19.667 | Внутренняя | Выбор режима компоновки фигурной скобки и потребление ожидающего маркера concurrent в самоприменимой компоновке происходят в одном решении, повторная проверка состояния убрана. Компоновка импорта модуля, шаблона записи и тела не изменилась. |
| 5.19.666 | Внутренняя | Предпросмотр фигурной скобки в самоприменимой компоновке читает два следующих значимых токена за один проход, а не пересматривает ведущие переносы ради второго. Распознавание полей записи и режимы скобок не изменились. |
| 5.19.665 | Внутренняя | Кадры компоновки в самоприменимом компиляторе хранят свой режим и открывающий разделитель как фиксированный набор значений, а не свободные строки, поэтому значение вне известного набора туда не попадёт. Вывод компоновки не изменился. |
| 5.19.664 | Внутренняя | Самоприменимая компоновка записывает предыдущий значимый токен как присутствующий или отсутствующий, а не подставляет пустую строку вместо отсутствия. Решения о продолжении строки, разделители и вывод компоновки не изменились. |
| 5.19.663 | Внутренняя | Активная область шаблона в самоприменимой компоновке хранит глубину и вид одним значением, а вид ограничен областями привязки, case и for. Компоновка шаблонов и продолжение по вертикальной черте не изменились. |
| 5.19.662 | Внутренняя | Кадры компоновки в самоприменимом компиляторе лежат в одном стеке вместо трёх параллельных массивов для режима, открывающего разделителя и наличия элементов, поэтому они больше не могут расходиться. Вывод компоновки не изменился. |
| 5.19.661 | Внутренняя | Ожидающий неявный разделитель в самоприменимой компоновке хранится как один необязательный токен, а не как флаг рядом с позицией, которая могла устареть. Расстановка неявных разделителей, явные точки с запятой и вывод токенов не изменились. |
| 5.19.660 | Внутренняя | Некорректный код с повторённым заголовком concurrent больше не порождает лишний разделитель операторов в самоприменимой компоновке. На разделителе снимаются все устаревшие маркеры текущей глубины, а обычное тело concurrent потребляет ровно один. |
| 5.19.659 | Внутренняя | Неиспользуемое поле в результате интерполяции самоприменимого лексера удалено. Нормальное закрытие, баланс на конце файла и восстановление после переноса уже описывались токенами и следующей позицией, поэтому токены, диагностика и позиции не изменились. |
| 5.19.658 | Внутренняя | Символ перевода страницы в исходном коде отклоняется самоприменимым лексером с TPZ0001, а не принимается молча как пробел, как и в компиляторе Stage 0. Обработка пробела, табуляции, возврата каретки и перевода строки не изменилась. |
| 5.19.657 | Внутренняя | Просмотр за пределами потока в самоприменимом парсере возвращает настоящий последний токен потока, а не отдельно построенную метку конца, поэтому все запасные пути совпадают. Вид конечного токена, его позиция, диагностика и восстановление не изменились. |
| 5.19.656 | Внутренняя | Два флага допуска в самоприменимом парсере читаются и записываются напрямую, а не через поиск со значением по умолчанию и пару снятия и добавления, поэтому пустая ячейка больше не чинится молча. Результаты разбора не изменились. |
| 5.19.655 | Внутренняя | Самоприменимый парсер читает курсоры позиции и последней границы напрямую, а не через помощник, который при пустой ячейке мог подставить значение от вызывающей стороны. Дерево разбора, диагностика, позиции и восстановление не изменились. |
| 5.19.654 | Внутренняя | Оба компилятора потребляют ожидающий > через обычный курсор токенов, поэтому у закрывающей угловой скобки один владелец. Вложенные обобщения, аргументы типа через запятую, разделение >> и обработка лишней закрывающей скобки не изменились. |
| 5.19.653 | Внутренняя | Самоприменимый парсер завершает список аргументов типа по одному курсору токенов, не заглядывая дополнительно в хранилище ожидающей закрывающей скобки. Разбор аргументов типа, дерево разбора и диагностика не изменились. |
| 5.19.652 | Внутренняя | Тип, записанный строковым литералом с интерполяцией, отклоняется самоприменимым парсером с TPZ2001, тем же кодом, сообщением и позицией, что уже выдавал компилятор Stage 0. Раньше такой тип принимался. |
| 5.19.651 | Внутренняя | Использование None как имени параметра отклоняется с TPZ2012 в обоих компиляторах, для обычных функций, методов протокола и обеих форм лямбды. None является конструктором Option и не может быть обычным именем привязки. |
| 5.19.650 | Внутренняя | Ресурс using, связанный с именем None, отклоняется самоприменимым парсером с TPZ2012, как и в компиляторе Stage 0. Разбор значения и тела ресурса и все остальные формы привязки не изменились. |
| 5.19.649 | Внутренняя | Ссылка на член пространства имён, названный ключевым словом, даёт от самоприменимого компилятора TPZ3013 вместо общей ошибки об отсутствии экспорта, так что оба компилятора выдают одну диагностику на один и тот же код. |
| 5.19.648 | Внутренняя | Член пространства имён в позиции типа записывается в самоприменимом компиляторе как цель типа, а исключение для приватного значения по умолчанию в записи действует только в позиции значения, поэтому приватная привязка, использованная как тип, снова даёт TPZ3009. |
| 5.19.647 | Внутренняя | Модуль, в котором произошло столкновение имён верхнего уровня, сохраняет объявленные экспорты в самоприменимом компиляторе, поэтому импортирующая сторона больше не получает ложное сообщение о том, что модуль ничего не экспортирует. Столкновение по-прежнему сообщается. |
| 5.19.646 | Внутренняя | Проверка поверхности импорта в самоприменимом компиляторе выполняется даже тогда, когда модуль уже сообщил о столкновении имён, поэтому независимая ошибка импорта больше не проглатывается. Оба компилятора сообщают сначала столкновение, затем ошибку импорта. |
| 5.19.645 | Внутренняя | Объявление export let mut даёт TPZ3011 в самоприменимом компиляторе даже там, где имя уже сталкивается, поэтому диагностика больше не теряется, а оба компилятора совпадают и по порядку сообщений. |
| 5.19.644 | Внутренняя | После двух объявлений одного имени в одной области видимости следующая ссылка указывает в самоприменимом компиляторе на позднее объявление, а не на первое. Затенение во вложенных областях и записанные объявления не изменились. |
| 5.19.643 | Внутренняя | Оба компилятора заглядывают внутрь вложенного оператора using при проверке блока инициализации импортированного модуля, поэтому обращение к имени раньше его объявления в значении ресурса или в теле даёт TPZ3018, а не проходит незамеченным. |
| 5.19.642 | Внутренняя | Самоприменимая проверка типов отклоняет повторяющиеся поля в структурном типе записи и в литерале записи с TPZ5022, а не принимает их. Запись, написанная в другом порядке полей, по-прежнему присваивается тому же ожидаемому типу. |
| 5.19.641 | Внутренняя | Встроенные функции в самоприменимой проверке типов берут свой тип и сигнатуру вызова из одного каталога, а не из двух мест, описывавших одни и те же имена параметров, значения по умолчанию и их число. Поведение вызовов не изменилось. |
| 5.19.640 | Внутренняя | Проверка модульной единицы в компиляторе Stage 0 идёт по одному пути независимо от того, сохраняет ли вызывающая сторона типовые результаты. Порядок зависимостей, проверка точки входа, экспорты, псевдонимы и соответствия протоколам не изменились. |
| 5.19.639 | Внутренняя | Структурные записи в самоприменимой проверке типов получают канонический порядок полей в одном месте, поэтому запись в обратном порядке даёт тот же тип привязки. Там, где ожидается точный тип записи, известное поле сохраняет свой литеральный тип. |
| 5.19.638 | Внутренняя | Подстановка аргументов типа в самоприменимой проверке типов читает привязки напрямую, а не пересобирает пару параллельных списков на каждый вызов, а сортировка массива определяет тип элемента один раз и для решения о возможности, и для сообщения. |
| 5.19.637 | Внутренняя | Экспортированные обобщённые псевдонимы типов подставляют свои аргументы в enum, записи и newtype, поэтому поля, шаблоны вариантов и методы, доступные через псевдоним с указанием пространства имён, разрешаются, а не отказывают. |
| 5.19.636 | Внутренняя | Явные аргументы типа и ожидаемый тип результата сохраняют в самоприменимой проверке типов свои литеральные типы, а обычные аргументы по-прежнему расширяются, поэтому контекстный вызов, возвращающий обобщение с литеральным аргументом, принимается, а не отклоняется. |
| 5.19.635 | Внутренняя | Обход типа в самоприменимой проверке типов принадлежит двум местам, одному для проверок о типе и одному для перезаписи его частей, вместо семи процедур, обходивших одни и те же дочерние узлы. Каждое решение сохраняет своё правило. |
| 5.19.634 | Внутренняя | Компилятор Stage 0 обходит части типа по одному общему перечню, заменяя повторявшиеся списки дочерних узлов в поиске неизвестных типов, сборе переменных, обнаружении проекций и проверке аргументов именованных типов. Каждое решение сохраняет своё правило. |
| 5.19.633 | Внутренняя | Пять проверок возможностей в самоприменимой проверке типов используют одну проекцию дочерних элементов именованного типа, поэтому поиск в записях, enum и newtype и подстановка обобщений записаны один раз. Набор допустимых типов не изменился. |
| 5.19.632 | Внутренняя | Проверки возможности кодирования и декодирования JSON в компиляторе Stage 0 используют один обход, сохраняя два настоящих различия. Один встроенный тип можно только кодировать, а рекурсивный именованный тип отклоняется при декодировании, которому нужна конечная схема. |
| 5.19.631 | Внутренняя | Вызов метода протокола в компиляторе Stage 0 выводит тип получателя один раз и использует его для проверки диспетчеризации, а не обходит выражение получателя во второй раз. Допуск и отклонение соответствия и диагностика не изменились. |
| 5.19.630 | Внутренняя | Проверка кодируемости при вызове JSON.stringify в компиляторе Stage 0 использует уже выведенный тип аргумента и обращается ко второй пробе, только если этот тип остался неизвестным. Набор кодируемых значений не изменился. |
| 5.19.629 | Внутренняя | Тела функций и тела методов получателя в компиляторе Stage 0 используют один жизненный цикл для контекста возврата, изоляции циклов и сбора пропущенных возвратов. Свободные функции по-прежнему публикуют выведенные сигнатуры, а методы обновляют каталог методов. |
| 5.19.628 | Внутренняя | Одна лексическая область видимости в компиляторе Stage 0 хранит типы привязок, изменяемые имена, отложенные возвраты, связи псевдонимов и данные о вызываемых объектах в одном кадре вместо пяти параллельных списков. Затенение, изменяемость и диагностика рекурсии не изменились. |
| 5.19.627 | Внутренняя | Методы получателя, вручную написанные методы протокола и соответствия ищутся в компиляторе Stage 0 по вложенным каталогам, а самоприменимая проверка типов отвечает о соответствии по индексу, а не перебором списка. Порядок вывода не изменился. |
| 5.19.626 | Внутренняя | Автодополнение и подсказка сигнатуры в редакторе разрешают привязки из вашего кода раньше встроенных имён, поэтому массив с именем Map предлагает члены массива, а написанная вами функция print показывает свою сигнатуру, а не встроенную. |
| 5.19.625 | Внутренняя | Автодополнение в редакторе предлагает весь набор встроенных имён, которые принимает проверка типов, включая типы ByteBuffer и template, статические пространства имён Math, JSON и Test, протоколы вроде Show и значения RoundingMode. |
| 5.19.624 | Внутренняя | Шаблон записи с указанием имени типа регистрирует привязки своих полей при разрешении имён в Stage 0, поэтому корректный код в блоке инициализации импортированного модуля больше не получает ложный TPZ3018. Вложенный типизированный подшаблон тоже указывает на своё объявление. |
| 5.19.623 | Внутренняя | Проверка порядка инициализации верхнего уровня в компиляторе Stage 0 собирает имена, связанные шаблоном записи с указанием типа, поэтому привязка внутри блока корректно затеняет более позднее имя верхнего уровня и ложный TPZ5002 не выдаётся. |
| 5.19.622 | Внутренняя | Исходный код самоприменимой проверки типов проходит через запечатанный компилятор Stage 2 без диагностик. Значения, которые расширялись из-за ветви match, оканчивающейся на return, остаются конкретными, а длина массива проверяется до обращения по индексу. |
| 5.19.621 | Внутренняя | Глубоко рекурсивные программы достигают языкового предела рекурсии и сообщают TPZ5009 в месте вызова, а не исчерпывают стек хоста. Один стек выполнения в 64 MiB общий для продуктов и встроенных образов компилятора. |
| 5.19.620 | Внутренняя | Самоприменимая проверка типов строит индекс привязок верхнего уровня один раз на модуль, а не пересматривает каждый оператор верхнего уровня для каждой ссылки. Правила порядка инициализации и диагностика TPZ5002 не изменились. |
| 5.19.619 | Внутренняя | Оба компилятора требуют точное число аргументов типа для каждого именованного типа, от int и string до Array, Map, Option и ваших собственных записей, enum и newtype. Запись File как типа обозначает ресурс, который возвращает open, а единичный тип пишется только как (). |
| 5.19.618 | Внутренняя | Запись template как типа значения или возвращаемого значения работает в обоих компиляторах, а не падает с несовпадением двух одноимённых типов. Объявление записи, enum или newtype с именем template отклоняется с TPZ5022. |
| 5.19.617 | Внутренняя | Значение по умолчанию для параметра функции, записанное строкой с интерполяцией, отклоняется самоприменимой проверкой типов, которая раньше его принимала. Константным выражением считается только строка из литерального текста, как и в компиляторе Stage 0. |
| 5.19.616 | Внутренняя | Интерполяция ByteBuffer или значения, содержащего его внутри записи, объединения, полезной нагрузки enum или newtype, отклоняется самоприменимой проверкой типов с TPZ5001 и в обычных строках, и в тегированных шаблонах. Раньше это проходило незамеченным. |
| 5.19.615 | Внутренняя | Когда вызов метода протокола отклонён из-за того, что получатель не соответствует протоколу, самоприменимая проверка типов продолжает проверять остальные аргументы, поэтому неверный тип аргумента сообщается рядом с ошибкой соответствия, а не скрывается за ней. |
| 5.19.614 | Внутренняя | Число аргументов в TPZ5004 показывает, сколько аргументов действительно передано в месте вызова, включая переданное через конвейер значение и лишние аргументы. Вызов функции с одним параметром и двумя аргументами сообщает про два, а не про один. |
| 5.19.613 | Внутренняя | Повторяющиеся вещественные и единичные ключи в литерале отображения больше не отклоняются самоприменимой проверкой типов с TPZ5602. Статическое обнаружение дубликатов остаётся за целыми, логическими и обычными строковыми ключами, а дубликат при выполнении даёт TPZ4601. |
| 5.19.612 | Внутренняя | Лямбда, переданная в контекст, ожидающий другое число параметров, даёт от самоприменимой проверки типов TPZ5004 перед несовпадением типов, как и в компиляторе Stage 0. Вывод типов продолжается, поэтому следующая ошибка тоже сообщается. |
| 5.19.611 | Внутренняя | Шаблон конструктора newtype, записанный через переименованный импорт, теперь сопоставляется с тем типом, который действительно выбран этим импортом, и оба компилятора принимают его, даже если в другом модуле объявлен тип с тем же именем. |
| 5.19.610 | Внутренняя | Шаблоны записей, записанные через выборочный импорт, теперь разрешаются в саму импортированную запись, а проверка полноты match различает одноимённые записи из разных модулей вместо того, чтобы считать их одной. |
| 5.19.609 | Внутренняя | Производное соответствие протоколу теперь следует за импортированным типом через его псевдоним или имя с пространством имён, поэтому корректный импортированный тип больше не отклоняется, а соответствие не перетекает между одноимёнными типами из разных модулей. Отображаемые имена типов не меняются. |
| 5.19.608 | Внутренняя | Протокол, объявленный с импортированным типом в сигнатуре, теперь видит настоящий импортированный тип, поэтому подходящая реализация принимается, а не отклоняется как несовпадение. |
| 5.19.607 | Внутренняя | Закрытые типы, доступные через открытое значение или псевдоним, теперь несут идентичность объявившего их модуля, поэтому передача записи одного модуля туда, где ожидается одноимённая запись другого, отклоняется с TPZ5001. Поведение Топаза 5.19 не изменилось. |
| 5.19.606 | Внутренняя | Приложения на Лиспексе теперь завершаются на самоприменимом маршруте, а не останавливаются с незавершённым вычислением, потому что значения от хоста Лиспекса сопоставляются с теми же типами, которые одобрила проверка. |
| 5.19.605 | Внутренняя | Внутренние проверки приведены в соответствие с действующим правилом, по которому любая команда с выбором компилятора без указания использует Rust, а самоприменимая компиляция включается только явным --compiler self. Поведение продукта не изменилось. |
| 5.19.604 | Внутренняя | Абсолютный входной файл под явно заданным абсолютным корнем исходников теперь сохраняет указанный корень, поэтому модули ищутся по настоящим путям, а не в удвоенном каталоге. Вывод --exports-json перечисляет все разрешённые модули, включая те, что ничего не экспортируют. |
| 5.19.603 | Внутренняя | Передача самого входного файла в --root теперь отклоняется с TPZ3002 и сообщением о том, что корнем исходников должен быть каталог, содержащий вход. Раньше оба компилятора принимали такой вызов и давали разные неверные идентичности модулей. |
| 5.19.602 | Внутренняя | При разрешении импортов больше не создаётся полная копия исходника каждого модуля, что убирает одно выделение памяти на модуль. Разбор, идентичности модулей, диагностика и все последующие этапы не изменились. |
| 5.19.601 | Внутренняя | Когда два модуля импортируют один и тот же отсутствующий модуль, самоприменимый компилятор сообщает TPZ3001 один раз, а не по разу на каждый импортирующий модуль, как это уже делал компилятор на Rust. |
| 5.19.600 | Внутренняя | Оператор, который не разобрался, больше не закрывает секцию импортов, поэтому следующий import не отмечается как запоздалый. Оба компилятора сообщают только о настоящей синтаксической ошибке. |
| 5.19.599 | Внутренняя | Сообщения самоприменимого компилятора о пропущенной фигурной скобке теперь называют сам токен { или } вместо описания словами, поэтому оба компилятора дают одинаковый текст в записях, перечислениях, протоколах, блоках функций, шаблонах и выражениях match. |
| 5.19.598 | Внутренняя | После того как >> закрывает список типовых параметров, оставшийся > остаётся видимым для парсера самоприменимого компилятора. Лишняя угловая скобка в псевдониме типа, обобщённой функции или реализации протокола указывает на то же место и ожидает тот же токен в обоих компиляторах. |
| 5.19.597 | Внутренняя | Диапазон без конечной точки после .. теперь и в самоприменимом компиляторе даёт одно понятное сообщение с указанием на сам ... В конце файла, внутри скобок, в массиве, с шагом и в охранном выражении match второе наведённое сообщение больше не появляется. |
| 5.19.596 | Внутренняя | Включение map, оборвавшееся без разделителя ключа и значения, теперь получает одинаковое сообщение от обоих компиляторов, то самое, которое называет пропущенный токен и показывает ожидаемую форму тела. |
| 5.19.595 | Внутренняя | Выражение в скобках прямо перед стрелкой охранного выражения match или условия включения больше не принимается за лямбду, поэтому такие формы проверяются и выполняются в самоприменимом компиляторе так же, как в компиляторе на Rust. Явно сгруппированные лямбды работают по-прежнему. |
| 5.19.594 | Внутренняя | Испорченный элемент внутри match или concurrent теперь сообщается один раз, и разбор продолжается со следующего варианта или ветви, вместо того чтобы разворачивать всё выражение и добавлять несуществующие ошибки. |
| 5.19.593 | Внутренняя | Пустой match теперь и в самоприменимом компиляторе отмечается тем же сообщением о необходимости хотя бы одного case и на том же промежутке фигурных скобок. Раньше он проходил вообще без диагностики. |
| 5.19.592 | Внутренняя | Варианты в match и ветви в concurrent теперь и в самоприменимом компиляторе требуют разделителя между собой, а его отсутствие отмечается там, где начинается следующий вариант или ветвь. Корректные разделители, закрывающая скобка и конец файла принимаются как прежде. |
| 5.19.591 | Внутренняя | Два оператора в блоке без разделителя между ними теперь дают в обоих компиляторах одно сообщение на втором операторе, а не это сообщение и ещё две ошибки на закрывающей фигурной скобке. |
| 5.19.590 | Внутренняя | Лишняя закрывающая фигурная скобка на верхнем уровне программы теперь даёт в обоих компиляторах одинаковую пару сообщений, потому что парсер самоприменимого компилятора оставляет её следующему элементу так же, как компилятор на Rust. |
| 5.19.589 | Внутренняя | Некорректные экспортируемые объявления enum, record и newtype больше не приводят к аварийному завершению компилятора. Они отмечаются обычным сообщением о разделителе на самом ключевом слове, а корректные экспортируемые объявления не изменились. |
| 5.19.588 | Внутренняя | В самоприменимом компиляторе export больше не принимает блок impl как целое объявление, и ошибка указывает на impl уже при разборе. Экспорт отдельных методов внутри impl работает по-прежнему. |
| 5.19.587 | Внутренняя | Параметр self без типа считается получателем только когда стоит первым и не является вариативным. Запись его после другого параметра или с раскрытием теперь отклоняется и в самоприменимом компиляторе, как уже было в компиляторе на Rust. |
| 5.19.586 | Внутренняя | Если mut написан не на своём месте, перед let или после имени привязки, самоприменимый компилятор теперь даёт подсказку про let mut вместо общего сообщения о выражении или знаке равенства. |
| 5.19.585 | Внутренняя | Элемент, не являющийся функцией, внутри тела impl или protocol теперь отмечается отдельным сообщением о том, что такие тела содержат только методы или только сигнатуры, как и в компиляторе на Rust. |
| 5.19.584 | Внутренняя | Слова enum, record, newtype, impl и protocol читаются как обычные имена, пока за ними не идёт точная форма объявления. Самоприменимый компилятор теперь следует тому же правилу, поэтому эти слова остаются пригодны как идентификаторы, а ошибка отмечается там же, где и в компиляторе на Rust. |
| 5.19.583 | Внутренняя | Пустые скобки полезной нагрузки у варианта перечисления теперь отклоняются в самоприменимом компиляторе с требованием первого типа. Вариант без нагрузки по-прежнему пишется без скобок, а восстановление после неудачного объявления даёт ту же последовательность, что и компилятор на Rust. |
| 5.19.582 | Внутренняя | Пустой список типовых параметров <> в объявлении типа или функции теперь отклоняется в самоприменимом компиляторе с требованием типового параметра на закрывающей скобке. Объявления без типовых параметров не затронуты. |
| 5.19.581 | Внутренняя | Повторяющиеся локальные имена в выборочном импорте теперь сообщаются в том же порядке, что и в компиляторе на Rust, по положению более раннего имени в паре, а не более позднего. |
| 5.19.580 | Внутренняя | Испорченное предложение timeout в concurrent теперь даёт одно сообщение и восстанавливается до парной скобки, поэтому идущие следом наведённые ошибки исчезли. Корректные длительности разбираются как раньше. |
| 5.19.579 | Внутренняя | Команда topaz check --compiler self снова возвращает настоящую диагностику парсера от установленного самоприменимого компилятора. Раньше отклонённая программа выдавала внутреннюю ошибку несовпадения вместо настоящих сообщений TPZ2001. |
| 5.19.578 | Внутренняя | Обновление записи теперь требует запятую или закрывающую фигурную скобку после ведущего раскрытия, а любое второе или последующее раскрытие отклоняется одним точным сообщением с восстановлением на парной скобке. Обычные литералы записей не изменились. |
| 5.19.577 | Внутренняя | Пояснения к диагностике теперь проходят весь самоприменимый маршрут, поэтому подсказка о том, что явные типовые аргументы стоит убрать, доходит до редактора и до diagnostics.jsonl, а не теряется сразу после самого сообщения. |
| 5.19.576 | Внутренняя | В Топазе скобки группируют ровно одно выражение, и запятая внутри них теперь даёт в самоприменимом компиляторе одно сообщение на самой запятой с восстановлением до парной скобки, а не вторую ошибку. |
| 5.19.575 | Внутренняя | Выражение вида f<x+y>() в самоприменимом компиляторе снова читается как сравнение, а не как обобщённый вызов, поэтому оно доходит до проверки и даёт ту же ошибку сравнения TPZ5007, что и компилятор на Rust. |
| 5.19.574 | Внутренняя | Явные типовые аргументы распознаются только после идентификатора, обращения к члену или необязательного доступа, поэтому (identity)<int>(1) больше не считается обобщённым вызовом в самоприменимом компиляторе и даёт тот же TPZ5002. |
| 5.19.573 | Внутренняя | Вызов JSON.parseAs или JSON.decode с неверным числом явных типовых аргументов теперь даёт только сообщение о количестве TPZ5510 без последующего несовпадения типов. Корректные вызовы не изменились. |
| 5.19.572 | Внутренняя | Явные типовые аргументы применяются только когда их число в точности совпадает с ожидаемым, поэтому вызов с неверным числом даёт лишь сообщение о количестве, а обычный вывод типов продолжается без лишних несовпадений. |
| 5.19.571 | Внутренняя | Тип, указанный у привязки внутри тела обобщённой функции, теперь связывается с типовым параметром этой функции, а явные типовые аргументы принимаются у стандартных обобщённых конструкторов и методов получателя, таких как Some, Ok, map и reduce. Вызовы через необязательный доступ их отклоняют. |
| 5.19.570 | Внутренняя | Типизированные шаблоны теперь выполняются на целевом бэкенде с тем смыслом, который задаёт проверка, охватывая примитивы, литералы, объединения, структурные записи, Option, Result, Array, Set, Map, диапазоны, арность вызываемых значений и обобщённые записи, перечисления и newtype. |
| 5.19.569 | Внутренняя | Собственная автоматизация сборки проекта переведена на текущие мажорные версии публичных действий GitHub и на явно заданный рантайм Node 24. Код продукта, опубликованные выпуски и артефакты не изменились. |
| 5.19.568 | Внутренняя | Целевой бэкенд теперь сопоставляет списковые шаблоны с остаточным сегментом, структурные и именованные шаблоны записей и конструкторы newtype, а также требует точного совпадения типа записи и перечисления. Имена, связанные именованным шаблоном записи, тоже считаются инициализированными. |
| 5.19.567 | Внутренняя | Управление циклами теперь работает на целевом бэкенде. Оператор for принимает break и continue, loop возвращает значение, переданное через break, помеченное управление проходит сквозь for, дающий значение, а каждая итерация while, for и loop получает свою область видимости. |
| 5.19.566 | Внутренняя | using File теперь выполняется на целевом бэкенде. Дескриптор закрывается автоматически, когда блок завершается нормально либо через возврат, распространение ?, break или continue, а достигнутые defer выполняются в обратном порядке перед этим закрытием. |
| 5.19.565 | Внутренняя | concurrent теперь планирует свои ветви на целевом бэкенде. Ветви чередуются, а не выполняются по одной до конца, истёкшее предложение timeout бросает незавершённые ветви и вычисляет else, а ошибка внутри ветви проявляется даже за более ранней бесконечной ветвью. |
| 5.19.564 | Внутренняя | Целевой бэкенд теперь вычисляет null, целочисленные диапазоны, литералы множеств и включения для массивов, множеств и отображений, разворачивает раскрытие массива в порядке исходного кода и возвращает значения тела for, дающего значение, в порядке итерации. |
| 5.19.563 | Внутренняя | Функции и лямбды теперь передаются как значения на целевом бэкенде вместе с захваченной областью видимости. Поля записи, названные как встроенные методы, вызываются раньше этих методов, работают колбэки высшего порядка у Array, Option, Result и Map, а print как значение доходит до хоста. |
| 5.19.562 | Внутренняя | Вызовы теперь вычисляются в порядке записи на целевом бэкенде. Вызываемое значение или получатель вычисляется один раз до аргументов, конвейер сначала вычисляет ведущее значение, необязательный вызов на None или null возвращается до аргументов, а раскрытие разворачивается на своём месте. |
| 5.19.561 | Внутренняя | Пользовательские вызовы на целевом бэкенде теперь связывают аргументы так, как они записаны. Именованные аргументы попадают в объявленные позиции, опущенные параметры берут значения по умолчанию, а явное раскрытие вместе с идущими за ним позиционными значениями образует вариативный массив. |
| 5.19.560 | Внутренняя | Методы, написанные в блоке impl для собственной записи, перечисления или newtype, теперь проверяются самоприменимым компилятором и вызываются на целевом бэкенде. Ручная реализация протокола имеет приоритет над производными Show, Eq и Order. |
| 5.19.559 | Внутренняя | Самоприменимый компилятор теперь проверяет ручные объявления impl Protocol<Type>, регистрируя только полную и точную реализацию и сохраняя прежнюю диагностику для неверной цели, повтора, пропущенного метода или несовпадающей сигнатуры. |
| 5.19.558 | Внутренняя | Статические вызовы протокола вида P.m(...) теперь проверяются самоприменимым компилятором. Соответствующий получатель получает конкретные типы параметров и результата, несоответствующий даёт TPZ5522, а именованные аргументы и раскрытие по-прежнему отклоняются. |
| 5.19.557 | Внутренняя | Объявления пользовательских протоколов теперь проверяются самоприменимым компилятором, который отклоняет имя встроенного протокола, конфликт и повтор имени, обобщённый метод, неверный получатель, отсутствующий тип результата, вариативность, значение по умолчанию и вложенное объявление. |
| 5.19.556 | Внутренняя | Корректное объявление протокола больше не помечает самоприменимую сборку как содержащую неподдерживаемый синтаксис. Сигнатуры протокола существуют на этапе компиляции и не порождают операций выполнения, а действительно неподдерживаемый синтаксис вне протокола по-прежнему отмечается. |
| 5.19.555 | Внутренняя | Значение по умолчанию у параметра метода протокола теперь отмечается правилом протокола и кодом TPZ5022 в самоприменимом компиляторе, а не посторонней ошибкой о несвязанном имени из самого выражения по умолчанию. |
| 5.19.554 | Внутренняя | FS.list больше не превращает элемент каталога с именем, не являющимся корректным Unicode, в строку с символами замены, способную совпасть с другим элементом. Такой каталог возвращает ошибку по обычному каналу Result. |
| 5.19.553 | Внутренняя | FS.readText и FS.open теперь находят файлы в корне пакета, чьё настоящее имя каталога не является корректным Unicode и доступ к которому идёт через символьную ссылку с именем в Unicode. Проверки прав, границ и отказ при выходе по ссылке не изменились. |
| 5.19.552 | Внутренняя | Команда topaz build --target python больше не удаляет пользовательский файл с именем, не являющимся корректным Unicode, при очистке кэшей от прежних версий. Удаляются только записи с точным именем сгенерированного кэша в Unicode. |
| 5.19.551 | Внутренняя | Сервер разработки теперь следит за входными файлами со временем изменения раньше 1970 года и за файлами в каталоге с именем, не являющимся корректным Unicode, поэтому атомарная замена с тем же временем всё равно вызывает пересборку. |
| 5.19.550 | Внутренняя | Веб-сервер разработки больше не отвечает 404, когда пакет открыт через символьную ссылку с именем в Unicode на каталог, настоящее имя которого не является корректным Unicode. Сборка и сервер используют один и тот же каталог вывода. |
| 5.19.549 | Внутренняя | Каталог хранилища сборки, заданный через TOPAZ_STORAGE_DIR, с именем, не являющимся корректным Unicode, теперь отклоняется сразу с сообщением о том, что путь невозможно представить в Unicode, а не разводит сборку по подменному пути. |
| 5.19.548 | Внутренняя | Наборы, которые читает topaz compiler validate, теперь требуют, чтобы каждый путь участника был точным Unicode, поэтому два разных файла больше не сливаются в одно имя при приёме и проверке. Непредставимый путь сообщается как ошибка. |
| 5.19.547 | Внутренняя | Пакет с файлом исходника, имя которого не является корректным Unicode, теперь отклоняется до вычисления хеша и до копирования, поэтому topaz vendor больше не перезаписывает уже скопированный пакет и лишь потом падает. Обычные исходники пакета не изменились. |
| 5.19.546 | Внутренняя | Ресурсы и стили, объявленные в web.styles и web.assets, теперь требуют точных путей в Unicode, поэтому объявленный ресурс больше не пропадает молча и не выкладывается по пути, который не указывает на его источник. |
| 5.19.545 | Внутренняя | Команда topaz test теперь разрешает выбранный тестовый файл, который является символьной ссылкой с именем в Unicode на каталог с некорректным именем, и подписывает результат тем путём, который был указан. Пути вне пакета и без .tpz по-прежнему отклоняются. |
| 5.19.544 | Внутренняя | Несохранённые буферы редактора теперь остаются привязанными к своему модулю, даже когда рабочая область открыта через символьные ссылки в каталог, настоящее имя которого не является корректным Unicode. Импортируемые модули снова читают открытый документ, а не файл на диске. |
| 5.19.543 | Внутренняя | В Linux компилятор различает модули из разных каталогов, чьи имена содержат байты, не являющиеся корректным UTF-8, даже если доступ к ним идёт через символические ссылки. Такие модули больше не принимаются за один файл и не отклоняются как конфликт. |
| 5.19.542 | Внутренняя | Импорт модуля в Linux разрешается и тогда, когда в его каталоге лежит посторонний файл с именем, не являющимся корректным UTF-8. Перечисление каталога пропускает только записи, непредставимые в Unicode, и не считает весь каталог нечитаемым. |
| 5.19.541 | Внутренняя | Импорт одного и того же файла дважды через ссылки или псевдонимы теперь сообщается как конфликт модулей TPZ3004, а не загружается как два разных модуля. Импорт действительно разных файлов, проверка корня и прочая диагностика не затронуты. |
| 5.19.540 | Внутренняя | Проверка имён больше не обходит дерево типов лишний раз перед записью ссылок. Диагностика, сведения об областях видимости и вывод компилятора те же, уменьшилась лишь избыточная работа. |
| 5.19.539 | Внутренняя | Из слоя доступа к файлам убрано неиспользуемое требование проверки существования файла вместе с десятью его реализациями. Чтение файлов, перечисление каталогов, поиск в пакетах, наложения редактора и диагностика работают как прежде. |
| 5.19.538 | Внутренняя | 22 стандартных модуля описаны теперь в едином каталоге, поэтому разрешение модулей и автодополнение в редакторе не могут разойтись в перечне существующих модулей. Подписи автодополнения, пути и исходники модулей не изменились. |
| 5.19.537 | Внутренняя | Входной файл с повторяющимся расширением исходника, например a.tpz.tpz, даёт теперь одно и то же имя модуля в обоих компиляторах. Отбрасывается только последнее расширение, поэтому цепочка импортов в диагностике совпадает с вашим файлом. |
| 5.19.536 | Внутренняя | Проверка инициализаторов читает имена прямо из текста исходника и создаёт копию только тогда, когда имя нужно сохранить или сообщается о реальном нарушении. Формулировка TPZ3018, позиции и остальные результаты не изменились. |
| 5.19.535 | Внутренняя | Объявления let и const верхнего уровня записывают сведения об области видимости тем же явным путём, что и все прочие объявления, а не полагаются на молчаливый пропуск. Затенение, нумерация областей и диагностика не изменились. |
| 5.19.534 | Внутренняя | Три места в разрешении модулей, где вместо заведомо успешного поиска молча подставлялось запасное значение, обращаются к таблицам напрямую. Внутреннее несоответствие проявляется, а не превращается в неверный порядок зависимостей или потерянный экспорт. |
| 5.19.533 | Внутренняя | Обход графа импортов, порядок зависимостей и сообщения о циклах в самоприменимом компиляторе читают массивы напрямую, без подстановки заведомо ненужного значения. Форма графа, тексты о циклах и порядок не изменились. |
| 5.19.532 | Внутренняя | Из разбора импортов убраны два неиспользуемых поля, а диагностика выбранного имени читает точные позиции напрямую, без недостижимого отката на весь путь импорта. Привязка псевдонимов, подсказки и сообщения не изменились. |
| 5.19.531 | Внутренняя | Работа с локальными областями видимости в самоприменимом компиляторе напрямую читает и обновляет активную область, а не пропускает молча невозможный промах. Лексический поиск, затенение, нумерация областей и диагностика не изменились. |
| 5.19.530 | Внутренняя | Обращения к таблицам модулей в самоприменимом компиляторе идут к каталогу напрямую, а внутренняя ошибка об отсутствующей таблице модуля, которая не могла возникнуть, убрана. Разрешение импортов, пространства имён и диагностика не изменились. |
| 5.19.529 | Внутренняя | Двенадцать обращений к таблицам модулей самоприменимого компилятора индексируют привязки напрямую, а не подставляют неверный ответ вроде неразрешённой ссылки или пропущенной диагностики. Разрешение импортов, пространства имён и диагностика не изменились. |
| 5.19.528 | Внутренняя | Два цикла сортировки в самоприменимом компиляторе читают массивы напрямую, поэтому внутренняя ошибка границ проявляется как сбой, а не как молча переставленный результат. Порядок запросов, порядок экспортов и подсказки не изменились. |
| 5.19.527 | Внутренняя | Сортировка диагностик, выбор дочерних узлов и разрешение членов при проверке профиля читают массивы напрямую, поэтому повреждённый внутренний индекс даёт сбой, а не потерянный узел или неразрешённое имя. Политики профилей и диагностика не изменились. |
| 5.19.526 | Внутренняя | Нормализация Unicode и приведение регистра в самоприменимом компиляторе собирают результат один раз, а не перестраивают всю строку на каждом символе, поэтому длинные имена обрабатываются заметно быстрее. Итоговый текст и сообщения о конфликтах прежние. |
| 5.19.525 | Внутренняя | Подсказки об опечатках в самоприменимом компиляторе отсеивают слишком длинное имя по длине в байтах ещё до разбиения на символы, поэтому огромный идентификатор не разворачивается целиком впустую. Сами подсказки и их формулировки не изменились. |
| 5.19.524 | Внутренняя | Расчёт редакционного расстояния для подсказок об опечатках в самоприменимом компиляторе индексирует массивы напрямую, а не подставляет пустой символ или выдуманное расстояние при выходе за границы. Подсказки, разрешение ничьих и формулировки прежние. |
| 5.19.523 | Внутренняя | Подсказки об опечатках в компиляторе на Rust собирают не более 65 символов имени и строят сравниваемую цель один раз на запрос, а не заново для каждого кандидата. Идентификатор длиной в несколько килобайт больше не просматривается целиком. |
| 5.19.522 | Внутренняя | Подсказки об опечатках в самоприменимом компиляторе переиспользуют уже построенные массивы символов, а не создают их заново для расчёта расстояния. Каждый кандидат разворачивается один раз, сами подсказки не изменились. |
| 5.19.521 | Внутренняя | При ранжировании подсказок об опечатках самоприменимый компилятор вычисляет расстояние каждого кандидата один раз, а не пересчитывает его при каждом улучшении варианта. Ранжирование, разрешение ничьих и формулировки не изменились. |
| 5.19.520 | Внутренняя | Ранжирование опечаток в самоприменимом компиляторе переиспользует три буфера строк на всё сравнение, а не выделяет новый массив на каждый символ. Расход памяти остаётся пропорционален имени кандидата, все подсказки не изменились. |
| 5.19.519 | Внутренняя | Компилятор на Rust хранит три строки вместо построения полной матрицы расстояний для каждого кандидата на опечатку. Расход памяти падает с произведения длин обоих имён до длины кандидата, все подсказки не изменились. |
| 5.19.518 | Внутренняя | Когда два имени одинаково близки к опечатке, оба компилятора предлагают лексикографически меньшее. Одна и та же опечатка получает одну и ту же подсказку при каждом запуске и не зависит от внутреннего порядка контейнеров. |
| 5.19.517 | Внутренняя | При опечатке в прямом вызове подсказки берутся только из имён, которые действительно можно вызвать. Самоприменимый компилятор больше не предлагает невызываемое локальное значение или встроенную функцию, скрытую видимой одноимённой локальной. |
| 5.19.516 | Внутренняя | Подсказки для неизвестного имени в самоприменимом компиляторе просматривают только объявления того модуля, где имя использовано, а не все объявления программы. Порядок кандидатов, ранжирование и сообщения TPZ5002 не изменились. |
| 5.19.515 | Внутренняя | Самоприменимая проверка находит вызов по точной позиции, а не просматривает весь список записанных вызовов по нескольку раз на выражение. Порядок вызовов, работа с конструктором Map, типы результатов и диагностика не изменились. |
| 5.19.514 | Внутренняя | Ошибочный выход из цикла, добавленный в предыдущей версии, приводил к тому, что компилятор на Rust отклонял исходники самоприменимой проверки. После удаления сборка снова проходит, а диагностика правил Лиспекс сохраняет код, формулировку и место. |
| 5.19.513 | Внутренняя | Проверка косвенного использования правил Лиспекс больше не просматривает все вызовы программы для каждой ссылки на правило. Код TPZ5500, формулировка и место не изменились, а большие программы с правилами проверяются быстрее. |
| 5.19.512 | Внутренняя | Анализ захватов в замыканиях в самоприменимом компиляторе вычисляет предков области объявления один раз, а не обходит цепочку областей заново для каждой ссылки. Захваченные имена, их порядок и всё последующее не изменились. |
| 5.19.511 | Внутренняя | Сбор захватов замыканий в компиляторе на Rust вычисляет предков области объявления один раз, а не обходит цепочку областей заново для каждой ссылки. Захваченные имена, позиции и вывод Stage 1 не изменились. |
| 5.19.510 | Внутренняя | Вывод захватов в компиляторе на Rust группирует их по модулям за один проход, а не пересматривает весь список захватов для каждого модуля. Порядок захватов, позиции и вывод Stage 1 не изменились. |
| 5.19.509 | Внутренняя | Компилятор на Rust больше не копирует имя цели вызова только ради сверки с тремя рантайм-префиксами и сохраняет копию лишь для вызовов, у которых действительно есть рантайм-запись. Планы вызовов и вывод Stage 1 не изменились. |
| 5.19.508 | Внутренняя | Оба пути построения Stage 1 в компиляторе на Rust используют общую сортировку операций, которая индексирует порядок модулей один раз, а не просматривает список модулей с обеих сторон каждого сравнения. Порядок операций и вывод Stage 1 прежние. |
| 5.19.507 | Внутренняя | При сравнении захватов самоприменимый компилятор читает идентификатор модуля через уже имеющийся прямой доступ, а не просматривает список модулей с обеих сторон. Написание идентификаторов, порядок захватов и вывод Stage 1 не изменились. |
| 5.19.506 | Внутренняя | Сортировка захватов в компиляторе на Rust больше не копирует модуль и имя во временный ключ, а сравнивает существующие значения в том же порядке. Порядок захватов, устранение дублей и вывод Stage 1 не изменились. |
| 5.19.505 | Внутренняя | Захваты членов пространства имён в самоприменимом компиляторе находят псевдоним по индексу, построенному один раз, а не просматривают все разрешённые объявления для каждой ссылки. Типы захватов, порядок и вывод Stage 1 не изменились. |
| 5.19.504 | Внутренняя | Компилятор на Rust ищет псевдоним пространства имён для захвата члена по индексу, построенному на проходе объявлений, а не просматривает все разрешённые объявления. Поведение псевдонимов, порядок захватов и вывод Stage 1 не изменились. |
| 5.19.503 | Внутренняя | Поиск цели захвата в самоприменимом компиляторе переиспользует уже имеющийся индекс позиций типизированных узлов, а не просматривает все узлы дважды на каждую ссылку. Выбранная цель, порядок захватов и вывод Stage 1 не изменились. |
| 5.19.502 | Внутренняя | Модуль захвата в компиляторе на Rust определяется по одному индексу, а имя копируется только в итоговый захват, а не для каждого объемлющего замыкания. Содержимое захватов и вывод Stage 1 не изменились. |
| 5.19.501 | Внутренняя | Определение цели захвата в компиляторе на Rust использует индексы позиций, построенные за один проход по типизированным узлам, а не просматривает их заново для каждой ссылки. Порядок поиска, цепочки захватов и вывод Stage 1 не изменились. |
| 5.19.500 | Внутренняя | Обогащение вызовов в компиляторе на Rust один раз группирует ссылки по файлам и ищет только в диапазоне, который может содержать вызываемое имя, а не фильтрует весь список ссылок для каждого вызова. Идентификатор цели и вывод Stage 1 прежние. |
| 5.19.499 | Внутренняя | Поиск ссылки на имя в компиляторе на Rust стал точным обращением по позиции вместо линейного просмотра всех ссылок для каждого идентификатора, члена и привязки. Разрешённые цели и вывод Stage 1 не изменились. |
| 5.19.498 | Внутренняя | Семантические типы больше не копируются дважды по пути к Stage 1 в компиляторе на Rust, который использует значения самой проверки и делает одну копию в конце. Написание типов, операции и вывод Stage 1 не изменились. |
| 5.19.497 | Внутренняя | При построении Stage 1 компилятор на Rust больше не копирует каждый вызов во вторую таблицу, а одно обращение на выражение обслуживает и план вызова, и подстановку рантайма. Вызовы, планы и вывод Stage 1 не изменились. |
| 5.19.496 | Внутренняя | Каждая операция функции и лямбды записывает свою позицию при создании, и родитель замыкания читается оттуда. Скопированная таблица идентификаторов и запасной просмотр всех операций убраны, родительские связи и вывод Stage 1 не изменились. |
| 5.19.495 | Внутренняя | Родители замыканий в самоприменимом компиляторе адресуются двумя числовыми координатами позиции, а не строкой, которая формировалась при каждом обращении. Разрешение родителя, вставка захватов и вывод Stage 1 не изменились. |
| 5.19.494 | Внутренняя | Отложенные операнды образцов let в самоприменимом компиляторе хранят только позиции и получают метки при выгрузке, а не копируют идентификаторы и метки заранее. Порядок операндов и вывод Stage 1 не изменились. |
| 5.19.493 | Внутренняя | Обычные операнды связываются прямо при принятии операции в самоприменимом компиляторе, а откладываются только образцы let, что убирает полный второй проход по всем операциям. Порядок операндов, метки и вывод Stage 1 не изменились. |
| 5.19.492 | Внутренняя | Метки операндов в самоприменимом компиляторе хранятся в одном месте и находятся через небольшой индекс позиций, а не дублируются для каждой операции. Непрочитанная внутренняя метка убрана, метки и вывод Stage 1 не изменились. |
| 5.19.491 | Внутренняя | Самоприменимый компилятор сначала проверяет, является ли родитель включением или for, и только затем берёт метку операнда, поэтому дочерние узлы этих форм не копируют метки, которые всё равно перестраиваются. Порядок операндов и вывод Stage 1 прежние. |
| 5.19.490 | Внутренняя | Семантический тип узла и его рантайм-представление выводятся в самоприменимом компиляторе за один шаг, а не пересчитываются при сборке каждой операции. Все соответствия типов и вывод Stage 1 не изменились. |
| 5.19.489 | Внутренняя | Рантайм-запись операции берётся из той же таблицы, которая уже определяет её вид и идентификатор в самоприменимом компиляторе, что убирает второй большой разбор по видам синтаксиса. Все рантайм-записи и вывод Stage 1 не изменились. |
| 5.19.488 | Внутренняя | Классификация потока управления в самоприменимом компиляторе определяет вид управления и владение целью в одном месте. Поведение ветвления, match, циклов, break, continue, return, очистки, распространения и concurrent не изменилось. |
| 5.19.487 | Внутренняя | Роли операций в самоприменимом компиляторе берутся из той же таблицы, что вид и идентификатор, а отдельными правилами остались только исключение протоколов и требование метода реализации. Роли, виды и вывод Stage 1 не изменились. |
| 5.19.486 | Внутренняя | Две почти одинаковые таблицы, сопоставлявшие синтаксический узел с видом операции и с суффиксом идентификатора, объединены в одну. Все виды операций, идентификаторы и вывод Stage 1 прежние, а дублирующегося кода в компиляторе стало намного меньше. |
| 5.19.485 | Внутренняя | Операнды для for и включений строятся один раз в собственном проходе самоприменимого компилятора, а не заполняются, затем очищаются и создаются заново. Порядок операндов, их сопоставление и вывод Stage 1 не изменились. |
| 5.19.484 | Внутренняя | Перестроение операндов включения больше не просматривает всё синтаксическое дерево модуля для каждого включения, а использует позиции дочерних узлов, записанные на первом проходе. Порядок частей, устранение дублей и вывод Stage 1 не изменились. |
| 5.19.483 | Внутренняя | Каждая метка операнда строится один раз из сохранённого префикса родителя и собственного сегмента, а не обходом цепочки предков заново для каждой операции. Написание меток, порядок операндов и вывод Stage 1 не изменились. |
| 5.19.482 | Внутренняя | Имя, изменяемость, способ хранения и идентификатор объявления привязки создаются в самоприменимом компиляторе вместе, а не отыскиваются заново при сборке операции. Образцы, параметры, привязки const и using не изменились. |
| 5.19.481 | Внутренняя | Самоприменимый компилятор помечает при принятии узла, находится ли он внутри protocol, поэтому каждый дочерний узел читает только флаг родителя, а не обходит цепочку предков. Работа с протоколами и вывод Stage 1 не изменились. |
| 5.19.480 | Внутренняя | Изменяемость привязки читается у её собственного родителя let, а не поиском вверх от каждой именованной привязки, и оба компилятора теперь сверяются и по этому полю. Изменяемый let, параметры и привязки в match работают как прежде. |
| 5.19.479 | Внутренняя | Операнды добавляются за один проход самоприменимого компилятора, откладывается только каждый образец let, а не выполняется двойной обход всех операций. Порядок «значение перед образцом» для let и порядок остальных операндов не изменились. |
| 5.19.478 | Внутренняя | При принятии узлов записывается, какие включения и узлы for требуют особой пересборки операндов, поэтому последующий проход не просматривает всё синтаксическое дерево модуля заново. Порядок операндов и вывод Stage 1 не изменились. |
| 5.19.477 | Внутренняя | Вид и тип каждого типизированного узла проецируются один раз в единый каталог по позициям в самоприменимом компиляторе, а исходный массив узлов и два отдельных поиска убраны. Написание типов, представление и вывод Stage 1 не изменились. |
| 5.19.476 | Внутренняя | Каждая ссылка один раз приводится к итоговому идентификатору и хранится в едином каталоге по позициям, а не проходит одни и те же правила приоритета при каждом обращении. Откат к встроенному имени и вывод Stage 1 не изменились. |
| 5.19.475 | Внутренняя | При декодировании самоприменимый компилятор готовит каждый типизированный вызов один раз в виде плана, а не перечитывает исходный вызов для каждого узла. Форма при отсутствии вызова, порядок аргументов и вычислений, а также вывод Stage 1 не изменились. |
| 5.19.474 | Внутренняя | Захваты модулей теперь раскладываются один раз по спискам для каждого модуля, а не отбираются из общего массива при обработке каждого модуля. Порядок модулей и захватов, пропуск захватов вне диапазона модуля и вывод Stage 1 не изменились. |
| 5.19.473 | Внутренняя | Лямбды и объявления методов теперь связывают свои замыкания в момент принятия узла, поэтому повторный проход по всему синтаксическому дереву больше не нужен. Ключи замыканий, порядок и тождество захватов, ошибка отсутствия родителя и вывод Stage 1 не изменились. |
| 5.19.472 | Внутренняя | Пустые индексы и списки очистки теперь создаются прямо там, где они хранятся, а не через две вспомогательные функции. Ключи и порядок вставки, выбор первого прямого потомка, обработка defer и вывод Stage 1 не изменились. |
| 5.19.471 | Внутренняя | Клаузы включений теперь берут итератор, шаблон и условие из уже готового индекса потомков, а не пересматривают всё синтаксическое дерево для каждой клаузы. Исходный порядок клауз, поведение условия if и тела, а также вывод Stage 1 не изменились. |
| 5.19.470 | Внутренняя | Имена привязок функций верхнего уровня и тождество объявления теперь берутся из готового индекса потомков, а не из полного обхода синтаксического дерева при каждом обращении. Имена привязок, участки объявлений, приоритет тождества ссылок и вывод Stage 1 не изменились. |
| 5.19.469 | Внутренняя | Поиск написания идентификаторов, импортов и членов теперь режет один UTF-8 буфер, созданный для модуля, вместо перекодирования всего исходника при каждом обращении. Написания, пустая строка для неверного участка, правила профиля и результаты не изменились. |
| 5.19.468 | Внутренняя | Две записи профиля, которые никто не импортировал, стали приватными для модуля, а три пустых индексных Map создаются напрямую, а не через помощник, вставлявший и удалявший фиктивную запись. Правила профиля, сообщения и результаты не изменились. |
| 5.19.467 | Внутренняя | Находки профиля теперь принимаются за один проход, который проверяет дубликат по пути к месту вставки, вместо двух обходов результата. Правило дубликатов, канонический порядок находок, порядок слияния и результаты профиля не изменились. |
| 5.19.466 | Внутренняя | Каждый импорт теперь получает путь модуля из индекса потомков, который профиль уже строит, а не пересматривает синтаксическое дерево по виду и диапазону. Опознание запрещённых модулей и импортов тестового фреймворка, диагностика и результаты профиля не изменились. |
| 5.19.465 | Внутренняя | Порядок зависимостей модулей теперь получается одной сортировкой тождеств и выбором модуля по индексу вместо двух рукописных сортировок вставками и постоянного сдвига массива. Выбор готового модуля, порядок зависимостей, диагностика циклов и результат разрешения имён не изменились. |
| 5.19.464 | Внутренняя | Каждая локальная область теперь хранит карту имён для пространств значений и типов, поэтому идентификатор находится напрямую, а не перебором всех привязок от внутренней области наружу. Затенение, приоритет первой привязки, диагностика и результат разрешения имён не изменились. |
| 5.19.463 | Внутренняя | Шесть рабочих записей модуля разрешения имён, которые никто не импортировал, стали приватными, и модуль экспортирует единственную точку входа. Приём и поверхность импорта, диагностика, факты имён, инициализация модулей и результат разрешения не изменились. |
| 5.19.462 | Внутренняя | Проверка типов в экспортируемой сигнатуре, ссылки в импортированных инициализаторах и проверка отсутствия экспорта теперь читают индекс привязок, а не перебирают их заново. Конфликтующая привязка и export let mut по-прежнему не считаются экспортом, диагностика и поведение во время выполнения не изменились. |
| 5.19.461 | Внутренняя | Конфликты привязок теперь находятся через уже готовый индекс имён, который также даёт участок первой привязки для TPZ3008. Порядок приёма, сообщения о конфликтах, их участки и порядок, поведение во время выполнения не изменились. |
| 5.19.460 | Внутренняя | Принятые привязки теперь попадают в общий индекс имён и, если экспортированы, в индекс экспортированных имён, поэтому ссылки на модуль, локальные, выбранные и по пространству имён больше не перебирают упорядоченный список. Правила выбора, подсказки, диагностика и поведение во время выполнения не изменились. |
| 5.19.459 | Внутренняя | Таблицы модулей теперь имеют индекс тождеств рядом с упорядоченным списком, поэтому вычисление пространства имён, выбранные импорты и импорты по пространству имён и проверка поверхности импорта берут таблицу напрямую. Порядок таблиц, индексы модулей, порядок привязок, диагностика и поведение не изменились. |
| 5.19.458 | Внутренняя | Обнаружение модулей теперь проверяет принадлежность множеству тождеств загруженных модулей, а принятый и отклонённый результаты используют один общий проход по публичным рёбрам импорта вместо повторных линейных обходов. Исключение неразрешённых рёбер, дубликаты рёбер, порядок обнаружения и диагностика циклов не изменились. |
| 5.19.457 | Внутренняя | Пометка модулей, входящих в цикл, теперь использует по одному множеству прямой и обратной достижимости на якорный модуль вместо нового поиска для каждого кандидата. Канонические пути циклов, основной участок, обработка самоимпорта, текст и порядок диагностики и порядок зависимостей не изменились. |
| 5.19.456 | Внутренняя | Диагностика циклов и построение порядка зависимостей теперь используют один граф модулей с отсортированными тождествами и множествами зависимостей, а не собирают его дважды и не копируют массивы путей на каждой ветке. Канонические пути циклов, участки, порядок зависимостей и запасной порядок при цикле не изменились. |
| 5.19.455 | Внутренняя | Построение порядка зависимостей теперь проверяет кандидатов через множества разрешённых и готовых модулей и карту зависимостей, а не перебирает весь список рёбер в каждом раунде. Дубликаты рёбер по-прежнему не влияют, неразрешённые цели исключаются, порядок и диагностика не изменились. |
| 5.19.454 | Внутренняя | Разрешение имён в Stage 0 теперь не копирует тождества модулей и рёбер в несколько собственных структур, а заимствует их при поиске циклов и упорядочивании, а при сортировке ищет модуль по рангу. Порядок зависимостей, диагностика циклов и участки, поведение во время выполнения не изменились. |
| 5.19.453 | Внутренняя | Цепочка импортов в ошибке инициализации модуля теперь строится одним общим механизмом для Stage 0 и для сгенерированного Rust, а корпус модулей Python пополнился случаем инициализации. Код ошибки, сообщение, участок, вывод и файлы совпадают у интерпретатора и обоих генерируемых бэкендов. |
| 5.19.452 | Внутренняя | Локальные области теперь заимствуют имена объявлений прямо из исходника модуля, а собственную копию хранит только долгоживущий факт объявления. Порядок областей, затенение, факты объявлений, диагностика, цели ссылок и поведение во время выполнения не изменились. |
| 5.19.451 | Внутренняя | Временная таблица модулей теперь заимствует тождества модулей из результата разрешения имён, а не копирует каждое. Тождество файла, привязки, экспорт, диагностика, цели ссылок и поведение во время выполнения не изменились. |
| 5.19.450 | Внутренняя | Таблица модулей теперь хранит целевой файл рядом с привязками и экспортом, поэтому разрешению имён больше не нужен второй индекс, чтобы найти файл для ссылок по пространству имён и квалифицированных типов. Диагностика, цели ссылок, проверка и поведение во время выполнения не изменились. |
| 5.19.449 | Внутренняя | Если импортированный модуль читает более позднюю привязку в сразу вычисляемом инициализаторе, самоприменимый компилятор теперь выдаёт TPZ3018 так же, как Stage 0. Входной модуль и const верхнего уровня освобождены, а отложенные позиции вроде тел функций, лямбд, defer и concurrent не сообщаются. |
| 5.19.448 | Внутренняя | Приватный для модуля тип в экспортируемой публичной поверхности теперь отклоняется самоприменимым компилятором с TPZ3014. Это касается параметров и возвращаемых значений экспортируемых функций, тел вложенных псевдонимов типов, полезной нагрузки перечислений, полей записей и основы newtype, а экспортированный тип остаётся допустимым. |
| 5.19.447 | Внутренняя | Диагностика импорта в самоприменимом компиляторе теперь дословно совпадает со Stage 0. Сообщение о модуле без экспорта стало таким же, а для отсутствующего выбранного импорта, значения по пространству имён и квалифицированного типа снова предлагается ближайшее экспортированное имя. |
| 5.19.446 | Внутренняя | Значение по умолчанию для поля записи снова может читать неизменяемый приватный для пространства имён let из другого модуля, который самоприменимый компилятор раньше отклонял с TPZ3009. Вне значения по умолчанию и для изменяемой привязки такая ссылка по-прежнему отклоняется. |
| 5.19.445 | Внутренняя | Объявление protocol больше не попадает в привязки и таблицу экспорта самоприменимого компилятора, поэтому локальный protocol и следующий за ним let с тем же именем принимаются. export protocol отклоняется с TPZ2001 и TPZ3007, как это уже делал Stage 0. |
| 5.19.444 | Внутренняя | Повтор имени внутри одной альтернативы or-шаблона теперь считается конфликтом и в самоприменимом компиляторе. Для let [x, x] | [x, x] = [1, 2] выдаётся TPZ3008 на каждом повторе со ссылкой на первую привязку, ровно как в Stage 0. |
| 5.19.443 | Внутренняя | Если модуль импортирует сам себя и при этом входит в более длинный цикл, самоприменимый компилятор теперь сообщает о цикле из нескольких модулей, а не о самоимпорте. Модуль, который импортирует только себя, по-прежнему получает именно это сообщение. |
| 5.19.442 | Внутренняя | Диагностика цикла импортов теперь указывает на первое ребро того цикла, о котором сообщает, а не на произвольное ребро той же группы. Модуль, импортирующий сам себя, по-прежнему указывает на свой импорт. |
| 5.19.441 | Внутренняя | Импорт соседнего модуля, не объявленного в манифесте как extern, теперь даёт TPZ5030 в самоприменимом компиляторе, а не ошибку отсутствия файла. Неверные колонки повтора отклоняются с TPZ5032, сообщение о зарезервированном topaz.* содержит границу версии, а одна группа цикла даёт одну диагностику. |
| 5.19.440 | Внутренняя | Самоприменимый компилятор теперь сравнивает имена файлов модулей с полным свёртыванием регистра Unicode и каноническим разложением. Соседство straße.tpz и strasse.tpz, а также составленной и разложенной формы имени даёт TPZ3004 с обоими именами-кандидатами. |
| 5.19.439 | Внутренняя | Приватный protocol верхнего уровня в импортированном модуле теперь принимается обоими компиляторами, а не считается свободным оператором. Точка входа вне корня проекта останавливает работу сразу, а импорт сначала проверяется на вложенность, затем посегментно, и исходник читается только после успеха всех сегментов. |
| 5.19.438 | Внутренняя | Проверка путей в самоприменимом компиляторе теперь сравнивает сегменты пути целиком, поэтому файл вида main..tpz принимается, а root/../main.tpz отклоняется с TPZ3002 ещё до чтения файла. |
| 5.19.437 | Внутренняя | Оба парсера теперь резервируют фигурную скобку конструкции только на внешнем уровне выражения, поэтому if ready {} сохраняет пустое тело, обновление записи в скобках снова разбирается, а стрелка ветви match сохраняется перед телом лямбды. make() {} отклоняется с TPZ2001. |
| 5.19.436 | Внутренняя | Профиль agent-pack теперь определяет свободный assert по разрешённому тождеству, поэтому пользовательский assert принимается, а встроенный по-прежнему отклоняется. Запуск с --compiler self --profile agent-pack снова доходит до проверки исходников, а встроенная запись запуска Лиспекс проверяется в текущей версии. |
| 5.19.435 | Внутренняя | Мутаторы, колбэки Array и Map, методы Option, Result и File теперь становятся первоклассными значениями получателя и в сгенерированном Rust, догоняя проверяющий и интерпретатор. Единый список зарезервированных имён членов закрывает конфликты вроде sortBy, update, set и named. |
| 5.19.434 | Внутренняя | Именованные конвейеры ByteBuffer.set, fill и copy и первоклассные значения okOr в обычной, опциональной и конвейерной форме теперь принимаются сгенерированным Rust, как их уже выполнял интерпретатор. okOrElse с колбэком остаётся только вызовом, порядок вычислений и ошибки не изменились. |
| 5.19.433 | Внутренняя | Вызовы встроенных методов получателя в прямой, опциональной и конвейерной форме теперь принимают именованные аргументы и в сгенерированном Rust, где также распознаются ByteBuffer.set, fill и copy. Поиск члена, диспетчеризация и генерация кода читают один общий каталог получателей, формы вызова и ошибки не изменились. |
| 5.19.432 | Внутренняя | Именованный аргумент s для file.write теперь работает в сгенерированном Rust в прямой, конвейерной, опциональной и опционально-конвейерной форме, как уже позволяли проверяющий и рантайм. На всех трёх публичных страницах сигнатура показана как file.write(s: string). |
| 5.19.431 | Внутренняя | Четыре пути сгенерированного Rust для ресурсных read, write и close теперь порождают встроенную ветку из одного общего места, а не из четырёх копий. Порядок вычислений, эффекты и ошибки хоста, короткое замыкание, участки и сгенерированные байты не изменились. |
| 5.19.430 | Внутренняя | Прямые sortBy и retain теперь используют общий разбор единственного аргумента-колбэка, а все четыре пути колбэков в сгенерированном Rust делят одну проекцию затенения полем записи. Приём аргументов, порядок ошибки изменяемого корня, эффекты колбэков, участки и сгенерированные байты не изменились. |
| 5.19.429 | Внутренняя | Прямые map, filter, sortedBy, mapValues и flatMap в сгенерированном Rust теперь используют тот же разбор аргумента-колбэка и генератор тела колбэка, что и опциональные пути. Поведение коллекций, ленивость и ошибки колбэков, участки и сгенерированные байты не изменились. |
| 5.19.428 | Внутренняя | Вызовы получателя только для чтения теперь готовят позиционные и именованные аргументы через тот же общий механизм, что и остальные вызовы в сгенерированном Rust, а локальный цикл отрисовки убран. Обработка распаковки, отказ при нарушении порядка, метки, быстрый путь ByteBuffer.get, участки и сгенерированные байты не изменились. |
| 5.19.427 | Внутренняя | Прямой и опциональный okOrElse в сгенерированном Rust теперь готовят аргументы один раз, и этот результат делят вызов при затенении полем записи и встроенная ветка. Короткое замыкание, порядок ведущего элемента конвейера и аргументов, поведение заполнителя, ленивость колбэков, участки и байты не изменились. |
| 5.19.426 | Внутренняя | Codec.zstdCompress теперь проходит через общий связыватель фиксированных параметров сгенерированного Rust, который научился значениям по умолчанию, поэтому каждый аргумент готовится один раз вместо трёх копий. Позиционное и именованное поведение, значения по умолчанию, сообщения об отказе и байты не изменились. |
| 5.19.425 | Внутренняя | Вызовы значения, вызовы пользовательских методов получателя, вызовы при затенении полем записи и встроенный запасной путь в сгенерированном Rust теперь готовят аргументы за один проход в исходном порядке вместо трёх. Момент ошибки порядка, распаковка, метки, приоритеты, участки и байты не изменились. |
| 5.19.424 | Внутренняя | Вызовы получателя с распаковкой теперь готовят аргументы один раз в сгенерированном Rust, и этот результат делят ветка вызова значения и ветка ошибки арности, вместо двух обходов одного списка. Порядок вычислений, распаковка, ошибки, участки и байты не изменились. |
| 5.19.423 | Внутренняя | Путь ошибки распакованных аргументов для вызовов по пространству имён и вызовов получателя теперь описан в одном месте сгенерированного Rust, а каждая сторона передаёт только своё временное имя и сообщение. Обработка порядка, порядок вычислений, участки распаковки, ошибка арности и байты не изменились. |
| 5.19.422 | Внутренняя | Конвейерные вызовы получателя с распаковкой теперь готовят список аргументов один раз в сгенерированном Rust, и его делят ветка затенения полем записи и ветка ошибки арности. Обработка заполнителя, порядок вычислений, участки распаковки, проверки метода и байты не изменились. |
| 5.19.421 | Внутренняя | Быстрый позиционный путь опционального вызова Map.update теперь использует ту же проверку заполнителя, что и путь привязки в сгенерированном Rust, а второй локальный обход убран. Выбор пути, формы вызова, обновление и обратная запись колбэка, ошибки, участки и байты не изменились. |
| 5.19.420 | Внутренняя | Определение заполнителя и условие выбора пути для конвейерных вызовов теперь заданы один раз в сгенерированном Rust и используются связывателем и опциональными путями reduce и Map.update. Порядок привязки, быстрые пути, метки, ошибки, участки и байты не изменились. |
| 5.19.419 | Внутренняя | Статические аргументы конвейера теперь хранятся один раз в сгенерированном Rust, а слоты параметров и проекция затенения полем записи обращаются к ним по индексу, что убирает по одной копии каждого записанного или вставленного значения. Порождаемый текст и байты, привязка, метки и ошибки не изменились. |
| 5.19.418 | Внутренняя | Опциональные конвейерные пути reduce и Map.update теперь читают подготовленный текст аргументов на месте в сгенерированном Rust, а не копируют его. Порядок вычислений, привязка, метки, свёртка и проверки обновления, обратная запись колбэка, участки и байты не изменились. |
| 5.19.417 | Внутренняя | Вызовы reduce и Map.update с именованными аргументами теперь используют одну общую подготовку аргументов в сгенерированном Rust, сохраняя прежние сообщения об отказе для каждого метода. Эффекты в исходном порядке, переупорядоченная привязка, метки, порядок ошибок и поведение не изменились. |
| 5.19.416 | Внутренняя | Мутаторы Array с колбэком sortBy и retain теперь порождаются из одного места сгенерированного Rust и для прямого, и для опционального получателя. Порядок ошибок, диспетчеризация при затенении полем, ошибки колбэка до обратной записи, устойчивая сортировка, порядок оставленных элементов, участки и поведение не изменились. |
| 5.19.415 | Внутренняя | filter и mapValues для Map теперь порождаются одним общим механизмом сгенерированного Rust, а прямой и опциональный пути лишь указывают, какой из двух нужен. Во время выполнения filter по-прежнему работает и с другими перебираемыми значениями, а mapValues остаётся только для Map, поведение не изменилось. |
| 5.19.414 | Внутренняя | Or-шаблоны и структурные шаблоны теперь завершают ветку одним общим шагом сгенерированного Rust, который порождает тело и необязательный страж в расширенной области привязок. Видимость привязок, приоритет первого совпадения, переход к следующей ветке, ошибки стража и поведение не изменились. |
| 5.19.413 | Внутренняя | Ветки match с одной привязкой и без привязок теперь завершаются через одну общую границу сгенерированного Rust, принимающую необязательное статическое условие и страж. Видимость для стража, приоритет первого совпадения, переход дальше при ложном страже и поведение не изменились. |
| 5.19.412 | Внутренняя | Ветки match с шаблоном-джокером и с литералом или диапазоном теперь используют один путь завершения в сгенерированном Rust, где отсутствие статического условия означает неопровержимый джокер. Смысл сравнения, порядок стража, приоритет первого совпадения, переход дальше и поведение не изменились. |
| 5.19.411 | Внутренняя | Все шесть семейств структурных шаблонов теперь обрабатываются одним рекурсивным механизмом сгенерированного Rust и на верхнем уровне, и во вложении, поэтому четыре отдельных адаптера исчезли. Временные имена в порождаемом коде сдвигаются, но меняются именно идентификаторы, а не поведение языка. |
| 5.19.410 | Внутренняя | Общая подготовка и завершение вокруг шести семейств структурных шаблонов теперь управляются в одном месте сгенерированного Rust, а каждое семейство предоставляет только свой шаг разбора. Приём конструкторов, номинальное тождество, вложенные шаблоны, стражи, участки и поведение не изменились. |
| 5.19.409 | Внутренняя | Ветки со всеохватной привязкой и ветки с типизированной одиночной привязкой теперь используют общее расширение области, порядок тела перед стражем и завершение, которые раньше повторялись в сгенерированном Rust. Путь с голым вариантом перечисления остался отдельным, так как порождает одно тело в двух областях, поведение не изменилось. |
| 5.19.408 | Внутренняя | Условия литеральных и диапазонных шаблонов теперь имеют по одному владельцу в сгенерированном Rust, а ветки без привязок используют общее завершение. Отказ для интерполированных строк, отрицательные границы, включающие и исключающие диапазоны, ошибки сравнения, приоритет первого совпадения и поведение не изменились. |
| 5.19.407 | Внутренняя | Бэкенд Rust готовит альтернативные шаблоны с | и на верхнем уровне, и во вложенном виде по одному общему пути, поэтому допуск альтернатив, порядок имён привязок и сборка цепочки первого совпадения подчиняются одному правилу. Порядок и область привязок, охранные условия, диагностика и сгенерированный код не изменились. |
| 5.19.406 | Внутренняя | Повторяющееся имя привязки в альтернативном шаблоне верхнего уровня, например case [x, x] | [x, x], отклоняется с тем же сообщением, что и в остальных формах шаблонов, вместо выпуска некорректного кода Rust. Пять путей извлечения привязок в бэкенде Rust используют один отказ и одну форму кортежа. |
| 5.19.405 | Внутренняя | Операторный for, for как выражение и клаузы списковых включений используют один путь подготовки шаблона итерации в бэкенде Rust, поэтому допуск шаблонов, отказ при повторной привязке и ошибка несовпадения TPZ5003 ведут себя одинаково во всех трёх. Управление циклом и сгенерированный код не изменились. |
| 5.19.404 | Внутренняя | Списковые шаблоны компилируются в одно сопоставление среза Rust, что убирает арифметику индексов за привязками начала, остатка и конца, а вместе с ней и панику, до которой мог дойти сгенерированный код. Пустые, фиксированные, вложенные шаблоны, отказ при нескольких остатках и поведение ошибок не изменились. |
| 5.19.403 | Внутренняя | Бэкенд Rust осматривает значение в шаблоне enum один раз вместо двух и связывает каждую полезную нагрузку через проверенный доступ, убирая панику по индексу нагрузки в сгенерированном коде. Ошибка числа аргументов TPZ5004 при совпавшем теге сохраняет сообщение, место и порядок. |
| 5.19.402 | Внутренняя | Шаблоны newtype верхнего уровня и вложенные используют одно сопоставление в бэкенде Rust. Два места, где сгенерированный код доставал значение без проверки, исчезли, а идентичность объявления, допуск формы с одним аргументом, вложенные шаблоны, охранные условия и поведение ошибок не изменились. |
| 5.19.401 | Внутренняя | Бэкенд Rust ищет каждое поле шаблона записи один раз вместо двух, и одна проверенная привязка убирает панику, до которой сгенерированный код мог дойти при отсутствующем поле. Открытое сопоставление по-прежнему принимает лишние поля, а идентичность объявления проверяется первой. |
| 5.19.400 | Внутренняя | Раскрытие именованной записи проверяет объявленный состав полей сразу после вычисления раскрытия. Пропущенное или повторяющееся поле даёт TPZ5004, неизвестное даёт TPZ5006, и значения, переданные из внешней программы, больше не роняют интерпретатор и не расходятся со сгенерированным кодом Rust. |
| 5.19.399 | Внутренняя | Обработка тайм-аута в concurrent для бэкенда Rust держит проверенное значение в миллисекундах в одном месте, а не восстанавливает его позже, поэтому из компилятора ушёл непроверенный шаг. Синтаксис, поведение тайм-аута и else, диагностика и сгенерированный код не изменились. |
| 5.19.398 | Внутренняя | Тайм-аут concurrent переводится в миллисекунды и должен помещаться в беззнаковое 64-битное значение. Наибольшие принимаемые формы это 18446744073709551615ms, 18446744073709551s и 307445734561825m, а следующее значение отклоняется с TPZ5001 везде, от проверяющего модуля до обоих генераторов кода. |
| 5.19.397 | Внутренняя | Интерпретатор держит всё приостанавливаемое состояние выполнения в одном месте, поэтому ветвь concurrent и действие defer меняют весь контекст один раз на входе и один раз на выходе, а не ведут собственные списки полей. Поведение, планирование и диагностика не изменились. |
| 5.19.396 | Внутренняя | Действие defer, завершившееся ошибкой, больше ничего за собой не оставляет. Внешнее списковое включение сохраняет полный результат, приватное состояние модуля перестаёт читаться после ошибки в значении по умолчанию записи, а утёкший параметр типа не доходит до следующего defer. |
| 5.19.395 | Внутренняя | Соседние ветви concurrent больше не мешают друг другу. Списковые включения в параллельных ветвях выдают полные результаты, а ветвь не может прочитать неэкспортированное значение модуля через приостановленное значение по умолчанию записи, вместо этого возникает TPZ5001. |
| 5.19.394 | Внутренняя | Когда вопросительный знак выносит ошибку из значения по умолчанию импортированной записи, выданный ему приватный доступ отзывается при раскрутке конструктора. Более позднее чтение значения, которое модуль не экспортирует, даёт TPZ5001 вместо самого значения. |
| 5.19.393 | Внутренняя | Все пути выхода из функции в интерпретаторе проходят через один выход, будь то обычное завершение, явный return, вопросительный знак или ветвь case. Момент срабатывания defer, охрана типа возврата, её сообщение и место не изменились. |
| 5.19.392 | Внутренняя | Вызовы замыканий в интерпретаторе заканчивают проверку числа аргументов, раскрытия и именованных мест до того, как сдвинется живое состояние, и каждый отказ возвращается в окружение вызывающего через один выход. Приоритет ошибок, сообщения, места и межмодульное поведение не изменились. |
| 5.19.391 | Внутренняя | Именованные аргументы сопоставляются с параметрами по одному общему правилу в вызовах встроенных функций, замыканий и extern в обоих движках, поэтому повторяющееся или неизвестное имя аргумента отклоняется везде одинаково. Число аргументов, значения по умолчанию и охрана типов остаются за каждой формой вызова. |
| 5.19.390 | Внутренняя | Когда в сгенерированном коде Rust истекает срок concurrent, ожидающие ветви и их частичные результаты освобождаются до запуска блока else, как это уже делал интерпретатор. Всё, что удерживала ветвь, отпускается до начала эффектов else. |
| 5.19.389 | Внутренняя | Все четыре способа вызвать замыкание в сгенерированном коде Rust идут через один путь, поэтому обычный вызов, раскрытие, именованные аргументы и их сочетание разделяют ограничение рекурсии, правила числа аргументов, вычисление значений по умолчанию и ошибки имён аргументов. Поведение не изменилось. |
| 5.19.388 | Внутренняя | Именованные вызовы замыканий в сгенерированном коде Rust, с раскрытием и без него, используют один путь для ограничения рекурсии, числа аргументов, заполнения мест, значений по умолчанию и ошибок имён. Раскрытие по-прежнему требует переменного параметра и проверяет, что у каждого пропущенного места есть значение по умолчанию. |
| 5.19.387 | Внутренняя | Именованные аргументы встроенных функций связываются по одному общему списку параметров в обоих движках, а map, filter и reduce с получателем корректно не считают параметр, который получатель уже занял. При раскрытии с именами ошибки имён по-прежнему сообщаются до отказа для непеременного раскрытия. |
| 5.19.386 | Внутренняя | Композиция функций в сгенерированном коде Rust завершается по одному пути. Любая форма вызова передаётся левой функции без изменений, а правая всегда получает ровно одно промежуточное значение, при этом привязка аргументов, порядок вычисления и места ошибок не изменились. |
| 5.19.385 | Внутренняя | Option.okOrElse работает по одному общему определению в обоих движках. Some завершается как Ok без вызова обратного вызова, None вызывает его один раз без аргументов и оборачивает результат в Err, а любой другой получатель даёт обычную ошибку отсутствующего члена. |
| 5.19.384 | Внутренняя | Option.flatMap и Result.flatMap делят одно определение с map в обоих движках. Some и Ok вызывают обратный вызов один раз и возвращают его результат напрямую, None и Err проходят насквозь, а прочие получатели дают ошибку отсутствующего члена в любом из движков. |
| 5.19.383 | Внутренняя | Option.map и Result.map определены один раз для обоих движков. Some и Ok вызывают обратный вызов один раз и снова оборачивают результат, None и Err проходят насквозь без вызова, а любой другой получатель, как и прежде, уходит в отображение массива. |
| 5.19.382 | Внутренняя | Map.update работает по одному общему определению. Для отсутствующего ключа кладётся начальное значение без вызова функции, для присутствующего функция вызывается один раз и результат пишется на прежнее место, а порядок вставки, видимые через псевдонимы изменения и ошибки нехешируемого ключа не изменились. |
| 5.19.381 | Внутренняя | Map.filter и Map.mapValues используют одно определение в обоих движках. filter получает ключ и значение и сохраняет исходную пару при истине, mapValues получает значение и кладёт результат по тому же ключу, а порядок пар сохраняется. |
| 5.19.380 | Внутренняя | Метод массива retain работает по одному общему определению в обоих движках. Предикат вызывается по одному разу на элемент от начала к концу, оставленные элементы записываются обратно в получатель и видны через псевдонимы, а ошибка в предикате оставляет массив нетронутым. |
| 5.19.379 | Внутренняя | sortedBy и sortBy собирают ключи по одному общему определению. Все обратные вызовы для ключей проходят от начала к концу до сортировки, sortedBy возвращает новый массив, sortBy пишет обратно в получатель, равные ключи сохраняют порядок, а при ошибке получатель остаётся нетронутым. |
| 5.19.378 | Внутренняя | Интерпретатор выполняет map, filter и reduce одним и тем же механизмом, вызваны ли они как свободные функции или на получателе-массиве. Порядок вычисления получателя, члена и аргументов, поведение именованных аргументов и раскрытия, эффекты обратных вызовов, ошибки и результаты не изменились. |
| 5.19.377 | Внутренняя | Сгенерированный код Rust вызывает map, filter и reduce по одному общему пути вместо цикла, встроенного в каждое место вызова, охватывая свободные вызовы, получатели-массивы, а также именованную, конвейерную и опциональную формы. Порядок вычисления, эффекты, ошибки, места и результаты не изменились. |
| 5.19.376 | Внутренняя | Для map, filter и reduce, вызванных как обычные функции, есть одно определение проверки аргументов, порядка обхода и сборки результата, которое ведут и интерпретатор, и сгенерированный код Rust. Пустой вход, порядок и эффекты обратных вызовов, ошибки, места и накопитель не изменились. |
| 5.19.375 | Внутренняя | Тридцать встроенных функций, выходящих за пределы программы, включая print, input, open, операции FS, утверждения Test и операции Лиспекс, выполняются по одному общему определению в обоих движках. Эффекты, ошибки, места, именованные аргументы и раскрытие не изменились. |
| 5.19.374 | Внутренняя | Четыре функции преобразования toInt, toIntRadix, fromCodePoint и toFloat вошли в общее определение обоих движков, которое теперь покрывает все 73 чистые встроенные функции без получателя. Результаты преобразования, ошибки числа и типа аргументов, их места и перекрытие прелюдии не изменились. |
| 5.19.373 | Внутренняя | Ещё пятьдесят статических встроенных функций из Bytes, ByteBuffer, Encoding, Codec, Hash, Cli, Path, Regex, CSV, TOML, URL, Date, BigInt и Decimal выполняются по общему для обоих движков определению, доводя его до 69. Значения по умолчанию, результаты и ошибки не изменились. |
| 5.19.372 | Внутренняя | Девятнадцать статических встроенных функций, включая Array.of, Map.new, Map.ofEntries, Set.of, JSON.stringify, JSON.parse и члены Math, выполняются по одному общему определению, которое вызывают и интерпретатор, и сгенерированный код Rust. Результаты, ошибки и перекрытие пространства имён не изменились. |
| 5.19.371 | Внутренняя | Сгенерированный код Rust принимает Array.of, Map.new, Set.of, JSON.stringify, JSON.parse и тринадцать членов Math как значения первого класса, что интерпретатор уже позволял. Прямые вызовы и перекрытие локальными именами не изменились. |
| 5.19.370 | Внутренняя | Вызовы через пространство имён в бэкенде Rust держат по одной копии каждого отрисованного аргумента вместо двух. Именованные аргументы по-прежнему вычисляются в порядке исходника и передаются в порядке параметров, а ошибки числа, имени, повтора, пропуска, раскрытия и позиционного после именованного не изменились. |
| 5.19.369 | Внутренняя | Вызов export из сгенерированного кода Rust идёт по одному пути, синхронный он или асинхронный. Инициализация export, разрешение требуемого члена и диспетчеризация имеют одного владельца, а публичные интерфейсы, места ошибок поиска и сроки не изменились. |
| 5.19.368 | Внутренняя | Сгенерированный код Rust больше не создаёт аргументы программы и стандартный ввод только ради передачи в инициализацию, которая их не использовала. Вызовы export сохраняют публичные сигнатуры, а выбор точки входа, аргументы явного main, порядок инициализации и результаты не изменились. |
| 5.19.367 | Внутренняя | Бэкенд Rust больше не выбирает форму инициализации, ища в сгенерированном тексте ожидание. Каждая сгенерированная программа использует одну асинхронную инициализацию, а порядок инициализации, значения, ошибки, export и результаты не изменились. |
| 5.19.366 | Внутренняя | Регистрация методов и протоколов в сгенерированных программах хранит идентичность и имена методов как статический текст, не выделяя копию на каждую запись. Порядок регистрации, приоритет последней записи при повторе, поиск, откат и результаты не изменились. |
| 5.19.365 | Внутренняя | Диспетчеризация протоколов в сгенерированных программах больше не собирает имя для поиска на каждый вызов. Методы хранятся по модулю, протоколу, типу и имени метода, а поиск заимствует эти части, при этом порядок регистрации, встроенный откат и результаты не изменились. |
| 5.19.364 | Внутренняя | Регистрация нескольких методов одного типа в сгенерированной программе выделяет идентичность типа один раз, а не на каждый метод. Порядок регистрации, приоритет последней записи при повторе, очистка при старте, поиск и результаты не изменились. |
| 5.19.363 | Внутренняя | Диспетчеризация методов в сгенерированных программах ищет метод сначала по типу, затем по имени, не копируя ни одну из строк, что убирает два выделения памяти из каждого вызова метода получателя и протокола. Порядок регистрации, повторы, поведение при отсутствии метода и результаты не изменились. |
| 5.19.362 | Внутренняя | Бэкенд Rust перестал копировать целиком накопленный исходник фабрик замыканий перед финальным форматированием и отрисовывает его на месте. Порядок и содержимое фабрик замыканий, сгенерированный исходник и поведение захвата не изменились. |
| 5.19.361 | Внутренняя | Список имён export в сгенерированном коде Rust отрисовывается один раз как литерал массива, а не собирается из временной строки на каждое имя. Порядок объявления export, экранирование строк, возвращаемый список и поведение во время выполнения не изменились. |
| 5.19.360 | Внутренняя | Сборка перечня export в бэкенде Rust заимствует канонический набор рантайм-экспортов модуля вместо его пересоздания, а модули extern собирают свой перечень напрямую. Ошибки неэкспортированного имени и недоступного export, импорты только типов и сгенерированный код не изменились. |
| 5.19.359 | Внутренняя | При выпуске тела модуля бэкенд Rust переиспользует порядок export, уже вычисленный на раннем проходе, вместо повторного извлечения каждого имени. Объявления только типов по-прежнему стираются, а порядок export, сгенерированный код и поведение во время выполнения не изменились. |
| 5.19.358 | Внутренняя | Разрешение значения по умолчанию записи, ссылающегося на собственные рантайм-экспорты модуля, выполняется прямым поиском вместо перебора, а отсутствующий перечень экспортов сообщается как ошибка компилятора с местом, а не считается данностью. Порядок полей, устранение повторов и поведение не изменились. |
| 5.19.357 | Внутренняя | Бэкенд Rust находит каждую экспортируемую привязку прямым поиском, не перебирая привязки модуля на каждый export. Упорядоченный список export по-прежнему определяет порядок полей записи, а экспорты ячеек верхнего уровня сохраняют свои метки и поведение при ошибке. |
| 5.19.356 | Внутренняя | Выборочные импорты разрешаются через поиск во множествах и в точке входа, и в транзитивных модулях, вместо перебора трёх растущих списков, а оба пути теперь используют одно решение. Порядок объявлений в сгенерированных записях, ошибки импорта, импорты только типов и выпущенный код не изменились. |
| 5.19.355 | Внутренняя | Сборка области видимости модуля в бэкенде Rust перемещает привязки импортов и констант на место, а не копирует их. Порядок, при котором импорты идут перед константами, поведение при переобъявлении и поиске, выпущенный код и поведение во время выполнения не изменились. |
| 5.19.354 | Внутренняя | На всех хостах, где работает встроенный вычислитель Лиспекс, включая интерпретатор, сгенерированный код Rust и сгенерированный код Python, записанное поведение сходится. Диагностика E120 для define-syntax, приписанная фазе чтения, сообщается из фазы нормализации, где ей и место. |
| 5.19.353 | Внутренняя | Встроенный вычислитель Лиспекс переходит с 1.12.4 на 1.19.4. Программы могут склеивать begin и быть пустыми, диагностика использует стабильные публичные E-коды, явные эффекты вывода пишут в стандартный вывод, семантическая ошибка гостя завершает работу кодом 1, а два снятых профиля ресурсов отклоняются сразу. |
| 5.19.352 | Внутренняя | План переноса Лиспекс 1.19.4 в продукт записан и закреплён, включая то, какие файлы копируются, какие границы не трогаются и в каком порядке идёт работа. Встроенный вычислитель и поведение продукта остаются нетронутыми, пока следующий патч не выполнит его. |
| 5.19.351 | Внутренняя | Значения констант в бэкенде Rust хранятся в одном хранилище с ключами, поэтому поиск константы по имени или через пространство имён больше не обходит список. Константы точки входа и модулей, значения по умолчанию импортированных записей и скалярные значения по умолчанию функций делят его, а приоритет слияния прежний. |
| 5.19.350 | Внутренняя | Проверка того, что имя обозначает константу, в бэкенде Rust стала прямым поиском, а не перебором списка привязок. Константы точки входа, константы модулей и значения по умолчанию импортированных записей используют один и тот же индекс, а порядок выпуска и вычисления не изменился. |
| 5.19.349 | Внутренняя | Сбор собственных рантайм-ссылок модуля для значений по умолчанию записей лишился проверки на повтор имени, которая ничего не могла найти, поскольку правило единственной привязки уже гарантирует уникальность имени. Порядок исходника и идентичность ссылок не изменились. |
| 5.19.348 | Внутренняя | Первое появление собственной рантайм-ссылки внутри значения по умолчанию записи распознаётся через множество уже виденных имён, а не перебором растущего списка, и это множество переиспользуется при повторных объявлениях записи. Порядок первого появления и идентичность скрытых полей не изменились. |
| 5.19.347 | Внутренняя | Имена предыдущих неизменяемых привязок, на которые может ссылаться значение по умолчанию записи, хранятся во множестве, поэтому сборщик проверяет вхождение, а не ищет перебором. Имя становится видимым для последующих значений по умолчанию ровно как раньше, и его копия не создаётся. |
| 5.19.346 | Внутренняя | При сборе фактов выборочного импорта принятые константы и рантайм-ссылки проверяются по двум индексам имён, а не перебором результатов на каждый импорт. Приоритет первого принятого в порядке исходника, обработка псевдонимов и допуск экспорта не изменились. |
| 5.19.345 | Внутренняя | Факты импорта пространств имён собираются за один обход, где каждый целевой модуль ищется один раз, а квалифицированные значения констант и рантайм-ссылки получаются вместе. Сортировка имён экспорта и поведение при отсутствующем целевом модуле не изменились. |
| 5.19.344 | Внутренняя | Константы и рантайм-ссылки выборочного импорта собираются за один проход в порядке исходника, а приватные рантайм-ссылки, нужные значениям по умолчанию записей, берутся в том обходе, который уже проходит по записям. Отдельный обход модуля исчез. |
| 5.19.343 | Внутренняя | Всё, что нужно значениям по умолчанию модуля, от значений констант до тел значений по умолчанию записей, собирается за один прямой проход по верхнему уровню модуля. Шесть отдельных обходов всего исходника исчезли, а результат генерации не изменился. |
| 5.19.342 | Внутренняя | Решение о том, на какое имя может ссылаться значение по умолчанию записи, больше не требует перечитывания предшествующих и последующих операторов. Один прямой обход несёт оставшиеся счётчики и увиденные изменяемые имена, а решения о ссылке вперёд и на изменяемое имя не изменились. |
| 5.19.341 | Внутренняя | Подсчёт того, сколько раз имя связывается на верхнем уровне модуля, происходит внутри уже идущего прохода по объявлениям, а не отдельным обходом после него. Проекция типов и сбор значений по умолчанию записей получают готовые счётчики, и поведение не изменилось. |
| 5.19.340 | Внутренняя | Обработка объявлений модуля в бэкенде Rust передаёт этапу типов готовые продукты вместо сырых наборов псевдонимов, схем, именованных типов, методов и протоколов. Сгенерированный код и поведение во время выполнения не изменились. |
| 5.19.339 | Внутренняя | Сгенерированный бэкенд Rust завершает разрешение псевдонимов каждого модуля за один шаг. Вложенные псевдонимы внутри блоков обходятся, перекрытые записи удаляются, а совпавшие имена помечаются до сборки типовой информации модуля. |
| 5.19.338 | Внутренняя | Слияние скрытых рантайм-ссылок, пересекающих границы модулей, выполняет одно правило, которое сортирует результат и убирает дубликаты. Сборка типовой информации программы отвечает только за порядок шагов. |
| 5.19.337 | Внутренняя | Один шаг собирает полную типовую информацию модуля, от локальных объявлений через проекцию псевдонимов до фактов рантайма и умолчаний записей. Режим именной идентичности 5.20 выбирается один раз для всей программы, а не для каждого модуля. |
| 5.19.336 | Внутренняя | Сбор рантайм-значений и фактов умолчаний записей стал одним шагом. Импортированные константы, собственные и внешние рантайм-ссылки, скрытые ссылки и отложенные выражения умолчаний собираются вместе до завершения типовой информации модуля. |
| 5.19.335 | Внутренняя | Один проход в порядке исходного текста строит действующие псевдонимы модуля, его экспортируемую поверхность типов и привязки импорта типов вместе и передаёт все три как один результат. |
| 5.19.334 | Внутренняя | Исходник модуля, его рантайм-идентичность и происхождение из сгенерированной стандартной библиотеки хранятся как один факт вместо трёх разрозненных полей. Проверки квалифицированных типов, выбор рантайм-метода и допуск встроенных средств Лиспекс читают этот же факт. |
| 5.19.333 | Внутренняя | Экспортированные значения констант, набор имён рантайм-экспорта и набор неизменяемых привязок верхнего уровня собраны в одну рантайм-поверхность значений. Сбор констант и ссылок при импорте и анализ умолчаний записей читают её же. |
| 5.19.332 | Внутренняя | Шесть разрозненных наборов умолчаний записей, куда входят значения констант, импортированные и собственные рантайм-ссылки, скрытые ссылки и ссылки между модулями, стали одним продуктом. Построение записей, инициализация умолчаний и межмодульное распространение работают с ним. |
| 5.19.331 | Внутренняя | Определения методов модуля и имена его протоколов хранятся вместе как одна запись локальных объявлений методов. Сбор псевдонимов читает оба оттуда, а имена кандидатов действующих методов получателя остаются в проекции псевдонимов. |
| 5.19.330 | Внутренняя | Импорт типов через пространство имён и выборочный импорт типов хранятся в одной таблице привязок. Поиск объявлений типизированного JSON, обнаружение вариантов, поиск квалифицированных типов и анализ умолчаний записей обращаются к одной таблице. |
| 5.19.329 | Внутренняя | Обычная таблица псевдонимов, таблица обобщённых псевдонимов и набор псевдонимов, отключённых из-за совпадения имён, хранятся как один локальный результат разрешения. Просмотр псевдонимов модуля, допуск квалифицированных псевдонимов и обнаружение транзитивных типов читают его. |
| 5.19.328 | Внутренняя | Имена экспортируемых типов, экспортируемые определения enum, record и newtype, а также экспортируемые методы получателя образуют одну поверхность экспортируемых типов. Проекция импорта, проверки квалифицированных типов, допуск псевдонимов и обнаружение вариантов читают её. |
| 5.19.327 | Внутренняя | Локальные определения enum, record и newtype вместе с четырьмя таблицами объявлений схем для псевдонимов типов и этих трёх форм собраны в одно локальное объявление. Семь разрозненных полей убраны, а разрешение псевдонимов, поиск схем, проверки типов и извлечение экспорта читают одно место. |
| 5.19.326 | Внутренняя | Десять наборов, описывающих действующие типы модуля, схемы, методы получателя и происхождение схем, свёрнуты в одну проекцию псевдонимов. Шаг применения импорта пишет прямо в неё, а сбор псевдонимов читает тот же результат, поэтому промежуточный адаптер убран. |
| 5.19.325 | Внутренняя | Действующая проекция импорта и карты происхождения схем определяются в уже выполняемом проходе импорта, поэтому сбор псевдонимов берёт готовый результат, а второй обход каждого модуля и пересборка карт происхождения исчезли. |
| 5.19.324 | Внутренняя | Типовая информация модуля и сбор псевдонимов совместно владеют тремя таблицами именных определений, четырьмя таблицами объявлений схем и набором кандидатов методов получателя вместо копирования. Импорт копирует только тот набор, который принимает экспортированный элемент. |
| 5.19.323 | Внутренняя | Таблицы псевдонимов и набор конфликтов используются совместно, а не копируются целиком, поэтому просмотр тела функции, лямбды и defer переиспользует те же таблицы. Только просмотр псевдонима из другого модуля строит нужное объединение конфликтов. |
| 5.19.322 | Внутренняя | Сбор псевдонимов переиспользует уже построенную информацию модуля и добавляет только проекцию импорта. Второй обход объявлений, повторный проход по перекрытым псевдонимам и неиспользуемое поле версии языка убраны. |
| 5.19.321 | Внутренняя | Методы верхнего уровня, протоколы, псевдонимы типов, record, enum и newtype собираются за один проход по исходному тексту. Идентичность метода завершается после того, как известны все собственные цели методов, поэтому она больше не зависит от порядка объявлений. |
| 5.19.320 | Внутренняя | Сбор псевдонимов типов верхнего уровня за один проход даёт ссылки на схемы, обычную и обобщённую таблицы разрешения и пометки дублирующихся имён. Затем структурный обход применяет блочное перекрытие псевдонимов во всех позициях, где может стоять блок. |
| 5.19.319 | Внутренняя | Обнаружение протоколов перенесено в единый проход сбора методов, который засевает встроенные протоколы Show, Eq и Order и собирает имена объявленных протоколов рядом с целями реализаций и записями диспетчеризации. Статическая и получательская диспетчеризация используют один перечень. |
| 5.19.318 | Внутренняя | Объявления схем и рантайм-определения enum, record и newtype строятся за один проход, общий для сбора псевдонимов и межмодульной типовой информации. В этом проходе фиксируются арность и порядок вариантов, поля записей и владение источниками умолчаний. |
| 5.19.317 | Внутренняя | Наличие в единице компиляции собственных или протокольных объявлений методов записывается во время сбора объявлений и читается прямо при выпуске элементов. Отдельный проход по всей единице, решавший это после сборки, убран. |
| 5.19.316 | Внутренняя | Межмодульная типовая информация собирает собственные цели методов и кандидатов экспортируемых методов получателя за один проход, а затем пересекает кандидатов с готовым набором экспортируемых enum, record и newtype. |
| 5.19.315 | Внутренняя | Сбор псевдонимов строит собственные цели методов, протокольно-квалифицированные и собственные записи диспетчеризации и кандидатов вызова получателя за один проход по исходному тексту. Нужен ли реестр методов, определяется прямым чтением записанного факта. |
| 5.19.314 | Внутренняя | Сборщики enum, record и newtype на границе псевдонимов и на межмодульной границе используют один запуск сбора собственных целей методов. Идентичность объявления и идентичность метода строятся из одного набора входов. |
| 5.19.313 | Внутренняя | Методы получателя, приходящие через импорт, собираются в том же проходе, который проецирует импортированные определения типов и схемы, поэтому каждая цель импорта и каждое выбранное имя разрешаются один раз. |
| 5.19.312 | Внутренняя | Выборочный импорт больше не выполняет четыре прохода для определений типов и схем record, enum и newtype. Один проход в порядке исходного текста разрешает каждую цель импорта один раз и переиспользует найденное экспортированное определение при регистрации схемы. |
| 5.19.311 | Внутренняя | Точечные пути модулей строит один общий сборщик, которым пользуются все девять мест, где они нужны, включая импортированные константы, планы импорта точки входа, импорт методов получателя, определения типов и схемы. Импорт, псевдонимы, умолчания и вывод не изменились. |
| 5.19.310 | Внутренняя | Сколько раз связано каждое имя верхнего уровня модуля, считается один раз на модуль вместо пятикратной пересборки и повторного просмотра на шести проверках уникальности. Обработка конфликтов, умолчания записей, импорт и вывод не изменились. |
| 5.19.309 | Внутренняя | Шесть мест, которым нужно имя простой привязки, с типом или без, читают его через одну общую проекцию, а не через временный список. Полный сбор образцов остаётся там, где нужно несколько разобранных имён, а поведение экспорта и вывод не изменились. |
| 5.19.308 | Внутренняя | Экспорт с типом вида export let value: int = 41 теперь компилируется и сгенерированным бэкендом Rust. Раньше он проходил разрешение, проверку, интерпретатор и сгенерированный Python, а затем останавливался на TPZ6001. Отказ от экспорта с разбором остался прежним. |
| 5.19.307 | Внутренняя | Использование обобщённого типа без аргументов типа отклоняется одинаково для локальных типов и для типов, пришедших через выборочный импорт. Интерпретатор и сгенерированный бэкенд Rust доходят до сверки с объявлением и сообщают об ошибке арности TPZ5099, а не совпадают лишь по идентичности. |
| 5.19.306 | Внутренняя | Сопоставление квалифицированного модулем типа проверяет экспорт и число аргументов типа одинаково в интерпретаторе, сгенерированном бэкенде Rust и сгенерированном Python. Приватный тип доходит до ошибки TPZ5001 о неэкспортированном типе, а обобщённый тип без аргументов больше не считается необобщённым. |
| 5.19.305 | Внутренняя | Шесть путей сопоставления квалифицированного модулем типа сравнивают идентичность, сохранённую вместе с определением, вместо повторного построения текста идентичности в каждом месте. Допуск экспорта, подстановка обобщений, диагностика и результаты не изменились. |
| 5.19.304 | Внутренняя | При создании варианта enum, record или newtype идентичность метода берётся прямо из уже разрешённого определения, а идентичность объявления выводится из неё без повторного поиска. Идентичность, диспетчеризация, порядок полей и вариантов и результаты не изменились. |
| 5.19.303 | Внутренняя | Восемь мест сопоставления образцов и типов сравнивают идентичность, хранимую вместе с определением enum, record или newtype, вместо повторного поиска типа в глобальных таблицах. Откат образца, псевдонимы, подстановка обобщений и диагностика не изменились. |
| 5.19.302 | Внутренняя | Создание вариантов enum, record и newtype получает идентичность объявления и идентичность метода из одного поиска. Раньше таблицы просматривались дважды ради двух идентичностей, а поведение создания, порядок умолчаний и результаты остались прежними. |
| 5.19.301 | Внутренняя | В режиме 5.20 поиск вариантов значения enum сравнивает идентичность, уже хранимую в каждом определении-кандидате, вместо запроса к глобальным таблицам для каждого кандидата. Порядок и арность вариантов, псевдонимы, образцы и результаты не изменились. |
| 5.19.300 | Внутренняя | Выборочный импорт разрешает целевой модуль один раз и берёт рантайм-привязку и определения enum, record и newtype из этого одного разрешения. Имена с псевдонимом и без, экспорт только типов и инициализация модуля работают как прежде. |
| 5.19.299 | Внутренняя | Чтение члена через пространство имён разрешает модуль один раз и использует этот результат для набора приватных умолчаний записей, поиска в окружении и допуска экспорта. Поведение, коды диагностики, текст и позиции не изменились. |
| 5.19.298 | Внутренняя | Поиск модуля, допуск экспорта, наличие рантайм-привязки и диагностику о неэкспортированном имени выполняет один поиск экспортированной привязки, общий для выборочного импорта и доступа через пространство имён. Диагностика для экспорта только типов осталась своей. |
| 5.19.297 | Внутренняя | Каждое принятое объявление экспорта даёт не более одного имени, поэтому регистрация записывает это имя напрямую, а не через список, который был пустым или содержал один элемент. Набор объявлений, экспортирующих имя, не изменился. |
| 5.19.296 | Внутренняя | Интерпретатор строил точечный путь импорта в двух разных местах, при сборе сведений о модуле и при выполнении импорта. Теперь оба используют один сборщик, а текст пути, привязка псевдонима, ошибка отсутствующего модуля и порядок инициализации не изменились. |
| 5.19.295 | Внутренняя | Идентичности целевых модулей в области импорта типизированного JSON используются совместно, а не копируются для каждой спецификации импорта, а уже инициализированный модуль переиспользует свой ключ. Маршрутизация импорта, межмодульные источники схем и результаты не изменились. |
| 5.19.294 | Внутренняя | Ключ рантайм-области, по которому находится модуль, создаётся один раз и используется совместно регистрацией модуля, идентичностью текущего модуля, картой модулей и индексом источников. Идентичность и порядок модулей, маршрутизация, импорт и экспорт сохраняют поведение. |
| 5.19.293 | Внутренняя | Идентичность объявления выполняемого модуля создаётся один раз и используется совместно, а модуль точки входа несёт пустую идентичность вместо отдельного случая отсутствия. Сбор экспорта, диспетчеризация внешних функций и повторный запуск ведут себя как прежде. |
| 5.19.292 | Внутренняя | Регистрация модуля и его типовая область держат одну идентичность объявления вместо двух одинаковых копий, а разрешение объявлений типизированного JSON возвращает эту идентичность, не копируя текст. Диспетчеризация протоколов и проверка соответствия читают её как есть. |
| 5.19.291 | Внутренняя | Сбор сведений о модуле больше не пишет в глобальные таблицы enum, record и newtype во время подготовки модуля. Готовый модуль владеет своими определениями, и они публикуются в глобальные таблицы в единственной точке установки модуля. |
| 5.19.290 | Внутренняя | Идентичность объявления и ключ рантайм-области идут вместе как одна идентичность модуля, принадлежащая подготовленному модулю, поэтому подготовка и установка больше не передают два значения рядом. Маршрутизация, импорт, экспорт и повторный запуск не изменились. |
| 5.19.289 | Внутренняя | Область модуля больше не вставляется как заглушка до заполнения. Готовый модуль строится первым, новая запись пишется полной за один шаг, а существующая запись сохраняет окружение верхнего уровня и рантайм-экспорт, заменяя только состояние программы. |
| 5.19.288 | Внутренняя | Подготовка модуля даёт один готовый результат, содержащий его типовую область, приватные значения, доступные умолчаниям записей, и план регистрации вызываемых элементов. Установка разбирает этот результат в одной точке. |
| 5.19.287 | Внутренняя | План регистрации методов, реализаций протоколов и объявлений протоколов строится на этапе подготовки и запоминает место каждого элемента в исходном тексте, не копируя объявления. Полный обход, повторявшийся при регистрации, убран, а порядок регистрации не изменился. |
| 5.19.286 | Внутренняя | Подготовка модуля читает его верхний уровень один раз вместо шести. Маршруты импорта типизированного JSON, приватные неизменяемые значения, псевдонимы типов и определения enum, record и newtype собираются вместе, а отдельный обход целей методов сохранён, потому что идентичности требуют полного набора. |
| 5.19.285 | Внутренняя | Подготовка программы собирает типовую область модуля локально и переносит её на место один раз, до регистрации методов и выполнения операторов. Импорт, псевдонимы верхнего уровня, маршруты типизированного JSON и определения типов пишутся прямо в эту область. |
| 5.19.284 | Внутренняя | Области модулей создаются в одном месте и для отдельных программ, и для разрешённых модулей единицы, и для сгенерированных стандартных модулей. Инициализация единицы по-прежнему готовит источник, окружение и идентичности перед передачей, а порядок и результаты не изменились. |
| 5.19.283 | Внутренняя | Типовая информация хранится по модулям, а не по источникам, и остаётся лёгкий индекс от источника к модулю. Поиск псевдонимов, диспетчеризация протоколов и маршрутизация типизированного JSON читают модуль напрямую, минуя обёртку с ключом по источнику. |
| 5.19.282 | Внутренняя | Одна запись модуля, найденная по его идентичности, владеет и рантайм-областью, и типовой областью, заменяя две параллельные карты. Допуск импорта, экспорт, поиск квалифицированных типов и маршрутизация типизированного JSON читают из этой записи. |
| 5.19.281 | Внутренняя | Идентичность выполняемого модуля и признак внешнего модуля хранятся вместе как один контекст текущего модуля и создаются один раз на модуль. Повторное выполнение внешнего модуля, границы экспорта и порядок инициализации не изменились. |
| 5.19.280 | Внутренняя | Квалификатор объявления и ключ рантайм-области текущего модуля хранятся как одна идентичность, создаваемая один раз на модуль. Модуль точки входа не имеет квалификатора объявления, но по-прежнему использует свою идентичность как ключ рантайм-области. |
| 5.19.279 | Внутренняя | Окружение верхнего уровня, экспортированные имена и приватные неизменяемые значения модуля хранятся в одной рантайм-записи по идентичности модуля, заменяя три параллельные карты. Поиск при импорте, проверка экспортированных значений и доступ к умолчаниям записей читают её. |
| 5.19.278 | Внутренняя | Исходник-определитель, маршруты импорта типизированного JSON и определения типов модуля объединены в одну типовую запись по идентичности модуля, заменяя три параллельные карты. Выборочный импорт, поиск квалифицированных типов и маршрутизация схем читают её. |
| 5.19.277 | Внутренняя | Типовое состояние источника, то есть модуль, к которому он относится, его псевдонимы типов верхнего уровня и объявления типизированного JSON, хранится одной записью вместо трёх параллельных карт. Развёртывание псевдонимов и генерация схем читают её, а идентичность модуля восстанавливается после подмены источника замыкания как прежде. |
| 5.19.276 | Внутренняя | Каждое определение enum, record и newtype несёт свой исходник-определитель вместе с идентичностью и объявлением, поэтому три параллельные карты маршрутизации для выборочного импорта убраны. Локальный и квалифицированный поиск читают позиции объявления прямо из определения. |
| 5.19.275 | Внутренняя | Идентичность метода вычисляется один раз для типа и хранится вместе с его определением, поэтому две параллельные таблицы идентичностей убраны. Регистрация методов и поиск идентичности разрешаются прямо из таблиц типов, а поведение идентичностей 5.20 и 5.19 сохранено. |
| 5.19.274 | Внутренняя | Полные объявления enum, record и newtype находятся вместе с рантайм-идентичностью и полезной нагрузкой в одном дескрипторе, а четыре параллельные таблицы объявлений убраны. Загрузка модулей, выборочный импорт и квалифицированный поиск используют один дескриптор. |
| 5.19.273 | Внутренняя | Рантайм-идентичность и полезная нагрузка enum и record объединены в одну таблицу дескрипторов для каждого, что убирает четыре параллельные карты идентичностей. Загрузка модулей, активные определения и выборочный импорт используют дескрипторы напрямую. |
| 5.19.272 | Внутренняя | Таблицы вариантов и последовательности полей и умолчаний записей строятся один раз при инициализации модуля и дальше используются совместно. Выборочный импорт разделяет их вместо копирования нагрузки, пять путей копирования передают только ссылку, а порядок, арность и умолчания не изменились. |
| 5.19.271 | Внутренняя | Аргументы обобщённых типов создаются парсером один раз, и их используют анализатор типов, проекция схемы и бэкенд Python. Проверка соответствия и раскрытие псевдонимов больше не копируют узлы, а вложенные обобщения, типизированные шаблоны, вывод схемы JSON и диагностика остались прежними. |
| 5.19.270 | Внутренняя | Этапы конвейера переиспользуют один узел, созданный парсером, и правая часть канала больше не копируется во время выполнения. Порядок вычисления, подстановка заполнителя, вставка первого аргумента, сокращение полей и диагностика работают как прежде. |
| 5.19.269 | Внутренняя | Генераторы массивов, множеств и Map используют один узел тела, созданный парсером, поэтому интерпретатор передаёт его в каждое предложение без копирования. Порядок предложений, области видимости, вычисление ключей и значений, обработка дубликатов и результаты не изменились. |
| 5.19.268 | Внутренняя | Объявление newtype хранится один раз и используется номинальными схемами, объявлениями схем и выводом схемы JSON, а не копируется трижды во время выполнения. Создание, извлечение значения, сопоставление с образцом, параметры обобщений и диагностика прежние. |
| 5.19.267 | Внутренняя | Объявления записей и выражения значений по умолчанию создаются парсером один раз и используются объявлениями схем, выводом схемы JSON и созданием записей, поэтому копирование во время выполнения исчезло. Порядок полей, значения по умолчанию, обновления, производные и диагностика прежние. |
| 5.19.266 | Внутренняя | Объявление enum хранится один раз и используется номинальными схемами, объявлениями схем и выводом схемы JSON вместо трёх копий во время выполнения. Порядок и арность вариантов, создание, сопоставление с образцом, производные и результаты не изменились. |
| 5.19.265 | Внутренняя | Объявления псевдонимов типов и стоящий за ними тип используются таблицей псевдонимов, выводом схемы, областями видимости блоков и бэкендом Python без копирования. Разрешение псевдонимов и параметров обобщений, раскрытие типов, соответствие, диагностика и результаты прежние. |
| 5.19.264 | Внутренняя | Действие defer регистрируется по ссылке на разобранное выражение, а не копированием, поэтому отложенная работа обходится дешевле. Место регистрации, лексическая область видимости, порядок от последнего к первому, разматывание при раннем выходе и обработка ошибок не изменились. |
| 5.19.263 | Внутренняя | Деструктурирующие привязки let переиспользуют разобранный шаблон вместо копирования при создании шага привязки. Правила привязки, изменяемость, сопоставление с образцом, диагностика и результаты прежние. |
| 5.19.262 | Внутренняя | Строковые литералы используются совместно, а не копируются во время интерполяции и работы теговых шаблонов, поэтому каждая строка делает меньше работы. Разбор экранирования, поиск тега, порядок частей, отрисовка и результаты не изменились. |
| 5.19.261 | Внутренняя | Присваивания переиспользуют разобранные цель и значение, включая вложенные пути по полям и индексам и ??=, вместо копирования на каждом шаге. Проверка цели, проверка изменяемости, порядок вычисления, ленивость ??=, отклонение необязательных путей и вложенные обновления прежние. |
| 5.19.260 | Внутренняя | Шаблон цикла for создаётся один раз и переиспользуется, идёт ли цикл на верхнем уровне, внутри блока или как выражение-значение. Привязка, порядок обхода, области видимости цикла, break и continue, собранные значения и диагностика прежние. |
| 5.19.259 | Внутренняя | Условие while, в том числе записанное с шаблоном привязки, создаётся один раз и переиспользуется на каждой итерации, а не копируется на каждом витке. Порядок вычисления условия и тела, области видимости, break и continue и результаты цикла прежние. |
| 5.19.258 | Внутренняя | Каждое явное выражение поля в литерале записи или обновлении создаётся один раз и используется анализатором типов, бэкендами и вычислением записей вместо копирования для номинальных записей. Порядок в исходнике и порядок вычисления, распаковка, значения по умолчанию и полученные записи прежние. |
| 5.19.257 | Внутренняя | Создание номинальной записи с распаковкой переиспользует разобранное выражение вместо копирования. Проверка явных полей, диагностика дубликатов и неизвестных полей, вычисление базы в первую очередь, значения по умолчанию и порядок полей прежние. |
| 5.19.256 | Внутренняя | Доступ к члену держит получателя в одной общей ячейке, поэтому встроенные методы коллекций, строк, Option, Result, JSON, байтов, путей и дат больше не копируют получателя целиком. Разрешение членов, проверка изменяемости, диагностика отсутствующего члена и выбор метода прежние. |
| 5.19.255 | Внутренняя | JSON.parseAs и JSON.decode вычисляют свой аргумент прямо на месте вызова, в том числе через каналы и заполнители, а не копируют выражение заранее. Проверка аргументов, диагностика, области видимости, порядок вычисления и разбор работают как прежде. |
| 5.19.254 | Внутренняя | Каждая ветвь выражения concurrent создаётся парсером один раз и используется анализатором типов и бэкендами, поэтому запуск ветви больше не копирует её тело. Порядок ветвей, изолированные окружения, поочерёдное планирование, тайм-ауты и поведение при ошибке прежние. |
| 5.19.253 | Внутренняя | Блок else по тайм-ауту в concurrent передаётся выполняющемуся выражению напрямую, а не копией. Обработка тайм-аута, планирование ветвей, истечение, отмена и выполнение else не изменились. |
| 5.19.252 | Внутренняя | Обычные вызовы, вызовы значений-функций, вызовы встроенных функций и вызовы через канал вычисляют вызываемое выражение на месте, а не копируют его в новый шаг. Особые маршруты вызова, вычисление вызываемого перед аргументами и сокращённое вычисление прежние. |
| 5.19.251 | Внутренняя | Интерполируемые строки и теговые шаблоны создают литерал один раз на входе и вычисляют каждую вставку на месте, вместо копирования всего литерала и вставки на каждом сегменте. Разбор, порядок, отрисовка, части шаблона и значения прежние. |
| 5.19.250 | Внутренняя | match создаёт области видимости до вычисления охранных выражений, тел ветвей и значений return и берёт каждое из них прямо из общего списка ветвей, без копирования. Порядок ветвей, области видимости привязок и поведение возврата прежние. |
| 5.19.249 | Внутренняя | Конструкторы Some, Ok, Err и newtype вычисляют свой аргумент на месте, а вызовы enum и протоколов обходят аргументы слева направо по одному общему списку вместо перевёрнутого стека скопированных узлов. Порядок аргументов, в том числе при вызове через канал, прежний. |
| 5.19.248 | Внутренняя | Обычные вызовы, вызовы методов и необязательные вызовы берут каждый аргумент прямо из общего списка и переносят готовые значения в стек, а не копируют их. Порядок вычисления и порядок аргументов прежние. |
| 5.19.247 | Внутренняя | Элементы массивов и распаковки, элементы множеств, ключи и значения Map и значения полей записей вычисляются прямо из общего списка, который держит окружающий литерал, без копирования каждого потомка. Порядок вычисления и результаты прежние. |
| 5.19.246 | Внутренняя | Анализатор типов узнаёт ожидаемый тип результата окружающего вызова до разбора аргументов, поэтому Ok внутри обратного вызова Result.flatMap получает конкретный тип. Ложная ошибка TPZ5001, сообщавшая о Result<string, E> там, где ожидался Result<string, string>, исчезла. |
| 5.19.245 | Внутренняя | Выполнение блока для if, для else по тайм-ауту в concurrent и в виде блочного выражения переиспользует разобранный блок вместо копирования. Поведение при вычислении не изменилось. |
| 5.19.244 | Внутренняя | Выполнение инструкций вычисляет дочерние выражения на месте, включая условия, значения return и break, выражения-инструкции и инициализаторы привязок, вместо обёртывания каждого в скопированный узел. Порядок вычисления и поведение прежние. |
| 5.19.243 | Внутренняя | Выполняющийся блок хранит ссылку на блок и достигнутую позицию вместо копирования оставшихся инструкций, а инструкции и выражения верхнего уровня вычисляются на месте. Поведение не изменилось. |
| 5.19.242 | Внутренняя | Лексические области видимости ищут привязки по имени в прямой таблице, а не в упорядоченном дереве, поскольку порядок объявления и вычисления задаёт сама программа. Собственный анализатор типов проходит свою работу быстрее, поведение не изменилось. |
| 5.19.241 | Внутренняя | Анализатор типов применяет объявленный тип результата функции только к настоящим проверкам return, а для вложенных None, Ok и Err, для стандартных вызовов-обёрток и для сгенерированных вызовов Лиспекс берёт ожидаемый тип из проверяемого выражения. Ложные сообщения о вложенных значениях исчезли. |
| 5.19.240 | Внутренняя | Ожидаемый тип привязывается именно к тому выражению, которому принадлежит, и доходит только до ветвей if и match и концов блоков, дающих окружающий результат. Вложенные конструкции и промежуточные инструкции больше не вызывают ложных ошибок типов. |
| 5.19.239 | Внутренняя | Команды, несущие компилятор, по умолчанию используют сборку Rust Stage 0, поэтому устаревший встроенный анализатор больше не выдаёт ложную диагностику при обычных запусках. Устранена неоднозначность обобщённого Option, и каждое значение в шаблоне enum с несколькими значениями сохраняет свой тип. |
| 5.19.238 | Внутренняя | Поведение Лиспекс совпадает в интерпретаторе, сгенерированном Rust и сгенерированном Python. Диагностика чтения и нормализации, порядок поиска и позиция в исходнике для несвязанного имени, сокращённое вычисление и уже записанный вывод при ошибке программы одинаковы, а манифест возможностей опубликован полностью. |
| 5.19.237 | Внутренняя | Бэкенд Python сохраняет известную длину массива и сведения, общие для всех элементов, при sort и sortBy, а при retain отпускает известную длину, поскольку результат может стать короче. |
| 5.19.236 | Внутренняя | Статические операции с массивом, такие как push, pop, reverse, insert, removeAt и clear, обновляют все сведения бэкенда Python о каждом слоте и о длине массива и держат псевдонимы одного хранилища в согласии. |
| 5.19.235 | Внутренняя | Бэкенд Python различает коллекции пространства имён и локальные и даёт каждой изменяемой привязке собственную идентичность, поэтому изменение через один псевдоним затрагивает ровно те привязки, что делят коллекцию, а переприсваивание начинается с чистого листа. |
| 5.19.234 | Внутренняя | Бэкенд Python отличает ключи, о наличии которых известно, от ключей с полностью известным значением, поэтому Map.update по известному ключу объединяет возвращённое обратным вызовом значение с исходным. |
| 5.19.233 | Внутренняя | Изменения коллекций в бэкенде Python описываются как обновление, удаление или сброс, поэтому Map.remove по известному ключу убирает только этот ключ и оставляет сведения об остальной части Map. |
| 5.19.232 | Внутренняя | Map.insert с известным ключом фиксирует вставленное значение, поэтому бэкенд Python переносит его форму, форму вызова и вложенное содержимое в последующие обращения по этому ключу. |
| 5.19.231 | Внутренняя | Изменения массивов и Map проходят в бэкенде Python по одному пути, поэтому изменение через любую привязку одинаково сбрасывает остальные привязки, делящие ту же коллекцию. |
| 5.19.230 | Внутренняя | Если бэкенд Python знает все ключи Map и все они несут значения одного вида, обращение по ключу, вычисляемому во время выполнения, тоже опирается на эти общие сведения. |
| 5.19.229 | Внутренняя | Map.get с ключом, известным лишь во время выполнения, пользуется сведениями бэкенда Python о неизменяемом Map, если все известные записи несут значения одного вида. |
| 5.19.228 | Внутренняя | Map, построенный из известных ключей, несёт в бэкенде Python полную картину каждого значения, включая его форму, способ вызова и вложенное содержимое, поэтому сопоставление результата Map.get опирается на реальные сведения. |
| 5.19.227 | Внутренняя | Бэкенд Python описывает содержимое Option и Result путями, а не фиксированной парой полей, поэтому значения любой глубины вложенности отслеживаются одинаково. |
| 5.19.226 | Внутренняя | Когда все ветви if или match дают одну форму, бэкенд Python сохраняет узнанное о значении, форме вызова, вложенном содержимом Option и полях записи, отдавая предпочтение наблюдённому, а не объявленному. |
| 5.19.225 | Внутренняя | Функция, возвращающая вызываемое значение внутри Option или Result, сохраняет форму вызова в бэкенде Python, и фактически возвращаемое телом предпочитается объявленному откату. |
| 5.19.224 | Внутренняя | Значения уровня модуля несут свою форму, содержимое Option или Result и форму вызова по всему бэкенду Python, поэтому выборочный импорт или обращение к члену пространства имён видит те же сведения, что и определение. |
| 5.19.223 | Внутренняя | Извлечение значения из Some или Ok даёт в бэкенде Python одни и те же сведения независимо от того, пришло ли оно из конструктора, привязки, возврата или массива, разбираемого шаблоном. |
| 5.19.222 | Внутренняя | Бэкенд Python записывает форму каждого слота массива и содержимое его Option, а если все слоты совпадают, использует это при индексе, вычисляемом во время выполнения, и при сопоставлении с образцом. |
| 5.19.221 | Внутренняя | Массивы значений Map несут в бэкенде Python сведения по каждому слоту через литералы, распаковки и псевдонимы, поэтому чтение по известному индексу видит и содержимое Map, и записи внутри него. |
| 5.19.220 | Внутренняя | Записи, лежащие в массиве, сохраняют в бэкенде Python всё дерево полей, поэтому чтение по известному индексу добирается до вложенных полей независимо от того, лежит ли запись прямо там или внутри Option, Result либо значения Map. |
| 5.19.219 | Внутренняя | Замена поля записи очищает и заново строит сведения бэкенда Python о поддереве этого поля за одну операцию, общую для обновлений записей и присваиваний по пути. |
| 5.19.218 | Внутренняя | Объявленное и наблюдённое содержимое записей в слотах массива хранится в бэкенде Python в одном месте, поэтому чтение поля элемента массива проходит через один поиск. |
| 5.19.217 | Внутренняя | Присваивание по вложенному пути записи заменяет в бэкенде Python только то поле, в которое идёт запись, оставляя сведения о соседних полях и других корнях нетронутыми. |
| 5.19.216 | Внутренняя | Присваивание целой записи в поле переносит в бэкенде Python всё её вложенное содержимое, включая формы значений, формы вызова и цели обратных вызовов. |
| 5.19.215 | Внутренняя | Создание записей, их обновление и присваивание полей фиксируют значение поля в бэкенде Python по одному общему пути, поэтому все три случая согласованы. |
| 5.19.214 | Внутренняя | Литералы записей и обновления записей собирают сведения о полях и укладывают их по одним и тем же путям одним общим шагом в бэкенде Python. |
| 5.19.213 | Внутренняя | Значения по умолчанию номинальных записей, содержащие вызываемое значение, описываются в бэкенде Python в одном месте, поэтому анализ всего модуля и обновления записей читают одни и те же значения. |
| 5.19.212 | Внутренняя | Обновление номинальной записи проверяет вызываемые значения по умолчанию один раз и обходит значение однократно вместо двух проходов, а таблица значений по умолчанию в бэкенде Python больше не копируется целиком. |
| 5.19.211 | Внутренняя | Чтение поля записи в бэкенде Python определяет форму значения, форму вызова и цель обратного вызова по одному общему правилу вместо трёх отдельных путей. |
| 5.19.210 | Внутренняя | Поля записей внутри Option следуют в бэкенде Python тому же правилу, а вложенные обращения выстраивают один канонический путь до поля. |
| 5.19.209 | Внутренняя | Записи, доступные через значение Map, Option или Ok, проецируются прямо из привязки, пространства имён, возврата или конструктора, откуда они пришли, без копирования всей таблицы в бэкенде Python. |
| 5.19.208 | Внутренняя | Сопоставление результата Map.get определяет сам Map, ключ, форму значения, форму вызова и вложенные записи в одном месте бэкенда Python. |
| 5.19.207 | Внутренняя | Индексирование массива в бэкенде Python находит привязку и решает, известен ли индекс заранее, одним общим шагом, поэтому все обращения к слотам идут по одному пути. |
| 5.19.206 | Внутренняя | Литералы массивов и распаковки обходятся в бэкенде Python за один проход, собирая цели обратных вызовов, известные длины и формы вызова, и объединение ветвей идёт так же. |
| 5.19.205 | Внутренняя | Всё, что бэкенд Python знает об элементах массива, от форм слотов и содержимого Option до целей обратных вызовов, форм вызова и длин, собрано в одной структуре. |
| 5.19.204 | Внутренняя | Значения Map несут свою форму, содержимое Option и форму вызова в одной структуре и для локальных привязок, и для значений уровня модуля в бэкенде Python, а собираются за один проход. |
| 5.19.203 | Внутренняя | Вложенные поля записей с кооперативными обратными вызовами сохраняют цели планирования при обновлении полей, слиянии ветвей и разборе шаблонов. Все три пути используют один общий поиск. |
| 5.19.202 | Внутренняя | Формы получателей и сведения о вызовах для членов записи собираются один раз из представлений парсера и проверяющего. Дублирующий этап фильтрации убран. |
| 5.19.201 | Внутренняя | Прямой доступ к полю и обёрточные пути читают формы получателей и сигнатуры вызова вложенных записей из одного источника, поэтому оба маршрута согласны в том, какой вызов члена допустим. |
| 5.19.200 | Внутренняя | Функция, возвращающая запись, обёрнутую в Result, сохраняет сведения о вложенных членах этого значения в бэкенде Python, поэтому вызовы после unwrap() попадают в нужный метод. |
| 5.19.199 | Внутренняя | Значения из Map, содержащие запись внутри Result, несут сведения о вложенных членах, и цепочка unwrap() после Map.get достигает методов записи в бэкенде Python. |
| 5.19.198 | Внутренняя | Значение из Map, содержащее запись внутри Option, больше не теряет сведения о вложенных членах, поэтому опциональная цепочка после Map.get находит методы записи в бэкенде Python. |
| 5.19.197 | Внутренняя | Привязки из шаблона Map.get знают форму получателя и сигнатуру вызова хранимой записи, поэтому вложенные вызовы членов правильно компилируются для Python. |
| 5.19.196 | Внутренняя | Поиск в Map через локальный псевдоним по фиксированному ключу возвращает верную форму получателя, включая форму внутри Option и Result, при генерации Python. |
| 5.19.195 | Внутренняя | Объявленные сигнатуры вызова для функций, хранимых в Map, доходят до бэкенда Python через локальные псевдонимы, и вызов значения, связанного шаблоном Map.get, передаёт аргументы как объявлено. |
| 5.19.194 | Внутренняя | Функции, хранящиеся в массиве, сохраняют объявленные сигнатуры после регистрации массива как изменяемого и после последующих обновлений, поэтому динамические вызовы и вызовы через конвейер по-прежнему работают верно. |
| 5.19.193 | Внутренняя | Записи, доступные через псевдоним Option, раскрывают сигнатуры и значения по умолчанию своих вызываемых полей, поэтому вызов такого поля через опциональный доступ использует объявленные значения. |
| 5.19.192 | Внутренняя | Привязка, объявленная как запись внутри Option, сохраняет объявленную форму получателя при переприсваивании переменной, так как объявление больше не разделяет время жизни с отслеживаемым значением. |
| 5.19.191 | Внутренняя | Привязки и экспортируемые значения модуля с записью внутри Option несут формы получателей и сигнатуры вызова вложенных полей, и опциональная цепочка разрешается через них. |
| 5.19.190 | Внутренняя | Функция, возвращающая запись, обёрнутую в Option, сохраняет сведения о вложенных членах возвращаемого значения, поэтому опциональная цепочка на результате вызова разрешается в бэкенде Python. |
| 5.19.189 | Внутренняя | Импортированные модули приводятся к устойчивому порядку до вычисления сведений о возвращаемых записях и значений по умолчанию для полей записи в Python, поэтому оба вычисляются после регистрации импортов и фактов изменения. |
| 5.19.188 | Внутренняя | Значения по умолчанию для полей записи фиксируются в модуле, где запись объявлена, и пустое значение остаётся пустым, поэтому импортирующий модуль не переосмысливает его в своём пространстве имён. |
| 5.19.187 | Внутренняя | При построении именованной записи сигнатуры вызова её вызываемых полей сначала заполняются из объявленных типов полей, а выражение по умолчанию затем переопределяет имена параметров, значения по умолчанию и кооперативные цели. |
| 5.19.186 | Внутренняя | Формы получателей и сигнатуры вызова доходят до каждого уровня вложенной записи, независимо от того, записан ли тип на месте или получен из псевдонима типа, разрешённого проверяющим. |
| 5.19.185 | Внутренняя | Функция с объявленным структурным типом возврата даёт формы получателей и сигнатуры вызова прямых полей этой записи, в том числе когда значение приходит из завершающего выражения тела. |
| 5.19.184 | Внутренняя | Вызовы через импорт пространства имён разрешаются по одному правилу, учитывающему сам импорт и любое локальное имя, которое его перекрывает, вместо нескольких расходящихся поисков. |
| 5.19.183 | Внутренняя | Все функции модуля регистрируются до вычисления сведений о возвращаемых записях, поэтому обёртка, вызывающая функцию, объявленную ниже в файле, получает те же сведения, что и вызывающая выше. |
| 5.19.182 | Внутренняя | Обёртка, передающая результат другой функции, наследует её кооперативные цели обратных вызовов, поэтому цели сохраняются на любой глубине передачи. |
| 5.19.181 | Внутренняя | Сведения о возврате функции записывают кооперативные цели обратных вызовов полей записи рядом с формами получателей и сигнатурами вызова, поэтому вызов члена на возвращённой записи их находит. |
| 5.19.180 | Внутренняя | Обновление записи начинается с объявленных сведений исходного значения и заменяет сигнатуру, кооперативные цели и вложенные сведения только для полей, указанных в обновлении. |
| 5.19.179 | Внутренняя | Обновление структурной записи копирует формы получателей исходного значения и подставляет новые формы для полей и вложенных полей, указанных в обновлении. |
| 5.19.178 | Внутренняя | Генерация кода, поиск динамических значений по умолчанию и сведения о привязках разрешают основу построения именованной записи одинаково, поэтому формы получателей согласованы независимо от того, читаются они из объявления или из значений полей. |
| 5.19.177 | Внутренняя | Объявленные формы элементов массива, включая форму внутри вложенного Option, отделены от сведений об обратных вызовах, собранных по потоку, поэтому переприсваивание массива их не теряет. |
| 5.19.176 | Внутренняя | Индексация массива сохраняет форму элемента, установленную проверяющим, а имена, скобочные выражения, индексный доступ и доступ к члену разрешаются в один корень через локальные псевдонимы, изменяющие вызовы и немедленно вызываемые лямбды. |
| 5.19.175 | Внутренняя | Тела defer анализируются после завершения блока, в порядке, обратном регистрации, поэтому бэкенд Python видит отложенные изменения и перепривязки в порядке их фактического выполнения. |
| 5.19.174 | Внутренняя | Отслеживание изменений разбирает выполняемую и пропускаемую ветви отдельно для &&, ||, ?? и вызовов с опциональным получателем, поэтому внешний псевдоним, затронутый лишь в одной ветви, всё равно учитывается. |
| 5.19.173 | Внутренняя | Тела for, while и loop, включения, а также ветви concurrent вместе с блоком else по тайм-ауту строят множество изменённых корней по одному нарастающему правилу. |
| 5.19.172 | Внутренняя | Локальный псевдоним хранит множество достижимых корней параметров, ветви if и match объединяют эти множества на выходе, а псевдоним, объявленный внутри отдельной ветви, перекрывает внешний. |
| 5.19.171 | Внутренняя | Изменяемые локальные массивы отслеживаются как корни от объявления и через каждое переприсваивание, поэтому связанные с ними сведения сбрасываются и восстанавливаются в нужных точках. |
| 5.19.170 | Внутренняя | Программы с изменяемыми локальными псевдонимами прогоняются через бэкенд Python так же, как их выполняет компилятор, а входной модуль и его импорты разрешаются и проверяются вместе. |
| 5.19.169 | Внутренняя | Проверяющий прослеживает изменяемый локальный псевдоним до неизменяемого параметра-массива, из которого он получен, и считает этот параметр корнем эффекта, опираясь на типы, записанные в исходном коде. |
| 5.19.168 | Внутренняя | Параметры-массивы типизированной лямбды, сохранённой в переменной, отслеживаются внутри лямбды, поэтому изменения, сделанные напрямую или через обёртку, проявляются как эффекты вызова этого значения. |
| 5.19.167 | Внутренняя | Когда if или исчерпывающий match даёт вызываемые значения с совместимыми сигнатурами, результат сохраняет все параметры-массивы, изменяемые в любой достижимой ветви, а не только общие для всех. |
| 5.19.166 | Внутренняя | Экспортируемое вызываемое значение сохраняет запись о том, какие параметры-массивы оно изменяет, и эта запись восстанавливается при доступе через выборочный импорт или вызов через пространство имён. |
| 5.19.165 | Внутренняя | Привязки с вызываемым значением несут набор изменяемых им параметров-массивов, и этот набор остаётся согласованным при регистрации, обновлении и очистке неизменяемого псевдонима. |
| 5.19.164 | Внутренняя | Эффекты изменения параметров для локальных вызовов, выборочных импортов и вызовов через пространство имён выводятся из прямых сводок наращиванием до устойчивого состояния, поэтому ответ одинаков при любой глубине обёрток. |
| 5.19.163 | Внутренняя | Каждая функция записывает, какие параметры-массивы она изменяет, поэтому вызов известной изменяющей функции сразу сбрасывает устаревшие сведения о переданных массивах. |
| 5.19.162 | Внутренняя | Параметры типизированной лямбды регистрируются как привязки, а изменяемый массив, переданный через цепочку псевдонимов в немедленно вызываемую лямбду, теряет внешние сведения сразу после возврата из вызова. |
| 5.19.161 | Внутренняя | Изменения внутри немедленно вызываемой лямбды, в том числе через её параметры, считаются эффектами окружающего выражения, поэтому сведения о захваченных внешних значениях сбрасываются сразу после её выполнения. |
| 5.19.160 | Внутренняя | Изменения, происходящие в середине выражения, учитываются при понижении выражения в инструкции, поэтому последующая часть того же выражения читает массив в состоянии после вызова. |
| 5.19.159 | Внутренняя | Внешние значения, изменяемые ветвью concurrent или её блоком else по тайм-ауту, собираются до генерации тел, поэтому ни одна ветвь не читает устаревшие сведения, и все они сбрасываются на одной общей границе. |
| 5.19.158 | Внутренняя | Шаблоны, предложения, фильтры и тела собирающих значения циклов for и включений генерируются в собственной области, поэтому ни разу не выполнившийся цикл или ничего не пропустивший фильтр не оставляет сведений об обратных вызовах. |
| 5.19.157 | Внутренняя | Вызов с опциональным получателем генерируется в собственной области, поэтому при отсутствующем получателе аргументы не вычисляются и сведения об обратных вызовах не выходят наружу. |
| 5.19.156 | Внутренняя | Ветви if, операторов сокращённого вычисления, ?? и прямого сопоставления генерируются в собственной области, поэтому невыполненная ветвь не оставляет присваиваний обратных вызовов, влияющих на специализацию последующего кода. |
| 5.19.155 | Внутренняя | Быстрые охранники прямого сопоставления регистрируют привязки шаблона и сведения о вызове значений из Map.get в области своей ветви, входя в неё и выходя без копирования окружающего контекста. |
| 5.19.154 | Внутренняя | Необходимость понижения охранника ветви определяется с учётом окружающего контекста, поэтому охранник с кооперативным включением или функцией высшего порядка идёт по защищённому пути и в сопоставлении-инструкции, и в сопоставлении-выражении. |
| 5.19.153 | Внутренняя | Каждая итерация кооперативного цикла достигает точки планировщика сразу после охранника и привязок шаблона и до выполнения тела, что делает чередование параллельных задач детерминированным. |
| 5.19.152 | Внутренняя | Инструкционные циклы for, собирающие значения циклы for и включения обрабатывают шаблон элемента через одну общую процедуру, поэтому логика шаблона и обновление сведений больше не существуют в трёх копиях. |
| 5.19.151 | Внутренняя | Инструкционный цикл for следует тому же порядку, что и собирающий значения, беря элемент, проверяя охранник шаблона и затем связывая в области, поэтому разбор и обработка ошибок в обоих совпадают. |
| 5.19.150 | Внутренняя | Условие if в позиции инструкции понижается через общую границу выражений, поэтому условие с циклом или функцией высшего порядка вычисляется и ветвится точно так же, как на Stage 0. |
| 5.19.149 | Внутренняя | Анализ изменения массивов перечисляет все виды инструкций, которые могут его содержать, включая присваивания, циклы while, блоки using, break и return, поэтому пропущенный случай ломает сборку, а не проходит незаметно. |
| 5.19.148 | Внутренняя | Изменения массивов отслеживаются и внутри строковой интерполяции, в левой части конвейера, а также в предложениях и телах включений, поэтому и локальные, и модульные привязки читаются после такого изменения верно. |
| 5.19.147 | Внутренняя | При определении того, изменяет ли вызов массив, скобки вокруг получателя проходятся напрямую, без пересборки выражения, что уменьшает работу при компиляции. |
| 5.19.146 | Внутренняя | Присваивание простому имени, по индексу и в поле записи генерируется отдельными путями, у каждого свои проверка изменяемости, вычисление операндов, запись и обновление сведений. |
| 5.19.145 | Внутренняя | Каждое присваивание завершается одним общим шагом, обновляющим сведения о цели, поэтому изменяемые массивы и записи не остаются с устаревшими данными. |
| 5.19.144 | Внутренняя | Правая часть присваивания вычисляется непосредственно перед записью и до повторного чтения цели, поэтому присваивание, ссылающееся на собственную цель, даёт верное значение. |
| 5.19.143 | Внутренняя | Присваивания простому имени, по прямому индексу и по пути в записи вычисляют свои части в одном общем порядке, поэтому эффекты внутри присваивания происходят предсказуемо. |
| 5.19.142 | Внутренняя | Цепочка членов слева от присваивания обходится один раз и сразу даёт корневую привязку и путь к полю, заменяя повторные обходы. |
| 5.19.141 | Внутренняя | Разбирающая привязка сводит все исходы охранника шаблона к одному завершающему шагу, поэтому после прохождения охранника имена попадают в область одинаково. |
| 5.19.140 | Внутренняя | Локальные привязки, привязки входного модуля и импортированные привязки верхнего уровня генерируются одним общим путём, поэтому три случая больше не расходятся. |
| 5.19.139 | Внутренняя | Составные присваивания завершают понижение правой части до записи и до обратного чтения цели, поэтому шаги составного обновления применяются в задуманном порядке. |
| 5.19.138 | Внутренняя | ??= не вычисляет правую часть, если цель уже содержит значение, поэтому при несостоявшемся присваивании ничего из этой части не выполняется. |
| 5.19.137 | Внутренняя | Присваивание в поле записи вычисляет базовое значение и путь к полю в фиксированном порядке, что делает изменение глубоко вложенных записей согласованным. |
| 5.19.136 | Внутренняя | Присваивание по индексу массива вычисляет операнды в фиксированном порядке, поэтому индекс или значение с побочными эффектами ведёт себя так же, как на Stage 0. |
| 5.19.135 | Внутренняя | Бэкенд Python классифицирует цели присваивания отдельными путями для имён, позиций индекса и путей полей записи, отделяя вычисление операндов от самого присваивания. |
| 5.19.134 | Внутренняя | Деструктурирующие привязки в бэкенде Python проходят по одному пути, который определяет момент появления имени в области видимости, проверяет условие образца и отклоняет повторные объявления. |
| 5.19.133 | Внутренняя | Простые и деструктурирующие привязки let используют один вспомогательный путь в бэкенде Python, поэтому регистрация в локальной и глобальной области видимости не расходится. |
| 5.19.132 | Внутренняя | Составные арифметические присваивания вроде += в бэкенде Python понижаются по тому же арифметическому пути, что и обычные операторы, сохраняя точность и порядок вычисления для целых, вещественных и строковых операндов. |
| 5.19.131 | Внутренняя | Присваивания, начинающиеся с индекса и продолжающиеся полями или индексами, бэкенд Python перестраивает от самого внутреннего шага наружу. Обычная, составная и объединяющая формы повторяют порядок вычисления и сокращённое вычисление Stage 0. |
| 5.19.130 | Внутренняя | Присваивания вложенным полям записи бэкенд Python перестраивает от внутреннего поля наружу через обычные чтение поля и обновление записи, поэтому обычные, составные и объединяющие присваивания следуют порядку вычисления Stage 0. |
| 5.19.129 | Внутренняя | Составные присваивания по индексу используют в бэкенде Python тот же арифметический шаг, что переменные и поля записи, поэтому сложение целых, вещественных и строк ведёт себя так же, как на Stage 0. |
| 5.19.128 | Внутренняя | Составное присваивание по индексу в бэкенде Python читает текущее значение этой позиции до вычисления правой части. Программа, где правая часть меняет ту же позицию, даёт результат Stage 0. |
| 5.19.127 | Внутренняя | Деструктурирующий let следует одному набору правил в локальной области видимости, во входном модуле и в импортированных модулях. Вычисление значения, условие образца, проверки типа TPZ5001 и отклонение повторных привязок стали общими. |
| 5.19.126 | Внутренняя | Вложенные и локальные неизменяемые типизированные let сначала вычисляют значение и проверяют его тип до привязки имени, поэтому при несовпадении типа возникает та же ошибка TPZ5001, что и на Stage 0. |
| 5.19.125 | Внутренняя | Верхнеуровневые const и простые let порождаются одинаково во входном и импортированных модулях. Неизменяемые типизированные привязки проверяют тип во время выполнения и сообщают TPZ5001 точно так же, как Stage 0. |
| 5.19.124 | Внутренняя | Внешние и обычные импортированные модули возвращают в бэкенде Python экспорт и имя инициализатора в одном виде, поэтому оба вида собираются одним путём. |
| 5.19.123 | Внутренняя | Генерация кода для обычного импортированного модуля идёт из одного места, где готовятся входные данные, порождается тело, строится пространство имён и пишется инициализатор. |
| 5.19.122 | Внутренняя | Тело обычного импортированного модуля порождается в порядке исходного текста одним выделенным шагом, который также размещает экспорт, диагностику и вспомогательный код значений по умолчанию. |
| 5.19.121 | Внутренняя | Подготовка обычного импортированного модуля стала явным шагом, который до генерации кода фиксирует контекст, значения по умолчанию, регистрацию протоколов, получателей и функций, начальные элементы инициализации и импортированные привязки. |
| 5.19.120 | Внутренняя | Генерация кода для внешнего импортированного модуля происходит внутри одной границы, которой принадлежат ячейки функций, пространство имён, инициализатор и экспортированные результаты. |
| 5.19.119 | Внутренняя | Экспортированные операторы сохраняются в порядке исходного текста при разборе модуля, поэтому подготовка экспорта внешнего модуля больше не обходит приватные операторы. |
| 5.19.118 | Внутренняя | Верхнеуровневые объявления импорта сохраняются в порядке исходного текста при разборе модуля, и подготовка привязок импортированных модулей читает готовый список напрямую, а не ищет по исходному тексту заново. |
| 5.19.117 | Внутренняя | Верхнеуровневые объявления функций сохраняются в порядке исходного текста при разборе модуля, и регистрация функций и сведения о типе возврата читают только эту общую запись. |
| 5.19.116 | Внутренняя | Имена протоколов и их реализации для получателей сохраняются в порядке исходного текста при разборе модуля, что убирает три повторных прохода по исходному тексту при регистрации и подготовке. |
| 5.19.115 | Внутренняя | Имена верхнеуровневых const и let собираются один раз в упорядоченный список, и таблицы методов получателей строятся из него без ещё одного прохода по исходному тексту. |
| 5.19.114 | Внутренняя | Число имён на уровне модуля и привязки каждого оператора собираются за один проход для областей видимости значений записи по умолчанию, поэтому одни и те же образцы не разбираются дважды. |
| 5.19.113 | Внутренняя | Значения по умолчанию для экспортированных неизменяемых let в импортированном модуле выводятся прямо из уже собранных сведений, без повторного обхода разобранного дерева и поэлементного поиска. |
| 5.19.112 | Внутренняя | Имена рантайма и изменяемых let для каждого оператора хранятся в порядке исходного текста, поэтому переход между областями видимости больше не перечитывает разобранные образцы. |
| 5.19.111 | Внутренняя | Количество верхнеуровневых функций, const и let подсчитывается во время прохода, который уже читает модуль, что убирает отдельные предварительные проходы для вспомогательных областей видимости. |
| 5.19.110 | Внутренняя | Решение о том, какие имена активны при входе в оператор и выходе из него, принимает сама область видимости значений записи по умолчанию, а построение записей, новых типов, перечислений и псевдонимов вынесено в отдельные шаги. |
| 5.19.109 | Внутренняя | Записи, новые типы, перечисления, псевдонимы схем JSON, области видимости импорта и реализации получателей собираются в порядке исходного текста за один проход по модулю. |
| 5.19.108 | Внутренняя | Вспомогательные области видимости для значений записи по умолчанию считают привязки рантайма один раз и накапливают ранее встреченные изменяемые имена по ходу движения, что оставляет два линейных прохода. |
| 5.19.107 | Внутренняя | Псевдонимы типов схем JSON и области видимости импорта собираются вместе с именованными определениями типов за один проход, поэтому после составления каталога разобранное дерево не читается снова. |
| 5.19.106 | Внутренняя | Каталог записей, новых типов и перечислений используется совместно без копирования и дублируется только при добавлении импортированных значений по умолчанию. |
| 5.19.105 | Внутренняя | Сведения об объявлении и методах получателя присоединяются к записям, новым типам и перечислениям при построении каталога, поэтому каждый последующий потребитель не повторяет эту работу. |
| 5.19.104 | Внутренняя | Базовые таблицы записей, новых типов и перечислений строятся один раз на модуль, и входной модуль и генерация схем выводятся из этих же таблиц. |
| 5.19.103 | Внутренняя | Поля записей, их значения по умолчанию и вспомогательные элементы строятся один раз на модуль и переиспользуются всеми, кому они нужны. |
| 5.19.102 | Внутренняя | Кандидаты в члены пространства имён для значений записи по умолчанию собираются по каждой записи за один входной проход и сверяются после сборки каталога, без повторного чтения разобранного дерева. |
| 5.19.101 | Внутренняя | Ранее встреченные неизменяемые привязки let и ссылки на значения рантайма по умолчанию для каждой записи вычисляются за один входной проход и используются совместно генерацией входного модуля, схем и классов. |
| 5.19.100 | Внутренняя | Собственные и экспортированные значения const вычисляются в порядке исходного текста за один проход, а обращение к другому модулю читает его общий список напрямую. |
| 5.19.99 | Внутренняя | Привязки импорта по умолчанию и имена значений рантайма по умолчанию собираются за один проход по модулю вместо двух отдельных построений каталога и повторных чтений исходного текста. |
| 5.19.98 | Внутренняя | Имена неизменяемых верхнеуровневых let и экспортированных const и let вычисляются за один обход, и анализ значений рантайма по умолчанию и анализ скрытых ссылок читают один и тот же результат. |
| 5.19.97 | Внутренняя | Идентичности импорта, локальные имена и индексы поиска выводятся один раз на единицу компиляции, и анализы совместно используют этот каталог с сохранённым порядком исходного текста. |
| 5.19.96 | Внутренняя | Сбор значений по умолчанию у выбранных импортированных const использует общую проверку однозначной привязки, поэтому одно правило определяет, сколько раз может быть привязано верхнеуровневое имя. |
| 5.19.95 | Внутренняя | Сколько раз привязано каждое верхнеуровневое имя, подсчитывается один раз на модуль, и обработка импорта и анализ скрытых ссылок читают одни и те же числа. |
| 5.19.94 | Внутренняя | Набор имён экспортированных const и let с одной привязкой вычисляется один раз на модуль, что избавляет от повторных проходов по исходному тексту. |
| 5.19.93 | Внутренняя | Имена верхнеуровневых неизменяемых let, доживающих до времени выполнения, вычисляются один раз на модуль, и анализ скрытых ссылок и анализ значений рантайма по умолчанию обращаются к одному общему набору. |
| 5.19.92 | Внутренняя | Скрытые ссылки рантайма в импортированных модулях прослеживаются через наложенные представления поверх существующих таблиц имён, а не через их временные копии. |
| 5.19.91 | Внутренняя | Ссылки рантайма, которые делают значения записи по умолчанию, вычисляются один раз на модуль и используются совместно генерацией определений, схем и классов. |
| 5.19.90 | Внутренняя | Значения верхнеуровневых и экспортированных const, нужные значениям записи по умолчанию, вычисляются один раз на модуль и передаются всем последующим этапам без копирования. |
| 5.19.89 | Внутренняя | Импортированные и собственные const собираются в одну упорядоченную последовательность для значений записи по умолчанию, которую напрямую читают локальные определения и генерация экспорта. |
| 5.19.88 | Внутренняя | Наборы заблокированных имён и заполнители конвейера внутри блоков concurrent используются совместно, а не копируются, поэтому вход в ветвь не дублирует эти коллекции. |
| 5.19.87 | Внутренняя | Бэкенд Python держит по одной таблице на лексическую область видимости и копирует её только при её реальном изменении, а не дублирует весь стек заранее. |
| 5.19.86 | Внутренняя | Разрешённые имена модулей используются в бэкенде Python напрямую для идентификации исходного текста и схем, поэтому они больше не создаются заново при каждом копировании контекста. |
| 5.19.85 | Внутренняя | Таблицы диспетчеризации функций, методов, протоколов и пространств имён в бэкенде Python используются совместно и копируются только при изменении, что удешевляет вход в ветвь. |
| 5.19.84 | Внутренняя | Временные контексты получателей и протоколов в бэкенде Python переиспользуют идентичность модуля вызывающей стороны и общие таблицы типов, поэтому копия ветви остаётся лёгкой копией ссылок. |
| 5.19.83 | Внутренняя | Таблицы имён значений для методов получателей импортированных модулей используются совместно, а не копируются целиком при подготовке модулей и генерации методов. |
| 5.19.82 | Внутренняя | Контексты входного, внешнего и импортированного модулей в бэкенде Python читают таблицы псевдонимов модулей, принадлежащие проверяющему, напрямую, поэтому создание контекста больше не копирует эти таблицы. |
| 5.19.81 | Внутренняя | Таблицы определений записей переносятся в контекст генерации кода Python один раз, а списки задач для вспомогательного кода значений по умолчанию ссылаются на существующие имена и выражения исходного текста вместо копирования целых деревьев. |
| 5.19.80 | Внутренняя | Поиск специализаций обобщённых типов идёт через один индекс на нативном пути, а порождённое имя Rust для каждой специализации запоминается и не создаётся заново. |
| 5.19.79 | Внутренняя | Построение имени Rust для специализации обобщённого типа больше не копирует аргументы типов и не создаёт временный список для их объединения. |
| 5.19.78 | Внутренняя | Имена параметров нативных функций берутся прямо из исходного текста и используются совместно, поэтому специализации обобщённых типов больше не копируют список имён. |
| 5.19.77 | Внутренняя | Параметры обобщённых типов и именованные параметры вызова разрешаются прямо из исходного текста и самого объявления, без пересоздания временных списков имён. |
| 5.19.76 | Внутренняя | Поиск специализаций обобщённых типов читает имена и аргументы типов на месте через вложенный индекс, поэтому для каждого обращения не создаются строки и списки ключей. |
| 5.19.75 | Внутренняя | Сигнатуры обычных и обобщённых функций хранятся один раз и используются совместно, поэтому генерация тела функции или места вызова больше не копирует сигнатуру целиком. |
| 5.19.74 | Внутренняя | Полностью нативные сборки получают собственную таблицу активных функций, а гибридные используют общую, что убирает копирование этой таблицы для каждой функции. |
| 5.19.73 | Внутренняя | Гибридные функции читают заранее вычисленные сведения по каждому модулю, поэтому записи модулей больше не фильтруются и не копируются для каждой функции. |
| 5.19.72 | Внутренняя | Один индекс типизированных локальных переменных используется всеми контекстами, поэтому гибридные функции больше не копируют его каждая. |
| 5.19.71 | Внутренняя | Нативный поиск типизированных локальных переменных читает имя на месте из одного индекса, указывающего обратно в исходный текст, поэтому строка для каждого обращения не создаётся. |
| 5.19.70 | Внутренняя | Результаты последнего прохода, определяющего пригодность функций к гибридной компиляции, попадают прямо в план сборки, поэтому уцелевшие кандидаты не порождаются повторно. |
| 5.19.69 | Внутренняя | Кандидаты для гибридной компиляции собираются за один проход в таблицы по модулям, упорядоченные по месту в исходном тексте, что убирает повторную фильтрацию и копирование полного списка кандидатов. |
| 5.19.68 | Внутренняя | Решения о гибридной сборке для каждой функции записываются в один индекс по модулю и позиции в исходном тексте, поэтому их вывод больше не обходит разобранное дерево и не пересоздаёт ключи модулей. |
| 5.19.67 | Внутренняя | Бэкенд Rust строит отчёт о выборе по тому же плану, из которого идёт генерация, и передаёт план генератору один раз, поэтому план целиком больше не копируется. |
| 5.19.66 | Внутренняя | Планы замыканий в бэкенде Rust хранятся по иерархии модуль, функция, участок, поэтому выбор и генерация находят план напрямую, не собирая текстовый ключ на каждый поиск. |
| 5.19.65 | Внутренняя | Читатель JSON IR строит индекс операций поверх уже разобранных строк документа, поэтому нужные идентификаторы операций попадают в готовую программу без копирования текста при каждом поиске. |
| 5.19.64 | Внутренняя | Операции JSON и компактного IR проверяются на минимальную структуру операндов прямо при декодировании, а ссылки по индексам сверяются там же, поэтому испорченная программа отклоняется во время чтения, а не при втором проходе после сборки. |
| 5.19.63 | Внутренняя | Потребность программы в услугах хоста определяется один раз при декодировании IR по разрешённым идентификаторам встроенных вызовов, поэтому операции не пересматриваются, а пользовательский метод с именем встроенного не принимается за встроенный. |
| 5.19.62 | Внутренняя | Запуск на целевой платформе с доступом к хосту разбирает полезную нагрузку IR один раз, и одна разобранная программа используется и маршрутизацией хост-эффектов, и выполнением. |
| 5.19.61 | Внутренняя | Продукты целевых платформ без хоста и их канонические экспорты работают в потоках с ограниченной областью, которые читают полезную нагрузку IR, аргументы, стандартный ввод и данные адаптера прямо у вызывающей стороны, а не по копии. |
| 5.19.60 | Внутренняя | Рантаймы компилятора Stage 1 и Stage 2 работают в потоках с ограниченной областью и читают байты запроса на месте, поэтому раунд обмена фактами больше не копирует весь запрос. |
| 5.19.59 | Внутренняя | Раунды обмена фактами в компиляторе Stage 2 читают закэшированную подготовленную программу на месте и копируют только дескриптор программы, не дублируя оборачивающие идентификаторы. |
| 5.19.58 | Внутренняя | Продукт самокомпиляции фиксируется сразу после сборки и доступен только на чтение, поэтому потребители не пересчитывают хеши одних и тех же полей, а исходные байты ответа не удерживаются. |
| 5.19.57 | Внутренняя | Продукт самокомпиляции больше не хранит режим языка отдельной строкой. Идентификаторы вызова и манифесты продукта берут версию языка из запроса понижения по одному общему пути. |
| 5.19.56 | Внутренняя | Поля схемы, дублировавшиеся в каждом продукте самокомпиляции, убраны. Кодировщик пишет канонические константы схемы напрямую, а проверка входящих значений сохранена. |
| 5.19.55 | Внутренняя | Поля отката убраны из продукта самокомпиляции, поскольку самоприменимый компилятор никогда не откатывается к целевым компиляторам. В манифестах и записях происхождения политика отката по-прежнему указана явной константой. |
| 5.19.54 | Внутренняя | Статус и число раундов обмена фактами хранятся только в одной части продукта самокомпиляции, а манифесты и прочие потребители получают их одним и тем же способом. |
| 5.19.53 | Внутренняя | Сгенерированный Rust хранится в продукте самокомпиляции в одном месте и выдаётся по ссылке, поэтому проверки, сверявшие продукт с его же копией, больше не нужны. |
| 5.19.52 | Внутренняя | Дублирующая копия JSON фронтенда верхнего уровня удалена из продукта самокомпиляции, и остаётся одно место хранения. |
| 5.19.51 | Внутренняя | Типизированные результаты переиспользуют уже разобранный документ фронтенда, поэтому предпросмотр компилятора из командной строки и сборка самоприменимого продукта не разбирают JSON фронтенда повторно. |
| 5.19.50 | Внутренняя | Проверенные ответы Stage 1 и документы фронтенда сохраняются в готовом результате, поэтому понижение и сборка продукта переиспользуют их, а не разбирают сериализованный JSON заново. |
| 5.19.49 | Внутренняя | Пути токенов, разрешения имён, типизированного продукта и управления Stage 1 читают ответы фронтенда по одному перечню полей и одному разборщику JSON и схемы, а байтовый ввод везде проходит одну проверку UTF-8. |
| 5.19.48 | Внутренняя | Типизированные продукты читают ответы Stage 1 тем же разборщиком, что и пониженный и сгенерированный маршруты, включая UTF-8, JSON, корневые поля и схему обмена. |
| 5.19.47 | Внутренняя | Все маршруты, которые ведут компилятор, продвигают раунд обмена фактами одинаково, включая порядок запросов, пустые раунды, монтирование, уже отвеченные запросы и подачу фактов. |
| 5.19.46 | Внутренняя | Stage 2 по-прежнему перекодирует запись неподвижной точки как канонический способ записи наблюдений, а публичная подача фактов Stage 1 перешла на общие документы ответов и общий ход раундов, поэтому нагрузка не копируется. |
| 5.19.45 | Внутренняя | При приёме сгенерированного образа компилятора вместе проверяются схема, статус неподвижной точки, политика отката и происхождение, и в записи видно, создан ли образ загрузочным компилятором или ступенью Stage 1. |
| 5.19.44 | Внутренняя | Байты манифеста, метки и образы программ обоих сгенерированных компиляторов собраны в один перечень, и каждая ступень работает со своими артефактами одинаково. |
| 5.19.43 | Внутренняя | Разбор схемы, числовых значений и дайджестов для обоих сгенерированных манифестов компилятора собран в один типизированный дескриптор образа. |
| 5.19.42 | Внутренняя | Кодировщики продуктов Stage 1 и Stage 2 принимают своих производителей по одинаковым правилам и одинаково формируют список файлов компилятора, шаблон рантайма и поля исходников целевой платформы. |
| 5.19.41 | Внутренняя | Имена шаблонов рантайма и их дайджесты задаются в самоприменимом фронтенде в одном месте, и кодировщик больше не принимает дайджест от вызывающей стороны. |
| 5.19.40 | Внутренняя | Манифесты и наблюдения Stage 2 создаются прямо из проверенного продукта, а версия языка и сгенерированный Rust читаются на месте. Промежуточный результат не пересобирается, а JSON фронтенда, ответы и исходники не копируются. |
| 5.19.39 | Внутренняя | Все самоприменимые рантаймы целевых платформ, с хостом и без него, получают принятый продукт, полезную нагрузку IR и данные адаптера через один вход рантайма, а отдельные неиспользуемые точки входа для IR удалены. |
| 5.19.38 | Внутренняя | Фасад Rust берёт явную функцию main и список экспортов, вызываемых хостом, прямо из данных входного модуля и больше не пересматривает пониженную программу ради того же списка. |
| 5.19.37 | Внутренняя | Данные адаптера вычисляются один раз и переиспользуются экспортами входа и фасадом Rust на самоприменимых маршрутах Web и сервиса, а целевая платформа Python получает их вместе с JSON IR одним входом рантайма. |
| 5.19.36 | Внутренняя | Структура, происхождение и статус завершения принятого продукта самокомпиляции проверяются в одном месте, которым пользуются и адаптеры целевых платформ, и полезные нагрузки рантайма. |
| 5.19.35 | Внутренняя | Проверка структуры и происхождения продукта самокомпиляции отделена от кодирования манифеста, поэтому выполнение и наблюдение не создают манифесты ради того, чтобы их выбросить, а кодировщик не разбирает собственный вывод. |
| 5.19.34 | Внутренняя | Типизированный, пониженный и сгенерированный прогоны сверяют состояние, диагностику и вывод одной общей проверкой, а режим языка, набор исходников целевой платформы, идентификаторы вызова и результата берутся из одной явной записи. |
| 5.19.33 | Внутренняя | Идентификатор набора исходников целевой платформы вычисляется прямо по полям в каноническом порядке, без промежуточных массивов строк, а порядок модулей, содержимое, дубликаты идентификаторов и правило единственной точки входа проверяются при создании исходников. |
| 5.19.32 | Внутренняя | Чтение итогового сгенерированного ответа вынесено в отдельный шаг с собственной входной записью, куда собраны статус завершения, перечень неподдерживаемого, бюджеты сгенерированного Rust, происхождение и сборка результата. |
| 5.19.31 | Внутренняя | Сгенерированный ответ декодируется в пониженный результат за один шаг, потому что построение результата больше не переплетено с ведением раундов фактов. Запрос не перекодируется, искусственный вызов не создаётся, ответ не копируется. |
| 5.19.30 | Внутренняя | Пониженный и сгенерированный маршруты Stage 1 используют одни и те же поля ответа, одно декодирование UTF-8, JSON, объектов и схемы и одни конверты статуса и запросов, а объекты JSON передаются по ссылке, без копирования больших массивов. |
| 5.19.29 | Внутренняя | Пониженный маршрут Stage 0 и сгенерированный маршрут Stage 1 проходят одинаковые переходы состояний при запросе фактов, одинаково обрабатывая пустые, неупорядоченные, повторные и уже отвеченные запросы, и берут происхождение из одного источника. |
| 5.19.28 | Внутренняя | Разборщик обмена Stage 1 внутри Stage 0 разделён на отдельные части для модулей, массивов операций и строк, перечня неподдерживаемого и согласования статуса, а также идентификаторов происхождения и набора исходников. |
| 5.19.27 | Внутренняя | Из самоприменимого обмена Stage 1 удалена неиспользуемая публичная запись, а импорты типов, нужные вложенным полям происхождения, сохранены. |
| 5.19.26 | Внутренняя | Предпросмотр замкнутых целых в самоприменимом генераторе хранит одно отображение идентификатора операции на операцию вместо параллельного массива и индекса. Правила выбора и вид предпросмотра не изменились. |
| 5.19.25 | Внутренняя | Вызовы с распаковкой и именованными аргументами в сгенерированном рантайме раскрывают значение в массив один раз и передают его во все ветви. Если параметр по умолчанию подставить нельзя, возвращается стандартная ошибка числа аргументов, а проверка получателя в интерпретаторе следует одной классификации. |
| 5.19.24 | Внутренняя | Встроенные функции как значения в сгенерированном Rust принимают аргументы в общих точных формах, поэтому лишние проверки числа аргументов и оборачивающие слои убраны. Необязательные аргументы ByteBuffer и Zstd преобразуются по форме, а несовпадение даёт структурированную ошибку рантайма. |
| 5.19.23 | Внутренняя | Интерпретатор и сгенерированный рантайм делят один набор точных преобразований аргументов. Встроенные функции высшего порядка и пространств имён принимают от нуля до трёх аргументов напрямую, а необязательные аргументы ByteBuffer и Zstd преобразуются по форме и без значения по умолчанию дают структурированную ошибку. |
| 5.19.22 | Внутренняя | Вызовы встроенных членов и методов ресурсов хоста принимают от нуля до четырёх аргументов в порядке вызова, проверяя их число и передавая владение за один шаг. round и div у Decimal преобразуют необязательные аргументы для всех форм, поэтому в диспетчеризации нет достижимых аварийных остановок. |
| 5.19.21 | Внутренняя | Вызовы Test и Лиспекса проверяют число аргументов и передают владение за один шаг, а сообщения об ошибках числа аргументов для обратных вызовов Stage 1 и разбора дат ISO стали точнее. Бэкенды Rust и Python согласованы по значениям входного модуля, методам получателя и протокола и по поиску. |
| 5.19.20 | Внутренняя | Таблицы идентификаторов Unicode генерируются типизированными записями диапазонов, поэтому поиск, решающий, допустим ли символ в идентификаторе, проверяется по типам. Метка конца ввода больше не считается однобайтовым символом. |
| 5.19.19 | Внутренняя | Закрывающие токены, которые самоприменимый лексер вставляет при восстановлении после ошибки, помечаются как синтетические и сохраняют это происхождение до конца потока разметки. Состояние разметки индексируется напрямую там, где длина гарантирована, вместо отката, скрывающего ошибку. |
| 5.19.18 | Внутренняя | Строка в тройных кавычках, вложенная в однострочную интерполяцию, больше не обходит правило переноса строки. Оба лексера закрывают вложенную строку и интерполяцию на первом переносе и сообщают TPZ0003 в позиции начала внешней строки. |
| 5.19.17 | Внутренняя | Экспортируемые значения, записи, перечисления и новые типы на поверхности модулей 5.20 несут полную именную форму как канонический идентификатор, поэтому выборочный импорт и импорт пространства имён проверяют члены по этим данным, не занося невыбранные имена в область видимости. |
| 5.19.16 | Внутренняя | Вызов встроенной функции как значения сверяет число аргументов с одной таблицей, поэтому точные, необязательные и вариативные вызовы дают одинаковую ошибку. Чтение ещё не заданной экспортированной привязки верхнего уровня в сгенерированном Rust возвращает стандартную ошибку несвязанного значения вместо подставного. |
| 5.19.15 | Внутренняя | Оба компилятора доверяют идентификатору, установленному разрешением имён, поэтому пользовательская запись или функция с именем члена Test или FS больше не подпадает под правила встроенных пространств имён. Цели предпросмотра, кроме ast, resolved и typed, и недопустимые режимы языка отклоняются до чтения исходника. |
| 5.19.14 | Внутренняя | Именные записи, перечисления и новые типы в 5.20 разделяют публичное имя, идентификатор объявления и идентификатор метода получателя при создании, сравнении, упорядочивании, в образцах и охранах типа. Типизированные схемы JSON раскрывают псевдонимы в объявляющем модуле, и импортированные типы ведут себя одинаково на любом бэкенде. |
| 5.19.13 | Внутренняя | Версии языка и ключевые слова задаются каждое одним объявлением, из которого получаются порядок, написание и точный разбор, а селектор корпуса использует этот парсер с явным потолком 5.7. topaz run сохраняет семантику замороженного однофайлового маршрута 5.1 и модульного маршрута 5.2 и новее. |
| 5.19.12 | Внутренняя | Публичный снимок исходников воспроизводит дерево одного коммита без исключений и записывает идентификаторы коммита, дерева и блобов, права на исполнение, длины в байтах и дайджесты SHA-256 в манифест вне полезной нагрузки. Корневые LICENSE, NOTICE и THIRD-PARTY-NOTICES.md проверяются. |
| 5.19.11 | Внутренняя | Топаз публикуется под Apache-2.0, а в корне репозитория лежат LICENSE и NOTICE. Все 40 пакетов Cargo и 4 пакета Node, принадлежащие Топазу, объявляют эту лицензию, лицензии 165 включённых пакетов Rust вынесены в отдельный перечень, и каждый путь в дереве классифицирован. |
| 5.19.10 | Внутренняя | Дополнение членов в редакторе предлагает stringify, parseAs, decode и parse из пространства имён JSON, которых в прежнем списке не было. Оба проверяющих читают один каталог встроенных пространств имён и принимают вызываемые статические члены и значения RoundingMode с одинаковой диагностикой. |
| 5.19.9 | Внутренняя | Псевдоним вызываемого имени сохраняет число обобщённых параметров, имена параметров и значения по умолчанию. Оба компилятора одинаково диагностируют целочисленное деление, остаток, смену знака, арифметическое переполнение и порядок инициализации на верхнем уровне, а немедленная инструкция отклоняет привязку, объявленную позже. |
| 5.19.8 | Внутренняя | Оба компилятора согласованы в выводе типа возврата, когда он опущен, включая Result, Option, соединение пустых массивов и рекурсию, а также в привязке обобщённых вызовов, инициализации using File, обычном, ??= и арифметическом присваивании и ожидаемом типе внутри if и match. |
| 5.19.7 | Внутренняя | Оба компилятора согласованы в управлении циклами с метками и с результирующим значением через границы функций, лямбд и включений, а также в покрытии образцов, включая маску, привязку, литерал, тип, конструктор, список, запись и or-образцы, с диагностикой невозможных образцов и полнотой match на замкнутой области. |
| 5.19.6 | Внутренняя | Интерпретатор Лиспекса покрывает все 205 строк возможностей из исходника, из сгенерированного Rust и Python, в Web и из установленного продукта Топаз. Программа совпадает по статусу, байтам вывода, диагностике, предупреждениям, коду выхода, значениям и ресурсам на всех пяти маршрутах. |
| 5.19.5 | Внутренняя | Процедуры высшего порядка Лиспекса all?, any?, filter, fold-left, fold-right, for-each, map, reduce, string-for-each, string-map, vector-for-each и vector-map завершены, и интерпретатор покрывает все 205 строк возможностей без неподдерживаемых. |
| 5.19.4 | Внутренняя | Тридцать шесть возможностей Лиспекса для символов, строк и вывода готовы, и поддержка выросла со 157 до 193 из 205 строк. Полное преобразование регистра строк учитывает греческую конечную сигму и отображения с изменением длины, а display, write, newline и println выводятся в правильном порядке. |
| 5.19.3 | Внутренняя | Тридцать девять возможностей Лиспекса для списков и поиска готовы, это 28 составных обращений вида c...r плюс assoc, assq, assv, list-copy, list-first, list-ref, list-rest, list-tail, make-list, memv и nth. Поддержка выросла со 118 до 157 из 205 строк. |
| 5.19.2 | Внутренняя | Тридцать четыре числовые возможности Лиспекса готовы, включая варианты целочисленного деления, преобразование точных и неточных чисел, округление, gcd и lcm, возведение в степень, точный целочисленный квадратный корень и числовые предикаты. Поддержка выросла с 84 до 118 из 205 строк. |
| 5.19.1 | Внутренняя | Исправлена корректность самоприменимого фронтенда в разрешении имён, идентификаторах Unicode, контекстной типизации, захватах и диагностике. Stage 2 и сборка плейграунда для WASM генерируются один раз перед запуском проверяющего, а описания продукта и общая терминология согласованы на английском, корейском и русском. |