В этом выпуске представлено 5 месяцев работы: изменения от 206 разных участников, распределенные по 925 коммитам.

Изначально предполагалось, что этот цикл выпуска будет короче, но в итоге он оказался довольно продолжительным. Была переработана система сборки, в том числе добавлен протокол сервера сборки, а компоновщик ELF был усовершенствован до такой степени, что мы ожидаем, что инкрементальная компиляция будет работать для всех пользователей x86_64-linux.

Поддерживаемые архитектуры

Zig поддерживает широкий спектр архитектур и операционных систем. В разделах Таблица поддержки и Дополнительные платформы перечислены платформы, для которых Zig может создавать программы, а в zig-bootstrap README — платформы, для которых можно легко выполнить кросс-компиляцию самого компилятора Zig.

Заметные изменения

  • aarch64-openbsd теперь изначально тестируется в CI Zig, обеспечивая высококачественную поддержку в будущем.
  • Задания CI для aarch64-freebsd и aarch64-netbsd теперь выполняются не только при пуше в master, но и при pull-реквестах.
  • Обходной путь для ошибки LLVM, которая сломала большинство двоичных файлов aarch64-windows, включая Zig компилятор.
  • Компилятор Zig теперь применяет обязательные методы защиты кода при работе с aarch64-openbsd, чтобы полученные двоичные файлы действительно работали.
  • Теперь Zig предоставляет трассировку стека при сбоях и неудачных проверках на 32-битных процессорах ARM. Для платформ, поддерживающих только формат Thumb, еще предстоит проделать работу.
  • Теперь Zig предоставляет трассировку стека при сбоях и неудачных проверках утверждений на SPARC.
  • Теперь Zig обрабатывает коды операций аутентификации указателей при раскручивании стека на AArch64.
  • Добавлена поддержка целевых платформ loongarch32-linux-gnu[sf].
  • Теперь Zig поддерживает 64-битные системы SPARC, особенно sparc64-linux. Во многом это стало возможным благодаря новому компоновщику Zig для ELF, который теперь лучше поддерживает эту платформу, чем LLD.
  • Стандартная библиотека Zig была портирована на ABI x32 и N32 для x86-64 и 64-битных процессоров MIPS соответственно. Это нишевые ABI ILP32, которые позволяют использовать 64-битный набор команд при наличии только 32-битных указателей. Идея заключается в том, чтобы пожертвовать доступным адресным пространством ради меньшего потребления памяти и более эффективного использования кэша.
  • Для некоторых игровых консолей добавлена информация о целевых платформах: aarch64-switch, arm-gba, mipsel-psx и powerpc-wiiu.
  • В Zig добавлена поддержка очень ранней версии xtensa-linux. Обратите внимание, что на данный момент эта поддержка доступна только через бэкенд C или экспериментальный бэкенд LLVM.
  • Стандартная библиотека Zig теперь поддерживает arc[eb]-linux, csky-linux и m88k-openbsd при использовании бэкенда C.
  • Стандартная библиотека Zig теперь поддерживает microblaze[el]-linux, sh[eb]-linux и sparc-linux без использования библиотеки libc.
  • Теперь Zig принудительно использует -mabi=ieeelongdouble для всех платформ PowerPC. Это лишь формализация того, что и так было реальностью: Zig никогда не поддерживал формат IBM «double-double» для long double и, скорее всего, никогда не будет его поддерживать. В результате в этом выпуске прекращена поддержка powerpc-linux-gnueabi[hf], поскольку glibc поддерживает на этих платформах только формат «double-double». Платформы powerpc-linux-musleabi[hf] по-прежнему поддерживаются, поскольку они используют формат IEEE.
  • В этом выпуске прекращена поддержка powerpc64-linux-gnu. Zig всегда поддерживал только компоновку двоичных файлов ELFv2 для 64-битных процессоров PowerPC, а glibc официально не поддерживает ELFv2 с порядком байтов от старшего к младшему, а также IEEE long double, как указано выше.
  • Способность Zig определять модель и характеристики центрального процессора была значительно улучшена. Это касается практически всех архитектур во всех поддерживаемых операционных системах.
  • Базовая модель процессора была изменена для некоторых целевых архитектур:
    • aarch64-haiku: cortex_a55
    • m68k-*: M68030
    • mips64-openbsd: octeon
    • powerpc-netbsd: 750
    • powerpc64-freebsd: pwr8
    • powerpc64-linux: pwr8
    • powerpc64-openbsd: pwr9
    • s390x-*: arch11
    • sparc-*: generic
    • sparc-linux: v9
    • sparc64-*: ultrasparc
    • xtensa-*: esp32
  • В синтаксисе запросов для целевой платформы Zig автоматическое определение версии нативной libc теперь выполняется только в том случае, если в тройке (target triple) действительно используется нативная libc (то есть компонент ABI опущен). Мы полагаем, что такое поведение лучше соответствует интуитивному представлению пользователей о работе запросов целевой платформы — особенно с учетом того, как обрабатывается компонент ОС.

