rust/tests/ui/expr/malformed_closure/ruby_style_closure.stderr

error[E0425]: cannot find value `x` in this scope
  --> $DIR/ruby_style_closure.rs:12:14
   |
LL |         Some(x * 2)
   |              ^ not found in this scope

error: aborting due to previous error

For more information about this error, try `rustc --explain E0425`.
Emit proper errors on missing closure braces This commit focuses on emitting clean errors for the following syntax error: ``` Some(42).map(\|a\| dbg!(a); a ); ``` Previous implementation tried to recover after parsing the closure body (the `dbg` expression) by replacing the next `;` with a `,`, which made the next expression belong to the next function argument. As such, the following errors were emitted (among others): - the semicolon token was not expected, - a is not in scope, - Option::map is supposed to take one argument, not two. This commit allows us to gracefully handle this situation by adding giving the parser the ability to remember when it has just parsed a closure body inside a function call. When this happens, we can treat the unexpected `;` specifically and try to parse as much statements as possible in order to eat the whole block. When we can't parse statements anymore, we generate a clean error indicating that the braces are missing, and return an ExprKind::Err. 2021-08-16 08:22:36 -05:00			error[E0425]: cannot find value `x` in this scope
Suppress errors due to TypeError not coercing with inference variables 2022-12-30 12:40:16 -06:00			`--> $DIR/ruby_style_closure.rs:12:14`
Emit proper errors on missing closure braces This commit focuses on emitting clean errors for the following syntax error: ``` Some(42).map(\|a\| dbg!(a); a ); ``` Previous implementation tried to recover after parsing the closure body (the `dbg` expression) by replacing the next `;` with a `,`, which made the next expression belong to the next function argument. As such, the following errors were emitted (among others): - the semicolon token was not expected, - a is not in scope, - Option::map is supposed to take one argument, not two. This commit allows us to gracefully handle this situation by adding giving the parser the ability to remember when it has just parsed a closure body inside a function call. When this happens, we can treat the unexpected `;` specifically and try to parse as much statements as possible in order to eat the whole block. When we can't parse statements anymore, we generate a clean error indicating that the braces are missing, and return an ExprKind::Err. 2021-08-16 08:22:36 -05:00			`\|`
			`LL \| Some(x * 2)`
			`\| ^ not found in this scope`

Suppress errors due to TypeError not coercing with inference variables 2022-12-30 12:40:16 -06:00			`error: aborting due to previous error`
Emit proper errors on missing closure braces This commit focuses on emitting clean errors for the following syntax error: ``` Some(42).map(\|a\| dbg!(a); a ); ``` Previous implementation tried to recover after parsing the closure body (the `dbg` expression) by replacing the next `;` with a `,`, which made the next expression belong to the next function argument. As such, the following errors were emitted (among others): - the semicolon token was not expected, - a is not in scope, - Option::map is supposed to take one argument, not two. This commit allows us to gracefully handle this situation by adding giving the parser the ability to remember when it has just parsed a closure body inside a function call. When this happens, we can treat the unexpected `;` specifically and try to parse as much statements as possible in order to eat the whole block. When we can't parse statements anymore, we generate a clean error indicating that the braces are missing, and return an ExprKind::Err. 2021-08-16 08:22:36 -05:00
Suppress errors due to TypeError not coercing with inference variables 2022-12-30 12:40:16 -06:00			For more information about this error, try `rustc --explain E0425`.