Rust 1.100 стабилизировал тип never, а nightly ускорил проверку типов

Тип never стабилизировали после 5 неудачных попыток, Cargo получил задержку для свежих версий пакетов, а nightly включил параллельный фронтенд.

Обложка: Rust 1.100 стабилизировал тип never, а nightly ускорил проверку типов

12 ноября 2026 года вышел Rust 1.100.0. Главное изменение — стабильный тип never (!): по словам Rust Release Team, к нему шли 10 лет и 5 неудачных попыток. Ради стабилизации в язык внесли редкое ломающее изменение для редакций 2015, 2018 и 2021.

Через 4 дня, 16 ноября, команда компилятора сообщила о включении параллельного фронтенда в nightly по умолчанию. Проверка типов и заимствований теперь идёт в несколько потоков: на 8 потоках cargo check одного крейта в тестах команды в среднем быстрее на 44,23%.

При обновлении до 1.100 часть старого кода может перестать собираться или получить новые предупреждения о недостижимом коде. В Cargo появилась задержка для свежих версий зависимостей — она снижает риск подтянуть вредоносный пакет в первые часы после публикации. Пользователи nightly уже собирают проекты с 2 потоками фронтенда по умолчанию.

Ключевые выводы
  • Rust 1.100.0 вышел 12 ноября 2026 года; обновление: rustup update stable.
  • Тип never (!) теперь можно писать в любой позиции, например Result<T, !>; Infallible стал его псевдонимом.
  • Ломающее изменение: в редакциях 2015, 2018 и 2021 тип never при выводе типов больше не превращается в ().
  • Cargo умеет не брать версии зависимостей моложе заданного срока (global-min-publish-age) и сообщает о неиспользуемых зависимостях.
  • Параллельный фронтенд включён в nightly с nightly-2026-11-14, по умолчанию 2 потока; в stable он пока выключен, срок стабилизации не назван.

Что даёт стабильный тип never?

Теперь тип ! можно указывать в любой позиции программы, например внутри параметров обобщённых типов. Он обозначает вычисление, которое никогда не возвращает значение: такой тип имеют return, break или std::process::exit. Поскольку значений у ! не существует, компилятор разрешает приводить его к любому типу — поэтому одна ветка match может вернуть число, а другая выйти из функции.

Раньше ! разрешалось писать только в возвращаемом типе функции (-> !). В 1.100 это ограничение сняли: в примере из анонса функция принимает Result с невозможной ошибкой и извлекает значение без unwrap и обработки ветки ошибки.

			fn infallible_unwrap<T>(res: Result<T, !>) -> T {
    // ^^ writing `Result<_, !>` was not allowed before
    let Ok(v) = res;
    v
}
		

Одновременно Infallible стал псевдонимом типа never, поэтому все прежние API с Infallible теперь совместимы с !. По словам авторов анонса, так задумывалось с самого начала, и именно это усложняло стабилизацию. В целях проекта на 2026 год эта задача теперь отмечена как завершённая.

Что может сломаться при обновлении до Rust 1.100?

В редких случаях старый код перестаёт собираться или получает новые предупреждения о недостижимом коде из-за смены правила never type fallback. Когда компилятор не может вывести тип выражения с !, он подставляет запасной вариант: раньше в редакциях 2015, 2018 и 2021 это был пустой кортеж (), а теперь сам тип !. В редакции 2024 так работало с самого начала.

