Suggest ; on parse error when applicable

[estebank]

Given the following code:

fn main() {
    let x = 100;
    println!("{}", x)
    let y = 200;
    println!("{}", y)
}

The current output is:

error: expected one of `.`, `;`, `?`, `}`, or an operator, found keyword `let`
 --> src/main.rs:4:5
  |
3 |     println!("{}", x)
  |                      - expected one of `.`, `;`, `?`, `}`, or an operator
4 |     let y = 200;
  |     ^^^ unexpected token

We should detect cases where a semicolon would be appropriate (probe that the current token and maybe limited lookahead confirm that what comes next could be a valid statement on its own) and suggest a semicolon. If there is a missing }, we already suggest that it might belong there. We might want to silence one or the other depending on whether the current token might be starting a statement or an item (let vs struct, etc.).

[pierwill]

Just a guess: could this be addressed with another else if self.look_ahead(1, |t|) { block, as in

rust/compiler/rustc_parse/src/parser/diagnostics.rs

Line 1168 in 3a24abd

} else if self.look_ahead(1, |t| {

?

[pierwill]

I think we would need to answer this question: why is the logic here not handling the cases we want to handle?

rust/compiler/rustc_parse/src/parser/diagnostics.rs

Lines 1184 to 1202 in 3a24abd

	} else if self.look_ahead(0, |t| {
	t == &token::CloseDelim(token::Brace)
	|| (
	t.can_begin_expr() && t != &token::Semi && t != &token::Pound
	// Avoid triggering with too many trailing `#` in raw string.
	)
	}) {
	// Missing semicolon typo. This is triggered if the next token could either start a
	// new statement or is a block close. For example:
	//
	// let x = 32
	// let y = 42;
	let sp = self.prev_token.span.shrink_to_hi();
	self.struct_span_err(sp, &msg)
	.span_label(self.token.span, "unexpected token")
	.span_suggestion_short(sp, "add `;` here", ";".to_string(), appl)
	.emit();
	return Ok(());
	}

[pierwill]

Just a guess: could this be addressed with another else if self.look_ahead(1, |t|) { block, as in

rust/compiler/rustc_parse/src/parser/diagnostics.rs

Line 1168 in 3a24abd

} else if self.look_ahead(1, |t| {

?

This seems to be on track given the clue "probe that the current token and maybe limited lookahead confirm that what comes next could be a valid statement on its own"...

[estebank]

I think we would need to answer this question: why is the logic here not handling the cases we want to handle?

That is a great question: as the code is written it looks like it should work. I don't know why it isn't triggering :(

It might be that expect_semi() isn't being called in these case. It might be a good idea to uplift most of this method into

rust/compiler/rustc_parse/src/parser/diagnostics.rs

Lines 213 to 217 in 3a24abd

	pub(super) fn expected_one_of_not_found(
	&mut self,
	edible: &[TokenKind],
	inedible: &[TokenKind],
	) -> PResult<'a, bool /* recovered */> {

[ebobrow]

I'd like to give this a try.

@rustbot claim