Система уровней поддержки

Уровень поддержки Zig для различных целей делится на четыре уровня (Tier), где Tier 1 — самый высокий. Цель — чтобы для Tier 1 целей не было отключённых тестов. После релиза 1.0.0 это станет обязательным требованием.

Tier 1

  • Все неэкспериментальные функции языка работают корректно.
  • Компилятор может генерировать машинный код для этой платформы без использования LLVM.
  • Встроенный фаззер работает на этой платформе (если применимо).

Tier 2

  • Кроссплатформенные абстракции Стандартной библиотеки имеют реализации для этой цели.
  • В случае неудачных проверок и сбоев на этой цели создаются трассировки стека.
  • libc доступна для этой цели даже при кросс-компиляции (если применимо).
  • CI процессы выполняют сборку тестов модуля для этой цели при каждом пуше.

Tier 3

  • Компилятор может генерировать машинный код для этой цели, используя внешний бэкенд, например LLVM.
  • Компоновщик может создавать объектные файлы, библиотеки и исполняемые файлы для этой цели.

Tier 4

  • Компилятор может сгенерировать ассемблерный или исходный код на языке C для этой цели.

Таблица поддержки

В следующей таблице ✅ означает полную поддержку, ❌ — отсутствие поддержки, ⚠️ — частичную поддержку (например, только для некоторых подцелей или с известными проблемами). ❔ означает, что статус в основном неизвестен, обычно потому что цель редко тестируется. Наведите курсор на другие значки для получения подробностей.

Объекты, отмеченные 🪦, являются устаревшими. Компилятор Zig и стандартная библиотека поддерживают их по мере возможности, но со временем эта поддержка будет прекращена.

