macros: Improve IDE support

[nurmohammed840]

This refectory improve performance and enhance better compatibility with IDEs.

Here is two examples,

Before: Note that there is no inlay hints for function arguments.

After: Fixed inlay hint hints problem. channel(buffer: .., tokio::spawn(future: ..

---

Before: On syntax error. Run Test | Debug button dissipated. which is frustrating because the editor toggles back and forth while typing.

After: It fix that.

---

It introduce two changes:

1. Remove spaned, Because as it's not meant to be used here.
2. The function body is preserved as is.

[nurmohammed840]

I will send a fix tomorrow.

[nurmohammed840]

What’s really blocking the CI is that,

Current changes preserved async body as-is:

#[tokio::main]
async fn test_with_semicolon_without_return_type() {
    #![deny(clippy::semicolon_if_nothing_returned)]
    #[deny(clippy::semicolon_if_nothing_returned)]
    0;
}

So would convert into:

fn test_with_semicolon_without_return_type() {
    let body = async {
        #![deny(clippy::semicolon_if_nothing_returned)] // ❌
        #[deny(clippy::semicolon_if_nothing_returned)]
        0;
    };
    ...
}

I didn’t realize this, The previous implementation moved global inner attributes outside:

#[deny(clippy::semicolon_if_nothing_returned)]
fn test_with_semicolon_without_return_type() {
    let body = async {
        #[deny(clippy::semicolon_if_nothing_returned)]
        0;
    };
    ...
}

There are many ways to address this issue.
@Darksonn, The real question is, is it worth this fix? The documentation doesn’t mention this behavior.

[Darksonn]

If you believe the output changes are acceptable, you can update the outputs to make the tests pass. See tests-build/README.md for instructions. Then we will review whether the changes are important.

But keep in mind that just because something is not explained in the documentation, that doesn't mean we can just change it. We don't want to break existing users of the macro.

[davidbarsky]

Speaking as a person who works on rust-analyzer:

• I think the span changes are probably good?
• From a hygiene perspective, I worry about the type inference breakage. I think it's important to those to avoid breaking users.
• From a general "how does this this macro work does it work for IDEs" perspective, having the macro return the original tokens such that the expanded (but incorrect!) macro looks mostly correct would go a long way in terms of providing a good IDE experience.

[nurmohammed840]

Oh! It turns out span is used for type suggestion in return or end statements, so I'll revert the previous change.

Seems like it also fix some code suggestion: #3766

[nurmohammed840]

Fixed: #6930, #6306
Fixed: #5518, when fn main() accept no args

I didn’t encounter any problems #3579, Maybe this was already fixed previously

[taiki-e]

Thanks! Changes to parse_knobs and ItemFn looks generally good to me.

[taiki-e]

It seems that the double tokio::test attribute are now allowed?

tokio/tests-build/tests/fail/macros_invalid_input.rs

Lines 67 to 68 in d08578f

	#[tokio::test]
	#[tokio::test]

[nurmohammed840]

[tokio::test] attribute are now allowed ?

No user will receive a hard error as before. but the error message is slightly different.

[taiki-e]

Hmm, which is the new warning for this test function? The old version of the stderr file has an error referring to L67, but the new version has no error referring to L67-L69, which this test function contains.

[taiki-e]

I think this is wrong when code contains Self keyword. (see also #6306 (comment))

[nurmohammed840]

• fn method(self) { ... }
• fn method(self: ..) { ... }
  The self keyword is considered a function argument. And will fallback to async closure. Here is a test case for it.

[taiki-e]

I'm talking about Self that starts with an uppercase letter, not all lowercase self.

For example:

impl MyStruct {
    #[tokio::main]
    async fn func() {
        let mut this = Self::defalt(); 
        //             ^^^^

        // ...
    }
}

[nurmohammed840]

Aha! So in this case, we have to fallback to async block.

[taiki-e]

I think the cases where Self is included in the return type, generics, or where clause will still be missed.

[nurmohammed840]

I should be fine. We don't need to fallback to async block, If generics or return position contain Self keyword.

[taiki-e]

No. For example, the following conversion is incorrect:

impl MyStruct {
    // From:
    // #[tokio::main]
    // async fn func() -> Self { todo!() }
    //
    // To:
    fn func() -> Self {
        async fn func() -> Self { todo!() }
        let body = func();
        // ...
    }
}

error[E0401]: can't use `Self` from outer item
 --> src/lib.rs:9:28
  |
2 | impl MyStruct {
  | ---- `Self` type implicitly declared here, by this `impl`
...
9 |         async fn func() -> Self { todo!() }
  |                            ^^^^
  |                            |
  |                            use of `Self` from outer item
  |                            refer to the type directly here instead