По оценке команды, большинство проектов этого не заметит: сбои вероятны, например, если код игнорирует результат функции с обобщённым возвращаемым типом. Авторы заранее показывали предупреждения о будущей несовместимости и отправили патчи в публичные крейты. Если зависимость не собирается из-за ошибки с типом never, в анонсе советуют сначала обновить её.

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

  • замыкания точнее захватывают переменные из if let, из-за чего могут появиться новые ошибки;
  • часть реализаций трейтов для Box обобщили на произвольные аллокаторы — возможны новые ошибки вывода типов;
  • box-шаблоны синтаксически запрещены;
  • Cargo изменил раскладку каталога с промежуточными артефактами сборки (build-dir), что может сломать обходные решения в сборочных процессах (cargo#17287).

Какие ещё API стабилизировали?

Allocator API. Стабилизирована основа allocator_api: трейт Allocator и методы вроде Vec::new_in и Box::new_in. Теперь свой аллокатор можно передать в Vec и Box без nightly. Поддержку других коллекций и умных указателей команда обещает стабилизировать позже. Свой аллокатор полезен для арен и пулов, как в нашем разборе про Box.

DropGuard. Тип core::mem::DropGuard хранит значение и замыкание, которое вызывается при любом выходе из области видимости: обычном возврате, операторе ? или панике с раскруткой стека. Раньше для этого приходилось заводить обёртку с реализацией Drop. Функция DropGuard::dismiss отменяет вызов и возвращает значение — удобно для операций «всё или ничего». В примере из анонса вектор откатывается к исходной длине, если хотя бы одна строка не разобралась:

			use std::mem::DropGuard;
use std::num::ParseIntError;

/// Attempt to parse all `strings` and push them into `nums`.
/// If parsing any of them fails, `nums` remains unchanged.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
    let len = nums.len();
    let mut nums = DropGuard::new(nums, move |nums| {
        nums.truncate(len);    // 1. Reset the vec on failure
    });

    for s in strings {
        nums.push(s.parse()?); // 2. If `?` returns an error, roll back
    }

    DropGuard::dismiss(nums);  // 3. Parsing successful, dismiss the guard
    Ok(())
}
		

conjure_zst. Для авторов unsafe-кода появилась функция std::mem::conjure_zst: официальный способ создать значение типа нулевого размера вместо transmute из () и подобных приёмов. Функция помечена unsafe, потому что библиотеки часто полагаются на то, что такое значение нельзя получить из ничего. Пример из анонса: маркер Python<'py> в PyO3 означает, что поток держит GIL, глобальную блокировку интерпретатора Python.

Среди мелких добавлений: bool::toggle, Vec::from_fn, str::trim_prefix и str::trim_suffix, Box::map, Rc::map и Arc::map. Цель wasm32-wasip3 получила уровень поддержки Tier 2, а стандартная библиотека обновилась до Unicode 18.0.0.

Как Cargo 1.100 защищает от свежих вредоносных версий?

Cargo научился не брать версии зависимостей, опубликованные слишком недавно (механизм min-publish-age, или dependency cooldown). Вредоносные релизы обычно обнаруживают в первые часы или дни после публикации, поэтому пауза перед обновлением снижает риск подхватить скомпрометированный пакет при cargo update. Настройка включается в .cargo/config.toml:

			[registry]
global-min-publish-age = "3 days"
		

После этого Cargo пропускает более свежие версии и показывает, что именно придержал:

			$ cargo update
    Updating crates.io index
     Locking 2 packages to highest compatible version as of min-publish-age
      Adding cc v1.11.0 (available: v1.18.0, published 3 hours ago)
      Adding clap 4.6.7 (available: 4.6.9, published 2 days ago)
		

Если новая версия нужна срочно, например в ней закрыта уязвимость, проверку можно обойти для одного обновления: CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update clap --precise 4.6.9. Версия запишется в Cargo.lock и останется там до следующего cargo update.

Ограничения, о которых предупреждают авторы:

  • механизм работает только с реестрами, где хранится время публикации: версии без поля pubtime в индексе не задерживаются;
  • cargo install игнорирует минимальный возраст как для самого крейта, так и для его зависимостей (версию можно зафиксировать явно: cargo install foo@1.2.3);
  • задержка снижает риск части атак на цепочку поставок, но не даёт полной защиты и не заменяет проверку обновлений.

В планах команды — карантин для подозрительных версий на crates.io и автоматическое обнаружение таких релизов. О том, чем ещё проверять зависимости, у нас есть отдельный разбор.

Ещё одно нововведение в Cargo — предупреждение cargo::unused_dependencies о неиспользуемых зависимостях (включено по умолчанию, относится к новой системе линтов [lints.cargo] в Cargo.toml). У rustc для этого есть линт unused_crate_dependencies, но в связке с Cargo он даёт ложные срабатывания. Предупреждение появляется только при сборке всех целей, использующих зависимость (например, cargo check --bin foo его не покажет), и не распространяется на dev-dependencies.

