failed to parse if_chain macro invocation

[digama0]

Here's a simple version of the problem using the if_chain macro:

#[macro_use] extern crate if_chain;

fn main() {
  if_chain! {
    then { let _ = drop(()); }
  }
}

In rustc this works fine, but rust-analyzer marks the (()) as failed to parse macro invocation. Note that if_chain! is a macro_rules macro, so this is an issue in macro expansion. The contents of the then { ... } branch is matched using the matcher then { $($then:tt)* } so even though this portion of the code is mostly untouched by the macro (it's supposed to expand to just let _ = drop(());) it is matched as a list of token trees, of which (()) is one of them. The let _ = is also part of the error, so it may be getting confused with the other matches in the macro.

[digama0]

Here's a MWE without the use of if_chain:

fn main() {
  macro_rules! identity { ($($es:tt)*) => { $($es)* } }
  identity! { let _ = (); }
}

Adding any tokens after the call to identity, or a semicolon, fixes the error, so I think it has something to do with the fact that this expands directly to a sequence of statements and is used in expression context.

[edwin0cheng]

[deleted]

[digama0]

Are you sure? In the simplified version there is no alternate case to match.

[edwin0cheng]

Yeah, you are right, it is another issue.

[edwin0cheng]

Diagnosis

The syntax tree of that MWE (without semicolon) :

  BLOCK_EXPR
     MACRO_CALL

But with semicolon:

BLOCK_EXPR
   EXPR_STMT
       MACRO_CALL

And in to_fragment_kind: (The function we check what kind of macro should expand)

https://github.com/rust-analyzer/rust-analyzer/blob/b7fa6dfabc7a5326c78aa19807fd6c30ca5d1b4b/crates/hir_expand/src/db.rs#L407-L409

So that's why the one without semi colon we will treat it as expr and such that it failed to expand.

On the other hand, in body lowering code:

https://github.com/rust-analyzer/rust-analyzer/blob/b7fa6dfabc7a5326c78aa19807fd6c30ca5d1b4b/crates/hir_def/src/body/lower.rs#L543

We only handle expr macro expansion in expression collecting code.

Fixes

So, to fix this bug, we have to handle MacroStmts in lowering AND change to_fragment_kind function I mentioned above.

[digama0]

Note that adding a semicolon is not necessarily an option, for example in

fn foo() -> bool {
  macro_rules! identity { ($($es:tt)*) => { $($es)* } }
  identity! { let _ = (); true }
}

adding a semicolon would cause a typechecking error. It would be an option to introduce an extra block scope here, i.e. assume that identity! yields an EXPR and then after macro expansion use the expression { let _ = (); true } even though the macro doesn't ask for braces. This might not always work though, since braces sometimes cause a change to drop order and whether things are moved vs reborrowed.

[lambda-fairy]

For reference, this is how rustc expands @digama0's snippet:

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
fn foo() -> bool {
    macro_rules! identity { ($ ($ es : tt) *) => { $ ($ es) * } }
    let _ = ();
    true
}

So the tokens are substituted right in, with no extra braces or semicolons.