Handle DeinitializerDeclSyntax errors in a single diagnostic

Author: kimdv

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -1981,7 +1981,7 @@ public let DECL_NODES: [Node] = [
   Node(
     kind: .returnClause,
     base: .syntax,
-    nameForDiagnostics: nil,
+    nameForDiagnostics: "return clause",
     children: [
       Child(
         name: "arrow",

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -788,40 +788,36 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     if shouldSkip(node) {
       return .skipChildren
     }
+
+    var nodes: [SyntaxProtocol] = []
+
     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]
-      )
+      nodes += [name]
     }
     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]
-      )
+      nodes += [params]
     }
     if let unexpected = node.unexpectedBetweenEffectSpecifiersAndBody,
       let returnType = unexpected.compactMap({ $0.as(ReturnClauseSyntax.self) }).only
     {
+      nodes += [returnType]
+    }
+
+    if !nodes.isEmpty {
       addDiagnostic(
-        returnType,
-        .deinitCannotHaveReturnType,
+        nodes[0],
+        DeinitializerSignatureError(nodes: nodes),
         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,18 @@ public struct CannotParseVersionTuple: ParserError {
   }
 }
 
+public struct DeinitializerSignatureError: ParserError {
+  public let nodes: [Syntax]
+
+  init(nodes: [any SyntaxProtocol]) {
+    self.nodes = nodes.map(Syntax.init)
+  }
+
+  public var message: String {
+    return "deinitializers cannot have \(nodesDescription(nodes, format: true))"
+  }
+}
+
 public struct DuplicateEffectSpecifiers: ParserError {
   public let correctSpecifier: TokenSyntax
   public let unexpectedSpecifier: TokenSyntax
@@ -706,7 +709,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)
   }
 

Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift

@@ -325,6 +325,8 @@ extension SyntaxKind {
       return "regex literal"
     case .repeatStmt:
       return "'repeat' statement"
+    case .returnClause:
+      return "return clause"
     case .returnStmt:
       return "'return' statement"
     case .sameTypeRequirement:

Tests/SwiftParserTest/DeclarationTests.swift

@@ -913,7 +913,7 @@ final class DeclarationTests: ParserTestCase {
       }
       """,
       diagnostics: [
-        DiagnosticSpec(message: "expected '->' and return type in subscript", fixIts: ["insert '->' and return type"])
+        DiagnosticSpec(message: "expected '->' and return type in return clause", fixIts: ["insert '->' and return type"])
       ],
       fixedSource: """
         struct Foo {
@@ -1474,7 +1474,7 @@ final class DeclarationTests: ParserTestCase {
       diagnostics: [
         DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected brace before subscript"),
         DiagnosticSpec(locationMarker: "2️⃣", message: "expected parameter clause in subscript", fixIts: ["insert parameter clause"]),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected '->' and return type in subscript", fixIts: ["insert '->' and return type"]),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "expected '->' and return type in return clause", fixIts: ["insert '->' and return type"]),
       ],
       fixedSource: """
         }subscript() -> <#type#>

Tests/SwiftParserTest/ExpressionTests.swift

@@ -1011,7 +1011,7 @@ final class ExpressionTests: ParserTestCase {
         DiagnosticSpec(locationMarker: "1️⃣", message: "expected pattern in variable", fixIts: ["insert pattern"]),
         DiagnosticSpec(locationMarker: "2️⃣", message: "expected type in function type", fixIts: ["insert type"]),
         DiagnosticSpec(locationMarker: "2️⃣", message: "unexpected code '..' in function type"),
-        DiagnosticSpec(locationMarker: "3️⃣", message: "expected return type in function type", fixIts: ["insert return type"]),
+        DiagnosticSpec(locationMarker: "3️⃣", message: "expected return type in return clause", fixIts: ["insert return type"]),
       ],
       fixedSource: """
         let <#pattern#>:(<#type#>..)-> <#type#>

Tests/SwiftParserTest/StatementTests.swift

@@ -689,7 +689,7 @@ final class StatementTests: ParserTestCase {
         ),
         DiagnosticSpec(
           locationMarker: "2️⃣",
-          message: "expected '->' and return type in subscript",
+          message: "expected '->' and return type in return clause",
           fixIts: ["insert '->' and return type"]
         ),
         DiagnosticSpec(

Tests/SwiftParserTest/TypeTests.swift

@@ -55,7 +55,7 @@ final class TypeTests: ParserTestCase {
       diagnostics: [
         DiagnosticSpec(locationMarker: "1️⃣", message: "expected type in function type", fixIts: ["insert type"]),
         DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code '..' in function type"),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected return type in function type", fixIts: ["insert return type"]),
+        DiagnosticSpec(locationMarker: "2️⃣", message: "expected return type in return clause", fixIts: ["insert return type"]),
       ],
       fixedSource: """
         t as(<#type#>..)-> <#type#>

Tests/SwiftParserTest/translated/AsyncTests.swift

@@ -149,7 +149,7 @@ final class AsyncTests: ParserTestCase {
       }
       """,
       diagnostics: [
-        DiagnosticSpec(locationMarker: "1️⃣", message: "unexpected code 'async' in subscript")
+        DiagnosticSpec(message: "unexpected code 'async' before return clause")
       ]
     )
   }