注意点

Drop が見える範囲になくてもこのパターンになりうる。なぜなら、その型そのものが Drop を実装していなくても、そのフィールドの型が同じように参照を含んで Drop を実装しているならば、親の型にその影響が派生する。

例えば、std の Ref は Drop を実装しない。しかし、そのフィールドは Drop を実装する。そのため、Ref はこのパターンの原因になりうる。

関連エラー

このパターンは以下のエラーにつながる。

• [E0502] 不変参照と可変参照の同時使用 → 該当パターン
• [E0503] 可変参照中の値の使用 → 該当パターン
• [E0505] 参照中の変数の移動 → 該当パターン
• [E0506] 参照中の変数への書込 → 該当パターン
• and more?

サンプル (Drop あり)

以下では、_refs のライフタイムが延長されている。

fn main() {
    let mut var = 1;
    let _refs = MyRef(&var);
    var = 2;
    dbg!(var);
}

struct MyRef<'a>(&'a i32);
impl Drop for MyRef<'_> {
    fn drop(&mut self) {
        println!("ID [{}] is drpoped.", self.0)
    }
}

error[E0506]: cannot assign to `var` because it is borrowed
 --> src\main.rs:4:5
  |
3 |     let _refs = MyRef(&var);
  |                       ---- `var` is borrowed here
4 |     var = 2;
  |     ^^^^^^^ `var` is assigned to here but it was already borrowed
5 |     dbg!(var);
6 | }
  | - borrow might be used here, when `_refs` is dropped and runs the `Drop` code for type `MyRef`

サンプル (Drop なし)

以下では、MyRef1 には Drop が実装されていない。

fn main() {
    let mut var = 1;
    let _refs = MyRef1::new(&var);
    var = 2;
    dbg!(var);
}

struct MyRef1<'a>(MyRef2<'a>);
impl<'a> MyRef1<'a> {
    pub fn new(refs: &'a i32) -> Self {
        Self(MyRef2(refs))
    }
}

struct MyRef2<'a>(&'a i32);
impl Drop for MyRef2<'_> {
    fn drop(&mut self) {
        println!("ID [{}] is drpoped.", self.0)
    }
}

error[E0506]: cannot assign to `var` because it is borrowed
 --> src\main.rs:4:5
  |
3 |     let _refs = MyRef1::new(&var);
  |                             ---- `var` is borrowed here
4 |     var = 2;
  |     ^^^^^^^ `var` is assigned to here but it was already borrowed
5 |     dbg!(var);
6 | }
  | - borrow might be used here, when `_refs` is dropped and runs the destructor for type `MyRef1<'_>`

注意点

Drop が未使用でもこのパターンになりうる。なぜなら、トレイトが抽象化した型が Drop を実装している可能性がある。そのため、それらの用法も予めエラーにする必要がある。なお、この場合のトレイトによる抽象化は動的になる (静的なら型の全構造が分かるため、どこで Drop が使用されているかを完全に把握できる)。

関連エラー

このパターンは E0597 の特定パターンにつながる。

サンプル (Drop あり)

以下では、drop の時点で &data.id はダングリングポインタかもしれない。

fn main() {
    let mut data = MyData::default();
    data.on_drop = Some(OnDrop(&data.id));
}

#[derive(Default)]
struct MyData<'a> {
    id: i32,
    on_drop: Option<OnDrop<'a>>,
}

struct OnDrop<'a>(&'a i32);
impl<'a> Drop for OnDrop<'a> {
    fn drop(&mut self) {
        println!("ID [{}] is drpoped.", self.0)
    }
}

error[E0597]: `data.id` does not live long enough
 --> src\main.rs:3:38
  |
2 |     let mut data = MyData::default();
  |         -------- binding `data` declared here
3 |     data.on_drop = Some(OnDrop(&data.id));
  |                                ^^^^^^^^ borrowed value does not live long enough
4 | }
  | -
  | |
  | `data.id` dropped here while still borrowed
  | borrow might be used here, when `data` is dropped and runs the destructor for type `MyData<'_>`

サンプル (Drop なし)

以下では、MyTrait の具象型が Drop を実装する可能性がある。

fn main() {
    let mut data = MyData::default();
    data.my_trait = Some(Box::new(MyType(&data.id)));
    data.my_trait.unwrap().print_id();
}

#[derive(Default)]
struct MyData<'a> {
    id: i32,
    my_trait: Option<Box<dyn MyTrait<'a> + 'a>>,
}

trait MyTrait<'a> {
    fn print_id(&self); 
}

struct MyType<'a>(&'a i32);
impl<'a> MyTrait<'a> for MyType<'a> {
    fn print_id(&self) {
        println!("ID is [{}].", self.0);
    }
}

error[E0597]: `data.id` does not live long enough
 --> src\main.rs:3:42
  |
2 |     let mut data = MyData::default();
  |         -------- binding `data` declared here
3 |     data.my_trait = Some(Box::new(MyType(&data.id)));
  |                                          ^^^^^^^^ borrowed value does not live long enough
4 |     data.my_trait.unwrap().print_id();
5 | }
  | -
  | |
  | `data.id` dropped here while still borrowed
  | borrow might be used here, when `data` is dropped and runs the destructor for type `MyData<'_>`