Closures needlessly capture all generic parameters from parent item in TAIT

[jwong101]

I tried this code:

#![feature(type_alias_impl_trait)]

type Tait = impl Sized + 'static;

fn capture<T>() -> Tait {
    || 0u8
}

I expected to see this happen:

Successful compilation, since the generic parameter T is not used in the returned closure.

Instead, this happened:

   Compiling playground v0.0.1 (/playground)
error: type parameter `T` is part of concrete type but not used in parameter list for the `impl Trait` type alias
 --> src/lib.rs:6:5
  |
6 |     || 0u8
  |     ^^^^^^

This error also happens when returning async blocks:

// same error
fn capture_async<T>() -> Tait {
    async {
        0u8
    }
}

Also, this appears to only affect generic type parameters, as lifetimes aren't captured if the closure doesn't use them:

// compiles
fn capture_lt<'a>(_: &'a ()) -> Tait {
    || 0u8
}

Meta

Version:

rustc 1.76.0-nightly (2023-11-19 9a66e4471f71283fd54d)

[compiler-errors]

I don't think analysis is smart enough (or will become smart enough any time soon) to detect when the closure actually requires T to be captured. For example, if we use T inside the body:

fn test<T: Default>() -> impl Fn() {
  || { let _ = T::default(); }
}

but don't actually return it, we still need to capture T. This requires performing inference in the body of the closure, since we may only use T indirectly after doing method selection, for example.

[h33p]

I don't think analysis is smart enough (or will become smart enough any time soon) to detect when the closure actually requires T to be captured. For example, if we use T inside the body:

fn test<T: Default>() -> impl Fn() {
  || { let _ = T::default(); }
}

but don't actually return it, we still need to capture T. This requires performing inference in the body of the closure, since we may only use T indirectly after doing method selection, for example.

This one could in theory be lowered to fn() type, making the capture unnecessary. But this doesn't help the case, it instead makes it more complicated.

The general rule here seems to be "require T if the closure holds T, or returns T". Now, if we have a new type for each impl Fn() (aside from fn()), then we need to add "require T if T is used, unless impl Fn() is fn()".

None of these seem to be backwards incompatible changes, but yeah, tricky to implement.