`$lit:literal` chokes on `-(1)`

I tried this code:

macro_rules! is_literal {
    ($l:literal) => { true };
    ($e:expr) => { false };
}

fn main() {
    println!("{}", is_literal!(-(1)));
}

I expected to see this happen: one of true or false being printed

Given that -(1) is a valid expression, it should be picked up by $e:expr rather than failing at $lit:literal. Or it should be considered a valid literal expression.

Note that it also chokes on similar expressions, such as -(x) and -(x.method()).

Instead, this happened:

error: unexpected token: `(`
 --> src/main.rs:8:33
  |
2 |     ($l:literal) => { true };
  |      ---------- while parsing argument for this `literal` macro fragment
...
8 |     println!("{}", is_literal!(-(1)));
  |                                 ^

Meta

rustc --version --verbose:

rustc 1.73.0 (cc66ad468 2023-10-03)
binary: rustc
commit-hash: cc66ad468955717ab92600c770da8c1601a4ff33
commit-date: 2023-10-03
host: aarch64-apple-darwin
release: 1.73.0
LLVM version: 17.0.2

Happens on beta and nightly too.

Reproduce the macro-fragment parsing failure in src/main.rs using the is_literal! example and the reported rustc version. Investigate how literal and expression fragments handle parenthesized unary expressions; done means -(1), -(x), and -(x.method()) no longer fail during macro matching and produce a defined result.