Уровень Цель Компилятор Компоновщик Язык Стд. библ. Трасс. стека Fuzzer libc CI
1 x86_64-linux 🖥️⚡ ✅ ✅ ✅ ✅ ✅ ✅ ✅
* * *
2 aarch64-freebsd 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 aarch64[_be]-linux 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 aarch64-maccatalyst 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 aarch64-macos 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 aarch64[_be]-netbsd 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 aarch64-openbsd 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 aarch64-windows 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 arm-freebsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 arm[eb]-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 arm[eb]-netbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 arm-openbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 hexagon-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 loongarch32-linux 🖥🛠 ✅ ❔ ✅ ✅ ❌ ✅ ⚠️
2 loongarch64-linux 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 mips[el]-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 mips[el]-netbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 mips64[el]-linux 🖥️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 mips64[el]-openbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 powerpc-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 powerpc-netbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 powerpc-openbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 powerpc64[le]-freebsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 powerpc64[le]-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 powerpc64-openbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 riscv32-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 riscv32-netbsd 🖥️ ✅ ✅ ✅ ✅ ✅ ✅ ⚠️
2 riscv64-freebsd 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ⚠️
2 riscv64-linux 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 riscv64-netbsd 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ⚠️
2 riscv64-openbsd 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 s390x-linux 🖥️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 sparc64-linux 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 thumb[eb]-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 wasm32-wasi 🖥️🛠️ ✅ ✅ ✅ ⚠️ ❌ ✅ ✅
2 x86-linux 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 x86-netbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 x86-openbsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ⚠️
2 🪦 x86-windows 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 x86_64-freebsd 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 🪦 x86_64-maccatalyst 🖥️⚡ ✅ ✅ ✅ ✅ ✅ ✅ ⚠️
2 🪦 x86_64-macos 🖥️⚡ ✅ ✅ ✅ ✅ ✅ ✅ ⚠️
2 x86_64-netbsd 🖥️🛠️ ✅ ✅ ✅ ✅ ✅ ✅ ✅
2 x86_64-openbsd 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
2 x86_64-windows 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ✅ ✅
* * *
3 aarch64-haiku 🖥️🛠️ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
3 aarch64-ios 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ❌️ ❌️
3 aarch64-serenity 🖥️🛠️ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
3 aarch64-tvos 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ❌️ ❌️
3 aarch64-visionos 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ❌️ ❌️
3 aarch64-watchos 🖥️🛠️ ✅ ✅ ✅ ✅ ❌ ❌️ ❌️
3 arm-haiku 🖥️ ✅ ✅ ✅ ✅ ❌ ❌️ ❌️
3 mips64[el]-netbsd 🖥️ ✅ ✅ ✅ ❌️ ✅ ❌️ ❌️
3 riscv64-haiku 🖥️🛠️ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
3 riscv64-serenity 🖥️🛠️ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
3 🪦 thumb-windows 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ❌️
3 wasm64-wasi 🖥️🛠️ ✅ ❔ ❌️ ⚠️ ❌ ❌️ ❌️
3 🪦 x86-freebsd 🖥️ ✅ ✅ ✅ ✅ ❌ ✅ ❌
3 x86-haiku 🖥️ ✅ ✅ ✅ ✅ ❌ ❌️ ❌️
3 🪦 x86-illumos 🖥️ ✅ ✅ ✅ ✅ ❌ ❌️ ❌️
3 x86_64-dragonfly 🖥️🛠️ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
3 x86_64-haiku 🖥️⚡ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
3 x86_64-illumos 🖥️🛠️ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
3 x86_64-serenity 🖥️⚡ ✅ ✅ ✅ ✅ ❔ ❌️ ❌️
* * *
4 alpha-linux 📄 ❌️ ❔ ✅ ✅ ❌ ❌️ ❌️
4 alpha-netbsd 📄 ❌️ ❔ ✅ ✅ ❌ ❌️ ❌️
4 alpha-openbsd 📄 ❌️ ❔ ✅ ✅ ❌ ❌️ ❌️
4 arc[eb]-linux 📄 ❌️ ❔ ✅ ✅ ❌ ✅ ❌️
4 csky-linux 📄 ❌️ ❔ ✅ ✅ ❌ ✅ ❌️
4 hppa-linux 📄 ❌️ ❔ ❌️ ❌️ ❌ ❌️ ❌️
4 hppa-netbsd 📄 ❌️ ❔ ✅ ❌️ ❌ ❌️ ❌️
4 hppa-openbsd 📄 ❌️ ❔ ✅ ❌️ ❌ ❌️ ❌️
4 hppa64-linux 📄 ❌️ ❔ ❌️ ❌️ ❌ ❌️ ❌️
4 m68k-linux 🖥️ ❌️ ❔ ✅ ✅ ❌ ✅ ❌️
4 m68k-netbsd 🖥️ ❌️ ❔ ✅ ✅ ❌ ✅ ❌️
4 m88k-openbsd 📄 ❌️ ❔ ✅ ✅ ❌ ❌️ ❌️
4 microblaze[el]-linux 📄 ❌️ ❔ ✅ ❌️ ❌ ❌️ ❌️
4 or1k-linux 📄 ❌️ ❔ ✅ ✅ ❌ ❌️ ❌️
4 sh[eb]-linux 📄 ❌️ ❔ ✅ ❌️ ❌ ❌️ ❌️
4 sh[eb]-netbsd 📄 ❌️ ❔ ✅ ❌️ ❌ ❌️ ❌️
4 sh-openbsd 📄 ❌️ ❔ ✅ ❌️ ❌ ❌️ ❌️
4 sparc-linux 🖥️ ❌️ ❔ ✅ ✅ ❌ ✅ ❌️
4 sparc-netbsd 🖥️ ❌️ ❔ ✅ ❌️ ❌ ✅ ❌️
4 sparc64-netbsd 🖥️🛠️ ⚠️ ✅ ✅ ❌️ ✅ ✅ ❌️
4 sparc64-openbsd 🖥️🛠️ ⚠️ ✅ ✅ ❌️ ❌ ✅ ❌️
4 xtensa[eb]-linux 🖥️ ❌️ ❔ ✅ ❌️ ❌ ❌️ ❌️

Требования к версиям ОС

В стандартной библиотеке Zig есть минимальные требования к версиям некоторых поддерживаемых операционных систем, что влияет и на сам компилятор.

OS Version
Darwin 15.0+
DragonFly BSD 6.4+
FreeBSD 14.0+
Linux 5.10+
NetBSD 10.1+
OpenBSD 7.8+
Windows 10+

Дополнительные платформы

