From d763faf92198e3f0c851388c71d2bb8a2f04afd9 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Wed, 15 May 2019 19:47:18 -0700
Subject: Parse alternative incorrect uses of await and recover

---
 src/libsyntax/parse/parser.rs | 113 +++++++++++++++++++++++++++++++++++++++---
 1 file changed, 105 insertions(+), 8 deletions(-)

(limited to 'src/libsyntax/parse')

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 99e8db9d8e6..55e13ef00dc 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2629,14 +2629,94 @@ impl<'a> Parser<'a> {
                     db.note("variable declaration using `let` is a statement");
                     return Err(db);
                 } else if self.span.rust_2018() && self.eat_keyword(keywords::Await) {
-                    // FIXME: remove this branch 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()?;
-                    self.expect(&token::CloseDelim(token::Paren))?;
-                    hi = self.prev_span;
-                    ex = ExprKind::Await(ast::AwaitOrigin::MacroLike, expr);
+                    let await_sp = self.prev_span;
+                    match self.token {
+                        token::Not => {
+                            // 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))?;
+                            ex = ExprKind::Await(ast::AwaitOrigin::MacroLike, expr);
+                        }
+                        token::Question => {
+                            // Handle `await? <expr>`
+                            self.bump(); // `?`
+                            let expr = self.parse_expr().map_err(|mut err| {
+                                err.span_label(
+                                    await_sp,
+                                    "while parsing this incorrect await statement",
+                                );
+                                err
+                            })?;
+                            let sp = lo.to(expr.span);
+                            let expr_str = self.sess.source_map().span_to_snippet(expr.span)
+                                .unwrap_or_else(|_| pprust::expr_to_string(&expr));
+                            let expr = self.mk_expr(
+                                sp,
+                                ExprKind::Await(ast::AwaitOrigin::FieldLike, expr),
+                                ThinVec::new(),
+                            );
+                            hi = sp;
+                            ex = ExprKind::Try(expr);
+                            let mut err = self.struct_span_err(
+                                await_sp,
+                                "incorrect use of `await`",
+                            );
+                            err.span_suggestion(
+                                sp,
+                                "`await` is not a statement",
+                                format!("{}.await?", expr_str),
+                                Applicability::MachineApplicable,
+                            );
+                            err.emit();
+                        }
+                        ref t => {
+                            // Handle `await <expr>`
+                            let expr = if t == &token::OpenDelim(token::Brace) {
+                                // Handle `await { <expr> }`
+                                // this needs to be handled separatedly from the next arm to avoid
+                                // interpreting `await { <expr> }?` as `<expr>?.await`
+                                self.parse_block_expr(
+                                    None,
+                                    self.span,
+                                    BlockCheckMode::Default,
+                                    ThinVec::new(),
+                                )
+                            } else {
+                                self.parse_expr()
+                            }.map_err(|mut err| {
+                                err.span_label(
+                                    await_sp,
+                                    "while parsing this incorrect await statement",
+                                );
+                                err
+                            })?;
+                            let expr_str = self.sess.source_map().span_to_snippet(expr.span)
+                                .unwrap_or_else(|_| pprust::expr_to_string(&expr));
+                            let sp = lo.to(expr.span);
+                            hi = sp;
+                            ex = ExprKind::Await(ast::AwaitOrigin::FieldLike, expr);
+                            let mut err = self.struct_span_err(
+                                await_sp,
+                                "incorrect use of `await`",
+                            );
+                            err.span_suggestion(
+                                sp,
+                                "`await` is not a statement",
+                                format!("{}.await", expr_str),
+                                Applicability::MachineApplicable,
+                            );
+                            err.emit();
+                        }
+                    }
                 } else if self.token.is_path_start() {
                     let path = self.parse_path(PathStyle::Expr)?;
 
@@ -2913,6 +2993,23 @@ impl<'a> Parser<'a> {
                 ExprKind::Await(ast::AwaitOrigin::FieldLike, self_arg),
                 ThinVec::new(),
             );
+            if self.token == token::OpenDelim(token::Paren) &&
+                self.look_ahead(1, |t| t == &token::CloseDelim(token::Paren))
+            {
+                // future.await()
+                let lo = self.span;
+                self.bump(); // (
+                let sp = lo.to(self.span);
+                self.bump(); // )
+                let mut err = self.struct_span_err(span, "incorrect use of `await`");
+                err.span_suggestion(
+                    sp,
+                    "`await` is not a method call, remove the parentheses",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                );
+                err.emit()
+            }
             return Ok(await_expr);
         }
         let segment = self.parse_path_segment(PathStyle::Expr)?;
-- 
cgit 1.4.1-3-g733a5


From ee02661474abad0c91b8031c920904ab14f30c7e Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Wed, 15 May 2019 19:59:56 -0700
Subject: Split parser logic to its own method

---
 src/libsyntax/parse/parser.rs | 183 ++++++++++++++++++++++--------------------
 1 file changed, 96 insertions(+), 87 deletions(-)

