Источник изображения.

Вышел новый релиз языка программирования Rust версии 1.84. Этот язык общего назначения изначально разрабатывался проектом Mozilla, но теперь его поддерживает независимая некоммерческая организация Rust Foundation. Rust ориентирован на безопасную работу с памятью и обеспечивает высокий уровень параллелизма выполнения задач, не прибегая к сборщику мусора или полноценному runtime (runtime ограничен базовой инициализацией и поддержкой стандартной библиотеки). Что нового? Давайте разбираться.

Что основное, о чем нужно сказать? Система управления памятью в Rust предотвращает распространенные ошибки, связанные с указателями, такие как доступ к освобожденной памяти, разыменование нулевых указателей и выход за границы буфера. Это достигается благодаря концепциям владения, заимствования и времени жизни объектов, которые проверяются на этапе компиляции.

Для управления зависимостями и сборки проектов в Rust используется пакетный менеджер Cargo. Он автоматически загружает и компилирует необходимые библиотеки, называемые крейтами, из центрального репозитория crates.io.

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

Так что нового?

В релизе много интересного, но для того, чтобы статья была вменяемого размера, выделю основное. Итак, вот основные моменты, на которые стоит обратить внимание.

Trait solver

В компиляторе Rust началась миграция на новый обработчик типов (trait solver), который используется для проверки применимости типажей, нормализации типов и анализа их совместимости. В версии 1.84 этот обработчик применяется для проверки согласованности реализаций типажей. Он оценивает, что для определённого типа существует не более одной реализации типажа, учитывая код, подключённый из внешних crate-пакетов. Введение этой проверки позволило устранить проблемы старого обработчика типов, который мог допускать конфликты из-за пересечения различных реализаций типажей, что повышает надёжность и предсказуемость работы компилятора.

Cargo

В пакетном менеджере Cargo был стабилизирован механизм управления зависимостями, который автоматически учитывает минимально поддерживаемые версии компилятора Rust (MSRV, Minimum Supported Rust Version) для зависимых компонентов. Это нововведение избавляет разработчиков от необходимости вручную подбирать старые версии зависимостей в проектах, которые должны оставаться совместимыми со старыми версиями инструментария Rust. По умолчанию новый режим обработки зависимостей будет активирован начиная с релиза Rust 1.85. В текущей версии он доступен как опция: для его включения нужно в разделе [resolver] файла .cargo/config.toml указать параметр incompatible-rust-versions = «fallback».

Strict Proverance

Представлен новый API под названием «Strict Provenance», который предназначен для работы с указателями, включая их преобразование в целые числа и обратно, с сохранением связанных метаданных. Эти метаданные, называемые «provenance», содержат информацию о происхождении указателя и области его допустимого использования. Вместе с адресом указателя метаданные позволяют отслеживать его связь с другими указателями и определять, где и когда он может обращаться к памяти. Ранее преобразование указателя в целое число и обратно могло приводить к неопределённому поведению из-за сложностей в определении происхождения итогового указателя. Новый API устраняет эту проблему, обеспечивая возможность выполнения низкоуровневых операций, например, сохранения дополнительных данных в младших битах указателя, без необходимости преобразования указателя в целое число, что делает такие операции безопаснее и предсказуемее.

Стабильные API

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

    Ipv6Addr::is_unique_local
    Ipv6Addr::is_unicast_link_local
    core::ptr::with_exposed_provenance
    core::ptr::with_exposed_provenance_mut
    <ptr>::addr
    <ptr>::expose_provenance
    <ptr>::with_addr
    <ptr>::map_addr
    <int>::isqrt
    <int>::checked_isqrt
    <uint>::isqrt
    NonZero::isqrt
    core::ptr::without_provenance
    core::ptr::without_provenance_mut
    core::ptr::dangling
    core::ptr::dangling_mut
    Pin::as_deref_mut

Функции

