Fix up a mismatch between effect specifier lookahead and parsing

Sources/SwiftParser/Expressions.swift

@@ -2428,10 +2428,15 @@ extension Parser.Lookahead {
   // Consume 'async', 'throws', and 'rethrows', but in any order.
   mutating func consumeEffectsSpecifiers() {
     var loopProgress = LoopProgressCondition()
-    while let (_, handle) = self.at(anyIn: EffectSpecifier.self),
+    while let (spec, handle) = self.at(anyIn: EffectSpecifier.self),
       self.hasProgressed(&loopProgress)
     {
       self.eat(handle)
+
+      if spec.isThrowsSpecifier, self.consume(if: .leftParen) != nil {
+        _ = self.canParseSimpleOrCompositionType()
+        self.consume(if: .rightParen)
+      }
     }
   }
 

Sources/SwiftParser/Types.swift

@@ -37,7 +37,7 @@ extension Parser {
   mutating func parseTypeScalar(misplacedSpecifiers: [RawTokenSyntax] = []) -> RawTypeSyntax {
     let specifiersAndAttributes = self.parseTypeAttributeList(misplacedSpecifiers: misplacedSpecifiers)
     var base = RawTypeSyntax(self.parseSimpleOrCompositionType())
-    if self.withLookahead({ $0.atFunctionTypeArrow() }) {
+    if self.withLookahead({ $0.canParseFunctionTypeArrow() }) {
       var effectSpecifiers = self.parseTypeEffectSpecifiers()
       let returnClause = self.parseFunctionReturnClause(
         effectSpecifiers: &effectSpecifiers,
@@ -656,21 +656,9 @@ extension Parser.Lookahead {
       return false
     }
 
-    if self.atFunctionTypeArrow() {
-      // Handle type-function if we have an '->' with optional
-      // 'async' and/or 'throws'.
-      var loopProgress = LoopProgressCondition()
-      while let (_, handle) = self.at(anyIn: EffectSpecifier.self), self.hasProgressed(&loopProgress) {
-        self.eat(handle)
-      }
-
-      guard self.consume(if: .arrow) != nil else {
-        return false
-      }
-
+    if self.canParseFunctionTypeArrow() {
       return self.canParseType()
     }
-
     return true
   }
 
@@ -819,33 +807,12 @@ extension Parser.Lookahead {
     return self.consume(if: .rightParen) != nil
   }
 
-  mutating func atFunctionTypeArrow() -> Bool {
-    if self.at(.arrow) {
+  mutating func canParseFunctionTypeArrow() -> Bool {
+    if self.consume(if: .arrow) != nil {
       return true
     }
-
-    if let effect = self.at(anyIn: EffectSpecifier.self) {
-      if self.peek().rawTokenKind == .arrow {
-        return true
-      }
-
-      if effect.spec.isThrowsSpecifier && self.peek().rawTokenKind == .leftParen {
-        var lookahead = self.lookahead()
-        lookahead.consumeAnyToken()
-        lookahead.skipSingle()
-        return lookahead.atFunctionTypeArrow()
-      }
-
-      if peek(isAtAnyIn: EffectSpecifier.self) != nil {
-        var lookahead = self.lookahead()
-        lookahead.consumeAnyToken()
-        return lookahead.atFunctionTypeArrow()
-      }
-
-      return false
-    }
-
-    return false
+    self.consumeEffectsSpecifiers()
+    return self.consume(if: .arrow) != nil
   }
 
   mutating func canParseTypeIdentifier(allowKeyword: Bool = false) -> Bool {

Tests/SwiftParserTest/ExpressionTests.swift

@@ -2972,6 +2972,9 @@ final class StatementExpressionTests: ParserTestCase {
     assertParse(
       "[() throws(MyError) -> Void]()"
     )
+    assertParse(
+      "[() throws(any Error) -> Void]()"
+    )
     assertParse(
       "X<() throws(MyError) -> Int>()"
     )
@@ -2980,6 +2983,22 @@ final class StatementExpressionTests: ParserTestCase {
     )
   }
 
+  func testTypedThrowsClosureParam() {
+    assertParse(
+      """
+      try foo { (a, b) throws(S) in 1 }
+      """
+    )
+  }
+
+  func testTypedThrowsShorthandClosureParams() {
+    assertParse(
+      """
+      try foo { a, b throws(S) in 1 }
+      """
+    )
+  }
+
   func testArrayExprWithNoCommas() {
     assertParse("[() ()]")