From 758931948f3bd1a871133777279fbf5c8cebea8f Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Tue, 2 Jul 2019 06:30:21 +0200 Subject: Unsupport the await!(..) macro. --- src/libsyntax/ast.rs | 2 +- src/libsyntax/feature_gate.rs | 21 ++++------------- src/libsyntax/mut_visit.rs | 2 +- src/libsyntax/parse/diagnostics.rs | 23 +++++++++++++++---- src/libsyntax/parse/parser.rs | 46 +++++++++----------------------------- src/libsyntax/print/pprust.rs | 14 +++--------- src/libsyntax/util/parser.rs | 2 +- src/libsyntax/visit.rs | 2 +- 8 files changed, 41 insertions(+), 71 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 58a1c4aee9a..b633705a65f 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1178,7 +1178,7 @@ pub enum ExprKind { /// preexisting defs. Async(CaptureBy, NodeId, P), /// An await expression (`my_future.await`). - Await(AwaitOrigin, P), + Await(P), /// A try block (`try { ... }`). TryBlock(P), diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 34e4d7d5a19..beab3ecce74 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -468,10 +468,6 @@ declare_features! ( // Allows async and await syntax. (active, async_await, "1.28.0", Some(50547), None), - // Allows await! macro-like syntax. - // This will likely be removed prior to stabilization of async/await. - (active, await_macro, "1.28.0", Some(50547), None), - // Allows reinterpretation of the bits of a value of one type as another type during const eval. (active, const_transmute, "1.29.0", Some(53605), None), @@ -627,6 +623,8 @@ declare_features! ( (removed, quote, "1.33.0", Some(29601), None, None), // Allows using `#[unsafe_destructor_blind_to_params]` (RFC 1238). (removed, dropck_parametricity, "1.38.0", Some(28498), None, None), + (removed, await_macro, "1.37.0", Some(50547), None, + Some("subsumed by `.await` syntax")), // ------------------------------------------------------------------------- // feature-group-end: removed features @@ -2109,19 +2107,8 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> { ast::ExprKind::Async(..) => { gate_feature_post!(&self, async_await, e.span, "async blocks are unstable"); } - ast::ExprKind::Await(origin, _) => { - match origin { - ast::AwaitOrigin::FieldLike => - gate_feature_post!(&self, async_await, e.span, "async/await is unstable"), - ast::AwaitOrigin::MacroLike => - gate_feature_post!( - &self, - await_macro, - e.span, - "`await!()` macro syntax is unstable, and will soon be removed \ - in favor of `.await` syntax." - ), - } + ast::ExprKind::Await(_) => { + gate_feature_post!(&self, async_await, e.span, "async/await is unstable"); } _ => {} } diff --git a/src/libsyntax/mut_visit.rs b/src/libsyntax/mut_visit.rs index 43b6bea69d9..7b328e817bf 100644 --- a/src/libsyntax/mut_visit.rs +++ b/src/libsyntax/mut_visit.rs @@ -1139,7 +1139,7 @@ pub fn noop_visit_expr(Expr { node, id, span, attrs }: &mut Expr, vis.visit_id(node_id); vis.visit_block(body); } - ExprKind::Await(_origin, expr) => vis.visit_expr(expr), + ExprKind::Await(expr) => vis.visit_expr(expr), ExprKind::Assign(el, er) => { vis.visit_expr(el); vis.visit_expr(er); diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs index 9eb6aa303b0..730efb5ef01 100644 --- a/src/libsyntax/parse/diagnostics.rs +++ b/src/libsyntax/parse/diagnostics.rs @@ -869,13 +869,23 @@ impl<'a> Parser<'a> { Ok(()) } - /// Consume alternative await syntaxes like `await `, `await? `, `await()` - /// and `await { }`. + /// Consume alternative await syntaxes like `await!()`, `await `, + /// `await? `, `await()`, and `await { }`. crate fn parse_incorrect_await_syntax( &mut self, lo: Span, await_sp: Span, ) -> PResult<'a, (Span, ExprKind)> { + if self.token == token::Not { + // Handle `await!()`. + self.expect(&token::Not)?; + self.expect(&token::OpenDelim(token::Paren))?; + let expr = self.parse_expr()?; + self.expect(&token::CloseDelim(token::Paren))?; + let sp = self.error_on_incorrect_await(lo, self.prev_span, &expr, false); + return Ok((sp, ExprKind::Await(expr))) + } + let is_question = self.eat(&token::Question); // Handle `await? `. let expr = if self.token == token::OpenDelim(token::Brace) { // Handle `await { }`. @@ -893,10 +903,15 @@ impl<'a> Parser<'a> { err.span_label(await_sp, "while parsing this incorrect await expression"); err })?; + let sp = self.error_on_incorrect_await(lo, expr.span, &expr, is_question); + Ok((sp, ExprKind::Await(expr))) + } + + fn error_on_incorrect_await(&self, lo: Span, hi: Span, expr: &Expr, is_question: bool) -> Span { let expr_str = self.span_to_snippet(expr.span) .unwrap_or_else(|_| pprust::expr_to_string(&expr)); let suggestion = format!("{}.await{}", expr_str, if is_question { "?" } else { "" }); - let sp = lo.to(expr.span); + let sp = lo.to(hi); let app = match expr.node { ExprKind::Try(_) => Applicability::MaybeIncorrect, // `await ?` _ => Applicability::MachineApplicable, @@ -904,7 +919,7 @@ impl<'a> Parser<'a> { self.struct_span_err(sp, "incorrect use of `await`") .span_suggestion(sp, "`await` is a postfix operation", suggestion, app) .emit(); - Ok((sp, ExprKind::Await(ast::AwaitOrigin::FieldLike, expr))) + sp } /// If encountering `future.await()`, consume and emit error. diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs index fb5ff7e8f98..7fda9158b4b 100644 --- a/src/libsyntax/parse/parser.rs +++ b/src/libsyntax/parse/parser.rs @@ -2234,7 +2234,7 @@ impl<'a> Parser<'a> { } else if self.eat_keyword(kw::Let) { return self.parse_let_expr(attrs); } else if is_span_rust_2018 && self.eat_keyword(kw::Await) { - let (await_hi, e_kind) = self.parse_await_macro_or_alt(lo, self.prev_span)?; + let (await_hi, e_kind) = self.parse_incorrect_await_syntax(lo, self.prev_span)?; hi = await_hi; ex = e_kind; } else if self.token.is_path_start() { @@ -2282,31 +2282,6 @@ impl<'a> Parser<'a> { self.maybe_recover_from_bad_qpath(expr, true) } - /// Parse `await!()` calls, or alternatively recover from incorrect but reasonable - /// alternative syntaxes `await `, `await? `, `await()` and - /// `await { }`. - fn parse_await_macro_or_alt( - &mut self, - lo: Span, - await_sp: Span, - ) -> PResult<'a, (Span, ExprKind)> { - if self.token == token::Not { - // Handle correct `await!()`. - // FIXME: make this an error when `await!` is no longer supported - // https://github.com/rust-lang/rust/issues/60610 - self.expect(&token::Not)?; - self.expect(&token::OpenDelim(token::Paren))?; - let expr = self.parse_expr().map_err(|mut err| { - err.span_label(await_sp, "while parsing this await macro call"); - err - })?; - self.expect(&token::CloseDelim(token::Paren))?; - Ok((self.prev_span, ExprKind::Await(ast::AwaitOrigin::MacroLike, expr))) - } else { // Handle `await `. - self.parse_incorrect_await_syntax(lo, await_sp) - } - } - fn maybe_parse_struct_expr( &mut self, lo: Span, @@ -2509,18 +2484,19 @@ impl<'a> Parser<'a> { ) } - // Assuming we have just parsed `.`, continue parsing into an expression. + fn mk_await_expr(&mut self, self_arg: P, lo: Span) -> PResult<'a, P> { + let span = lo.to(self.prev_span); + let await_expr = self.mk_expr(span, ExprKind::Await(self_arg), ThinVec::new()); + self.recover_from_await_method_call(); + Ok(await_expr) + } + + /// Assuming we have just parsed `.`, continue parsing into an expression. fn parse_dot_suffix(&mut self, self_arg: P, lo: Span) -> PResult<'a, P> { if self.token.span.rust_2018() && self.eat_keyword(kw::Await) { - let span = lo.to(self.prev_span); - let await_expr = self.mk_expr( - span, - ExprKind::Await(ast::AwaitOrigin::FieldLike, self_arg), - ThinVec::new(), - ); - self.recover_from_await_method_call(); - return Ok(await_expr); + return self.mk_await_expr(self_arg, lo); } + let segment = self.parse_path_segment(PathStyle::Expr)?; self.check_trailing_angle_brackets(&segment, token::OpenDelim(token::Paren)); diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs index c7be0b12302..88ff6ee9071 100644 --- a/src/libsyntax/print/pprust.rs +++ b/src/libsyntax/print/pprust.rs @@ -2120,17 +2120,9 @@ impl<'a> State<'a> { self.ibox(0); self.print_block_with_attrs(blk, attrs); } - ast::ExprKind::Await(origin, ref expr) => { - match origin { - ast::AwaitOrigin::MacroLike => { - self.s.word("await!"); - self.print_expr_maybe_paren(expr, parser::PREC_FORCE_PAREN); - } - ast::AwaitOrigin::FieldLike => { - self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); - self.s.word(".await"); - } - } + ast::ExprKind::Await(ref expr) => { + self.print_expr_maybe_paren(expr, parser::PREC_POSTFIX); + self.s.word(".await"); } ast::ExprKind::Assign(ref lhs, ref rhs) => { let prec = AssocOp::Assign.precedence() as i8; diff --git a/src/libsyntax/util/parser.rs b/src/libsyntax/util/parser.rs index 1e52186a106..d71358f45c4 100644 --- a/src/libsyntax/util/parser.rs +++ b/src/libsyntax/util/parser.rs @@ -382,7 +382,7 @@ pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool { // X { y: 1 } + X { y: 2 } contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs) } - ast::ExprKind::Await(_, ref x) | + ast::ExprKind::Await(ref x) | ast::ExprKind::Unary(_, ref x) | ast::ExprKind::Cast(ref x, _) | ast::ExprKind::Type(ref x, _) | diff --git a/src/libsyntax/visit.rs b/src/libsyntax/visit.rs index 50be8c68f7f..5fee8ed81ab 100644 --- a/src/libsyntax/visit.rs +++ b/src/libsyntax/visit.rs @@ -757,7 +757,7 @@ pub fn walk_expr<'a, V: Visitor<'a>>(visitor: &mut V, expression: &'a Expr) { ExprKind::Async(_, _, ref body) => { visitor.visit_block(body); } - ExprKind::Await(_, ref expr) => visitor.visit_expr(expr), + ExprKind::Await(ref expr) => visitor.visit_expr(expr), ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => { visitor.visit_expr(left_hand_expression); visitor.visit_expr(right_hand_expression); -- cgit 1.4.1-3-g733a5 From b21f0a313e22875dcdd399f599f5542df6ebb5c2 Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Wed, 24 Jul 2019 04:05:20 +0200 Subject: Pacify tidy, the merciless. --- src/libsyntax/feature_gate.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index beab3ecce74..d11deeb8645 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -623,7 +623,7 @@ declare_features! ( (removed, quote, "1.33.0", Some(29601), None, None), // Allows using `#[unsafe_destructor_blind_to_params]` (RFC 1238). (removed, dropck_parametricity, "1.38.0", Some(28498), None, None), - (removed, await_macro, "1.37.0", Some(50547), None, + (removed, await_macro, "1.38.0", Some(50547), None, Some("subsumed by `.await` syntax")), // ------------------------------------------------------------------------- -- cgit 1.4.1-3-g733a5