Handle generic parameter on enum case

Sources/SwiftParser/Declarations.swift

@@ -808,6 +808,14 @@ extension Parser {
         let unexpectedPeriod = self.consume(if: .period)
         let (unexpectedBeforeName, name) = self.expectIdentifier(keywordRecovery: true)
 
+        let unexpectedGenericParameters: RawUnexpectedNodesSyntax?
+        if self.at(prefix: "<") {
+          let genericParameters = self.parseGenericParameters()
+          unexpectedGenericParameters = RawUnexpectedNodesSyntax([genericParameters], arena: self.arena)
+        } else {
+          unexpectedGenericParameters = nil
+        }
+
         let parameterClause: RawEnumCaseParameterClauseSyntax?
         if self.at(TokenSpec(.leftParen)) {
           parameterClause = self.parseParameterClause(RawEnumCaseParameterClauseSyntax.self) { parser in
@@ -836,6 +844,7 @@ extension Parser {
           RawEnumCaseElementSyntax(
             RawUnexpectedNodesSyntax(combining: unexpectedPeriod, unexpectedBeforeName, arena: self.arena),
             name: name,
+            unexpectedGenericParameters,
             parameterClause: parameterClause,
             rawValue: rawValue,
             trailingComma: keepGoing,

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1074,6 +1074,24 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: EnumCaseElementSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if let unexpectedBetweenNameAndParameterClause = node.unexpectedBetweenNameAndParameterClause,
+      let genericParameter = unexpectedBetweenNameAndParameterClause.compactMap({ $0.as(GenericParameterClauseSyntax.self) }).only
+    {
+      addDiagnostic(
+        genericParameter,
+        .genericParamCantBeUsedInEnumCaseDecl,
+        handledNodes: [unexpectedBetweenNameAndParameterClause.id]
+      )
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: IfConfigClauseSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -167,6 +167,9 @@ extension DiagnosticMessage where Self == StaticParserError {
   public static var forbiddenInterpolatedString: Self {
     return .init("argument cannot be an interpolated string literal")
   }
+  public static var genericParamCantBeUsedInEnumCaseDecl: Self {
+    return .init("generic signature cannot be declared in enum 'case'")
+  }
   public static var initializerInPattern: Self {
     .init("unexpected initializer in pattern; did you mean to use '='?")
   }

Tests/SwiftParserTest/DeclarationTests.swift

@@ -2946,4 +2946,117 @@ final class DeclarationTests: ParserTestCase {
       ]
     )
   }
+
+  // https://github.com/apple/swift-syntax/issues/2273
+  func testEnumCaseWithGenericParameter() {
+    assertParse(
+      """
+      enum Foo {
+        case foo1️⃣<T>(T)
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        )
+      ]
+    )
+
+    assertParse(
+      """
+      enum Foo {
+        case bar1️⃣<T>(param: T)
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        )
+      ]
+    )
+
+    assertParse(
+      """
+      enum Foo {
+        case baz1️⃣<T>
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        )
+      ]
+    )
+
+    assertParse(
+      """
+      enum Foo {
+        case one, two1️⃣<T>
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        )
+      ]
+    )
+
+    assertParse(
+      """
+      enum Foo {
+        case three1️⃣<T>, four
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        )
+      ]
+    )
+
+    assertParse(
+      """
+      enum Foo {
+        case five1️⃣<T>(param: T), six
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        )
+      ]
+    )
+
+    assertParse(
+      """
+      enum Foo {
+        case seven1️⃣<T>, eight2️⃣<U>
+      }
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "generic signature cannot be declared in enum 'case'"
+        ),
+      ]
+    )
+
+    assertParse(
+      """
+      enum Foo<T> {
+        case five(param: T), six
+      }
+      """
+    )
+  }
 }