Zig также поддерживает различные дополнительные цели, для которых не применяется система уровней:

  • aarch64-driverkit
  • aarch64[_be]-freestanding
  • aarch64-fuchsia
  • aarch64-hurd
  • aarch64-switch
  • aarch64-uefi
  • alpha-freestanding
  • amdgcn-amdhsa
  • amdgcn-amdpal
  • amdgcn-mesa3d
  • arc[eb]-freestanding
  • arm[eb]-freestanding
  • arm-3ds
  • arm-fuchsia
  • arm-gba
  • arm-uefi
  • arm-vita
  • avr-freestanding
  • bpf(eb,el)-freestanding
  • csky-freestanding
  • ez80-freestanding
  • ez80-tios
  • hexagon-freestanding
  • hppa[64]-freestanding
  • kalimba-freestanding
  • kvx-freestanding
  • lanai-freestanding
  • loongarch(32,64)-freestanding
  • loongarch(32,64)-uefi
  • m68k-freestanding
  • m88k-freestanding
  • microblaze[el]-freestanding
  • mips[64][el]-freestanding
  • mipsel-psx
  • mipsel-psp
  • msp430-freestanding
  • nvptx[64]-cuda
  • nvptx[64]-nvcl
  • or1k-freestanding
  • powerpc-wiiu
  • powerpc[64][le]-freestanding
  • powerpc64-ps3
  • propeller-freestanding
  • riscv(32,64)[be]-freestanding
  • riscv(32,64)-uefi
  • riscv64-fuchsia
  • riscv64-hurd
  • s390x-freestanding
  • sh[eb]-freestanding
  • sparc[64]-freestanding
  • spirv(32,64)-opencl
  • spirv(32,64)-opengl
  • spirv(32,64)-vulkan
  • spork8-freestanding
  • thumb[eb]-freestanding
  • thumb-fuchsia
  • thumb-gba
  • thumb-vita
  • ve-freestanding
  • wasm(32,64)-emscripten
  • wasm(32,64)-freestanding
  • x86[_16,_64]-freestanding
  • x86[_64]-hurd
  • x86[_64]-uefi
  • x86_64-driverkit
  • x86_64-fuchsia
  • x86_64-plan9
  • x86_64-ps4
  • x86_64-ps5
  • xcore-freestanding
  • xtensa[eb]-freestanding

Изменения в языке

Прогресс в обеспечении стабильности языка

С момента выхода Zig 0.16.0 был достигнут значительный прогресс в стабилизации языка. Это ключевой этап нашей дорожной карты и необходимое условие для выпуска Zig 1.0.

В частности, с момента выхода последнего релиза мы обсудили и приняли решения по многим языковым предложениям — приняли около 25 и отклонили около 125. На момент написания этой статьи в системе отслеживания проблем Codeberg оставалось открытым 23 языковых предложения, а в устаревшей системе отслеживания проблем GitHub - 61 языковое предложение. Таким образом, эта работа представляет собой значительный шаг к завершению разработки языка (хотя некоторые основные решения остаются).

Изменения в @bitCast

Zig 0.17.0 изменяет определение встроенной функции @bitCast.

Во многих случаях новое поведение эквивалентно старому: в частности, приведение целочисленного типа к другому целочисленному типу не изменилось, как и приведение целочисленного типа к packed struct или packed union.

Однако семантика вызовов @bitCast с использованием типов массивов или векторов изменилась. К сожалению, это изменение может привести к тому, что существующий код перестанет работать, но при этом не возникнет ошибка компиляции.. Поэтому при обновлении может быть полезно проверить все случаи использования @bitCast с массивами или векторами.

Новое определение @bitCast заключается в том, что оно интерпретирует логическое битовое представление значения как другой тип. Считается, что следующие типы имеют логические битовые представления:

  • void
  • bool
  • целые числа, за исключением comptime_int
  • числа с плавающей точкой, за исключением comptime_float
  • типы с целочисленной поддержкой enum(T), packed struct(T), и packed union(T)
  • массивы или векторы любого из этих типов.

Для целочисленных типов и типов с плавающей запятой логическое битовое представление начинается с младшего бита и заканчивается старшим битом. Для типов «массив» и «вектор» логические битовые представления всех элементов объединяются в последовательность, начиная с первого элемента.

На практике это означает, что новое определение @bitCast в значительной степени соответствует прежнему поведению на системах с порядком байтов little-endian. В отличие от прежнего варианта, новое поведение полностью не зависит от порядка байтов (endian-agnostic): операция выполняется одинаково независимо от того, какой порядок байтов используется на целевой системе.

Новое определение @bitCast запрещает преобразования между некоторыми типами, которые ранее были допустимы. В частности, больше не разрешены преобразования с участием типов extern struct или extern union. В большинстве случаев код, использующий подобные преобразования, нацелен на переинтерпретацию представления значения в памяти (этот прием иногда называют «type punning»); для достижения этой цели следует использовать @ptrCast или extern union.

