@@ -2234,7 +2234,7 @@ impl<'a> Parser<'a> {
2234
2234
} else if self . eat_keyword ( kw:: Let ) {
2235
2235
return self . parse_let_expr ( attrs) ;
2236
2236
} else if is_span_rust_2018 && self . eat_keyword ( kw:: Await ) {
2237
- let ( await_hi, e_kind) = self . parse_await_macro_or_alt ( lo, self . prev_span ) ?;
2237
+ let ( await_hi, e_kind) = self . parse_incorrect_await_syntax ( lo, self . prev_span ) ?;
2238
2238
hi = await_hi;
2239
2239
ex = e_kind;
2240
2240
} else if self . token . is_path_start ( ) {
@@ -2282,31 +2282,6 @@ impl<'a> Parser<'a> {
2282
2282
self . maybe_recover_from_bad_qpath ( expr, true )
2283
2283
}
2284
2284
2285
- /// Parse `await!(<expr>)` calls, or alternatively recover from incorrect but reasonable
2286
- /// alternative syntaxes `await <expr>`, `await? <expr>`, `await(<expr>)` and
2287
- /// `await { <expr> }`.
2288
- fn parse_await_macro_or_alt (
2289
- & mut self ,
2290
- lo : Span ,
2291
- await_sp : Span ,
2292
- ) -> PResult < ' a , ( Span , ExprKind ) > {
2293
- if self . token == token:: Not {
2294
- // Handle correct `await!(<expr>)`.
2295
- // FIXME: make this an error when `await!` is no longer supported
2296
- // https://github.com/rust-lang/rust/issues/60610
2297
- self . expect ( & token:: Not ) ?;
2298
- self . expect ( & token:: OpenDelim ( token:: Paren ) ) ?;
2299
- let expr = self . parse_expr ( ) . map_err ( |mut err| {
2300
- err. span_label ( await_sp, "while parsing this await macro call" ) ;
2301
- err
2302
- } ) ?;
2303
- self . expect ( & token:: CloseDelim ( token:: Paren ) ) ?;
2304
- Ok ( ( self . prev_span , ExprKind :: Await ( ast:: AwaitOrigin :: MacroLike , expr) ) )
2305
- } else { // Handle `await <expr>`.
2306
- self . parse_incorrect_await_syntax ( lo, await_sp)
2307
- }
2308
- }
2309
-
2310
2285
fn maybe_parse_struct_expr (
2311
2286
& mut self ,
2312
2287
lo : Span ,
@@ -2509,18 +2484,19 @@ impl<'a> Parser<'a> {
2509
2484
)
2510
2485
}
2511
2486
2512
- // Assuming we have just parsed `.`, continue parsing into an expression.
2487
+ fn mk_await_expr ( & mut self , self_arg : P < Expr > , lo : Span ) -> PResult < ' a , P < Expr > > {
2488
+ let span = lo. to ( self . prev_span ) ;
2489
+ let await_expr = self . mk_expr ( span, ExprKind :: Await ( self_arg) , ThinVec :: new ( ) ) ;
2490
+ self . recover_from_await_method_call ( ) ;
2491
+ Ok ( await_expr)
2492
+ }
2493
+
2494
+ /// Assuming we have just parsed `.`, continue parsing into an expression.
2513
2495
fn parse_dot_suffix ( & mut self , self_arg : P < Expr > , lo : Span ) -> PResult < ' a , P < Expr > > {
2514
2496
if self . token . span . rust_2018 ( ) && self . eat_keyword ( kw:: Await ) {
2515
- let span = lo. to ( self . prev_span ) ;
2516
- let await_expr = self . mk_expr (
2517
- span,
2518
- ExprKind :: Await ( ast:: AwaitOrigin :: FieldLike , self_arg) ,
2519
- ThinVec :: new ( ) ,
2520
- ) ;
2521
- self . recover_from_await_method_call ( ) ;
2522
- return Ok ( await_expr) ;
2497
+ return self . mk_await_expr ( self_arg, lo) ;
2523
2498
}
2499
+
2524
2500
let segment = self . parse_path_segment ( PathStyle :: Expr ) ?;
2525
2501
self . check_trailing_angle_brackets ( & segment, token:: OpenDelim ( token:: Paren ) ) ;
2526
2502
0 commit comments