Extract header nodes from DeclGroups

This also involves changing Child.Refactoring to support a new kind of change: “extracted”, in which a group of adjacent children are moved into a new child node.

Future commits will introduce clients that use the new *DeclHeaderSyntax nodes directly.

Author: beccadax

CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift

@@ -28,6 +28,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case accessorEffectSpecifiers
   case accessorParameters
   case actorDecl
+  case actorDeclHeader
   case arrayElement
   case arrayElementList
   case arrayExpr
@@ -54,6 +55,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case catchItem
   case catchItemList
   case classDecl
+  case classDeclHeader
   case classRestrictionType
   case closureCapture
   case closureCaptureClause
@@ -121,13 +123,15 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case enumCaseParameterClause
   case enumCaseParameterList
   case enumDecl
+  case enumDeclHeader
   case exposeAttributeArguments
   case expr
   case expressionPattern
   case expressionSegment
   case expressionStmt
   case exprList
   case extensionDecl
+  case extensionDeclHeader
   case fallThroughStmt
   case floatLiteralExpr
   case forceUnwrapExpr
@@ -243,6 +247,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case primaryAssociatedTypeClause
   case primaryAssociatedTypeList
   case protocolDecl
+  case protocolDeclHeader
   case regexLiteralExpr
   case repeatStmt
   case returnClause
@@ -262,6 +267,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case stringLiteralSegmentList
   case stringSegment
   case structDecl
+  case structDeclHeader
   case subscriptCallExpr
   case subscriptDecl
   case superExpr

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -53,25 +53,18 @@ public let TRAITS: [Trait] = [
     traitName: "DeclGroup",
     baseKind: .decl,
     children: [
-      Child(name: "attributes", kind: .node(kind: .attributeList)),
-      Child(name: "modifiers", kind: .node(kind: .declModifierList)),
       Child(
-        name: "introducer",
-        kind: .token(choices: [
-          .keyword(.actor), .keyword(.class), .keyword(.enum), .keyword(.extension), .keyword(.protocol),
-          .keyword(.struct),
-        ]),
-        documentation: "The token that introduces this declaration, eg. `class` for a class declaration."
-      ),
-      Child(name: "inheritanceClause", kind: .node(kind: .inheritanceClause), isOptional: true),
-      Child(
-        name: "genericWhereClause",
-        kind: .node(kind: .genericWhereClause),
+        name: "header",
+        kind: .node(kind: .declGroupHeader),
         documentation:
-          "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.",
-        isOptional: true
+          "The header of the declaration."
       ),
       Child(name: "memberBlock", kind: .node(kind: .memberBlock)),
+    ],
+    childHistory: [
+      [
+        "header": .extracted
+      ]
     ]
   ),
   Trait(
@@ -116,6 +109,13 @@ public let TRAITS: [Trait] = [
       Child(name: "name", kind: .token(choices: [.token(.identifier)]))
     ]
   ),