bitcast_extern_struct.zig
const TwoBytes = extern struct {
    b0: u8,
    b1: u8,
};
test "type pun extern struct" {
    const bytes: TwoBytes = .{ .b0 = 0x12, .b1 = 0xAB };
    const int: u16 = @bitCast(bytes);
    switch (std.lang.Endian.native) {
        .little => try expectEqual(0xAB_12, int),
        .big => try expectEqual(0x12_AB, int),
    }
}
const std = @import("std");
const expectEqual = std.testing.expectEqual;
$ zig test bitcast_extern_struct.zig
/home/ci/.cache/act/4666100c0c49f018/hostexecutor/src/download/0.17.0/release-notes/bitcast_extern_struct.zig:7:31: error: cannot @bitCast from 'bitcast_extern_struct.TwoBytes'
    const int: u16 = @bitCast(bytes);
                              ^~~~~
/home/ci/.cache/act/4666100c0c49f018/hostexecutor/src/download/0.17.0/release-notes/bitcast_extern_struct.zig:1:25: note: struct declared here
const TwoBytes = extern struct {
                 ~~~~~~~^~~~~~

⬇️

ptrcast_extern_struct.zig
const TwoBytes = extern struct {
    b0: u8,
    b1: u8,
};
test "type pun extern struct" {
    const bytes: TwoBytes = .{ .b0 = 0x12, .b1 = 0xAB };
    const int_ptr: *align(1) const u16 = @ptrCast(&bytes);
    switch (std.lang.Endian.native) {
        .little => try expectEqual(0xAB_12, int_ptr.*),
        .big => try expectEqual(0x12_AB, int_ptr.*),
    }
}
const std = @import("std");
const expectEqual = std.testing.expectEqual;
$ zig test ptrcast_extern_struct.zig
1/1 ptrcast_extern_struct.test.type pun extern struct...OK
All 1 tests passed.

Формально заданная и фаззингованная грамматика

Формальная грамматика Zig (grammar.peg) и фактическая реализация языка во многих местах расходились. Вероятно, формальная грамматика никогда на 100% не соответствовала написанным вручную токенизатору и парсеру.

Теперь эта проблема устранена, что открывает путь к дальнейшим изменениям грамматики и работе над спецификацией языка.

В общих чертах подход заключался в создании инструмента, который принимает на вход файл grammar.peg и генерирует простой парсер с рекурсивным спуском. Полученный парсер используется в качестве эталона («оракула») при фаззинг-тестировании: результаты его работы сравниваются с результатами работы написанного вручную парсера std.zig.Ast.parse(). Такой подход обеспечивает наличие единого источника истины и упрощает внесение изменений в грамматику языка.

Подробности: #36094

Перенос транслятора с языка C во внешний модуль

@cImport был признан устаревшим в Zig 0.16.0 и теперь удалён. Кроме того, в этом релизе std.Build.Step.TranslateC признан устаревшим в пользу явной зависимости от официального пакета ZSF translate-c, который представляет собой ту же реализацию, что и этап сборки, но предлагает больше вариантов настройки для транслируемого кода и имеет независимый от основного инструментария Zig график выпуска.

Руководство по обновлению

zig fetch --save git+https://codeberg.org/ziglang/translate-c
--- a/build.zig
+++ b/build.zig
@@ -1,16 +1,19 @@
 const std = @import("std");
+const Translator = @import("translate_c").Translator;

 pub fn build(b: *std.Build) void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});