Насколько параллельный фронтенд ускоряет сборку?

По данным команды компилятора, на 8 потоках cargo check одного крейта с нуля в среднем быстрее на 44,23%, а при сборке целого проекта выигрыш заметно меньше. Замеры выполнены на наборе rustc-perf.

Компилятор Rust состоит из двух частей: многопоточного бэкенда на базе LLVM и фронтенда (проверка типов и заимствований), который до сих пор работал в один поток. Опциональный параллельный режим появился в nightly 3 года назад (в 2023 году), его планировали стабилизировать в 2024-м, но не успели. В прошлом году Вадим Петроченков с другими контрибьюторами начал координированную доработку, и, по словам автора поста Якуба Беранека, с тех пор закрыли множество давних проблем.

Среднее изменение времени сборки одного крейта с нуля на реальных проектах из rustc-perf:

Среднее изменение времени сборки одного крейта (замеры команды компилятора Rust)

3 сервиса, 5 столбцов
Среднее изменение времени сборки одного крейта (замеры команды компилятора Rust)
Потоков фронтендаcheckclippydebugopt
2-21,95%-20,74%-14,2%-12,51%
4-37,99%-36,01%-29,14%-23,67%
8-44,23%-41,76%-36,1%-27,88%
Листайте столбцы →Смахните влевоВсе 5 столбцов

Разброс между проектами большой: на части тестов ускорения почти нет, зато cargo check для nalgebra, cargo и diesel на 8 потоках работает почти в 3 раза быстрее.

Rust 1.100 стабилизировал тип never, а nightly ускорил проверку типов_36
Как меняется время сборки nalgebra 0.33 с ростом числа потоков фронтенда. Источник: Rust Blog

При сборке проекта целиком ядра уже загружены другими задачами — Cargo компилирует несколько крейтов сразу, а LLVM работает в несколько потоков. На машине с 8 ядрами cargo check всего графа зависимостей самого Cargo занял 36,7 с с одним потоком фронтенда, 35,1 с на 2, 31,9 с на 4 и 30,8 с на 8 — около 15% ускорения.

Инкрементальным пересборкам (обычному циклу правки кода) параллельный фронтенд помогает слабее: в среднем на 3–5%. Авторы оговариваются, что хороших тестов для этого сценария у них нет и результаты у пользователей могут отличаться.

Как изменить число потоков или отключить параллельный режим?

Число потоков задают флагом компилятора --jobs-frontend через переменную RUSTFLAGS или .cargo/config.toml; по умолчанию в nightly работают 2 потока (команда выбрала это значение, чтобы находить ошибки без заметного роста памяти):

			[build]
rustflags = ["-Zunstable-options", "--jobs-frontend=8"]
		

Больше 8 потоков, по словам авторов, масштабируется плохо и расходует больше памяти. Значение --jobs-frontend=1 отключает параллельный режим; если пришлось это сделать, команда просит сообщить о причине в issue на GitHub или в Zulip.

Пока есть 2 известных ограничения: порядок диагностических сообщений может меняться от запуска к запуску, а собранный бинарный файл иногда не воспроизводится. Команда считает это багом и ведёт список открытых проблем.

Когда параллельный фронтенд появится в stable?

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

Сейчас часть фронтенда остаётся последовательной. В работе уже находятся параллельное раскрытие макросов и разрешение имён (проект GSoC 2025), а также открытый пул-реквест о параллельном преобразовании синтаксического дерева (AST) в промежуточное представление HIR.

Что сделать сейчас: обновиться через rustup update stable, собрать проект и проверить новые предупреждения; если зависимость падает из-за типа never, обновить её. В .cargo/config.toml стоит прописать global-min-publish-age. Тем, кто выбирает язык для нового сервиса, пригодится наше сравнение Rust, Go и Zig.

Источники: Rust Blog: Announcing Rust 1.100.0, Rust Blog: Enabling the parallel frontend on nightly, Rust Release Notes: Version 1.100.0, Rust Project Goals: Stabilize never type, Rust Edition Guide: Never type fallback change, Cargo Reference: registry.global-min-publish-age, Rust Blog: Faster compilation with the parallel front-end in nightly (2023)

Изображение на обложке: Rust Foundation