+  Trait(
+    traitName: "NamedDeclHeader",
+    baseKind: .declGroupHeader,
+    children: [
+      Child(name: "name", kind: .token(choices: [.token(.identifier)]))
+    ]
+  ),
   Trait(
     traitName: "MissingNode",
     documentation: """

CodeGeneration/Sources/SyntaxSupport/Traits.swift

@@ -736,7 +736,7 @@ class ValidateSyntaxNodes: XCTestCase {
         ValidationFailure(node: .attributedType, message: "child 'baseType' should not end with 'Type'"),
         ValidationFailure(node: .conformanceRequirement, message: "child 'leftType' should not end with 'Type'"),
         ValidationFailure(node: .conformanceRequirement, message: "child 'rightType' should not end with 'Type'"),
-        ValidationFailure(node: .extensionDecl, message: "child 'extendedType' should not end with 'Type'"),
+        ValidationFailure(node: .extensionDeclHeader, message: "child 'extendedType' should not end with 'Type'"),
         ValidationFailure(node: .genericParameter, message: "child 'inheritedType' should not end with 'Type'"),
         ValidationFailure(
           node: .implicitlyUnwrappedOptionalType,

CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift

@@ -226,32 +226,21 @@ extension Parser {
     }
 
     switch recoveryResult {
+    case (.group(let introducer), let handle)?:
+      let (header, shouldContinueParsing) = parseHeaderForDeclarationGroup(
+        attrs: attrs,
+        introducer: introducer,
+        introducerHandle: handle
+      )
+      return parseDeclarationGroup(for: header, shouldParseMemberBlock: shouldContinueParsing)
     case (.simple(.import), let handle)?:
       return RawDeclSyntax(self.parseImportDeclaration(attrs, handle))
-    case (.group(.class), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawClassDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
-    case (.group(.enum), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawEnumDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
     case (.simple(.case), let handle)?:
       return RawDeclSyntax(self.parseEnumCaseDeclaration(attrs, handle))
-    case (.group(.struct), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawStructDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
-    case (.group(.protocol), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawProtocolDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
     case (.simple(.associatedtype), let handle)?:
       return RawDeclSyntax(self.parseAssociatedTypeDeclaration(attrs, handle))
     case (.simple(.typealias), let handle)?:
       return RawDeclSyntax(self.parseTypealiasDeclaration(attrs, handle))
-    case (.group(.extension), let handle)?:
-      return RawDeclSyntax(self.parseExtensionDeclaration(attrs, handle))
     case (.simple(.func), let handle)?:
       return RawDeclSyntax(self.parseFuncDeclaration(attrs, handle))
     case (.simple(.subscript), let handle)?:
@@ -264,10 +253,6 @@ extension Parser {
       return RawDeclSyntax(self.parseOperatorDeclaration(attrs, handle))
     case (.simple(.precedencegroup), let handle)?:
       return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs, handle))
-    case (.group(.actor), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawActorDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
     case (.simple(.macro), let handle)?:
       return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle))
     case (.simple(.pound), let handle)?:
@@ -418,7 +403,56 @@ extension Parser {
     introducer: DeclGroupHeaderSyntax.IntroducerOptions,
     introducerHandle: RecoveryConsumptionHandle
   ) -> (RawDeclGroupHeaderSyntax, shouldContinueParsing: Bool) {
-    fatalError("not yet implemented")
+    func eraseToRawDeclGroupHeaderSyntax(
+      _ result: (some RawDeclGroupHeaderSyntaxNodeProtocol, Bool)
+    ) -> (RawDeclGroupHeaderSyntax, shouldContinueParsing: Bool) {
+      return (RawDeclGroupHeaderSyntax(result.0), result.1)
+    }
+
+    switch introducer {
+    case .class:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawClassDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle
+        )
+      )
+    case .enum:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawEnumDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle
+        )
+      )
+    case .struct:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawStructDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle
+        )
+      )
+    case .protocol:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawProtocolDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle
+        )
+      )
+    case .extension:
+      return (RawDeclGroupHeaderSyntax(self.parseExtensionDeclarationHeader(attrs, introducerHandle)), true)
+    case .actor:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawActorDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle
+        )
+      )
+    }
   }
 
   /// Returns `true` if it looks like the parser is positioned at a function declaration that’s missing the `func` keyword.
@@ -483,12 +517,121 @@ extension Parser {
   }
 }
 
+protocol DeclarationGroupHeaderTrait {
+  var introducer: RawTokenSyntax { get }
+
+  associatedtype Declaration: RawDeclSyntaxNodeProtocol
+
+  func makeDeclaration(
+    memberBlock: RawMemberBlockSyntax,
+    arena: __shared SyntaxArena
+  ) -> Declaration
+}
+
+extension RawExtensionDeclHeaderSyntax: DeclarationGroupHeaderTrait {
+  var introducer: RawTokenSyntax {
+    return self.extensionKeyword
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawExtensionDeclSyntax {
+    RawExtensionDeclSyntax(extensionHeader: self, memberBlock: memberBlock, arena: arena)
+  }
+}
+
+extension RawMissingDeclHeaderSyntax: DeclarationGroupHeaderTrait {
+  var introducer: RawTokenSyntax {
+    return self.placeholder
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawMissingDeclSyntax {
+    RawMissingDeclSyntax(
+      self.unexpectedBeforeAttributes,
+      attributes: self.attributes,
+      self.unexpectedBetweenAttributesAndModifiers,
+      modifiers: self.modifiers,
+      self.unexpectedBetweenModifiersAndPlaceholder,
+      placeholder: self.placeholder,
+      RawUnexpectedNodesSyntax(
+        combining: [
+          self.unexpectedBetweenPlaceholderAndInheritanceClause,
+          RawUnexpectedNodesSyntax([self.inheritanceClause], arena: arena),
+          self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+          RawUnexpectedNodesSyntax([self.genericWhereClause], arena: arena),
+          self.unexpectedAfterGenericWhereClause,
+        ],
+        RawUnexpectedNodesSyntax([memberBlock], arena: arena)!,
+        arena: arena
+      ),
+      arena: arena
+    )
+  }
+}
+
+extension RawDeclGroupHeaderSyntax: DeclarationGroupHeaderTrait {
+  private typealias ConcreteExistentialSelf = RawSyntaxNodeProtocol & DeclarationGroupHeaderTrait
+  private var asConcreteExistentialSelf: any ConcreteExistentialSelf {
+    let subtypes: [any ConcreteExistentialSelf.Type] = [
+      RawExtensionDeclHeaderSyntax.self,
+      RawProtocolDeclHeaderSyntax.self,
+      RawClassDeclHeaderSyntax.self,
+      RawActorDeclHeaderSyntax.self,
+      RawStructDeclHeaderSyntax.self,
+      RawEnumDeclHeaderSyntax.self,
+      RawMissingDeclHeaderSyntax.self,
+    ]
+
+    for subtype in subtypes {
+      if let result = subtype.init(self) {
+        return result
+      }
+    }
+
+    fatalError("Node \(self) does not have a known subtype")
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawDeclSyntax {
+    return RawDeclSyntax(asConcreteExistentialSelf.makeDeclaration(memberBlock: memberBlock, arena: arena))
+  }
+
+  var introducer: RawTokenSyntax {
+    return asConcreteExistentialSelf.introducer
+  }
+}
+
 extension Parser {
+  /// Parse a declaration group (class, struct, enum, actor, protocol, extension) body given its header.
+  mutating func parseDeclarationGroup<T>(
+    for header: T,
+    shouldParseMemberBlock: Bool = true
+  ) -> T.Declaration where T: DeclarationGroupHeaderTrait {
+    let memberBlock =
+      if shouldParseMemberBlock {
+        self.parseMemberBlock(introducer: header.introducer)
+      } else {
+        RawMemberBlockSyntax(
+          leftBrace: missingToken(.leftBrace),
+          members: RawMemberBlockItemListSyntax(elements: [], arena: self.arena),
+          rightBrace: missingToken(.rightBrace),
+          arena: self.arena
+        )
+      }
+    return header.makeDeclaration(memberBlock: memberBlock, arena: self.arena)
+  }
+
   /// Parse an extension declaration.
   mutating func parseExtensionDeclaration(
     _ attrs: DeclAttributes,
     _ handle: RecoveryConsumptionHandle
   ) -> RawExtensionDeclSyntax {
+    let header = parseExtensionDeclarationHeader(attrs, handle)
+    return parseDeclarationGroup(for: header)
+  }
+
+  /// Parse the header of an extension declaration.
+  mutating func parseExtensionDeclarationHeader(
+    _ attrs: DeclAttributes,
+    _ handle: RecoveryConsumptionHandle
+  ) -> RawExtensionDeclHeaderSyntax {
     let (unexpectedBeforeExtensionKeyword, extensionKeyword) = self.eat(handle)
     let type = self.parseType()
 
@@ -505,16 +648,14 @@ extension Parser {
     } else {
       whereClause = nil
     }
-    let memberBlock = self.parseMemberBlock(introducer: extensionKeyword)
-    return RawExtensionDeclSyntax(
+    return RawExtensionDeclHeaderSyntax(
       attributes: attrs.attributes,
       modifiers: attrs.modifiers,
       unexpectedBeforeExtensionKeyword,
       extensionKeyword: extensionKeyword,
       extendedType: type,
       inheritanceClause: inheritance,
       genericWhereClause: whereClause,
-      memberBlock: memberBlock,
       arena: self.arena
     )
   }