-    const translate_c = b.addTranslateC(.{
-        .root_source_file = b.path("src/c.h"),
+    const translate_c = b.dependency("translate_c", .{});
+
+    const translator: Translator = .init(translate_c, .{
+        .c_source_file = b.path("src/c.h"),
         .target = target,
         .optimize = optimize,
+ // additional options now available that go here:
+ // https://codeberg.org/ziglang/translate-c#options
     });
-    translate_c.linkSystemLibrary("glfw", .{});
-    translate_c.linkSystemLibrary("epoxy", .{});
+    translator.linkSystemLibrary("glfw3", .{});
+    translator.linkSystemLibrary("epoxy", .{});

     const exe = b.addExecutable(.{
         .name = "tetris",
@@ -21,7 +24,7 @@ pub fn build(b: *std.Build) void {
             .imports = &.{
                 .{
                     .name = "c",
-                    .module = translate_c.createModule(),
+                    .module = translator.mod,
                 },
             },
         }),

Добавлены @backingInt и @fromBackingInt

Появились новые встроенные функции @backingInt и @fromBackingInt. Они заменяют собой устаревшие @intFromEnum и @enumFromInt (#35966).

Функция @backingInt работает со всеми перечислениями (enum) и битовыми упаковками (bitpack), имеющими явный базовый целочисленный тип. Она также работает с размеченными объединениями (tagged unions), возвращая базовое целое число, соответствующее активному тегу. Если перечисление или битовая упаковка имеют значение undefined, то и возвращаемое базовое целое число будет undefined.

Тип результата функции @fromBackingInt определяется автоматически; это может быть любое перечисление или битовая упаковка с явным базовым целочисленным типом. Функция принимает параметр именно этого базового целочисленного типа. Для перечислений передача базового целого числа, которое равно undefined или соответствует недопустимому значению тега, приводит к ошибке (Illegal Behavior), выявляемой механизмами проверки безопасности. Для битовых упаковок передача базового целого числа со значением undefined приводит к получению битовой упаковки со значением undefined.

Функция @bitCast теперь также выполняет проверку на недопустимые значения тегов, если целевым типом является перечисление (enum).

Также добавлена ​​функция std.meta.BackingInt для получения типа результата @backingInt.

Теперь Zig требует, чтобы базовым целочисленным типом для пустых перечислений был noreturn, поскольку такие перечисления невозможно инстанцировать.

Пример использования

--- a/lib/std/Build.zig
+++ b/lib/std/Build.zig
@@ -145,7 +145,7 @@ pub const Graph = struct {

     pub fn addGeneratedFile(graph: *Graph, owner: *Step) Configuration.GeneratedFileIndex {
         graph.generated_files.append(graph.arena, owner) catch @panic("OOM");
-        return @enumFromInt(graph.generated_files.items.len - 1);
+        return @fromBackingInt(@intCast(graph.generated_files.items.len - 1));
     }

     pub fn dupeString(graph: *const Graph, bytes: []const u8) []const u8 {
@@ -2607,7 +2607,7 @@ pub const LazyPath = union(enum) {
             .src_path, .cwd_relative, .relative, .dependency => {},
             .generated => |gen| {
                 const graph = other_step.owner.graph;
-                const generated_owner_step = graph.generated_files.items[@intFromEnum(gen.index)];
+                const generated_owner_step = graph.generated_files.items[@backingInt(gen.index)];
                 other_step.dependOn(generated_owner_step);
             },
         }

zig fmt автоматически выполняет это обновление.

Добавлен @SpirvType

В SPIR-V существует ряд типов (например, изображения и сэмплеры), не имеющих аналогов в системе типов Zig. Ранее единственным способом работы с ними был встроенный ассемблер, из-за чего было невозможно объявить текстуру или буфер хранения как обычную глобальную переменную. В версии Zig 0.17.0 реализовано принятое предложение #35240, добавляющее встроенную функцию @SpirvType наряду с другими встроенными средствами создания типов:

@SpirvType(comptime options: std.lang.Type.Spirv) type
  • .sampler создает OpTypeSampler.
  • .image создает OpTypeImage.
  • .sampled_image создает OpTypeSampledImage на основе типа изображения с использованием .sampled.
  • .runtime_array создает OpTypeRuntimeArray.

Эти типы поддерживают индексацию и предоставляют поле len, подобно массиву.

Использование этой встроенной сущности при компиляции не для SPIR-V приводит к ошибке. Кроме того, параметры проверяются на совместимость с целевой операционной системой.

spirv_type.zig
const std = @import("std");

const Image = @SpirvType(.{
    .image = .{
        .usage = .{ .sampled = f32 },
        .format = .unknown,
        .dim = .@"2d",
        .depth = .not_depth,
        .arrayed = false,
        .multisampled = false,
        .access = .unknown,
    },
});

const SampledImage = @SpirvType(.{ .sampled_image = Image });

const texture = @extern(*addrspace(.constant) const SampledImage, .{
    .name = "texture",
    .decoration = .{ .descriptor = .{ .set = 0, .binding = 0 } },
});

const uv_in = @extern(*addrspace(.input) const @Vector(2, f32), .{
    .name = "uv",
    .decoration = .{ .location = 0 },
});

const color_out = @extern(*addrspace(.output) @Vector(4, f32), .{
    .name = "color",
    .decoration = .{ .location = 0 },
});

export fn main() callconv(.{ .spirv_fragment = .{} }) void {
    color_out.* = std.spirv.imageSampleImplicitLod(texture, uv_in.*);
}
$ zig build-obj spirv_type.zig -target spirv32-vulkan

Удален синтаксис умножения массивов

Синтаксис умножения массивов (a ** b) был удален в пользу втроенной функции @splat.

Миграция:

--- a/player/chromaprint.zig
+++ b/player/chromaprint.zig
@@ -35,7 +35,7 @@ pub const Chroma = struct {
     const max_index = @min(window_size / 2, freqToIndex(max_freq));
     const notes: [window_size]u8 = n: {
         @setEvalBranchQuota(window_size);
-        var result = [1]u8{0} ** window_size;
+        var result: [window_size]u8 = @splat(0);
         for (min_index..max_index) |i| {
             const freq = indexToFreq(i);
             const octave = freqToOctave(freq);
@@ -123,7 +123,7 @@ const RollingIntegralImage = struct {
     num_rows: u32,

     pub const init: RollingIntegralImage = .{
-        .data = [1]Float{0} ** data_size,
+        .data = @splat(0),
         .num_rows = 0,
     };

Добавлена встроенная функция @divCeil

Новая встроенная функция @divCeil выполняет целочисленное деление с округлением в сторону положительной бесконечности, дополняя существующие встроенные функции @divTrunc, @divFloor и @divExact.

@divCeil(5, 3) == 2
@divCeil(-5, 3) == -1

Как и в случае с другими встроенными функциями деления, вызывающая сторона гарантирует, что делитель не равен 0, и что результат не вызовет переполнения.

Больше никаких std.math.divCeil(a, b) catch unreachable!

Теперь @hasDecl возвращает true только для публичных объявлений.

Ранее @hasDecl возвращал true для публичных объявлений и объявлений, находящихся в том же файле. Теперь поведение одинаково независимо от того, в каком файле используется @hasDecl.

hasdecl.zig
const std = @import("std");

const Foo = struct {
    bar: i32,

    const baz = 1;
    pub var quux = "xxx";
};

test "@hasDecl example" {
    try std.testing.expect(!@hasDecl(Foo, "bar"));
    try std.testing.expect(!@hasDecl(Foo, "baz")); // different in 0.17.0
    try std.testing.expect(@hasDecl(Foo, "quux"));
}
$ zig test hasdecl.zig
1/1 hasdecl.test.@hasDecl example...OK
All 1 tests passed.

Разыменование и приведение к указателю на массив для срезов

Теперь разрешено разыменование и приведение к указателю на массив для срезов с длиной, известной на этапе компиляции (comptime).

Разрешено в текущей версии:

const slice: []const u16 = &.{ 1, 2, 3 };
const array: [3]u16 = slice.*;
const array_ptr: *const [3]u16 = slice;

Удалён синтаксис void{}

void{} больше не является допустимым синтаксисом. Вместо этого используйте {} (#15213).

Захват ошибки в errdefer удалён

errdefer |err| {
    // `err` — это возвращаемая ошибка; с ней можно что-нибудь сделать!
    // Как и в случае с обычными `defer` или `errdefer`, в этом блоке нельзя использовать `return` или `try`,
    // поэтому изменить возвращаемую ошибку не получится, но её можно, например, залогировать.
}

Перехват (|err|) больше не разрешен (#23734).

Для миграции разделите функцию на две:

fn processOneTarget(job: Job) void {
-    errdefer |err| std.debug.panic("panic: {s}", .{@errorName(err)});
+    processOneTargetInner(job) catch |err| std.debug.panic("panic: {s}", .{@errorName(err)});
+}
+fn processOneTargetInner(job: Job) !void {
     const target = job.target;

Удален тип i0

i0 больше не является допустимым примитивным целочисленным типом.

Этот тип не имел смысла, поэтому прямой альтернативы для него не существует. Однако в подавляющем большинстве случаев его можно безболезненно заменить на u0.

Теги internal и link_once из std.lang.GlobalLinkage были удалены, так как они имели неясную семантику и неполную поддержку на этапах генерации кода и компоновки (#36956). Для замены link_once, вероятнее всего, подойдет weak, а вместо internal следует просто не использовать @export для соответствующего символа.

Стандартная библиотека

  • Добавлена ​​поддержка f128 для @exp и @exp2 на основе работы Пин Так Питера Тана «Table-Driven Implementation of the Exponential Function in IEEE Floating-Point Arithmetic», адаптированной для работы с 128-битными числами (#31846).
  • Добавлен метод std.Io.Semaphore.waitTimeout (#31924).
  • Добавлены вспомогательные функции std.spirv для сэмплирования, получения информации и записи изображений (#36187).
  • ArrayHashMap.setKey больше не пересчитывает весь индекс (#32136).
  • std.Target.parseCpuModel теперь возвращает опциональное значение (optional) вместо ошибки.
  • std.debug.Pdb: устранено дублирование информации о местоположении в исходном коде для встраиваемых (inline) функций (#35438).
  • Проведен полный аудит пространства имен hash.crc (#35952).
  • В std.fs.path добавлены варианты функций relative и resolve, поддерживающие дописывание (appending) (#36784).

Признаны устаревшими

  • std.heap.memory_pool.AlignedManaged удален в пользу std.heap.memory_pool.Aligned.
  • std.heap.memory_pool.ExtraManaged удален в пользу std.heap.memory_pool.Extra.
  • Устаревший std.builtin в пользу std.lang.
  • std.meta.fieldInfo устарел в пользу @typeInfo.
  • Устарело std.meta.fieldNames в пользу @typeInfo.
  • Устаревший std.meta.fieldTypes в пользу @typeInfo.
  • Устаревший std.DoublyLinkedList.pop в пользу std.DoublyLinkedList.popLast.
  • std.gpu переименован в std.spirv.
  • Удален std.ascii.indexOfIgnoreCase в пользу std.ascii.findIgnoreCase.
  • Удален std.ascii.indexOfIgnoreCasePos в пользу std.ascii.findIgnoreCasePos.
  • Удален std.ascii.indexOfIgnoreCasePosLinear в пользу std.ascii.findIgnoreCasePosLinear.
  • Удален std.bit_set.Integer.initEmpty в пользу std.bit_set.Integer.empty.
  • Удален std.bit_set.Integer.initFull в пользу std.bit_set.Integer.full.
  • Удален std.bit_set.Array.initEmpty в пользу std.bit_set.Array.empty.
  • Удален std.bit_set.Array.initFull в пользу std.bit_set.Array.full.
  • Удален std.enums.EnumSet.initEmpty в пользу std.enums.EnumSet.empty.
  • Удален std.enums.EnumSet.initFull в пользу std.enums.EnumSet.full.
  • Удален std.mem.containsAtLeastScalar2 в пользу std.mem.containsAtLeastScalar.
  • Удален std.mem.readPackedIntNative в пользу std.mem.readPackedInt.
  • Удален std.mem.readPackedIntForeign в пользу std.mem.readPackedInt.
  • Удален std.mem.writePackedIntNative в пользу std.mem.writePackedInt.
  • Удален std.mem.writePackedIntForeign в пользу std.mem.writePackedInt.

StackFallbackAllocator переработан и переименован

std.heap.StackFallbackAllocator — это абстракция, полезная для оптимизации «small vec» (вектора малого размера), при которой типичные случаи могут размещаться в предварительно выделенном буфере на стеке, а редкие требуют динамического выделения памяти в куче.

Предыдущая реализация имела ряд недостатков:

Теперь буфер предоставляется в качестве аргумента, как и большинство других стандартных API, которым требуется буфер.

Вследствие этого StackFallbackAllocator был переименован в BufferFirstAllocator, а std.heap.stackFallback был удален.

Руководство по миграции:

var stack align(@max(
    @alignOf(std.heap.StackFallbackAllocator(0)),
    @alignOf(Item)),
) = std.heap.stackFallback(@sizeOf(Item), self.gpa);
const allocator = stack.get();

⬇️

var stack_buf: [1]Item = undefined;
var stack: std.heap.BufferFirstAllocator = .init(@ptrCast(&stack_buf), gpa);
const allocator = stack.allocator();

Добавлен SafeAllocator

std.heap.DebugAllocator заменен на потокобезопасный аллокатор std.heap.SafeAllocator, обеспечивающий следующие гарантии:

  • Метод deinit сообщает обо всех утечках и освобождает всю используемую память.
  • Любые несоответствия при операциях выделения памяти приводят к панике или ошибке сегментации.
  • Попытка освободить память, выделенную другим экземпляром SafeAllocator, вызывает панику (если различаются значения Options.canary).
  • Повторное освобождение памяти (double free) и состояния гонки при выполнении операций (изменение размера, перераспределение или освобождение) приводят к панике или ошибке сегментации.

Поскольку базовый аллокатор не использует память повторно, данный аллокатор также не выполняет повторного использования памяти, в результате большинство операций записи после освобождения приводят либо к ошибке сегментации, либо (в конечном счете) к обнаружению проблемы и панике.

Соответственно std.heap.DebugAllocator и std.heap.Check объявлены устаревшими.

За каждым выделенным блоком памяти следует структура AllocFooter, содержащая метаданные и трассировки стека. Она защищена контрольной суммой, позволяющей выявлять повреждения из-за выхода за границы выделенной области и обнаруживать несовпадение значений-канареек (canary). Память выделяемого блока имеет минимальное выравнивание, соответствующее выравниванию AllocFooter, благодаря чему этот «подвал» (footer) располагается с фиксированным смещением, зависящим от размера выделяемого блока. Память для блока размещается одним из двух способов:

  • Внутри сегментов (бакетов), заполняемых последовательно (для блоков малого размера).
  • В виде отдельного блока, выделяемого непосредственно базовым аллокатором.

Для отслеживания выделенных блоков памяти каждый поток ведет таблицу соответствующих записей. Поскольку в сценариях типа «производитель-потребитель» эта таблица может изменяться другими потоками, она реализована в виде связного спи