Make tokio-macros attributes more IDE friendly

[Veykril]

Motivation

Fixes #4154

Solution

As outlined in the aforementioned issue, in case the attribute fails its expansion for whatever reason, it now emits the input item alongside the compile_error! macro invocation to keep the item alive for IDE analysis.

[taiki-e]

impl LGTM. Could you add a short comment about why this trick is necessary? (because this is not a common pattern)

[Darksonn]

There is an alternative to the above implementation, which seems even better: First, move this entire thing into a new function that returns a Result<FinalConfig, SomeError>:

tokio/tokio-macros/src/entry.rs

Lines 193 to 281 in f0cb360

	if input.sig.asyncness.take().is_none() {
	let msg = "the `async` keyword is missing from the function declaration";
	return Err(syn::Error::new_spanned(input.sig.fn_token, msg));
	}
	let mut config = Configuration::new(is_test, rt_multi_thread);
	let macro_name = config.macro_name();
	for arg in args {
	match arg {
	syn::NestedMeta::Meta(syn::Meta::NameValue(namevalue)) => {
	let ident = namevalue
	.path
	.get_ident()
	.ok_or_else(|| {
	syn::Error::new_spanned(&namevalue, "Must have specified ident")
	})?
	.to_string()
	.to_lowercase();
	match ident.as_str() {
	"worker_threads" => {
	config.set_worker_threads(
	namevalue.lit.clone(),
	syn::spanned::Spanned::span(&namevalue.lit),
	)?;
	}
	"flavor" => {
	config.set_flavor(
	namevalue.lit.clone(),
	syn::spanned::Spanned::span(&namevalue.lit),
	)?;
	}
	"start_paused" => {
	config.set_start_paused(
	namevalue.lit.clone(),
	syn::spanned::Spanned::span(&namevalue.lit),
	)?;
	}
	"core_threads" => {
	let msg = "Attribute `core_threads` is renamed to `worker_threads`";
	return Err(syn::Error::new_spanned(namevalue, msg));
	}
	name => {
	let msg = format!(
	"Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`",
	name,
	);
	return Err(syn::Error::new_spanned(namevalue, msg));
	}
	}
	}
	syn::NestedMeta::Meta(syn::Meta::Path(path)) => {
	let name = path
	.get_ident()
	.ok_or_else(|| syn::Error::new_spanned(&path, "Must have specified ident"))?
	.to_string()
	.to_lowercase();
	let msg = match name.as_str() {
	"threaded_scheduler" | "multi_thread" => {
	format!(
	"Set the runtime flavor with #[{}(flavor = \"multi_thread\")].",
	macro_name
	)
	}
	"basic_scheduler" | "current_thread" | "single_threaded" => {
	format!(
	"Set the runtime flavor with #[{}(flavor = \"current_thread\")].",
	macro_name
	)
	}
	"flavor" | "worker_threads" | "start_paused" => {
	format!("The `{}` attribute requires an argument.", name)
	}
	name => {
	format!("Unknown attribute {} is specified; expected one of: `flavor`, `worker_threads`, `start_paused`", name)
	}
	};
	return Err(syn::Error::new_spanned(path, msg));
	}
	other => {
	return Err(syn::Error::new_spanned(
	other,
	"Unknown attribute inside the macro",
	));
	}
	}
	}
	let config = config.build()?;

Then, if the call to the method fails, we simply run the rest of the macro using a dummy config such as FinalConfig { flavor: current_thread, worker_threads: None, start_paused: None }, then add the compile_error! annotation at the end of that.

This way, the macro output is much closer to what it would be without the error.

[Veykril]

That is definitely an even better approach 👍

[Darksonn]

It seems like the #[tokio::test] macro isn't currently working correctly, causing CI to fail.

[Darksonn]

Please avoid force pushing the PR. It makes it difficult for me to see what has changed since I last looked at the PR.

[Veykril]

Sorry, a habit from another repo.
The sole change was that build_config mutated the signature(which was then discarded), moved the mutation to parse_knobs now.

[Darksonn]

Looks good to me. If it also passes CI, then we can merge it.

[Darksonn]

@Veykril Did you try whether your change actually makes rust-analyzer happy?

[Veykril]

Yep, here is a gif of before the PR

and one of after the PR

(Note everything suddenly going red is a bug in rust analyzer still, important part here are the completions)

[Noah-Kennedy]

Thanks for this improvement

[astrolemonade]

Hey! This is still happening, unfortunately! rust version rustc 1.85.0 (4d91de4e4 2025-02-17). Can you please have a look?
src/lib.rs:

pub struct Environment {
    pub name: String,
}

/tests/integration.rs

use example::Environment;

#[tokio::test]
async fn my_test() {
    let mut env = Environment {
        name: String::from("example")
    };
}

and
Cargo.toml

[package]
name = "example"
version = "0.1.0"
edition = "2024"

[dependencies]
tokio = { version = "1.44.1", features = ["full"] }

Trying to access env. doesn't show anything. It's weird that after expanding the macro:

// Recursive expansion of test macro
// ==================================

#[::core::prelude::v1::test]
fn my_test() {
    let body = async {
        let mut env = Environment {
            name: String::from("example"),
        };
    };
    let mut body = body;
    #[allow(unused_mut)]
    let mut body = unsafe { tokio::macros::support::Pin::new_unchecked(&mut body) };
    let body: ::core::pin::Pin<&mut dyn ::core::future::Future<Output = ()>> = body;
    #[allow(
        clippy::expect_used,
        clippy::diverging_sub_expression,
        clippy::needless_return
    )]
    {
        return tokio::runtime::Builder::new_current_thread()
            .enable_all()
            .build()
            .expect("Failed building the Runtime")
            .block_on(body);
    }
}

The completion works under the async block where env is defined.

[pallix]

@astrolemonade I have the same problem with emacs and actix::test.