Simplified recovery logic for parsing function signature in deinit

Author: nickolas-pohilets

Sources/SwiftParser/Declarations.swift

@@ -1122,7 +1122,6 @@ extension Parser {
     let (unexpectedBeforeDeinitKeyword, deinitKeyword) = self.eat(handle)
 
     var unexpectedNameAndSignature: [RawSyntax?] = []
-    var unexpectedAfterAsync: [RawSyntax?] = []
 
     // async is a contextual keyword
     // must be parsed before attempting to parse identifier
@@ -1135,24 +1134,12 @@ extension Parser {
       effectSpecifiers = parseDeinitEffectSpecifiers()
     }
     if effectSpecifiers == nil && self.at(.leftParen) && !self.currentToken.isAtStartOfLine {
-      let sig = parseFunctionSignature()
-      unexpectedNameAndSignature.append(contentsOf: sig.unexpectedBeforeInput?.elements ?? [])
-      unexpectedNameAndSignature.append(RawSyntax(sig.input))
-      unexpectedNameAndSignature.append(contentsOf: sig.unexpectedBetweenInputAndEffectSpecifiers?.elements ?? [])
-      if let effects = sig.effectSpecifiers {
-        effectSpecifiers = RawDeinitEffectSpecifiersSyntax(
-          effects.unexpectedBeforeAsyncSpecifier,
-          asyncSpecifier: effects.asyncSpecifier,
-          effects.unexpectedBetweenAsyncSpecifierAndThrowsSpecifier,
-          throwsSpecifier: effects.throwsSpecifier,
-          effects.unexpectedAfterThrowsSpecifier,
-          arena: self.arena
-        )
-      }
-      unexpectedAfterAsync.append(contentsOf: sig.unexpectedBetweenEffectSpecifiersAndOutput?.elements ?? [])
-      if let output = sig.output {
-        unexpectedAfterAsync.append(RawSyntax(output))
+      let input = parseParameterClause(RawParameterClauseSyntax.self) { parser in
+        parser.parseFunctionParameter()
       }
+      unexpectedNameAndSignature.append(RawSyntax(input))
+
+      effectSpecifiers = parseDeinitEffectSpecifiers()
     }
     let items = self.parseOptionalCodeBlock()
     return RawDeinitializerDeclSyntax(
@@ -1162,7 +1149,7 @@ extension Parser {
       deinitKeyword: deinitKeyword,
       RawUnexpectedNodesSyntax(unexpectedNameAndSignature, arena: self.arena),
       effectSpecifiers: effectSpecifiers,
-      RawUnexpectedNodesSyntax(unexpectedAfterAsync, arena: self.arena),
+      nil,
       body: items,
       arena: self.arena
     )

Sources/SwiftParser/Specifiers.swift

@@ -463,72 +463,6 @@ extension RawDeinitEffectSpecifiersSyntax {
       }
     }
   }
-
-  public init(
-    _ unexpectedBeforeAsyncSpecifier: RawUnexpectedNodesSyntax? = nil,
-    asyncSpecifier: RawTokenSyntax?,
-    _ unexpectedBetweenAsyncSpecifierAndThrowsSpecifier: RawUnexpectedNodesSyntax? = nil,
-    throwsSpecifier: RawTokenSyntax?,
-    _ unexpectedAfterThrowsSpecifier: RawUnexpectedNodesSyntax? = nil,
-    arena: __shared SyntaxArena
-  ) {
-    // Missing async keyword was created, meaning that throws and async are swapped
-    if asyncSpecifier?.isMissing ?? false {
-      var unexpectedBeforeAsync: [RawSyntax?] = []
-      var asyncKeyword: RawTokenSyntax? = asyncSpecifier?.raw.as(RawTokenSyntax.self)
-      var unexpectedAfterAsync: [RawSyntax?] = []
-
-      unexpectedBeforeAsync.append(contentsOf: unexpectedBeforeAsyncSpecifier?.elements ?? [])
-      unexpectedBeforeAsync.append(contentsOf: unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.elements ?? [])
-      if let throwsKeyword = throwsSpecifier, !throwsKeyword.isMissing {
-        unexpectedBeforeAsync.append(RawSyntax(throwsKeyword))
-      }
-      for elem in unexpectedAfterThrowsSpecifier?.elements ?? [] {
-        if let token = Syntax(raw: elem).as(TokenSyntax.self) {
-          if token.tokenKind == .keyword(.async) {
-            asyncKeyword = elem.as(RawTokenSyntax.self)
-          } else {
-            if asyncKeyword?.isMissing ?? true {
-              unexpectedBeforeAsync.append(elem)
-            } else {
-              unexpectedAfterAsync.append(elem)
-            }
-          }
-        }
-      }
-      self.init(
-        RawUnexpectedNodesSyntax(unexpectedBeforeAsync, arena: arena),
-        asyncSpecifier: asyncKeyword,
-        RawUnexpectedNodesSyntax(unexpectedAfterAsync, arena: arena),
-        arena: arena
-      )
-    } else {
-      let unexpectedAfterAsync: RawUnexpectedNodesSyntax?
-      if let throwsSpecifier = throwsSpecifier, throwsSpecifier.presence == .present {
-        var unexpected: [RawSyntax] = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier?.elements ?? []
-        unexpected.append(throwsSpecifier.raw)
-        unexpected.append(contentsOf: unexpectedAfterThrowsSpecifier?.elements ?? [])
-        unexpectedAfterAsync = RawUnexpectedNodesSyntax(unexpected, arena: arena)
-      } else {
-        if let afterThrows = unexpectedAfterThrowsSpecifier {
-          if let beforeThrows = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier {
-            unexpectedAfterAsync = RawUnexpectedNodesSyntax(beforeThrows.elements + afterThrows.elements, arena: arena)
-          } else {
-            unexpectedAfterAsync = afterThrows
-          }
-        } else {
-          unexpectedAfterAsync = unexpectedBetweenAsyncSpecifierAndThrowsSpecifier
-        }
-      }
-
-      self.init(
-        unexpectedBeforeAsyncSpecifier,
-        asyncSpecifier: asyncSpecifier,
-        unexpectedAfterAsync,
-        arena: arena
-      )
-    }
-  }
 }
 
 extension TokenConsumer {