Признак «const» применен в функциях:

   AtomicBool::from_ptr
    AtomicPtr::from_ptr
    AtomicU8::from_ptr
    AtomicU16::from_ptr
    AtomicU32::from_ptr
    AtomicU64::from_ptr
    AtomicUsize::from_ptr
    AtomicI8::from_ptr
    AtomicI16::from_ptr
    AtomicI32::from_ptr
    AtomicI64::from_ptr
    AtomicIsize::from_ptr
    <ptr>::is_null
    <ptr>::as_ref
    <ptr>::as_mut
    Pin::new
    Pin::new_unchecked
    Pin::get_ref
    Pin::into_ref
    Pin::get_mut
    Pin::get_unchecked_mut
    Pin::static_ref
    Pin::static_mut

Inline-вставки

Стабилизация ассемблерных Inline-вставок для архитектур s390x и Arm64EC предоставляет разработчикам возможность встраивать ассемблерный код непосредственно в программы на Rust. Это важно для задач, требующих высокой производительности и прямого управления процессором. Архитектура s390x используется в мейнфреймах IBM, а Arm64EC предназначена для совместимости ARM-устройств с программами Windows, что делает их поддержку актуальной для специализированных приложений.

WebAssembly

Для платформы WebAssembly расширены возможности за счет стабилизации трех ключевых функций. Multivalue позволяет функциям возвращать несколько значений, упрощая код и улучшая производительность. Reference-types вводит поддержку ссылок на объекты, такие как таблицы и функции, что открывает новые возможности для реализации сложных структур данных. Tail-call добавляет оптимизацию хвостовых вызовов, снижая нагрузку на стек при работе с рекурсией, что особенно полезно для функциональных языков и алгоритмов с глубокой рекурсией.

Поддержка wasm32v1-none

Второй уровень поддержки платформы wasm32v1-none гарантирует успешную сборку программ на Rust для этой минималистичной платформы. Это означает, что компилятор обеспечивает стабильную работу базовых функций без полной интеграции стандартной библиотеки. Такой уровень поддержки делает возможным использование Rust в специализированных средах с ограниченными ресурсами.

Что еще?

Rust активно используется в различных проектах благодаря своей производительности, безопасности и широким возможностям. Вот что можно выделить среди наиболее известных.

Релиз ОС на Rust

Опубликован релиз операционной системы Tock 2.2, которая написана на Rust и предназначена для использования на микроконтроллерах. Эта ОС позволяет одновременно запускать несколько приложений, которым нельзя доверять, на устройствах с ограниченными ресурсами, таких как датчики, модули TPM, аутентификационные брелоки и носимые устройства. Tock поддерживает микроконтроллеры на архитектурах ARM Cortex-M и RISC-V. Её ключевая особенность — изоляция уровней приложений, ядра и драйверов, а также обеспечение изоляции между отдельными приложениями и драйверами. Это достигается благодаря механизмам Rust и разделению на уровне защиты памяти.

VEKOS

Проект VEKOS (Verified Experimental Kernel OS) развивается как ядро операционной системы, написанное на Rust, с акцентом на верификацию компонентов. Для каждой операции с файловой системой, создания процессов и выделения памяти формируется криптографическое подтверждение, которое позволяет проверить корректность выполнения действий в реальном времени. Это напоминает использование технологий блокчейна для обеспечения прозрачности и надёжности работы операционной системы. В файловой системе VKFS используется структура «дерево Меркла», обеспечивающая целостность данных за счёт хеширования на всех уровнях. Выделение памяти реализовано в режиме Copy-On-Write (COW), что повышает эффективность использования ресурсов.

Разработка Mini-C

Группа исследователей из Microsoft и Inria разрабатывает Mini-C — подмножество языка C, предназначенное для автоматической трансляции программ на языке C в код на Rust. В отличие от c2rust, Mini-C генерирует код без использования блоков unsafe, но ориентирован преимущественно на проекты, которые имеют формальные доказательства надёжности. Предполагается, что такой подход упростит миграцию C-кода в Rust: сначала проект переводится в Mini-C, где исключены операции с указателями, а затем преобразуется в безопасный код на Rust. Это устраняет необходимость вручную исправлять unsafe-блоки после прямой трансляции из C в Rust.

Если вы уже опробовали новую версию, пишите о своих впечатлениях в комментариях.