"consider using a semicolon here" when ; is present with dbg!() inside inspect()

[matthiaskrgr]

fn main() {
let sum: i32 = [1,2,3].iter().inspect(|n| dbg!(n) ).sum();
}

This will suggest adding a ;

error[E0308]: mismatched types
 --> src/main.rs:3:43
  |
3 | let sum: i32 = [1,2,3].iter().inspect(|n| dbg!(n) ).sum();
  |                                           ^^^^^^^
  |                                           |
  |                                           expected `()`, found `&&{integer}`
  |                                           expected this to be `()`
  |                                           help: consider using a semicolon here
  |
  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

But doing so will "break" the code even more and not fix the error:

error: expected one of `)`, `,`, `.`, `?`, or an operator, found `;`
--> src/main.rs:2:50
 |
2 | let sum: i32 = [1,2,3].iter().inspect(|n| dbg!(n); ).sum();
 |                                                  ^ expected one of `)`, `,`, `.`, `?`, or an operator

error[E0308]: mismatched types
--> src/main.rs:2:43
 |
2 | let sum: i32 = [1,2,3].iter().inspect(|n| dbg!(n); ).sum();
 |                                           ^^^^^^^
 |                                           |
 |                                           expected `()`, found `&&{integer}`
 |                                           expected this to be `()`
 |                                           help: consider using a semicolon here
 |
 = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)

Could rust suggest adding { } around the macro?

[osa1]

The problem is we look at the macro-expanded code when generating this suggestion, which looks like this:

fn main() {
    let sum: i32 = [1, 2, 3]
        .iter()
        .inspect(|n| match n {
            tmp => {
                ... macro-generated stuff here ...
                tmp
            }
        })
        .sum();
}

Note that there are braces around tmp here. In this case adding a semicolon does work. So in that sense the suggestion is correct.

The problem is it's looking at macro-expanded code and making the suggestion based on that.

I can think of a few ways of improving this error:

• Not making any suggestions is better than making wrong suggestions, so we could just avoid this suggestion when the problematic code is macro expansion. If I implement this the error becomes:

  error[E0308]: mismatched types
   --> src/main.rs:2:49
    |
  2 |     let sum: i32 = [1, 2, 3].iter().inspect(|n| dbg!(n)).sum();
    |                                                 ^^^^^^^
    |                                                 |
    |                                                 expected `()`, found `&&{integer}`
    |                                                 expected this to be `()`
    |
    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
  

• Somehow check that the pre-macro-expansion code doesn't have {} but the expected type is (), and suggest adding braces. I don't know if it's possible to look at pre-macro-expansion code when type checking.

• Try to recover by adding a semicolon in the original code and type checking the macro expansion again. I'm not sure if this is even possible (possibly requires huge amounts of work unless the code is already there for this kind of recovery). If this is possible then we only suggest adding a semicolon when type checking the recovered version (with ;) works.