Add fixit for '-> throws' to 'throws ->' (#3335)

Author: Harlan

include/swift/AST/DiagnosticsParse.def

@@ -604,9 +604,9 @@ ERROR(generic_non_function,PointsToFirstBadToken,
       "only syntactic function types can be generic", ())
 ERROR(rethrowing_function_type,PointsToFirstBadToken,
       "only function declarations may be marked 'rethrows'", ())
-ERROR(throws_after_function_result,none,
+ERROR(throws_in_wrong_position,none,
       "'throws' may only occur before '->'", ())
-ERROR(rethrows_after_function_result,none,
+ERROR(rethrows_in_wrong_position,none,
       "'rethrows' may only occur before '->'", ())
 ERROR(throw_in_function_type,none,
       "expected throwing specifier; did you mean 'throws'?", ())

lib/Parse/ParseExpr.cpp

@@ -186,13 +186,13 @@ ParserResult<Expr> Parser::parseExprArrow() {
   if (Tok.is(tok::kw_throws)) {
     throwsLoc = consumeToken(tok::kw_throws);
     if (!Tok.is(tok::arrow)) {
-      diagnose(throwsLoc, diag::throws_after_function_result);
+      diagnose(throwsLoc, diag::throws_in_wrong_position);
       return nullptr;
     }
   }
   arrowLoc = consumeToken(tok::arrow);
   if (Tok.is(tok::kw_throws)) {
-    diagnose(Tok.getLoc(), diag::throws_after_function_result);
+    diagnose(Tok.getLoc(), diag::throws_in_wrong_position);
     throwsLoc = consumeToken(tok::kw_throws);
   }
   auto arrow = new (Context) ArrowExpr(throwsLoc, arrowLoc);

lib/Parse/ParsePattern.cpp

@@ -648,6 +648,26 @@ Parser::parseFunctionSignature(Identifier SimpleName,
   }
 
   SourceLoc arrowLoc;
+
+  auto diagnoseInvalidThrows = [&]() -> Optional<InFlightDiagnostic> {
+    if (throwsLoc.isValid())
+      return None;
+
+    if (Tok.is(tok::kw_throws)) {
+      throwsLoc = consumeToken();
+    } else if (Tok.is(tok::kw_rethrows)) {
+      throwsLoc = consumeToken();
+      rethrows = true;
+    }
+
+    if (!throwsLoc.isValid())
+      return None;
+
+    auto diag = rethrows ? diag::rethrows_in_wrong_position
+                         : diag::throws_in_wrong_position;
+    return diagnose(Tok, diag);
+  };
+
   // If there's a trailing arrow, parse the rest as the result type.
   if (Tok.isAny(tok::arrow, tok::colon)) {
     if (!consumeIf(tok::arrow, arrowLoc)) {
@@ -657,6 +677,15 @@ Parser::parseFunctionSignature(Identifier SimpleName,
       arrowLoc = consumeToken(tok::colon);
     }
 
+    // Check for 'throws' and 'rethrows' after the arrow, but
+    // before the type, and correct it.
+    if (auto diagOpt = diagnoseInvalidThrows()) {
+      assert(arrowLoc.isValid());
+      assert(throwsLoc.isValid());
+      (*diagOpt).fixItExchange(SourceRange(arrowLoc),
+                               SourceRange(throwsLoc));
+    }
+
     ParserResult<TypeRepr> ResultType =
       parseType(diag::expected_type_function_result);
     if (ResultType.hasCodeCompletion())
@@ -672,26 +701,14 @@ Parser::parseFunctionSignature(Identifier SimpleName,
   }
 
   // Check for 'throws' and 'rethrows' after the type and correct it.
-  if (!throwsLoc.isValid()) {
-    if (Tok.is(tok::kw_throws)) {
-      throwsLoc = consumeToken();
-    } else if (Tok.is(tok::kw_rethrows)) {
-      throwsLoc = consumeToken();
-      rethrows = true;
-    }
-
-    if (throwsLoc.isValid()) {
-      assert(arrowLoc.isValid());
-      assert(retType);
-      auto diag = rethrows ? diag::rethrows_after_function_result
-                           : diag::throws_after_function_result;
-      SourceLoc typeEndLoc = Lexer::getLocForEndOfToken(SourceMgr,
-                                                        retType->getEndLoc());
-      SourceLoc throwsEndLoc = Lexer::getLocForEndOfToken(SourceMgr, throwsLoc);
-      diagnose(Tok, diag)
-        .fixItInsert(arrowLoc, rethrows ? "rethrows " : "throws ")
-        .fixItRemoveChars(typeEndLoc, throwsEndLoc);
-    }
+  if (auto diagOpt = diagnoseInvalidThrows()) {
+    assert(arrowLoc.isValid());
+    assert(retType);
+    SourceLoc typeEndLoc = Lexer::getLocForEndOfToken(SourceMgr,
+                                                      retType->getEndLoc());
+    SourceLoc throwsEndLoc = Lexer::getLocForEndOfToken(SourceMgr, throwsLoc);
+    (*diagOpt).fixItInsert(arrowLoc, rethrows ? "rethrows " : "throws ")
+              .fixItRemoveChars(typeEndLoc, throwsEndLoc);
   }
 
   return Status;

test/Parse/errors.swift

@@ -110,10 +110,18 @@ func postThrows() -> Int throws { // expected-error{{'throws' may only occur bef
   return 5
 }
 
+func postThrows2() -> throws Int { // expected-error{{'throws' may only occur before '->'}}{{20-22=throws}}{{23-29=->}}
+  return try postThrows()
+}
+
 func postRethrows(_ f: () throws -> Int) -> Int rethrows { // expected-error{{'rethrows' may only occur before '->'}}{{42-42=rethrows }}{{48-57=}}
   return try f()
 }
 
+func postRethrows2(_ f: () throws -> Int) -> rethrows Int { // expected-error{{'rethrows' may only occur before '->'}}{{43-45=rethrows}}{{46-54=->}}
+  return try f()
+}
+
 // rdar://21328447
 func fixitThrow0() throw {} // expected-error{{expected throwing specifier; did you mean 'throws'?}} {{20-25=throws}}
 func fixitThrow1() throw -> Int {} // expected-error{{expected throwing specifier; did you mean 'throws'?}} {{20-25=throws}}