Handle DeinitializerDeclSyntax errors in a single diagnostic

Author: kimdv

Sources/SwiftParserDiagnostics/MissingNodesError.swift

@@ -161,15 +161,20 @@ func nodesDescriptionAndCommonParent(_ nodes: [some SyntaxProtocol], format: Boo
   }
 
   let partDescriptions = NodesDescriptionPart.descriptionParts(for: missingSyntaxNodes).map({ $0.description(format: format) ?? "syntax" })
-  switch partDescriptions.count {
+
+  return (nil, formatDescriptions(partDescriptions))
+}
+
+func formatDescriptions(_ descriptions: [String]) -> String {
+  switch descriptions.count {
   case 0:
-    return (nil, "syntax")
+    return "syntax"
   case 1:
-    return (nil, "\(partDescriptions.first!)")
+    return descriptions.first!
   case 2:
-    return (nil, "\(partDescriptions.first!) and \(partDescriptions.last!)")
+    return "\(descriptions.first!) and \(descriptions.last!)"
   default:
-    return (nil, "\(partDescriptions[0..<partDescriptions.count - 1].joined(separator: ", ")), and \(partDescriptions.last!)")
+    return "\(descriptions[0..<descriptions.count - 1].joined(separator: ", ")), and \(descriptions.last!)"
   }
 }
 

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -788,40 +788,44 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     if shouldSkip(node) {
       return .skipChildren
     }
-    if let unexpected = node.unexpectedBetweenDeinitKeywordAndEffectSpecifiers,
-      let name = unexpected.presentTokens(satisfying: { $0.tokenKind.isIdentifier == true }).only
-    {
-      addDiagnostic(
-        name,
-        .deinitCannotHaveName,
-        fixIts: [
-          FixIt(message: RemoveNodesFixIt(name), changes: .makeMissing(name))
-        ],
-        handledNodes: [name.id]
-      )
+
+    var name: TokenSyntax? {
+      return node.unexpectedBetweenDeinitKeywordAndEffectSpecifiers?.presentTokens(satisfying: { $0.tokenKind.isIdentifier == true }).only
     }
-    if let unexpected = node.unexpectedBetweenDeinitKeywordAndEffectSpecifiers,
-      let params = unexpected.compactMap({ $0.as(FunctionParameterClauseSyntax.self) }).only
-    {
-      addDiagnostic(
-        params,
-        .deinitCannotHaveParameters,
-        fixIts: [
-          FixIt(message: RemoveNodesFixIt(params), changes: .makeMissing(params))
-        ],
-        handledNodes: [params.id]
-      )
+
+    var params: FunctionParameterClauseSyntax? {
+      return node.unexpectedBetweenDeinitKeywordAndEffectSpecifiers?.compactMap({ $0.as(FunctionParameterClauseSyntax.self) }).only
     }
-    if let unexpected = node.unexpectedBetweenEffectSpecifiersAndBody,
-      let returnType = unexpected.compactMap({ $0.as(ReturnClauseSyntax.self) }).only
-    {
+
+    var returnType: ReturnClauseSyntax? {
+      return node.unexpectedBetweenEffectSpecifiersAndBody?.compactMap({ $0.as(ReturnClauseSyntax.self) }).only
+    }
+
+    var nodes: [any SyntaxProtocol] = []
+
+    if let name {
+      nodes.append(name)
+    }
+
+    if let params {
+      nodes.append(params)
+    }
+
+    if let returnType {
+      nodes.append(returnType)
+    }
+
+    if !nodes.isEmpty {
       addDiagnostic(
-        returnType,
-        .deinitCannotHaveReturnType,
+        node,
+        DeinitializerSignatureError(name: name, params: params, returnClause: returnType),
         fixIts: [
-          FixIt(message: RemoveNodesFixIt(returnType), changes: .makeMissing(returnType))
+          FixIt(
+            message: RemoveNodesFixIt(nodes),
+            changes: nodes.map { .makeMissing($0) }
+          )
         ],
-        handledNodes: [returnType.id]
+        handledNodes: nodes.map { $0.id }
       )
     }
 

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -120,18 +120,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var defaultOutsideOfSwitch: Self {
     .init("'default' label can only appear inside a 'switch' statement")
   }
-  public static var deinitCannotHaveName: Self {
-    .init("deinitializers cannot have a name")
-  }
-  public static var deinitCannotHaveParameters: Self {
-    .init("deinitializers cannot have parameters")
-  }
   public static var deinitCannotThrow: Self {
     .init("deinitializers cannot throw")
   }
-  public static var deinitCannotHaveReturnType: Self {
-    .init("deinitializers cannot have return type")
-  }
   public static var editorPlaceholderInSourceFile: Self {
     .init("editor placeholder in source file")
   }
@@ -305,6 +296,30 @@ public struct CannotParseVersionTuple: ParserError {
   }
 }
 
+public struct DeinitializerSignatureError: ParserError {
+  public let name: TokenSyntax?
+  public let params: FunctionParameterClauseSyntax?
+  public let returnClause: ReturnClauseSyntax?
+
+  public var message: String {
+    var descriptions: [String] = []
+
+    if name != nil {
+      descriptions += ["name"]
+    }
+
+    if params != nil {
+      descriptions += ["parameters"]
+    }
+
+    if returnClause != nil {
+      descriptions += ["return clause"]
+    }
+
+    return "deinitializers cannot have \(formatDescriptions(descriptions))"
+  }
+}
+
 public struct DuplicateEffectSpecifiers: ParserError {
   public let correctSpecifier: TokenSyntax
   public let unexpectedSpecifier: TokenSyntax
@@ -706,7 +721,7 @@ public struct RemoveRedundantFixIt: ParserFixIt {
 public struct RemoveNodesFixIt: ParserFixIt {
   public let nodesToRemove: [Syntax]
 
-  init(_ nodesToRemove: [some SyntaxProtocol]) {
+  init(_ nodesToRemove: [any SyntaxProtocol]) {
     self.nodesToRemove = nodesToRemove.map(Syntax.init)
   }