Disable code Action for clippy::needless_return

[aminya]

Rust-analyzer has started to give code action suggestions for removing return from my code despite me allowing clippy::needless_return via #![allow(clippy::needless_return)].

In my coding style, I do not like my returns to be implicit, and I don't really align with the push to force not using return statements in the Rust tooling (e.g. Clippy, Rust-analyzer, etc).

Could you add an option to remove this code action, or respect the clippy configuration enabled at the module level?

rust-analyzer version: 0.4.1838-standalone

rustc version: rustc 1.75.0-nightly (42b1224e9 2023-10-15)

relevant settings: (eg. client settings, or environment variables like CARGO, RUSTC, RUSTUP_HOME or CARGO_HOME)

The offending feature:

#16460

[lnicola]

Unfortunately, I don't think we respect #[allow(clippy::needless_return)] yet, but in VS Code you can disable it using:

{
    "rust-analyzer.diagnostics.disabled": [
        "needless_return"
    ]
}

[j0ni]

Weirdly, I see this showing up via eglot in emacs on a function which does not contain an explicit return.

It's annotated with a #[tokio::main] macro, so I guess the problem lies somewhere in the expanded code? I look forward to a working lints.rust (or lints.clippy I guess) entry for this!

[I-Info]

Maybe this rule should not be applied on the macro expansions. 🤔

[Veykril]

Our filtering for diagnostic level attributes is somewhat broken wrt to macros, that is a known issue.

[lnicola]

It should respect #[allow(clippy::needless_return)], but tokio::main doesn't even seem to expand to that. It only has #[allow(clippy::expect_used, clippy::diverging_sub_expression)] for me.

[Veykril]

Might be that needless_return doesn't trigger on macro expansions with clippy

[lnicola]

No, I think it's something kind of heuristic:

// no warning
fn main() {
    return tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()
        .expect("Failed building the Runtime")
        .block_on(async {});
}

// warning
fn main() {
    return tokio::runtime::Runtime::new()
        .expect("Failed building the Runtime")
        .block_on(async {});
}

// warning
fn main() {
    return tokio::runtime::Builder::new_current_thread()
        .build()
        .expect("Failed building the Runtime")
        .block_on(async {});
}

[lnicola]

I suspect it's this check: https://github.com/rust-lang/rust-clippy/blob/d2f76f7/clippy_lints/src/returns.rs#L378-L381.

[Veykril]

Oh, that's probably due to temporaries? (Then we most likelyneed that as well)

[lnicola]

Yeah: https://github.com/rust-lang/rust-clippy/blame/48b4aea/clippy_lints/src/returns.rs#L19-L20

Known problems: If the computation returning the value borrows a local variable, removing the return may run afoul of the borrow checker.

Sounds like a limitation of Clippy itself (it's too conservative here), but we probably want to match it anyway.

[arnfaldur]

Is there any way to disable this behavior?

[lnicola]

@arnfaldur see my comment at the top.

[arnfaldur]

@lnicola ah, sorry, didn't think too much about that as I don't use VSCode. There must be some way to configure LSPs in vim/emacs like that. I'll figure it out, thanks.