Rust: & mut самостоятельно заимствовать противоречащее самому себе.

Я считаю, что это правильное поведение. Чтобы понять, почему, рассмотрим код с явными аннотациями времени жизни:

struct A {
    a: i32
}

impl A {
    fn one<'a>(&'a mut self) -> &'a i32{
        self.a = 10;
        &self.a
    }
    fn two<'a>(&'a mut self) -> &'a i32 {
        loop {
            let k = self.one();
            if *k > 10i32 {
                return k;
            }
        }
    }
}

two должен возвращать ссылку с тем же временем жизни, что и переданный ему изменяемый заимствование. Однако, поскольку он получает свое. Это означает, что k должен иметь время жизни 'a . Однако, чтобы возвращаемое значение one имело время жизни 'a , входные данные one также должны иметь время жизни 'a . Это означает, что Rust вынужден не «повторно заимствовать» self и перемещать его в one . Поскольку изменяемые ссылки являются линейными, их можно перемещать только один раз, но loop означает, что one может потребоваться повторно вызывать одну и ту же изменяемую ссылку.

Второй пример работает только потому, что Rust видит, что цикл запускается только один раз, поэтому self будет перемещен только один раз.

Это похоже на проблему нелексических заимствований. Вы можете получить аналогичное поведение без каких-либо циклов:

struct Foo { data: Option<i32> }

fn main() {
    let mut x = Foo{data: Some(1)};

    foo(&mut x);
}

fn foo(x: &mut Foo) -> Option<&mut i32> {
    if let Some(y) = x.data.as_mut() {
        return Some(y);
    }

    println!("{:?}", x.data); 
    None
}

<anon>:14:22: 14:28 error: cannot borrow `x.data` as immutable because it is also borrowed as mutable
<anon>:14     println!("{:?}", x.data); 
                               ^~~~~~
note: in expansion of format_args!
<std macros>:2:43: 2:76 note: expansion site
<std macros>:1:1: 2:78 note: in expansion of println!
<anon>:14:5: 14:30 note: expansion site
<anon>:10:22: 10:28 note: previous borrow of `x.data` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `x.data` until the borrow ends
<anon>:10     if let Some(y) = x.data.as_mut() {
                               ^~~~~~
<anon>:16:2: 16:2 note: previous borrow ends here
<anon>:9 fn foo(x: &mut Foo) -> Option<&mut i32> {
...
<anon>:16 }
          ^
error: aborting due to previous error

Rustc не может «справиться» с доходностью условных займов.

CC @pcwalton

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

Следующий код вызывает функцию изменения, которая возвращает неизменяемую ссылку. После этого я не могу брать неизменяемые ссылки.

struct Foo (u8);

impl Foo {
    fn bar(&mut self) -> &u8 {
        self.0 += 1;
        &self.0
    }
}

fn main() {
    let mut x = Foo(42);
    let a = x.bar(); // note: borrow of `x` occurs here
    let b = x.0; // error: cannot use `x.0` because it was mutably borrowed
}

Детский манеж

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

Если вы посмотрите на пример @Gankro , он пройдет проверку заимствования, если вы удалите ключевое слово return, даже если полученная функция не будет работать должным образом.

Это заблокировано на нелексическом времени жизни, которое, в свою очередь, заблокировано на MIR. В идеале это будет исправлено к концу 2016 года, но исправление появится не скоро.

Обсуждение внутреннего устройства: https://internals.rust-lang.org/t/relaxing-the-borrow-checker-for-fn-mut-self-t/3256

Обсуждение функции нелексических заимствований: https://github.com/rust-lang/rfcs/issues/811

Так что чтение [внутренней темы] заставляет меня чувствовать, что это не поправимо (даже с NLL). Может кто-нибудь подтвердить? (@eddyb?)

cc @ rest-long / long

Это действительно NLL, и, если я не ошибаюсь, это было бы исправлено различными предложениями, которые я сделал. Это примерно соответствует «проблемному случаю №3» из моего первого сообщения в блоге . Основная идея (с точки зрения формулировки из последнего сообщения в блоге ) того, почему это будет работать, заключается в том, что подтип заимствования необходимо будет продлить только до конца 'a в ветви if , вызывающий return .

@nikomatsakis Не могли бы вы подробнее рассказать о том, как NLL взаимодействует с этой проблемой? В моей ментальной модели ссылок &mut их можно передать либо перемещением, либо повторным заимствованием , и проблема в этой проблеме заключается в том, что для возврата требуется режим перемещения и повторное использование self впоследствии требует повторного заимствования . Насколько я понимаю, время жизни новой &mut ограничено временем жизни переменной, содержащей &mut -reference - в данном случае переменной self , поэтому она ограничена тело функции, поэтому оно не может выходить за пределы вызова функции. Собирается ли NLL изменить это ограничение на повторные заимствования (или, может быть, такого ограничения нет)?

Также мне интересно, является ли устранение этой проблемы чем-то по своей сути связанным с NLL или это может быть ортогонально? Если последнее, может стоит посадить фикс перед NLL?

Кроме того, если NLL решит эту проблему, означает ли это, что в NLL вам никогда не придется вручную выбирать между перемещением и повторным заимствованием?

Это будет исправлено в ближайшее время?

@krdln

Не могли бы вы подробнее рассказать о том, как NLL взаимодействует с этой проблемой?

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

Более подробно, если вы возьмете здесь разработанную подпись, вы увидите, что мы должны вернуть ссылку с временем жизни 'a :

fn two<'a>(&'a mut self) -> &'a i32 { .. }

