Unhelpful compiler message when a reference is used inside of an await block

[DusterTheFirst]

When using a reference to self in an instance method and then attempting to call another method on the self reference inside of a async block (static lifetime) i get this unhelpful error, that does not mention anywhere where the usage of self is problematic. All it shows is where the block begins, and then where the self was defined.

The actual problem was on line 106, never mentioned in the error (inside of the async block)

[hellow554]

Hey @DusterTheFirst

as the tag suggests, we need an mcve to reproduce the issue. Can you share the login function, or better the project with us? E.g. a github link or similar, or maybe you can minimize the problem.

E.g. down to one file, preferable reproduceable on the playground.

If you need any help, just post it here, we are more than willing to help you.

[DusterTheFirst]

MCVE

use async_std::task;
use std::sync::{
    atomic::{AtomicU32, Ordering},
    Arc,
};

#[async_std::main]
async fn main() {
    let problem = Problem::new();
    problem.start().await;
}

struct Problem {
    x: Arc<AtomicU32>,
}

impl Problem {
    pub fn new() -> Problem {
        Problem {
            x: Arc::new(AtomicU32::new(0)),
        }
    }

    pub async fn start(&self) {
        // An arbitrary **SAFE** access to a value held "inside" of self
        let x = self.x.clone();

        // Spawn concurrent task
        task::spawn(async move { // <== This whole block is shown as the error, even though the problem lies within one line
            loop {
                // Some arbitrary other operation that occurs using self (but is not causing a problem)
                x.fetch_sub(1, Ordering::Relaxed);

                // A call on self that is causing the problem, but not explained in the error
                self.fn_that_takes_self().await;
            }
        });

        loop {
            // This works fine
            self.fn_that_takes_self().await;
        }
    }

    pub async fn fn_that_takes_self(&self) {
        // Use the self variable
        self.x.fetch_add(1, Ordering::Relaxed);
    }
}

The soulution to the problem, is to wrap the self into an arc so that it can be accessed by the 'static task and the other task simultaneously, which is not apparent from the error message.

Unhelpful Error message

The Error message should at least mention the line where the self is being used as to make it 'static. But for the sake of developer friendliness should also provide information that the reference cannot be passed safely through tasks without using a construct from std::sync.

Workaround to allow for both tasks to access self

use async_std::task;
use std::sync::{
    atomic::{AtomicU32, Ordering},
    Arc,
};

#[async_std::main]
async fn main() {
    let problem = Arc::new(Problem::new());
    problem.start().await;
}

struct Problem {
    x: Arc<AtomicU32>,
}

impl Problem {
    pub fn new() -> Problem {
        Problem {
            x: Arc::new(AtomicU32::new(0)),
        }
    }

    pub async fn start(self: Arc<Self>) {
        // An arbitrary **SAFE** access to a value held "inside" of self
        let x = self.x.clone();
        
        let arc_self = self.clone();

        // Spawn concurrent task
        task::spawn(async move {
            loop {
                // Some arbitrary other operation that occurs using self (but is not causing a problem)
                x.fetch_sub(1, Ordering::Relaxed);

                arc_self.fn_that_takes_self().await;
            }
        });

        loop {
            // This works fine (as it should)
            self.fn_that_takes_self().await;
        }
    }

    pub async fn fn_that_takes_self(&self) {
        // Use the self variable
        self.x.fetch_add(1, Ordering::Relaxed);
    }
}

[Aaron1011]

Minimized:

fn require_static<T: 'static>(val: T) -> T { val }

struct Problem;

impl Problem {
    pub async fn start(&self) {
        require_static(async move {
            &self;
        });
    }
}

fn main() {}

[Aaron1011]

This error is emitted during type-checking. In order to emit a nicer error, I think we'll need -Z borrowck=mir to be enabled, so that we have access to MIR when we construct the error.

cc @matthewjasper

[yoshuawuyts]

This is the current compiler output (June 2021, Rust 1.53):

   Compiling playground v0.0.1 (/playground)
error[E0759]: `self` has an anonymous lifetime `'_` but it needs to satisfy a `'static` lifetime requirement
 --> src/main.rs:6:24
  |
6 |     pub async fn start(&self) {
  |                        ^^^^^
  |                        |
  |                        this data with an anonymous lifetime `'_`...
  |                        ...is captured here...
7 |         require_static(async move {
  |         -------------- ...and is required to live as long as `'static` here

This seems like it addresses the issue raised here?