fixed-typed-throws-after-arrow-fixit

- `Parser.parseMisplacedEffectSpecifiers` will detect whether there is any misplaced typed throws. If yes, it will try to parse the thrown type and mark all tokens of the thrown type as missing.
- `ParseDiagnosticsGenerator.handleMisplacedEffectSpecifiersAfterArrow` will recognize the entire throws clause as correct instead of the throws specifier only.
- `ParseDiagnosticsGenerator.exchangeNodes` to replace `ParseDiagnosticsGenerator.exchangeTokens`, relaxing the input type from token to any syntax node.
- refactored `TokenMissingMaker` in Declaration.swift, moved to Parser.swift, creating `Parser.withAllTokensMarkedMissing` for more generalized use.

Author: AppAppWorks

Sources/SwiftParser/Declarations.swift

@@ -1281,17 +1281,7 @@ extension Parser {
             arena: self.arena
           )
 
-          /// Create a version of the same attribute with all tokens missing.
-          class TokenMissingMaker: SyntaxRewriter {
-            override func visit(_ token: TokenSyntax) -> TokenSyntax {
-              return .init(token.tokenKind, presence: .missing)
-            }
-          }
-          let tokenMissingMaker = TokenMissingMaker(arena: self.arena)
-          let missingAttributes = tokenMissingMaker.rewrite(
-            Syntax(raw: RawSyntax(recoveredAttributes), rawNodeArena: arena)
-          ).raw
-          attrs.attributes = missingAttributes.cast(RawAttributeListSyntax.self)
+          attrs.attributes = withAllTokensMarkedMissing(syntax: recoveredAttributes)
         }
 
         var (pattern, typeAnnotation) = self.parseTypedPattern()

Sources/SwiftParser/Parser.swift

@@ -826,6 +826,24 @@ extension Parser {
   }
 }
 
+// MARK: Marking Tokens As Missing
+extension Parser {
+  private class TokenMissingMaker: SyntaxRewriter {
+    override func visit(_ token: TokenSyntax) -> TokenSyntax {
+      TokenSyntax(token.tokenKind, presence: .missing)
+    }
+  }
+
+  /// Creates a replicate of `syntax` with all tokens marked as missing.
+  func withAllTokensMarkedMissing<T: RawSyntaxNodeProtocol>(syntax: T) -> T {
+    let tokenMissingMaker = TokenMissingMaker(arena: self.arena)
+    let allMissing = tokenMissingMaker.rewrite(
+      Syntax(raw: RawSyntax(syntax), rawNodeArena: self.arena)
+    ).raw
+    return allMissing.cast(T.self)
+  }
+}
+
 extension SyntaxText {
   func withBuffer<Result>(_ body: (UnsafeBufferPointer<UInt8>) throws -> Result) rethrows -> Result {
     try body(UnsafeBufferPointer<UInt8>(start: self.baseAddress, count: self.count))

Sources/SwiftParser/Specifiers.swift

@@ -772,16 +772,17 @@ extension Parser {
     _ effectSpecifiers: inout S?
   ) -> RawUnexpectedNodesSyntax? {
     var synthesizedAsync: RawTokenSyntax? = nil
-    var synthesizedThrows: RawTokenSyntax? = nil
-    var unexpected: [RawTokenSyntax] = []
+    var synthesizedThrowsClause: RawThrowsClauseSyntax? = nil
+    var unexpected: [RawSyntax] = []
     var loopProgress = LoopProgressCondition()
+
     while self.hasProgressed(&loopProgress) {
       if let (spec, handle, matchedSubset) = self.at(
         anyIn: S.MisspelledAsyncTokenKinds.self,
         or: S.CorrectAsyncTokenKinds.self
       ) {
         let misspelledAsync = self.eat(handle)
-        unexpected.append(misspelledAsync)
+        unexpected.append(RawSyntax(misspelledAsync))
         if effectSpecifiers?.asyncSpecifier == nil {
           if matchedSubset == S.CorrectAsyncTokenKinds.self {
             synthesizedAsync = missingToken(spec)
@@ -794,23 +795,82 @@ extension Parser {
         or: S.CorrectThrowsTokenKinds.self
       ) {
         let misspelledThrows = self.eat(handle)
-        unexpected.append(misspelledThrows)
-        if effectSpecifiers?.throwsClause == nil {
-          if matchedSubset == S.CorrectThrowsTokenKinds.self {
-            synthesizedThrows = missingToken(spec)
-          } else {
-            synthesizedThrows = missingToken(.throws)
+        unexpected.append(RawSyntax(misspelledThrows))
+        guard effectSpecifiers?.throwsClause == nil else {
+          continue
+        }
+        if matchedSubset == S.CorrectThrowsTokenKinds.self {
+          let synthesizedThrows = missingToken(spec)
+
+          // avoid generating diagnotics that suggest moving `throws` and the following type if there is any trivia
+          // between `throws` and the following left parenthesis, because the following type is likely to be the
+          // return type.
+          // e.g. -> throws (Int, Int)
+          //
+          // prefer pessimistic diagnostics even if they might be suboptimal.
+          // e.g. -> throws (any Error) Int
+          guard misspelledThrows.trailingTriviaByteLength == 0 && self.currentToken.leadingTriviaByteLength == 0 else {
+            synthesizedThrowsClause = RawThrowsClauseSyntax(
+              throwsSpecifier: synthesizedThrows,
+              leftParen: nil,
+              type: nil,
+              rightParen: nil,
+              arena: self.arena
+            )
+            continue
+          }
+
+          guard
+            withLookahead({ lookahead in
+              lookahead.consume(if: .leftParen) != nil && lookahead.canParseType()
+            })
+          else {
+            synthesizedThrowsClause = RawThrowsClauseSyntax(
+              throwsSpecifier: synthesizedThrows,
+              leftParen: nil,
+              type: nil,
+              rightParen: nil,
+              arena: self.arena
+            )
+            continue
           }
+
+          let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
+          if let unexpectedBeforeLeftParen {
+            unexpected += unexpectedBeforeLeftParen.elements
+          }
+          unexpected.append(RawSyntax(leftParen))
+          let type = self.parseType()
+          unexpected.append(RawSyntax(type))
+          let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
+          if let unexpectedBeforeRightParen {
+            unexpected += unexpectedBeforeRightParen.elements
+          }
+          if !rightParen.isMissing {
+            unexpected.append(RawSyntax(rightParen))
+          }
+
+          synthesizedThrowsClause = RawThrowsClauseSyntax(
+            throwsSpecifier: synthesizedThrows,
+            leftParen: missingToken(.leftParen),
+            type: self.withAllTokensMarkedMissing(syntax: type),
+            rightParen: rightParen.isMissing ? nil : missingToken(.rightParen),
+            arena: self.arena
+          )
+        } else {
+          synthesizedThrowsClause = RawThrowsClauseSyntax(
+            throwsSpecifier: missingToken(.throws),
+            leftParen: nil,
+            type: nil,
+            rightParen: nil,
+            arena: self.arena
+          )
         }
       } else {
         break
       }
     }
-    if synthesizedAsync != nil || synthesizedThrows != nil {
-      let synthesizedThrowsClause = synthesizedThrows.map {
-        RawThrowsClauseSyntax(throwsSpecifier: $0, leftParen: nil, type: nil, rightParen: nil, arena: self.arena)
-      }
-
+    if synthesizedAsync != nil || synthesizedThrowsClause != nil {
       if let specifiers = effectSpecifiers {
         effectSpecifiers = specifiers.withMisplaced(
           async: synthesizedAsync,