теперь обратите внимание, что мы вызываем let k = self.one() а затем возвращаем это k . Это означает, что тип k должен быть &'a i32 . Это, в свою очередь, означает, что когда мы вызываем self.one() , мы должны предоставить ему заем в self с типом &'a mut Self . Следовательно, при let k = self.one() мы выдаем ссуду в self с пожизненным сроком службы 'a . Это время жизни больше, чем цикл (и, действительно, всей функции), поэтому оно сохраняется, когда мы идем по циклу, что приводит к отчету об ошибке. Согласно предложенным мною правилам NLL, время жизни k требуется только для увеличения до 'a если используется if . Следовательно, если не взять if , кредит может закончиться раньше.

Это помогает?

@ osa1

Это будет исправлено в ближайшее время?

Нам еще предстоит сделать несколько шагов, прежде чем мы сможем это сделать, но ведется активная работа по выполнению необходимых рефакторингов.

@nikomatsakis
Спасибо, немного помогло. Но есть одна мелочь, которую я не понимаю - что именно происходит, когда вы пишете self в своем коде - как работает повторный заимствование self . Я читал ваше объяснение «Проблемного случая 3» ( get_default ), где вы встраиваете код внутри вызывающего, но там вы изменили каждое использование self на заимствование map переменная напрямую, так что удаление сахара не помогло мне.

Вот где я застрял: когда мы вызываем let k = self.one() , self нельзя переместить (потому что он понадобится позже), поэтому он считается заимствованным. Позже мы условно возвращаем этот k , так что заимствование должно иметь время жизни 'a , которое переживет вызов функции. Но! Мы позаимствовали у self , который живет только до конца функции. Это ограничение сокращает 'a , поэтому в моей ментальной модели даже при NLL мы должны получить ошибку «не живет достаточно долго».

@krdln мы фактически позаимствовали у *self - то есть мы повторно заимствовали то, что относится к self. Мы разрешаем вам одалживать *self на всю жизнь, пережив сам self , потому что тип self подразумевает «блокировку» на всю жизнь 'a . Следовательно, если мы можем гарантировать, что во время 'a self больше не используется, результатом должна быть эксклюзивная ссылка - в этом случае после возврата fn self был вытянут, и, следовательно, он мог не может использоваться, поэтому достаточно просто гарантировать, что self не будет использоваться до конца fn. (По крайней мере, я надеюсь, что это правда. =)

Это заблокировано на нелексическом времени жизни, которое, в свою очередь, заблокировано на MIR. В идеале это будет исправлено к концу 2016 года, но исправление появится не скоро.

Не очень удивительно, но я подтвердил, что начальный пример действительно компилируется каждую ночь, если вы включите нелексическую функцию времени жизни.

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

Я также должен упомянуть, что код starwed больше не компилируется в последнюю ночь. @oberien предложил regression-from-nightly-to-nightly ", а также мне было предложено пометить @nikomatsakis на случай, если это будет срочная проблема :)

Наткнулся на эту проблему, пытаясь сделать что-то очень похожее (что не разрешено текущей nll):

fn f(vec: &mut Vec<u8>) -> &u8 {
    if let Some(n) = vec.iter_mut().find(|n| **n == 1) {
        *n = 10;
        n
    } else {
        vec.push(10);
        vec.last().unwrap()
    }
}

fn main() {
    let mut vec = vec![1, 2, 3];
    f(&mut vec);
}

error[E0499]: cannot borrow `*vec` as mutable more than once at a time
 --> src/main.rs:6:9
  |
1 | fn f(vec: &mut Vec<u8>) -> &u8 {
  |           - let's call the lifetime of this reference `'1`
2 |     if let Some(n) = vec.iter_mut().find(|n| **n == 1) {
  |                      --- first mutable borrow occurs here
3 |         *n = 10;
4 |         n
  |         - returning this value requires that `*vec` is borrowed for `'1`
5 |     } else {
6 |         vec.push(10);
  |         ^^^ second mutable borrow occurs here

error[E0502]: cannot borrow `*vec` as immutable because it is also borrowed as mutable
 --> src/main.rs:7:9
  |
1 | fn f(vec: &mut Vec<u8>) -> &u8 {
  |           - let's call the lifetime of this reference `'1`
2 |     if let Some(n) = vec.iter_mut().find(|n| **n == 1) {
  |                      --- mutable borrow occurs here
3 |         *n = 10;
4 |         n
  |         - returning this value requires that `*vec` is borrowed for `'1`
...
7 |         vec.last().unwrap()
  |         ^^^ immutable borrow occurs here

(мы должны были удалить E-needtest, когда мы удалили NLL-fixed-by-NLL)