Rust: & mut self 차입 자체와 충돌합니다.

나는 이것이 올바른 행동이라고 믿습니다. 이유를 확인하려면 명시 적 수명 주석이있는 코드를 고려하세요.

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 . 이 수단은 녹하지 않도록 강제하는 것이 "reborrow" 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 의 예제를

이것은 비 어휘 수명에서 차단되며 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

그래서 [internals thread]를 읽으면 이것이 고칠 수없는 것처럼 느껴집니다 (NLL을 사용해도). 누군가 확인할 수 있습니까? (@eddyb?)

cc @ 휴식-장 / 장

이것은 실제로 NLL이고, 내가 착각하지 않으면 내가 만든 다양한 제안으로 수정 될 것입니다. 이것은 대략 내 첫 블로그 게시물의 "문제 사례 # 3"에 해당합니다. 이것이 작동하는 이유에 대한 기본 아이디어 ( 최신 블로그 게시물의 공식 측면 if 분기의 'a 끝까지 만 연장하면된다는 것입니다. if 를 유발하는 return .

@nikomatsakis NLL이이 문제와 어떻게 상호 작용하는지 자세히 &mut 참조의 내 정신 모델에서는 move 또는 reborrow를 통해 전달할 수 이동 모드가 필요하고 self 의 재사용이 필요하다는 것입니다. 나중에 다시 빌려야 합니다. 내 이해에 따르면 새로 재 빌린 &mut 참조의 수명은 &mut -reference를 보유한 변수의 수명에 의해 제한됩니다.이 경우에는 self 변수에 의해 제한됩니다. 따라서 함수 호출 외부로 확장 할 수 없습니다. NLL이 재 차입 제한을 변경합니까 (또는 그러한 제한이 없을 수도 있음)?

또한이 문제를 해결하는 것이 본질적으로 NLL과 관련이 있는지 아니면 직교 할 수 있는지 궁금합니다. 후자라면 NLL 이전에 수정을 할 가치가 있습니까?

또한 NLL이이 문제를 해결하려는 경우 NLL에서 이동과 재 차입 중에서 수동으로 선택할 필요가 없다는 의미입니까?

조만간 수정 될 예정입니까?

뿡뿡

NLL이이 문제와 어떻게 상호 작용하는지 자세히 설명해 주시겠습니까?

요약은 값이 어떤 경로의 기능 밖으로 반환됩니다 경우 오늘, 대출은 모든 경로의 기능의 나머지 부분에 대한 유효한 것이어야한다는 것입니다. 내가 작성한 NLL 제안에 따라 그 제한이 해제되었습니다.

더 자세하게 여기에서 정교한 서명을 받으면 수명이 'a 참조를 반환해야 함을 알 수 있습니다.

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

이제 let k = self.one() 호출 한 다음 k 를 반환하는 것을 확인합니다. 유형 것을이 수단 k 있어야합니다 &'a i32 . 이는 다시 self.one() 호출 할 때 &'a mut Self 유형으로 self 차용을 제공해야 함을 의미합니다. 따라서 let k = self.one() self 에서 평생 'a 로 self 대출을 발행합니다. 이 수명은 루프 (실제로 전체 함수)보다 크기 때문에 루프를 돌아 다닐 때 지속되어 오류보고가 발생합니다. 내가 제안하는 NLL 규칙에서의 수명 k 단지까지 연장 할 필요가 'a 경우 if 취해진 다. 따라서 if 를받지 않으면 대출이 더 일찍 종료 될 수 있습니다.

도움이 되나요?

@ osa1

조만간 수정 될 예정입니까?

이 작업을 수행하기 전에 아직 몇 단계를 거쳐야하지만 필요한 리팩토링을 수행하기위한 적극적인 작업이 있습니다.

뿡 빵뀨
감사합니다. 다소 도움이되었습니다. 하지만 제가 이해하지 못하는 한 가지 작은 것이 있습니다. self 를 코드에 작성할 때 정확히 어떤 일이 발생하는지 – self 의 재 차입이 작동하는 방식입니다. 호출자 내부에서 코드를 인라인하는 "문제 사례 3"( get_default )에 대한 설명을 읽었지만 self 의 모든 사용을 차용으로 변경했습니다. map 변수를 직접 사용하여 desugaring으로 해결되지 않았습니다.

제가 갇혀있는 부분은 다음과 같습니다. let k = self.one() 호출하면 self 를 이동할 수 없으므로 (나중에 필요하기 때문에) 빌린 것으로 간주됩니다. 나중에 조건부로 k 반환하므로, 차용은 함수 호출보다 오래 지속되는 'a 수명을 가져야합니다. 그러나! 함수가 끝날 때까지만 유지되는 self 에서 차용했습니다. 그 제한은 'a 를 줄여주는 것처럼 보이므로 NLL 하에서도 정신 모델에서 "충분히 오래 살지 않음"오류가 발생해야합니다.

@krdln 우리는 실제로 *self 에서 차용했습니다. 즉, self가 참조하는 것을 다시 빌 렸습니다. 우리는 대출 할 수 있도록 허용 *self 평생이 오래 살지에 대해 self 의 유형 때문에 자신을 self 전체 수명에 대한 '잠금'을 의미 'a . 따라서 'a 동안 self가 더 이상 사용되지 않는다는 것을 보장 할 수있는 한 결과는 배타적 참조가되어야합니다.이 경우 fn이 반환 된 후 self가 팝되었으므로 사용하지 않으므로 fn이 끝날 때까지 self가 사용되지 않도록 보장합니다. (적어도 그게 사실 이길 바랍니다. =)

이것은 비 어휘 수명에서 차단되며 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

(NLL에 의해 고정 된 NLL을 제거 할 때 E-needstest를 제거 했어야합니다)