[Parse] Adjust diagnostics for effects specifiers in closure signature

Author: rintaro

include/swift/AST/DiagnosticsParse.def

@@ -749,8 +749,7 @@ ERROR(async_after_throws,none,
       "'async' must precede %select{'throws'|'rethrows'}0", (bool))
 ERROR(async_init,none, "initializer cannot be marked 'async'", ())
 ERROR(duplicate_effect_specifier,none,
-      "unexpected %select{'throws'|'rethrows'|'async'}0",
-      (unsigned))
+      "unexpected '%0' specifier", (StringRef))
 
 // Enum Types
 ERROR(expected_expr_enum_case_raw_value,PointsToFirstBadToken,

lib/Parse/ParseExpr.cpp

@@ -2374,6 +2374,8 @@ ParserStatus Parser::parseClosureSignatureIfPresent(
         if (consumeIf(tok::arrow)) {
           if (!canParseType())
             return makeParserSuccess();
+
+          consumeEffectsSpecifiers();
         }
       }
 
@@ -2396,6 +2398,8 @@ ParserStatus Parser::parseClosureSignatureIfPresent(
       if (consumeIf(tok::arrow)) {
         if (!canParseType())
           return makeParserSuccess();
+
+        consumeEffectsSpecifiers();
       }
     }
 
@@ -2606,6 +2610,10 @@ ParserStatus Parser::parseClosureSignatureIfPresent(
         status.setIsParseError();
       } else {
         explicitResultType = new (Context) TypeExpr(explicitResultTypeRepr);
+
+        // Check for 'throws' and 'rethrows' after the type and correct it.
+        parseEffectsSpecifiers(arrowLoc, asyncLoc, throwsLoc,
+                               /*rethrows*/nullptr);
       }
     }
   }

lib/Parse/ParsePattern.cpp

@@ -848,7 +848,7 @@ ParserStatus Parser::parseEffectsSpecifiers(SourceLoc existingArrowLoc,
         Tok.isContextualKeyword("async")) {
 
       if (asyncLoc.isValid()) {
-        diagnose(Tok, diag::duplicate_effect_specifier, 2)
+        diagnose(Tok, diag::duplicate_effect_specifier, Tok.getText())
             .fixItRemove(Tok.getLoc());
       } else if (existingArrowLoc.isValid()) {
         SourceLoc insertLoc = existingArrowLoc;
@@ -876,18 +876,17 @@ ParserStatus Parser::parseEffectsSpecifiers(SourceLoc existingArrowLoc,
         (Tok.isAny(tok::kw_throw, tok::kw_try) && !Tok.isAtStartOfLine())) {
       bool isRethrows = Tok.is(tok::kw_rethrows);
 
-      if (Tok.isAny(tok::kw_throw, tok::kw_try)) {
+      if (throwsLoc.isValid()) {
+        diagnose(Tok, diag::duplicate_effect_specifier, Tok.getText())
+            .fixItRemove(Tok.getLoc());
+      } else if (Tok.isAny(tok::kw_throw, tok::kw_try)) {
         // Replace 'throw' or 'try' with 'throws'.
         diagnose(Tok, diag::throw_in_function_type)
             .fixItReplace(Tok.getLoc(), "throws");
       } else if (!rethrows && isRethrows) {
         // Replace 'rethrows' with 'throws' unless it's allowed.
         diagnose(Tok, diag::rethrowing_function_type)
             .fixItReplace(Tok.getLoc(), "throws");
-      } else if (throwsLoc.isValid()) {
-        diagnose(Tok, diag::duplicate_effect_specifier,
-                 rethrows ? (isRethrows ? 1 : 0) : 0)
-            .fixItRemove(Tok.getLoc());
       } else if (existingArrowLoc.isValid()) {
         diagnose(Tok, diag::async_or_throws_in_wrong_position,
                  rethrows ? (isRethrows ? 1 : 0) : 0)

lib/Parse/ParseType.cpp

@@ -1462,39 +1462,18 @@ bool Parser::canParseType() {
     break;
   }
 
-  // Handle type-function if we have an 'async'.
-  if (shouldParseExperimentalConcurrency() &&
-      Tok.isContextualKeyword("async")) {
-    consumeToken();
-
-    // 'async' isn't a valid type without being followed by throws/rethrows
-    // or a return.
-    if (!Tok.isAny(tok::kw_throws, tok::kw_rethrows, tok::arrow))
-      return false;
-  }
+  if (!isAtFunctionTypeArrow())
+    return true;
 
-  // Handle type-function if we have an arrow or 'throws'/'rethrows' modifier.
-  if (Tok.isAny(tok::kw_throws, tok::kw_rethrows)) {
+  // Handle type-function if we have an '->' with optional
+  // 'async' and/or 'throws'.
+  while (isEffectsSpecifier(Tok))
     consumeToken();
 
-    // Allow 'async' here even though it is ill-formed, so we can provide
-    // a better error.
-    if (shouldParseExperimentalConcurrency() &&
-        Tok.isContextualKeyword("async"))
-      consumeToken();
-
-    // "throws" or "rethrows" isn't a valid type without being followed by
-    // a return. We also accept 'async' here so we can provide a better
-    // error.
-    if (!Tok.is(tok::arrow))
-      return false;
-  }
+  if (!consumeIf(tok::arrow))
+    return false;
 
-  if (consumeIf(tok::arrow)) {
-    return canParseType();
-  }
-
-  return true;
+  return canParseType();
 }
 
 bool Parser::canParseTypeIdentifierOrTypeComposition() {

test/Parse/async.swift

@@ -22,6 +22,11 @@ func asyncGlobal6() -> Int throws async { }
 
 func asyncGlobal7() throws -> Int async { } // expected-error{{'async' may only occur before '->'}}{{35-41=}}{{21-21=async }}
 
+func asyncGlobal8() async throws async -> async Int async {}
+// expected-error@-1{{unexpected 'async' specifier}} {{34-40=}}
+// expected-error@-2{{unexpected 'async' specifier}} {{43-49=}}
+// expected-error@-3{{unexpected 'async' specifier}} {{53-59=}}
+
 class X {
   init() async { } // expected-error{{initializer cannot be marked 'async'}}
 

test/Parse/errors.swift

@@ -116,6 +116,27 @@ func postRethrows2(_ f: () throws -> Int) -> rethrows Int { // expected-error{{'
   return try f()
 }
 
+func postThrows3() {
+  _ = { () -> Int throws in } // expected-error {{'throws' may only occur before '->'}} {{19-26=}} {{12-12=throws }}
+}
+
+func dupThrows1() throws rethrows -> throws Int throw {}
+// expected-error@-1 {{unexpected 'rethrows' specifier}} {{26-35=}}
+// expected-error@-2 {{unexpected 'throws' specifier}} {{38-45=}}
+// expected-error@-3 {{unexpected 'throw' specifier}} {{49-55=}}
+
+func dupThrows2(_ f: () throws -> rethrows Int) {}
+// expected-error@-1 {{unexpected 'rethrows' specifier}} {{35-44=}}
+
+func dupThrows3() {
+  _ = { () try throws in }
+// expected-error@-1 {{expected throwing specifier; did you mean 'throws'?}} {{12-15=throws}}
+// expected-error@-2 {{unexpected 'throws' specifier}} {{16-23=}}
+
+  _ = { () throws -> Int throws in }
+// expected-error@-1 {{unexpected 'throws' specifier}} {{26-33=}}
+}
+
 func incompleteThrowType() {
   // FIXME: Bad recovery for incomplete function type.
   let _: () throws