Fails to parse attribute in expression: `return #[attr] v.f();` inside attribute macro's input.

[programmerjake]

Gives error:
Syntax Error: expected SEMICOLON on the return in lib.rs.

rust-analyzer version: rust-analyzer version: 0.3.2862-standalone [/home/jacob/.vscode-oss/extensions/rust-lang.rust-analyzer-0.3.2862-linux-x64/server/rust-analyzer]

rustc version: rustc 1.93.0 (254b59607 2026-01-19)

editor or extension: VSCodium with rust-analyzer extension

relevant settings:

{
  "rust-analyzer.imports.prefix": "crate",
  "rust-analyzer.imports.merge.glob": false,
  "rust-analyzer.cargo.features": "all",
  "rust-analyzer.runnables.extraTestBinaryArgs": [
      "--nocapture"
  ],
  "rust-analyzer.checkOnSave": true,
}

code snippet to reproduce:

Rustc compiles it with no errors or warnings:
https://play.rust-lang.org/?version=stable&mode=debug&edition=2024&gist=a0e293172a696adb24d2255941a1ad52

my_macro:

const BODY: &str = r#"
pub fn f(v: S) -> bool {
    return v.f();
}
"#;
use proc_macro::TokenStream;
#[proc_macro_attribute]
pub fn my_macro(_arg: TokenStream, _body: TokenStream) -> TokenStream {
    BODY.parse().unwrap()
}

lib:

pub struct S;

impl S {
    fn f(self) -> bool {
        true
    }
}

#[my_macro::my_macro]
pub fn f(v: S) -> bool {
    return #[foo] v.f();
}

[programmerjake]

it looks like this should be fixed by adding # to the list of tokens that can start an expression here:

rust-analyzer/crates/parser/src/grammar/expressions.rs

Line 17 in 7bf346e

const EXPR_FIRST: TokenSet = LHS_FIRST;

rust-analyzer/crates/parser/src/grammar/expressions.rs

Lines 326 to 327 in 7bf346e

	const LHS_FIRST: TokenSet =
	atom::ATOM_EXPR_FIRST.union(TokenSet::new(&[T![&], T![*], T![!], T![.], T![-], T![_]]));

rust-analyzer/crates/parser/src/grammar/expressions/atom.rs

Lines 42 to 68 in 7bf346e

	pub(super) const ATOM_EXPR_FIRST: TokenSet =
	LITERAL_FIRST.union(paths::PATH_FIRST).union(TokenSet::new(&[
	T!['('],
	T!['{'],
	T!['['],
	T![|],
	T![async],
	T![break],
	T![const],
	T![continue],
	T![do],
	T![gen],
	T![for],
	T![if],
	T![let],
	T![loop],
	T![match],
	T![move],
	T![return],
	T![become],
	T![static],
	T![try],
	T![unsafe],
	T![while],
	T![yield],
	LIFETIME_IDENT,
	]));

The set should be changed to match rustc:
https://github.com/rust-lang/rust/blob/5095b44caf4a043fb34250c6a70b78ca59b718e0/compiler/rustc_ast/src/token.rs#L670-L698

    pub fn can_begin_expr(&self) -> bool {
        match self.uninterpolate().kind {
            Ident(name, is_raw)              =>
                ident_can_begin_expr(name, self.span, is_raw), // value name or keyword
            OpenParen                         | // tuple
            OpenBrace                         | // block
            OpenBracket                       | // array
            Literal(..)                       | // literal
            Bang                              | // operator not
            Minus                             | // unary minus
            Star                              | // dereference
            Or | OrOr                         | // closure
            And                               | // reference
            AndAnd                            | // double reference
            // DotDotDot is no longer supported, but we need some way to display the error
            DotDot | DotDotDot | DotDotEq     | // range notation
            Lt | Shl                          | // associated path
            PathSep                           | // global path
            Lifetime(..)                      | // labeled loop
            Pound                             => true, // expression attributes
            OpenInvisible(InvisibleOrigin::MetaVar(
                MetaVarKind::Block |
                MetaVarKind::Expr { .. } |
                MetaVarKind::Literal |
                MetaVarKind::Path
            )) => true,
            _ => false,
        }
    }```

[programmerjake]

@rustbot label +A-parser