Borrow checking can be effected by seemingly irrelevant statements

[matthewjasper]

I tried this code:

trait Trait { type Item; }

impl<'a, X> Trait for &'a Vec<X> {
    type Item = &'a X;
}

impl<X> Trait for Box<dyn Trait<Item = X>> {
    type Item = X;
}

fn make_dyn_trait(_: &()) -> Box<dyn Trait<Item = &()>> {
    todo!()
}

struct diff<'a, M, N, S>(N, S)
where
    M: 'a,
    N: Trait<Item = &'a M>,
    S: Trait<Item = &'a M>;

fn may_panic<X>(_: X) { }

struct Droppable;

impl Drop for Droppable {
    fn drop(&mut self) {}
}


fn main() {
    let dyn_trait = make_dyn_trait(&());
    let storage = vec![()];
    let _x = may_panic(());
    let storage_ref = &storage;
    // Comment this line and compilation fails
    let a = Droppable;
    diff(dyn_trait, storage_ref);
}

I expected to see this happen: Commenting let statement has no effect on borrowck

Instead, this happened: borrowck succeed with the additional statement

See #80949 (comment) for an explanation of a similar bug that occurred after a change in mir generation.

[TechHara]

I have also encountered a similar issue. Having any statement at the end seems to compile.

use std::cell::RefCell;
use std::rc::Rc;

pub struct Node {
    pub next: Option<Rc<RefCell<Node>>>,
}

pub fn foo(root: Option<Rc<RefCell<Node>>>) {
    let mut queue = Vec::new();
    if let Some(x) = root {
        queue.push(x);
    }
    while !queue.is_empty() {
        let x = queue.pop().unwrap();
        if let Some(next) = x.borrow().next.clone() {
            queue.push(next);
        }
        // uncommenting any of the following will compile
        // ()
        // 0;
        // let completely_random_var = 0;
    }
}

fn main() {}

[TechHara]

Strangely enough, change below also successfully compiles.

--- before
+++ after
@@ -10,15 +10,10 @@
     if let Some(x) = root {
         queue.push(x);
     }
-    while !queue.is_empty() {
-        let x = queue.pop().unwrap();
+    while let Some(x) = queue.pop() {
         if let Some(next) = x.borrow().next.clone() {
             queue.push(next);
         }
-        // uncommenting any of the following will compile
-        // ()
-        // 0;
-        // let completely_random_var = 0;
     }
 }

[matthewjasper]

@TechHara I believe that's #69367

[matthewjasper]

This should probably be left until flow sensitive outlives (Polonius) is stabilized. In this example the inconsistent behaviour with the let x line can be fixed by adding more basic blocks to the MIR, but adding the second line results in MIR that needs more than basic block differences.

trait Trait {
    type Item;
}

impl<'a, X> Trait for &'a Vec<X> {
    type Item = &'a X;
}

impl<'a> Trait for &'a Droppable {
    type Item = &'a ();
}

impl<X> Trait for Box<dyn Trait<Item = X>> {
    type Item = X;
}

fn make_dyn_trait(_: &()) -> Box<dyn Trait<Item = &()>> {
    todo!()
}

struct diff<'a, 'b, M, N, S>(&'b N, &'b S)
where
    M: 'a,
    N: Trait<Item = &'a M>,
    S: Trait<Item = &'a M>;

fn may_panic<X>(_: X) {}

struct Droppable;

impl Drop for Droppable {
    fn drop(&mut self) {}
}

fn main2(c: bool) {
    let dyn_trait = make_dyn_trait(&());
    let (storage, mut optional_diff) = (Droppable, None);
    // uncomment this line only and this compiles
    // let x = String::new();
    let storage_ref = &storage;
    // uncomment this line and the line above doesn't change things
    // let y = String::new();
    optional_diff = Some(diff(&{ dyn_trait }, &storage_ref));
}