Что такое нелексические времена жизни (non-lexical lifetimes) в Rust?

Что такое нелексические времена жизни (NLL)?

Нелексические времена жизни (Non-Lexical Lifetimes, NLL) — это улучшение механизма проверки заимствований в компиляторе Rust, которое было стабилизировано в версии 1.36 (2019 год). До NLL компилятор использовал лексический подход: время жизни ссылки привязывалось к блоку кода (фигурным скобкам), где она была объявлена. NLL же позволяет компилятору отслеживать, до какого именно момента ссылка реально используется, а не до конца блока.

Главная идея: если ссылка больше не нужна (последнее чтение/использование), компилятор может "закончить" её время жизни раньше, даже если синтаксически она всё ещё находится внутри блока. Это делает проверку более точной и гибкой, позволяя писать более естественный код.

Пример: когда NLL спасает

Рассмотрим классический случай, который не компилировался до NLL:

fn main() {
    let mut data = vec![1, 2, 3];
    let x = &data[0];      // неизменяемая ссылка на data
    data.push(4);          // изменяемая операция
    println!("{}", x);     // последнее использование x
}

До NLL компилятор считал, что время жизни x — от строки объявления до конца блока main. Поэтому data.push(4) вызывало конфликт: изменяемая ссылка на data (через push) и неизменяемая ссылка x не могли сосуществовать. С NLL компилятор видит, что x используется только в println!. Если переставить строки:

fn main() {
    let mut data = vec![1, 2, 3];
    let x = &data[0];
    println!("{}", x);     // последнее использование x
    data.push(4);          // теперь OK: x уже не используется
}

Этот код работает с NLL! Компилятор понимает, что после println! ссылка x больше не нужна, и её время жизни заканчивается, позволяя изменять data.

Как это работает под капотом?

Компилятор строит граф потока управления (Control Flow Graph) и для каждой точки программы вычисляет, какие ссылки "живы" (могут быть использованы в будущем). Если ссылка не используется после определённой строки, она считается мёртвой, и заимствование завершается. Это называется анализ на основе потока данных (data-flow analysis).

Другой пример: условные ветвления

fn main() {
    let mut x = 10;
    let y = &mut x;
    if *y > 0 {
        println!("{}", y); // последнее использование y
    }
    // y больше не используется
    x = 20; // OK с NLL: y уже мёртв
}

До NLL компилятор считал, что y живёт до конца блока if (или до конца main), и запрещал присваивание x = 20. С NLL — работает.

Что NLL НЕ меняет?

• Основные правила заимствования остаются теми же: одна изменяемая ссылка или множество неизменяемых.
• NLL не отменяет необходимость аннотаций времен жизни в сигнатурах функций — это отдельная тема (они всё ещё лексические на уровне сигнатур).
• NLL не делает код небезопасным — он просто точнее определяет, когда ссылка "жива".

Итог

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

// Старый стиль (до NLL)
fn main() {
    let mut data = vec![1, 2, 3];
    let result = {
        let x = &data[0];
        let y = *x + 1; // используем x
        y // x умирает здесь, после закрытия блока
    };
    data.push(4); // теперь можно
    println!("{}", result);
}

// Новый стиль (с NLL)
fn main() {
    let mut data = vec![1, 2, 3];
    let x = &data[0];
    let result = *x + 1; // последнее использование x
    data.push(4);        // OK
    println!("{}", result);
}