`async fn` can assign to argument to change its lifetime, but normal `fn` and `async` blocks cannot.

[theemathas]

I tried this code:

#![allow(unused)]
async fn works<'a>(mut a: &'a i32, b: i32) {
    a = &b;
}
fn fails<'a>(mut a: &'a i32, b: i32) {
    a = &b;
}
fn also_fails<'a>(mut a: &'a i32, b: i32) -> impl Future<Output = ()> {
    async move {
        a = &b;
    }
}

I expected all 3 functions to compile, or all to fail to compile, but instead only the first function compiles:

error[E0521]: borrowed data escapes outside of async block
  --> src/lib.rs:10:9
   |
 8 | fn also_fails<'a>(mut a: &'a i32, b: i32) -> impl Future<Output = ()> {
   |                   ----- `a` declared here, outside of the async block body
 9 |     async move {
10 |         a = &b;
   |         ^^^^--
   |         |   |
   |         |   borrow is only valid in the async block body
   |         reference to `b` escapes the async block body here

error[E0597]: `b` does not live long enough
 --> src/lib.rs:6:9
  |
5 | fn fails<'a>(mut a: &'a i32, b: i32) {
  |          --                  - binding `b` declared here
  |          |
  |          lifetime `'a` defined here
6 |     a = &b;
  |     ----^^
  |     |   |
  |     |   borrowed value does not live long enough
  |     assignment requires that `b` is borrowed for `'a`
7 | }
  |  - `b` dropped here while still borrowed

Some errors have detailed explanations: E0521, E0597.
For more information about an error, try `rustc --explain E0521`.

Edit: The part below is filed separately as #148401

A different issue that's now filed separately

Additionally, there's this variant which has a very strange diagnostic that I don't understand:

#![allow(unused)]
fn weird<'a, 'b>(mut a: &'a i32, b: &'b i32) -> impl Future<Output = ()> + use<'a, 'b> {
    async move {
        a = b;
    }
}

error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
 --> src/lib.rs:3:5
  |
2 |   fn weird<'a, 'b>(mut a: &'a i32, b: &'b i32) -> impl Future<Output = ()> + use<'a, 'b> {
  |                                                   -------------------------------------- opaque type defined here
3 | /     async move {
4 | |         a = b;
5 | |     }
  | |_____^
  |
  = note: hidden type `{async block@src/lib.rs:3:5: 3:15}` captures lifetime `'_`

For more information about this error, try `rustc --explain E0700`.

See also #128225, where a variable can be assigned a value with a different lifetime.

Related to #148463, where a similar inconsistency occurs with patterns in function arguments.

Meta

Reproducible on the playground with version 1.93.0-nightly (2025-11-01 bd3ac0330018c23b111b)

[theemathas]

async blocks also can't assign to variables in a way that causes self-reference, if the involved variables are captured from the environment:

#![allow(unused)]
fn main() {
    let mut a = 0;
    let mut b = &1;
    async move {
        b = &a;
    };
}

error[E0521]: borrowed data escapes outside of async block
 --> src/main.rs:6:9
  |
4 |     let mut b = &1;
  |         ----- `b` declared here, outside of the async block body
5 |     async move {
6 |         b = &a;
  |         ^^^^--
  |         |   |
  |         |   borrow is only valid in the async block body
  |         reference to `a` escapes the async block body here

For more information about this error, try `rustc --explain E0521`.

I think that this should compile.

[theemathas]

Edit: Filed as #148401

The "very strange diagnostic that I don't understand" can be reduced to this:

struct SameLifetime<'a>(&'a i32, &'a i32);

fn weird<'a, 'b>(a: &'a i32, b: &'b i32) -> impl Sized + use<'a, 'b> {
    SameLifetime(a, b)
}

error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
 --> src/lib.rs:6:5
  |
5 | fn weird<'a, 'b>(mut a: &'a i32, b: &'b i32) -> impl Sized + use<'a, 'b> {
  |                                                 ------------------------ opaque type defined here
6 |     SameLifetime(a, b)
  |     ^^^^^^^^^^^^^^^^^^
  |
  = note: hidden type `SameLifetime<'_>` captures lifetime `'_`

For more information about this error, try `rustc --explain E0700`.

I'm not sure if specifically this part of the issue is a bug or not. It seems related to #128752

More concise version

fn weird(a: &i32, b: &i32) -> impl Sized {
    [a, b]
}

error[E0700]: hidden type for `impl Sized` captures lifetime that does not appear in bounds
 --> src/lib.rs:2:5
  |
1 | fn weird(a: &i32, b: &i32) -> impl Sized {
  |                               ---------- opaque type defined here
2 |     [a, b]
  |     ^^^^^^
  |
  = note: hidden type `[&i32; 2]` captures lifetime `'_`

For more information about this error, try `rustc --explain E0700`.