Extract type as type alias produces invalid code with trait object lifetime inference

[ChrisJefferson]

rust-analyzer version: (eg. output of "rust-analyzer: Show RA Version" command, accessible in VSCode via Ctrl/⌘+Shift+P)

rust-analyzer version: 0.3.2509-standalone [/home/caj/.vscode-server/extensions/rust-lang.rust-analyzer-0.3.2509-linux-x64/server/rust-analyzer]

rustc version: (eg. output of rustc -V)

rustc 1.87.0 (17067e9ac 2025-05-09)

editor or extension: (eg. VSCode, Vim, Emacs, etc. For VSCode users, specify your extension version; for users of other editors, provide the distribution if applicable)

VSCode

Consider the following code.

fn main() {
    let step = 3;
    let funcs: Box<dyn Fn(i64) -> i64> = Box::new(|i| i + step);

    println!("Hello, world! {}", funcs(2));
}

Select the type of 'funcs' and select 'Extract type as type alias'. This produces:

type Type = Box<dyn Fn(i64) -> i64>;

fn main() {
    let step = 3;
    let funcs: Type = Box::new(|i| i + step);

    println!("Hello, world! {}", funcs(2));
}

Which doesn't compile with error:

error[E0597]: `step` does not live long enough
 --> src/main.rs:5:40
  |
4 |     let step = 3;
  |         ---- binding `step` declared here
5 |     let funcs: Type = Box::new(|i| i + step);
  |                ----            ---     ^^^^ borrowed value does not live long enough
  |                |               |
  |                |               value captured here
  |                type annotation requires that `step` is borrowed for `'static`
...
8 | }
  | - `step` dropped here while still borrowed

[nicolas-guichard]

This is also true for non-lifetime generic parameters:

fn main() {
    let vec: Vec<_> = vec![3];
    dbg!(vec);
}

becomes:

type Type = Vec<_>;

fn main() {
    let vec: Type = vec![3];
    dbg!(vec);
}

[ChayimFriedman2]

@nicolas-guichard That's a completely different issue (easier to fix too).

[ChrisJefferson]

Just for information, the reason I wanted to do this is because cargo clippy is complaining about a too complex type (in my actual code the function is more complex).

[Hmikihiro]

// This type has an implicit 'static lifetime
type Type = Box<dyn Fn(i64) -> i64 /*+ 'static*/>;

fn main() {
    let step = 3;
    let funcs: Type = Box::new(|i| i + step);

    println!("Hello, world! {}", funcs(2));
}

Would adding a lifetime parameter like this resolve the issue?

type Type<'a> = Box<dyn Fn(i64) -> i64 + 'a>;

fn main() {
    let step = 3;
    let funcs: Type<'_> = Box::new(|i| i + step);

    println!("Hello, world! {}", funcs(2));
}