(limited to 'src/libsyntax/parse')

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 55e13ef00dc..83bfd93d066 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2630,93 +2630,9 @@ impl<'a> Parser<'a> {
                     return Err(db);
                 } else if self.span.rust_2018() && self.eat_keyword(keywords::Await) {
                     let await_sp = self.prev_span;
-                    match self.token {
-                        token::Not => {
-                            // 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))?;
-                            ex = ExprKind::Await(ast::AwaitOrigin::MacroLike, expr);
-                        }
-                        token::Question => {
-                            // Handle `await? <expr>`
-                            self.bump(); // `?`
-                            let expr = self.parse_expr().map_err(|mut err| {
-                                err.span_label(
-                                    await_sp,
-                                    "while parsing this incorrect await statement",
-                                );
-                                err
-                            })?;
-                            let sp = lo.to(expr.span);
-                            let expr_str = self.sess.source_map().span_to_snippet(expr.span)
-                                .unwrap_or_else(|_| pprust::expr_to_string(&expr));
-                            let expr = self.mk_expr(
-                                sp,
-                                ExprKind::Await(ast::AwaitOrigin::FieldLike, expr),
-                                ThinVec::new(),
-                            );
-                            hi = sp;
-                            ex = ExprKind::Try(expr);
-                            let mut err = self.struct_span_err(
-                                await_sp,
-                                "incorrect use of `await`",
-                            );
-                            err.span_suggestion(
-                                sp,
-                                "`await` is not a statement",
-                                format!("{}.await?", expr_str),
-                                Applicability::MachineApplicable,
-                            );
-                            err.emit();
-                        }
-                        ref t => {
-                            // Handle `await <expr>`
-                            let expr = if t == &token::OpenDelim(token::Brace) {
-                                // Handle `await { <expr> }`
-                                // this needs to be handled separatedly from the next arm to avoid
-                                // interpreting `await { <expr> }?` as `<expr>?.await`
-                                self.parse_block_expr(
-                                    None,
-                                    self.span,
-                                    BlockCheckMode::Default,
-                                    ThinVec::new(),
-                                )
-                            } else {
-                                self.parse_expr()
-                            }.map_err(|mut err| {
-                                err.span_label(
-                                    await_sp,
-                                    "while parsing this incorrect await statement",
-                                );
-                                err
-                            })?;
-                            let expr_str = self.sess.source_map().span_to_snippet(expr.span)
-                                .unwrap_or_else(|_| pprust::expr_to_string(&expr));
-                            let sp = lo.to(expr.span);
-                            hi = sp;
-                            ex = ExprKind::Await(ast::AwaitOrigin::FieldLike, expr);
-                            let mut err = self.struct_span_err(
-                                await_sp,
-                                "incorrect use of `await`",
-                            );
-                            err.span_suggestion(
-                                sp,
-                                "`await` is not a statement",
-                                format!("{}.await", expr_str),
-                                Applicability::MachineApplicable,
-                            );
-                            err.emit();
-                        }
-                    }
+                    let e = self.parse_async_macro_or_stmt(lo, await_sp)?;
+                    hi = e.0;
+                    ex = e.1;
                 } else if self.token.is_path_start() {
                     let path = self.parse_path(PathStyle::Expr)?;
 
@@ -2781,6 +2697,99 @@ impl<'a> Parser<'a> {
         self.maybe_recover_from_bad_qpath(expr, true)
     }
 
+    fn parse_async_macro_or_stmt(
+        &mut self,
+        lo: Span,
+        await_sp: Span,
+    ) -> PResult<'a, (Span, ExprKind)> {
+        Ok(match self.token {
+            token::Not => {
+                // Handle correct `await!(<expr>)`
+                // 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))?;
+                (expr.span, ExprKind::Await(ast::AwaitOrigin::MacroLike, expr))
+            }
+            token::Question => {
+                // Handle `await? <expr>`
+                self.bump(); // `?`
+                let expr = self.parse_expr().map_err(|mut err| {
+                    err.span_label(
+                        await_sp,
+                        "while parsing this incorrect await statement",
+                    );
+                    err
+                })?;
+                let sp = lo.to(expr.span);
+                let expr_str = self.sess.source_map().span_to_snippet(expr.span)
+                    .unwrap_or_else(|_| pprust::expr_to_string(&expr));
+                let expr = self.mk_expr(
+                    sp,
+                    ExprKind::Await(ast::AwaitOrigin::FieldLike, expr),
+                    ThinVec::new(),
+                );
+                let mut err = self.struct_span_err(
+                    await_sp,
+                    "incorrect use of `await`",
+                );
+                err.span_suggestion(
+                    sp,
+                    "`await` is not a statement",
+                    format!("{}.await?", expr_str),
+                    Applicability::MachineApplicable,
+                );
+                err.emit();
+                (sp, ExprKind::Try(expr))
+            }
+            ref t => {
+                // Handle `await <expr>`
+                let expr = if t == &token::OpenDelim(token::Brace) {
+                    // Handle `await { <expr> }`
+                    // this needs to be handled separatedly from the next arm to avoid
+                    // interpreting `await { <expr> }?` as `<expr>?.await`
+                    self.parse_block_expr(
+                        None,
+                        self.span,
+                        BlockCheckMode::Default,
+                        ThinVec::new(),
+                    )
+                } else {
+                    self.parse_expr()
+                }.map_err(|mut err| {
+                    err.span_label(
+                        await_sp,
+                        "while parsing this incorrect await statement",
+                    );
+                    err
+                })?;
+                let expr_str = self.sess.source_map().span_to_snippet(expr.span)
+                    .unwrap_or_else(|_| pprust::expr_to_string(&expr));
+                let sp = lo.to(expr.span);
+                let mut err = self.struct_span_err(
+                    await_sp,
+                    "incorrect use of `await`",
+                );
+                err.span_suggestion(
+                    sp,
+                    "`await` is not a statement",
+                    format!("{}.await", expr_str),
+                    Applicability::MachineApplicable,
+                );
+                err.emit();
+                (sp, ExprKind::Await(ast::AwaitOrigin::FieldLike, expr))
+            }
+        })
+    }
+
     fn maybe_parse_struct_expr(
         &mut self,
         lo: Span,
-- 
cgit 1.4.1-3-g733a5


From 01c6689604d671c5fa51671940f69833222194ef Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Wed, 15 May 2019 20:06:15 -0700
Subject: Simplify span usage for incorrect await

---
 src/libsyntax/parse/parser.rs                      |  6 +--
 .../incorrect-syntax-suggestions.stderr            | 60 +++++++---------------
 src/test/ui/feature-gate/await-macro.stderr        |  2 +-
 3 files changed, 23 insertions(+), 45 deletions(-)

(limited to 'src/libsyntax/parse')

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 83bfd93d066..45081aadfd9 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2738,7 +2738,7 @@ impl<'a> Parser<'a> {
                     ThinVec::new(),
                 );
                 let mut err = self.struct_span_err(
-                    await_sp,
+                    sp,
                     "incorrect use of `await`",
                 );
                 err.span_suggestion(
@@ -2775,7 +2775,7 @@ impl<'a> Parser<'a> {
                     .unwrap_or_else(|_| pprust::expr_to_string(&expr));
                 let sp = lo.to(expr.span);
                 let mut err = self.struct_span_err(
-                    await_sp,
+                    sp,
                     "incorrect use of `await`",
                 );
                 err.span_suggestion(
@@ -3010,7 +3010,7 @@ impl<'a> Parser<'a> {
                 self.bump(); // (
                 let sp = lo.to(self.span);
                 self.bump(); // )
-                let mut err = self.struct_span_err(span, "incorrect use of `await`");
+                let mut err = self.struct_span_err(sp, "incorrect use of `await`");
                 err.span_suggestion(
                     sp,
                     "`await` is not a method call, remove the parentheses",
diff --git a/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr b/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr
index f39ccfcc95c..2e2efedcf00 100644
--- a/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr
+++ b/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr
@@ -2,113 +2,91 @@ error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:10:13
    |
 LL |     let _ = await bar();
-   |             ^^^^^------
-   |             |
-   |             help: `await` is not a statement: `bar().await`
+   |             ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:14:13
    |
 LL |     let _ = await? bar();
-   |             ^^^^^-------
-   |             |
-   |             help: `await` is not a statement: `bar().await?`
+   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar().await?`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:18:13
    |
 LL |     let _ = await bar()?;
-   |             ^^^^^-------
-   |             |
-   |             help: `await` is not a statement: `bar()?.await`
+   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar()?.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:23:13
    |
 LL |     let _ = await { bar() };
-   |             ^^^^^----------
-   |             |
-   |             help: `await` is not a statement: `{ bar() }.await`
+   |             ^^^^^^^^^^^^^^^ help: `await` is not a statement: `{ bar() }.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:27:13
    |
 LL |     let _ = await(bar());
-   |             ^^^^^-------
-   |             |
-   |             help: `await` is not a statement: `(bar()).await`
+   |             ^^^^^^^^^^^^ help: `await` is not a statement: `(bar()).await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:31:13
    |
 LL |     let _ = await { bar() }?;
-   |             ^^^^^----------
-   |             |
-   |             help: `await` is not a statement: `{ bar() }.await`
+   |             ^^^^^^^^^^^^^^^ help: `await` is not a statement: `{ bar() }.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:35:14
    |
 LL |     let _ = (await bar())?;
-   |              ^^^^^------
-   |              |
-   |              help: `await` is not a statement: `bar().await`
+   |              ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
 
 error: incorrect use of `await`
-  --> $DIR/incorrect-syntax-suggestions.rs:39:13
+  --> $DIR/incorrect-syntax-suggestions.rs:39:24
    |
 LL |     let _ = bar().await();
-   |             ^^^^^^^^^^^-- help: `await` is not a method call, remove the parentheses
+   |                        ^^ help: `await` is not a method call, remove the parentheses
 
 error: incorrect use of `await`
-  --> $DIR/incorrect-syntax-suggestions.rs:43:13
+  --> $DIR/incorrect-syntax-suggestions.rs:43:24
    |
 LL |     let _ = bar().await()?;
-   |             ^^^^^^^^^^^-- help: `await` is not a method call, remove the parentheses
+   |                        ^^ help: `await` is not a method call, remove the parentheses
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:55:13
    |
 LL |     let _ = await bar();
-   |             ^^^^^------
-   |             |
-   |             help: `await` is not a statement: `bar().await`
+   |             ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:60:13
    |
 LL |     let _ = await? bar();
-   |             ^^^^^-------
-   |             |
-   |             help: `await` is not a statement: `bar().await?`
+   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar().await?`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:65:13
    |
 LL |     let _ = await bar()?;
-   |             ^^^^^-------
-   |             |
-   |             help: `await` is not a statement: `bar()?.await`
+   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar()?.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:70:14
    |
 LL |     let _ = (await bar())?;
-   |              ^^^^^------
-   |              |
-   |              help: `await` is not a statement: `bar().await`
+   |              ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
 
 error: incorrect use of `await`
-  --> $DIR/incorrect-syntax-suggestions.rs:75:13
+  --> $DIR/incorrect-syntax-suggestions.rs:75:24
    |
 LL |     let _ = bar().await();
-   |             ^^^^^^^^^^^-- help: `await` is not a method call, remove the parentheses
+   |                        ^^ help: `await` is not a method call, remove the parentheses
 
 error: incorrect use of `await`
-  --> $DIR/incorrect-syntax-suggestions.rs:80:13
+  --> $DIR/incorrect-syntax-suggestions.rs:80:24
    |
 LL |     let _ = bar().await()?;
-   |             ^^^^^^^^^^^-- help: `await` is not a method call, remove the parentheses
+   |                        ^^ help: `await` is not a method call, remove the parentheses
 
 error[E0728]: `await` is only allowed inside `async` functions and blocks
   --> $DIR/incorrect-syntax-suggestions.rs:55:13
diff --git a/src/test/ui/feature-gate/await-macro.stderr b/src/test/ui/feature-gate/await-macro.stderr
index 699a7a8886e..57aab6800f7 100644
--- a/src/test/ui/feature-gate/await-macro.stderr
+++ b/src/test/ui/feature-gate/await-macro.stderr
@@ -2,7 +2,7 @@ error[E0658]: `await!(<expr>)` macro syntax is unstable, and will soon be remove
   --> $DIR/await-macro.rs:9:5
    |
 LL |     await!(bar());
-   |     ^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/50547
    = help: add #![feature(await_macro)] to the crate attributes to enable
-- 
cgit 1.4.1-3-g733a5


From b9d6fe3ae96a7f1f478dc6baf29b8e4cff5ab865 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Thu, 16 May 2019 13:33:26 -0700
Subject: Review comments

- Change wording of suggestion
- Move recovery logic to `diagnostics.rs`
- Reduce ammount of code duplication
---
 src/libsyntax/parse/diagnostics.rs                 |  40 ++++++-
 src/libsyntax/parse/parser.rs                      | 124 +++++----------------
 .../incorrect-syntax-suggestions.stderr            |  26 ++---
 3 files changed, 81 insertions(+), 109 deletions(-)

(limited to 'src/libsyntax/parse')

diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs
index 32e1ee94f0d..61453e35095 100644
--- a/src/libsyntax/parse/diagnostics.rs
+++ b/src/libsyntax/parse/diagnostics.rs
@@ -1,5 +1,5 @@
 use crate::ast;
-use crate::ast::{Expr, ExprKind, Item, ItemKind, Pat, PatKind, QSelf, Ty, TyKind};
+use crate::ast::{BlockCheckMode, Expr, ExprKind, Item, ItemKind, Pat, PatKind, QSelf, Ty, TyKind};
 use crate::parse::parser::PathStyle;
 use crate::parse::token;
 use crate::parse::PResult;
@@ -223,4 +223,42 @@ impl<'a> Parser<'a> {
             false
         }
     }
+
+    /// Consume alternative await syntaxes like `await <expr>`, `await? <expr>`, `await(<expr>)`
+    /// and `await { <expr> }`.
+    crate fn parse_incorrect_await_syntax(
+        &mut self,
+        lo: Span,
+        await_sp: Span,
+    ) -> PResult<'a, (Span, ExprKind)> {
+        let is_question = self.eat(&token::Question); // Handle `await? <expr>`.
+        let expr = if self.token == token::OpenDelim(token::Brace) {
+            // Handle `await { <expr> }`.
+            // This needs to be handled separatedly from the next arm to avoid
+            // interpreting `await { <expr> }?` as `<expr>?.await`.
+            self.parse_block_expr(
+                None,
+                self.span,
+                BlockCheckMode::Default,
+                ThinVec::new(),
+            )
+        } else {
+            self.parse_expr()
+        }.map_err(|mut err| {
+            err.span_label(await_sp, "while parsing this incorrect await expression");
+            err
+        })?;
+        let expr_str = self.sess.source_map().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 app = match expr.node {
+            ExprKind::Try(_) => Applicability::MaybeIncorrect, // `await <expr>?`
+            _ => Applicability::MachineApplicable,
+        };
+        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)))
+    }
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index 45081aadfd9..bb0f9fa9502 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2629,10 +2629,9 @@ impl<'a> Parser<'a> {
                     db.note("variable declaration using `let` is a statement");
                     return Err(db);
                 } else if self.span.rust_2018() && self.eat_keyword(keywords::Await) {
-                    let await_sp = self.prev_span;
-                    let e = self.parse_async_macro_or_stmt(lo, await_sp)?;
-                    hi = e.0;
-                    ex = e.1;
+                    let (await_hi, e_kind) = self.parse_await_macro_or_alt(lo, self.prev_span)?;
+                    hi = await_hi;
+                    ex = e_kind;
                 } else if self.token.is_path_start() {
                     let path = self.parse_path(PathStyle::Expr)?;
 
@@ -2697,97 +2696,29 @@ impl<'a> Parser<'a> {
         self.maybe_recover_from_bad_qpath(expr, true)
     }
 
-    fn parse_async_macro_or_stmt(
+    /// Parse `await!(<expr>)` calls, or alternatively recover from incorrect but reasonable
+    /// alternative syntaxes `await <expr>`, `await? <expr>`, `await(<expr>)` and
+    /// `await { <expr> }`.
+    fn parse_await_macro_or_alt(
         &mut self,
         lo: Span,
         await_sp: Span,
     ) -> PResult<'a, (Span, ExprKind)> {
-        Ok(match self.token {
-            token::Not => {
-                // Handle correct `await!(<expr>)`
-                // 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))?;
-                (expr.span, ExprKind::Await(ast::AwaitOrigin::MacroLike, expr))
-            }
-            token::Question => {
-                // Handle `await? <expr>`
-                self.bump(); // `?`
-                let expr = self.parse_expr().map_err(|mut err| {
-                    err.span_label(
-                        await_sp,
-                        "while parsing this incorrect await statement",
-                    );
-                    err
-                })?;
-                let sp = lo.to(expr.span);
-                let expr_str = self.sess.source_map().span_to_snippet(expr.span)
-                    .unwrap_or_else(|_| pprust::expr_to_string(&expr));
-                let expr = self.mk_expr(
-                    sp,
-                    ExprKind::Await(ast::AwaitOrigin::FieldLike, expr),
-                    ThinVec::new(),
-                );
-                let mut err = self.struct_span_err(
-                    sp,
-                    "incorrect use of `await`",
-                );
-                err.span_suggestion(
-                    sp,
-                    "`await` is not a statement",
-                    format!("{}.await?", expr_str),
-                    Applicability::MachineApplicable,
-                );
-                err.emit();
-                (sp, ExprKind::Try(expr))
-            }
-            ref t => {
-                // Handle `await <expr>`
-                let expr = if t == &token::OpenDelim(token::Brace) {
-                    // Handle `await { <expr> }`
-                    // this needs to be handled separatedly from the next arm to avoid
-                    // interpreting `await { <expr> }?` as `<expr>?.await`
-                    self.parse_block_expr(
-                        None,
-                        self.span,
-                        BlockCheckMode::Default,
-                        ThinVec::new(),
-                    )
-                } else {
-                    self.parse_expr()
-                }.map_err(|mut err| {
-                    err.span_label(
-                        await_sp,
-                        "while parsing this incorrect await statement",
-                    );
-                    err
-                })?;
-                let expr_str = self.sess.source_map().span_to_snippet(expr.span)
-                    .unwrap_or_else(|_| pprust::expr_to_string(&expr));
-                let sp = lo.to(expr.span);
-                let mut err = self.struct_span_err(
-                    sp,
-                    "incorrect use of `await`",
-                );
-                err.span_suggestion(
-                    sp,
-                    "`await` is not a statement",
-                    format!("{}.await", expr_str),
-                    Applicability::MachineApplicable,
-                );
-                err.emit();
-                (sp, ExprKind::Await(ast::AwaitOrigin::FieldLike, expr))
-            }
-        })
+        if self.token == token::Not {
+            // Handle correct `await!(<expr>)`.
+            // 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((expr.span, ExprKind::Await(ast::AwaitOrigin::MacroLike, expr)))
+        } else { // Handle `await <expr>`.
+            self.parse_incorrect_await_syntax(lo, await_sp)
+        }
     }
 
     fn maybe_parse_struct_expr(
@@ -2938,10 +2869,13 @@ impl<'a> Parser<'a> {
     }
 
     /// Parses a block or unsafe block.
-    fn parse_block_expr(&mut self, opt_label: Option<Label>,
-                            lo: Span, blk_mode: BlockCheckMode,
-                            outer_attrs: ThinVec<Attribute>)
-                            -> PResult<'a, P<Expr>> {
+    crate fn parse_block_expr(
+        &mut self,
+        opt_label: Option<Label>,
+        lo: Span,
+        blk_mode: BlockCheckMode,
+        outer_attrs: ThinVec<Attribute>,
+    ) -> PResult<'a, P<Expr>> {
         self.expect(&token::OpenDelim(token::Brace))?;
 
         let mut attrs = outer_attrs;
diff --git a/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr b/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr
index bc7bd77479e..380da4448ad 100644
--- a/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr
+++ b/src/test/ui/await-keyword/incorrect-syntax-suggestions.stderr
@@ -2,43 +2,43 @@ error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:10:13
    |
 LL |     let _ = await bar();
-   |             ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
+   |             ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:14:13
    |
 LL |     let _ = await? bar();
-   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar().await?`
+   |             ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await?`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:18:13
    |
 LL |     let _ = await bar()?;
-   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar()?.await`
+   |             ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar()?.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:23:13
    |
 LL |     let _ = await { bar() };
-   |             ^^^^^^^^^^^^^^^ help: `await` is not a statement: `{ bar() }.await`
+   |             ^^^^^^^^^^^^^^^ help: `await` is a postfix operation: `{ bar() }.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:27:13
    |
 LL |     let _ = await(bar());
-   |             ^^^^^^^^^^^^ help: `await` is not a statement: `(bar()).await`
+   |             ^^^^^^^^^^^^ help: `await` is a postfix operation: `(bar()).await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:31:13
    |
 LL |     let _ = await { bar() }?;
-   |             ^^^^^^^^^^^^^^^ help: `await` is not a statement: `{ bar() }.await`
+   |             ^^^^^^^^^^^^^^^ help: `await` is a postfix operation: `{ bar() }.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:35:14
    |
 LL |     let _ = (await bar())?;
-   |              ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
+   |              ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:39:24
@@ -56,25 +56,25 @@ error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:55:13
    |
 LL |     let _ = await bar();
-   |             ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
+   |             ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:60:13
    |
 LL |     let _ = await? bar();
-   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar().await?`
+   |             ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await?`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:65:13
    |
 LL |     let _ = await bar()?;
-   |             ^^^^^^^^^^^^ help: `await` is not a statement: `bar()?.await`
+   |             ^^^^^^^^^^^^ help: `await` is a postfix operation: `bar()?.await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:70:14
    |
 LL |     let _ = (await bar())?;
-   |              ^^^^^^^^^^^ help: `await` is not a statement: `bar().await`
+   |              ^^^^^^^^^^^ help: `await` is a postfix operation: `bar().await`
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:75:24
@@ -94,13 +94,13 @@ error: expected expression, found `=>`
 LL |     match await { await => () }
    |                   ----- ^^ expected expression
    |                   |
-   |                   while parsing this incorrect await statement
+   |                   while parsing this incorrect await expression
 
 error: incorrect use of `await`
   --> $DIR/incorrect-syntax-suggestions.rs:108:11
    |
 LL |     match await { await => () }
-   |           ^^^^^^^^^^^^^^^^^^^^^ help: `await` is not a statement: `{ await => () }.await`
+   |           ^^^^^^^^^^^^^^^^^^^^^ help: `await` is a postfix operation: `{ await => () }.await`
 
 error: expected one of `.`, `?`, `{`, or an operator, found `}`
   --> $DIR/incorrect-syntax-suggestions.rs:111:1
-- 
cgit 1.4.1-3-g733a5


From 27a2881402f703b28d81d3001edeb28e18f7f4dd Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Thu, 16 May 2019 14:30:39 -0700
Subject: Fix span for await macro call

---
 src/libsyntax/parse/parser.rs               | 2 +-
 src/test/ui/feature-gate/await-macro.stderr | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/libsyntax/parse')

diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index bb0f9fa9502..c34c7f3f1bb 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -2715,7 +2715,7 @@ impl<'a> Parser<'a> {
                 err
             })?;
             self.expect(&token::CloseDelim(token::Paren))?;
-            Ok((expr.span, ExprKind::Await(ast::AwaitOrigin::MacroLike, expr)))
+            Ok((self.prev_span, ExprKind::Await(ast::AwaitOrigin::MacroLike, expr)))
         } else { // Handle `await <expr>`.
             self.parse_incorrect_await_syntax(lo, await_sp)
         }
diff --git a/src/test/ui/feature-gate/await-macro.stderr b/src/test/ui/feature-gate/await-macro.stderr
index 57aab6800f7..699a7a8886e 100644
--- a/src/test/ui/feature-gate/await-macro.stderr
+++ b/src/test/ui/feature-gate/await-macro.stderr
@@ -2,7 +2,7 @@ error[E0658]: `await!(<expr>)` macro syntax is unstable, and will soon be remove
   --> $DIR/await-macro.rs:9:5
    |
 LL |     await!(bar());
-   |     ^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^
    |
    = note: for more information, see https://github.com/rust-lang/rust/issues/50547
    = help: add #![feature(await_macro)] to the crate attributes to enable
-- 
cgit 1.4.1-3-g733a5


From 4117c6d33c572579081adcdf70dce29b25f9db15 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Thu, 16 May 2019 14:31:07 -0700
Subject: Move some parser recovery methods to diagnostics

---
 src/libsyntax/parse/diagnostics.rs | 268 ++++++++++++++++++++++++++++++++++++-
 src/libsyntax/parse/parser.rs      | 266 +-----------------------------------
 2 files changed, 271 insertions(+), 263 deletions(-)

(limited to 'src/libsyntax/parse')

diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs
index 61453e35095..ab5f87fa7ca 100644
--- a/src/libsyntax/parse/diagnostics.rs
+++ b/src/libsyntax/parse/diagnostics.rs
@@ -1,14 +1,16 @@
 use crate::ast;
 use crate::ast::{BlockCheckMode, Expr, ExprKind, Item, ItemKind, Pat, PatKind, QSelf, Ty, TyKind};
-use crate::parse::parser::PathStyle;
+use crate::parse::parser::{BlockMode, PathStyle, TokenType, SemiColonMode};
 use crate::parse::token;
 use crate::parse::PResult;
 use crate::parse::Parser;
 use crate::print::pprust;
 use crate::ptr::P;
+use crate::symbol::keywords;
 use crate::ThinVec;
-use errors::Applicability;
+use errors::{Applicability, DiagnosticBuilder};
 use syntax_pos::Span;
+use log::debug;
 
 pub trait RecoverQPath: Sized + 'static {
     const PATH_STYLE: PathStyle = PathStyle::Expr;
@@ -261,4 +263,266 @@ impl<'a> Parser<'a> {
             .emit();
         Ok((sp, ExprKind::Await(ast::AwaitOrigin::FieldLike, expr)))
     }
+
+    /// If encountering `future.await()`, consume and emit error.
+    crate fn recover_from_await_method_call(&mut self) {
+        if self.token == token::OpenDelim(token::Paren) &&
+            self.look_ahead(1, |t| t == &token::CloseDelim(token::Paren))
+        {
+            // future.await()
+            let lo = self.span;
+            self.bump(); // (
+            let sp = lo.to(self.span);
+            self.bump(); // )
+            let mut err = self.struct_span_err(sp, "incorrect use of `await`");
+            err.span_suggestion(
+                sp,
+                "`await` is not a method call, remove the parentheses",
+                String::new(),
+                Applicability::MachineApplicable,
+            );
+            err.emit()
+        }
+    }
+
+    crate fn could_ascription_be_path(&self, node: &ast::ExprKind) -> bool {
+        self.token.is_ident() &&
+            if let ast::ExprKind::Path(..) = node { true } else { false } &&
+            !self.token.is_reserved_ident() &&           // v `foo:bar(baz)`
+            self.look_ahead(1, |t| t == &token::OpenDelim(token::Paren)) ||
+            self.look_ahead(1, |t| t == &token::Lt) &&     // `foo:bar<baz`
+            self.look_ahead(2, |t| t.is_ident()) ||
+            self.look_ahead(1, |t| t == &token::Colon) &&  // `foo:bar:baz`
+            self.look_ahead(2, |t| t.is_ident()) ||
+            self.look_ahead(1, |t| t == &token::ModSep) &&  // `foo:bar::baz`
+            self.look_ahead(2, |t| t.is_ident())
+    }
+
+    crate fn bad_type_ascription(
+        &self,
+        err: &mut DiagnosticBuilder<'a>,
+        lhs_span: Span,
+        cur_op_span: Span,
+        next_sp: Span,
+        maybe_path: bool,
+    ) {
+        err.span_label(self.span, "expecting a type here because of type ascription");
+        let cm = self.sess.source_map();
+        let next_pos = cm.lookup_char_pos(next_sp.lo());
+        let op_pos = cm.lookup_char_pos(cur_op_span.hi());
+        if op_pos.line != next_pos.line {
+            err.span_suggestion(
+                cur_op_span,
+                "try using a semicolon",
+                ";".to_string(),
+                Applicability::MaybeIncorrect,
+            );
+        } else {
+            if maybe_path {
+                err.span_suggestion(
+                    cur_op_span,
+                    "maybe you meant to write a path separator here",
+                    "::".to_string(),
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                err.note("type ascription is a nightly-only feature that lets \
+                          you annotate an expression with a type: `<expr>: <type>`");
+                err.span_note(
+                    lhs_span,
+                    "this expression expects an ascribed type after the colon",
+                );
+                err.help("this might be indicative of a syntax error elsewhere");
+            }
+        }
+    }
+
+    crate fn recover_seq_parse_error(
+        &mut self,
+        delim: token::DelimToken,
+        lo: Span,
+        result: PResult<'a, P<Expr>>,
+    ) -> P<Expr> {
+        match result {
+            Ok(x) => x,
+            Err(mut err) => {
+                err.emit();
+                // recover from parse error
+                self.consume_block(delim);
+                self.mk_expr(lo.to(self.prev_span), ExprKind::Err, ThinVec::new())
+            }
+        }
+    }
+
+    crate fn recover_closing_delimiter(
+        &mut self,
+        tokens: &[token::Token],
+        mut err: DiagnosticBuilder<'a>,
+    ) -> PResult<'a, bool> {
+        let mut pos = None;
+        // we want to use the last closing delim that would apply
+        for (i, unmatched) in self.unclosed_delims.iter().enumerate().rev() {
+            if tokens.contains(&token::CloseDelim(unmatched.expected_delim))
+                && Some(self.span) > unmatched.unclosed_span
+            {
+                pos = Some(i);
+            }
+        }
+        match pos {
+            Some(pos) => {
+                // Recover and assume that the detected unclosed delimiter was meant for
+                // this location. Emit the diagnostic and act as if the delimiter was
+                // present for the parser's sake.
+
+                 // Don't attempt to recover from this unclosed delimiter more than once.
+                let unmatched = self.unclosed_delims.remove(pos);
+                let delim = TokenType::Token(token::CloseDelim(unmatched.expected_delim));
+
+                 // We want to suggest the inclusion of the closing delimiter where it makes
+                // the most sense, which is immediately after the last token:
+                //
+                //  {foo(bar {}}
+                //      -      ^
+                //      |      |
+                //      |      help: `)` may belong here (FIXME: #58270)
+                //      |
+                //      unclosed delimiter
+                if let Some(sp) = unmatched.unclosed_span {
+                    err.span_label(sp, "unclosed delimiter");
+                }
+                err.span_suggestion_short(
+                    self.sess.source_map().next_point(self.prev_span),
+                    &format!("{} may belong here", delim.to_string()),
+                    delim.to_string(),
+                    Applicability::MaybeIncorrect,
+                );
+                err.emit();
+                self.expected_tokens.clear();  // reduce errors
+                Ok(true)
+            }
+            _ => Err(err),
+        }
+    }
+
+    /// Recover from `pub` keyword in places where it seems _reasonable_ but isn't valid.
+    crate fn eat_bad_pub(&mut self) {
+        if self.token.is_keyword(keywords::Pub) {
+            match self.parse_visibility(false) {
+                Ok(vis) => {
+                    let mut err = self.diagnostic()
+                        .struct_span_err(vis.span, "unnecessary visibility qualifier");
+                    err.span_label(vis.span, "`pub` not permitted here");
+                    err.emit();
+                }
+                Err(mut err) => err.emit(),
+            }
+        }
+    }
+
+    // Eat tokens until we can be relatively sure we reached the end of the
+    // statement. This is something of a best-effort heuristic.
+    //
+    // We terminate when we find an unmatched `}` (without consuming it).
+    crate fn recover_stmt(&mut self) {
+        self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore)
+    }
+
+    // If `break_on_semi` is `Break`, then we will stop consuming tokens after
+    // finding (and consuming) a `;` outside of `{}` or `[]` (note that this is
+    // approximate - it can mean we break too early due to macros, but that
+    // should only lead to sub-optimal recovery, not inaccurate parsing).
+    //
+    // If `break_on_block` is `Break`, then we will stop consuming tokens
+    // after finding (and consuming) a brace-delimited block.
+    crate fn recover_stmt_(&mut self, break_on_semi: SemiColonMode, break_on_block: BlockMode) {
+        let mut brace_depth = 0;
+        let mut bracket_depth = 0;
+        let mut in_block = false;
+        debug!("recover_stmt_ enter loop (semi={:?}, block={:?})",
+               break_on_semi, break_on_block);
+        loop {
+            debug!("recover_stmt_ loop {:?}", self.token);
+            match self.token {
+                token::OpenDelim(token::DelimToken::Brace) => {
+                    brace_depth += 1;
+                    self.bump();
+                    if break_on_block == BlockMode::Break &&
+                       brace_depth == 1 &&
+                       bracket_depth == 0 {
+                        in_block = true;
+                    }
+                }
+                token::OpenDelim(token::DelimToken::Bracket) => {
+                    bracket_depth += 1;
+                    self.bump();
+                }
+                token::CloseDelim(token::DelimToken::Brace) => {
+                    if brace_depth == 0 {
+                        debug!("recover_stmt_ return - close delim {:?}", self.token);
+                        break;
+                    }
+                    brace_depth -= 1;
+                    self.bump();
+                    if in_block && bracket_depth == 0 && brace_depth == 0 {
+                        debug!("recover_stmt_ return - block end {:?}", self.token);
+                        break;
+                    }
+                }
+                token::CloseDelim(token::DelimToken::Bracket) => {
+                    bracket_depth -= 1;
+                    if bracket_depth < 0 {
+                        bracket_depth = 0;
+                    }
+                    self.bump();
+                }
+                token::Eof => {
+                    debug!("recover_stmt_ return - Eof");
+                    break;
+                }
+                token::Semi => {
+                    self.bump();
+                    if break_on_semi == SemiColonMode::Break &&
+                       brace_depth == 0 &&
+                       bracket_depth == 0 {
+                        debug!("recover_stmt_ return - Semi");
+                        break;
+                    }
+                }
+                token::Comma => {
+                    if break_on_semi == SemiColonMode::Comma &&
+                       brace_depth == 0 &&
+                       bracket_depth == 0 {
+                        debug!("recover_stmt_ return - Semi");
+                        break;
+                    } else {
+                        self.bump();
+                    }
+                }
+                _ => {
+                    self.bump()
+                }
+            }
+        }
+    }
+
+    crate fn consume_block(&mut self, delim: token::DelimToken) {
+        let mut brace_depth = 0;
+        loop {
+            if self.eat(&token::OpenDelim(delim)) {
+                brace_depth += 1;
+            } else if self.eat(&token::CloseDelim(delim)) {
+                if brace_depth == 0 {
+                    return;
+                } else {
+                    brace_depth -= 1;
+                    continue;
+                }
+            } else if self.token == token::Eof || self.eat(&token::CloseDelim(token::NoDelim)) {
+                return;
+            } else {
+                self.bump();
+            }
+        }
+    }
+
 }
diff --git a/src/libsyntax/parse/parser.rs b/src/libsyntax/parse/parser.rs
index c34c7f3f1bb..b1c3e46adc0 100644
--- a/src/libsyntax/parse/parser.rs
+++ b/src/libsyntax/parse/parser.rs
@@ -104,14 +104,14 @@ pub enum PathStyle {
 }
 
 #[derive(Clone, Copy, PartialEq, Debug)]
-enum SemiColonMode {
+crate enum SemiColonMode {
     Break,
     Ignore,
     Comma,
 }
 
 #[derive(Clone, Copy, PartialEq, Debug)]
-enum BlockMode {
+crate enum BlockMode {
     Break,
     Ignore,
 }
@@ -389,7 +389,7 @@ crate enum TokenType {
 }
 
 impl TokenType {
-    fn to_string(&self) -> String {
+    crate fn to_string(&self) -> String {
         match *self {
             TokenType::Token(ref t) => format!("`{}`", pprust::token_to_string(t)),
             TokenType::Keyword(kw) => format!("`{}`", kw.name()),
@@ -673,56 +673,6 @@ impl<'a> Parser<'a> {
         }
     }
 
-    fn recover_closing_delimiter(
-        &mut self,
-        tokens: &[token::Token],
-        mut err: DiagnosticBuilder<'a>,
-    ) -> PResult<'a, bool> {
-        let mut pos = None;
-        // we want to use the last closing delim that would apply
-        for (i, unmatched) in self.unclosed_delims.iter().enumerate().rev() {
-            if tokens.contains(&token::CloseDelim(unmatched.expected_delim))
-                && Some(self.span) > unmatched.unclosed_span
-            {
-                pos = Some(i);
-            }
-        }
-        match pos {
-            Some(pos) => {
-                // Recover and assume that the detected unclosed delimiter was meant for
-                // this location. Emit the diagnostic and act as if the delimiter was
-                // present for the parser's sake.
-
-                 // Don't attempt to recover from this unclosed delimiter more than once.
-                let unmatched = self.unclosed_delims.remove(pos);
-                let delim = TokenType::Token(token::CloseDelim(unmatched.expected_delim));
-
-                 // We want to suggest the inclusion of the closing delimiter where it makes
-                // the most sense, which is immediately after the last token:
-                //
-                //  {foo(bar {}}
-                //      -      ^
-                //      |      |
-                //      |      help: `)` may belong here (FIXME: #58270)
-                //      |
-                //      unclosed delimiter
-                if let Some(sp) = unmatched.unclosed_span {
-                    err.span_label(sp, "unclosed delimiter");
-                }
-                err.span_suggestion_short(
-                    self.sess.source_map().next_point(self.prev_span),
-                    &format!("{} may belong here", delim.to_string()),
-                    delim.to_string(),
-                    Applicability::MaybeIncorrect,
-                );
-                err.emit();
-                self.expected_tokens.clear();  // reduce errors
-                Ok(true)
-            }
-            _ => Err(err),
-        }
-    }
-
     /// Expect next token to be edible or inedible token.  If edible,
     /// then consume it; if inedible, then return without consuming
     /// anything.  Signal a fatal error if next token is unexpected.
@@ -2343,7 +2293,7 @@ impl<'a> Parser<'a> {
         })
     }
 
-    fn mk_expr(&self, span: Span, node: ExprKind, attrs: ThinVec<Attribute>) -> P<Expr> {
+    crate fn mk_expr(&self, span: Span, node: ExprKind, attrs: ThinVec<Attribute>) -> P<Expr> {
         P(Expr { node, span, attrs, id: ast::DUMMY_NODE_ID })
     }
 
@@ -2936,23 +2886,7 @@ impl<'a> Parser<'a> {
                 ExprKind::Await(ast::AwaitOrigin::FieldLike, self_arg),
                 ThinVec::new(),
             );
-            if self.token == token::OpenDelim(token::Paren) &&
-                self.look_ahead(1, |t| t == &token::CloseDelim(token::Paren))
-            {
-                // future.await()
-                let lo = self.span;
-                self.bump(); // (
-                let sp = lo.to(self.span);
-                self.bump(); // )
-                let mut err = self.struct_span_err(sp, "incorrect use of `await`");
-                err.span_suggestion(
-                    sp,
-                    "`await` is not a method call, remove the parentheses",
-                    String::new(),
-                    Applicability::MachineApplicable,
-                );
-                err.emit()
-            }
+            self.recover_from_await_method_call();
             return Ok(await_expr);
         }
         let segment = self.parse_path_segment(PathStyle::Expr)?;
@@ -3191,23 +3125,6 @@ impl<'a> Parser<'a> {
         return Ok(e);
     }
 
-    fn recover_seq_parse_error(
-        &mut self,
-        delim: token::DelimToken,
-        lo: Span,
-        result: PResult<'a, P<Expr>>,
-    ) -> P<Expr> {
-        match result {
-            Ok(x) => x,
-            Err(mut err) => {
-                err.emit();
-                // recover from parse error
-                self.consume_block(delim);
-                self.mk_expr(lo.to(self.prev_span), ExprKind::Err, ThinVec::new())
-            }
-        }
-    }
-
     crate fn process_potential_macro_variable(&mut self) {
         let (token, span) = match self.token {
             token::Dollar if self.span.ctxt() != syntax_pos::hygiene::SyntaxContext::empty() &&
@@ -3610,58 +3527,6 @@ impl<'a> Parser<'a> {
         Ok(lhs)
     }
 
-    fn could_ascription_be_path(&self, node: &ast::ExprKind) -> bool {
-        self.token.is_ident() &&
-            if let ast::ExprKind::Path(..) = node { true } else { false } &&
-            !self.token.is_reserved_ident() &&           // v `foo:bar(baz)`
-            self.look_ahead(1, |t| t == &token::OpenDelim(token::Paren)) ||
-            self.look_ahead(1, |t| t == &token::Lt) &&     // `foo:bar<baz`
-            self.look_ahead(2, |t| t.is_ident()) ||
-            self.look_ahead(1, |t| t == &token::Colon) &&  // `foo:bar:baz`
-            self.look_ahead(2, |t| t.is_ident()) ||
-            self.look_ahead(1, |t| t == &token::ModSep) &&  // `foo:bar::baz`
-            self.look_ahead(2, |t| t.is_ident())
-    }
-
-    fn bad_type_ascription(
-        &self,
-        err: &mut DiagnosticBuilder<'a>,
-        lhs_span: Span,
-        cur_op_span: Span,
-        next_sp: Span,
-        maybe_path: bool,
-    ) {
-        err.span_label(self.span, "expecting a type here because of type ascription");
-        let cm = self.sess.source_map();
-        let next_pos = cm.lookup_char_pos(next_sp.lo());
-        let op_pos = cm.lookup_char_pos(cur_op_span.hi());
-        if op_pos.line != next_pos.line {
-            err.span_suggestion(
-                cur_op_span,
-                "try using a semicolon",
-                ";".to_string(),
-                Applicability::MaybeIncorrect,
-            );
-        } else {
-            if maybe_path {
-                err.span_suggestion(
-                    cur_op_span,
-                    "maybe you meant to write a path separator here",
-                    "::".to_string(),
-                    Applicability::MaybeIncorrect,
-                );
-            } else {
-                err.note("type ascription is a nightly-only feature that lets \
-                          you annotate an expression with a type: `<expr>: <type>`");
-                err.span_note(
-                    lhs_span,
-                    "this expression expects an ascribed type after the colon",
-                );
-                err.help("this might be indicative of a syntax error elsewhere");
-            }
-        }
-    }
-
     fn parse_assoc_op_cast(&mut self, lhs: P<Expr>, lhs_span: Span,
                            expr_kind: fn(P<Expr>, P<Ty>) -> ExprKind)
                            -> PResult<'a, P<Expr>> {
@@ -4943,92 +4808,6 @@ impl<'a> Parser<'a> {
         Ok(self.parse_stmt_(true))
     }
 
-    // Eat tokens until we can be relatively sure we reached the end of the
-    // statement. This is something of a best-effort heuristic.
-    //
-    // We terminate when we find an unmatched `}` (without consuming it).
-    fn recover_stmt(&mut self) {
-        self.recover_stmt_(SemiColonMode::Ignore, BlockMode::Ignore)
-    }
-
-    // If `break_on_semi` is `Break`, then we will stop consuming tokens after
-    // finding (and consuming) a `;` outside of `{}` or `[]` (note that this is
-    // approximate - it can mean we break too early due to macros, but that
-    // should only lead to sub-optimal recovery, not inaccurate parsing).
-    //
-    // If `break_on_block` is `Break`, then we will stop consuming tokens
-    // after finding (and consuming) a brace-delimited block.
-    fn recover_stmt_(&mut self, break_on_semi: SemiColonMode, break_on_block: BlockMode) {
-        let mut brace_depth = 0;
-        let mut bracket_depth = 0;
-        let mut in_block = false;
-        debug!("recover_stmt_ enter loop (semi={:?}, block={:?})",
-               break_on_semi, break_on_block);
-        loop {
-            debug!("recover_stmt_ loop {:?}", self.token);
-            match self.token {
-                token::OpenDelim(token::DelimToken::Brace) => {
-                    brace_depth += 1;
-                    self.bump();
-                    if break_on_block == BlockMode::Break &&
-                       brace_depth == 1 &&
-                       bracket_depth == 0 {
-                        in_block = true;
-                    }
-                }
-                token::OpenDelim(token::DelimToken::Bracket) => {
-                    bracket_depth += 1;
-                    self.bump();
-                }
-                token::CloseDelim(token::DelimToken::Brace) => {
-                    if brace_depth == 0 {
-                        debug!("recover_stmt_ return - close delim {:?}", self.token);
-                        break;
-                    }
-                    brace_depth -= 1;
-                    self.bump();
-                    if in_block && bracket_depth == 0 && brace_depth == 0 {
-                        debug!("recover_stmt_ return - block end {:?}", self.token);
-                        break;
-                    }
-                }
-                token::CloseDelim(token::DelimToken::Bracket) => {
-                    bracket_depth -= 1;
-                    if bracket_depth < 0 {
-                        bracket_depth = 0;
-                    }
-                    self.bump();
-                }
-                token::Eof => {
-                    debug!("recover_stmt_ return - Eof");
-                    break;
-                }
-                token::Semi => {
-                    self.bump();
-                    if break_on_semi == SemiColonMode::Break &&
-                       brace_depth == 0 &&
-                       bracket_depth == 0 {
-                        debug!("recover_stmt_ return - Semi");
-                        break;
-                    }
-                }
-                token::Comma => {
-                    if break_on_semi == SemiColonMode::Comma &&
-                       brace_depth == 0 &&
-                       bracket_depth == 0 {
-                        debug!("recover_stmt_ return - Semi");
-                        break;
-                    } else {
-                        self.bump();
-                    }
-                }
-                _ => {
-                    self.bump()
-                }
-            }
-        }
-    }
-
     fn parse_stmt_(&mut self, macro_legacy_warnings: bool) -> Option<Stmt> {
         self.parse_stmt_without_recovery(macro_legacy_warnings).unwrap_or_else(|mut e| {
             e.emit();
@@ -6932,26 +6711,6 @@ impl<'a> Parser<'a> {
         Ok((class_name, ItemKind::Union(vdata, generics), None))
     }
 
-    fn consume_block(&mut self, delim: token::DelimToken) {
-        let mut brace_depth = 0;
-        loop {
-            if self.eat(&token::OpenDelim(delim)) {
-                brace_depth += 1;
-            } else if self.eat(&token::CloseDelim(delim)) {
-                if brace_depth == 0 {
-                    return;
-                } else {
-                    brace_depth -= 1;
-                    continue;
-                }
-            } else if self.token == token::Eof || self.eat(&token::CloseDelim(token::NoDelim)) {
-                return;
-            } else {
-                self.bump();
-            }
-        }
-    }
-
     fn parse_record_struct_body(
         &mut self,
     ) -> PResult<'a, (Vec<StructField>, /* recovered */ bool)> {
@@ -8649,21 +8408,6 @@ impl<'a> Parser<'a> {
         ).emit();
     }
 
-    /// Recover from `pub` keyword in places where it seems _reasonable_ but isn't valid.
-    fn eat_bad_pub(&mut self) {
-        if self.token.is_keyword(keywords::Pub) {
-            match self.parse_visibility(false) {
-                Ok(vis) => {
-                    let mut err = self.diagnostic()
-                        .struct_span_err(vis.span, "unnecessary visibility qualifier");
-                    err.span_label(vis.span, "`pub` not permitted here");
-                    err.emit();
-                }
-                Err(mut err) => err.emit(),
-            }
-        }
-    }
-
     /// When lowering a `async fn` to the HIR, we need to move all of the arguments of the function
     /// into the generated closure so that they are dropped when the future is polled and not when
     /// it is created.
-- 
cgit 1.4.1-3-g733a5


From c084d0ed7d1dcad99d523cb82d7fc78c6d76a8c6 Mon Sep 17 00:00:00 2001
From: Esteban Küber <esteban@kuber.com.ar>
Date: Thu, 16 May 2019 15:25:58 -0700
Subject: review comments

---
 src/libsyntax/parse/diagnostics.rs | 48 +++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 26 deletions(-)

(limited to 'src/libsyntax/parse')

diff --git a/src/libsyntax/parse/diagnostics.rs b/src/libsyntax/parse/diagnostics.rs
index ab5f87fa7ca..1a2393be806 100644
--- a/src/libsyntax/parse/diagnostics.rs
+++ b/src/libsyntax/parse/diagnostics.rs
@@ -274,14 +274,13 @@ impl<'a> Parser<'a> {
             self.bump(); // (
             let sp = lo.to(self.span);
             self.bump(); // )
-            let mut err = self.struct_span_err(sp, "incorrect use of `await`");
-            err.span_suggestion(
-                sp,
-                "`await` is not a method call, remove the parentheses",
-                String::new(),
-                Applicability::MachineApplicable,
-            );
-            err.emit()
+            self.struct_span_err(sp, "incorrect use of `await`")
+                .span_suggestion(
+                    sp,
+                    "`await` is not a method call, remove the parentheses",
+                    String::new(),
+                    Applicability::MachineApplicable,
+                ).emit()
         }
     }
 
@@ -327,12 +326,12 @@ impl<'a> Parser<'a> {
                 );
             } else {
                 err.note("type ascription is a nightly-only feature that lets \
-                          you annotate an expression with a type: `<expr>: <type>`");
-                err.span_note(
-                    lhs_span,
-                    "this expression expects an ascribed type after the colon",
-                );
-                err.help("this might be indicative of a syntax error elsewhere");
+                          you annotate an expression with a type: `<expr>: <type>`")
+                    .span_note(
+                        lhs_span,
+                        "this expression expects an ascribed type after the colon",
+                    )
+                    .help("this might be indicative of a syntax error elsewhere");
             }
         }
     }
@@ -409,10 +408,10 @@ impl<'a> Parser<'a> {
         if self.token.is_keyword(keywords::Pub) {
             match self.parse_visibility(false) {
                 Ok(vis) => {
-                    let mut err = self.diagnostic()
-                        .struct_span_err(vis.span, "unnecessary visibility qualifier");
-                    err.span_label(vis.span, "`pub` not permitted here");
-                    err.emit();
+                    self.diagnostic()
+                        .struct_span_err(vis.span, "unnecessary visibility qualifier")
+                        .span_label(vis.span, "`pub` not permitted here")
+                        .emit();
                 }
                 Err(mut err) => err.emit(),
             }
@@ -488,15 +487,12 @@ impl<'a> Parser<'a> {
                         break;
                     }
                 }
-                token::Comma => {
-                    if break_on_semi == SemiColonMode::Comma &&
+                token::Comma if break_on_semi == SemiColonMode::Comma &&
                        brace_depth == 0 &&
-                       bracket_depth == 0 {
-                        debug!("recover_stmt_ return - Semi");
-                        break;
-                    } else {
-                        self.bump();
-                    }
+                       bracket_depth == 0 =>
+                {
+                    debug!("recover_stmt_ return - Semi");
+                    break;
                 }
                 _ => {
                     self.bump()
-- 
cgit 1.4.1-3-g733a5