diff --git a/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift b/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift
index 28e4baf5045..b5a2a4e9f3c 100644
--- a/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift
@@ -139,6 +139,11 @@ public let ATTRIBUTE_NODES: [Node] = [
             name: "documentationArguments",
             kind: .node(kind: .documentationAttributeArgumentList)
           ),
+          Child(
+            name: "abiArguments",
+            kind: .node(kind: .abiAttributeArguments),
+            experimentalFeature: .abiAttribute
+          ),
         ]),
         documentation: """
           The arguments of the attribute.
@@ -267,6 +272,31 @@ public let ATTRIBUTE_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .abiAttributeArguments,
+    base: .syntax,
+    experimentalFeature: .abiAttribute,
+    nameForDiagnostics: "ABI-providing declaration",
+    documentation: "The arguments of the '@abi' attribute",
+    children: [
+      Child(
+        name: "provider",
+        kind: ChildKind.nodeChoices(choices: [
+          Child(name: "associatedType", kind: .node(kind: .associatedTypeDecl)),
+          Child(name: "declGroup", kind: .node(kind: .declGroupHeader)),
+          Child(name: "deinitializer", kind: .node(kind: .deinitializerDecl)),
+          Child(name: "enumCase", kind: .node(kind: .enumCaseDecl)),
+          Child(name: "function", kind: .node(kind: .functionDecl)),
+          Child(name: "initializer", kind: .node(kind: .initializerDecl)),
+          Child(name: "subscript", kind: .node(kind: .subscriptDecl)),
+          Child(name: "typeAlias", kind: .node(kind: .typeAliasDecl)),
+          Child(name: "variable", kind: .node(kind: .variableDecl)),
+          Child(name: "unsupported", kind: .node(kind: .decl)),
+        ])
+      )
+    ]
+  ),
+
   Node(
     kind: .conventionAttributeArguments,
     base: .syntax,
diff --git a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift
index 7247e17a909..b96cebedb4b 100644
--- a/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/CommonNodes.swift
@@ -180,6 +180,46 @@ public let COMMON_NODES: [Node] = [
     parserFunction: "parseDeclaration"
   ),
 
+  Node(
+    kind: .declGroupHeader,
+    base: .syntax,
+    nameForDiagnostics: "declaration group header",
+    parserFunction: "parseDeclarationGroupHeader",
+    traits: [
+      "WithAttributes",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "attributes",
+        kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true),
+        nameForDiagnostics: "attributes"
+      ),
+      Child(
+        name: "modifiers",
+        kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true),
+        nameForDiagnostics: "modifiers",
+        documentation: "Modifiers like `public` that are attached to the actor declaration."
+      ),
+      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),
+        documentation:
+          "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.",
+        isOptional: true
+      ),
+    ]
+  ),
+
   Node(
     kind: .expr,
     base: .syntax,
@@ -187,6 +227,51 @@ public let COMMON_NODES: [Node] = [
     parserFunction: "parseExpression"
   ),
 
+  Node(
+    kind: .missingDeclHeader,
+    base: .declGroupHeader,
+    nameForDiagnostics: "declaration group header",
+    documentation:
+      "In case the source code is missing a declaration group header, this node stands in place of the missing header.",
+    traits: [
+      "MissingNode",
+      "WithAttributes",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "attributes",
+        kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true),
+        documentation:
+          "If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these."
+      ),
+      Child(
+        name: "modifiers",
+        kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true),
+        documentation:
+          "If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these."
+      ),
+      Child(
+        name: "placeholder",
+        kind: .token(choices: [.token(.identifier)], requiresLeadingSpace: false, requiresTrailingSpace: false),
+        documentation: """
+          A placeholder, i.e. `<#decl#>`, that can be inserted into the source code to represent the missing declaration.
+
+          This token should always have `presence = .missing`.
+          """
+      ),
+      Child(name: "inheritanceClause", kind: .node(kind: .inheritanceClause), isOptional: true),
+      Child(
+        name: "genericWhereClause",
+        kind: .node(kind: .genericWhereClause),
+        documentation:
+          "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.",
+        isOptional: true
+      ),
+
+    ]
+  ),
+
   Node(
     kind: .missingDecl,
     base: .decl,
diff --git a/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift b/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift
index f95f3143669..a391f6ba2d3 100644
--- a/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift
@@ -94,7 +94,7 @@ public struct CompatibilityLayer {
       typeName: layoutNode.kind.rawValue,
       initialChildren: layoutNode.children,
       history: layoutNode.childHistory,
-      areRequirements: false
+      areRequirements: layoutNode.kind.isBase
     )
 
     deprecatedMembersByNode[node.syntaxNodeKind] = result
@@ -180,6 +180,8 @@ public struct CompatibilityLayer {
       vars += children.filter { knownVars.insert($0).inserted }
 
       // We don't create compatibility layers for protocol requirement inits.
+      // In theory, we *could* create compatibility layers for traits with `requiresInit: true`, but the only one we'd
+      // create so far is unnecessary and tricky to implement.
       if !areRequirements {
         initSignatures.append(InitSignature(children: children))
       }
diff --git a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift
index 0dea2d63426..46c58ca3b4c 100644
--- a/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/DeclNodes.swift
@@ -179,12 +179,11 @@ public let DECL_NODES: [Node] = [
   ),
 
   Node(
-    kind: .actorDecl,
-    base: .decl,
+    kind: .actorDeclHeader,
+    base: .declGroupHeader,
     nameForDiagnostics: "actor",
     traits: [
-      "DeclGroup",
-      "NamedDecl",
+      "NamedDeclHeader",
       "WithAttributes",
       "WithGenericParameters",
       "WithModifiers",
@@ -232,15 +231,38 @@ public let DECL_NODES: [Node] = [
           "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.",
         isOptional: true
       ),
+    ]
+  ),
+
+  Node(
+    kind: .actorDecl,
+    base: .decl,
+    nameForDiagnostics: "actor",
+    traits: [
+      "DeclGroup",
+      "NamedDecl",
+      "WithAttributes",
+      "WithGenericParameters",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "actorHeader",
+        kind: .node(kind: .actorDeclHeader),
+        documentation: "The header of the actor declaration."
+      ),
       Child(
         name: "memberBlock",
         kind: .node(kind: .memberBlock)
       ),
     ],
     childHistory: [
+      [
+        "actorHeader": .extracted
+      ],
       [
         "name": .renamed(from: "identifier")
-      ]
+      ],
     ]
   ),
 
@@ -333,37 +355,20 @@ public let DECL_NODES: [Node] = [
   ),
 
   Node(
-    kind: .classDecl,
-    base: .decl,
+    kind: .classDeclHeader,
+    base: .declGroupHeader,
     nameForDiagnostics: "class",
     documentation: """
-      A `class` declaration
+      A `class` declaration header
 
-      An example of a class declaration is
+      An example of a class declaration header is
 
       ```swift
-      class SomeClass {
-        let someMember: String
-
-        init(someMember: String) {
-          self.someMember = someMember
-        }
-
-        func foo() {
-          print(someMember)
-        }
-
-        static func bar() -> Int {
-          return 1
-        }
-      }
+      class SomeClass
       ```
-
-      A class declaration may be declared without any members.
       """,
     traits: [
-      "DeclGroup",
-      "NamedDecl",
+      "NamedDeclHeader",
       "WithAttributes",
       "WithGenericParameters",
       "WithModifiers",
@@ -412,6 +417,51 @@ public let DECL_NODES: [Node] = [
         documentation: "The `where` clause that applies to the generic parameters of this class declaration.",
         isOptional: true
       ),
+    ]
+  ),
+
+  Node(
+    kind: .classDecl,
+    base: .decl,
+    nameForDiagnostics: "class",
+    documentation: """
+      A `class` declaration
+
+      An example of a class declaration is
+
+      ```swift
+      class SomeClass {
+        let someMember: String
+
+        init(someMember: String) {
+          self.someMember = someMember
+        }
+
+        func foo() {
+          print(someMember)
+        }
+
+        static func bar() -> Int {
+          return 1
+        }
+      }
+      ```
+
+      A class declaration may be declared without any members.
+      """,
+    traits: [
+      "DeclGroup",
+      "NamedDecl",
+      "WithAttributes",
+      "WithGenericParameters",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "classHeader",
+        kind: .node(kind: .classDeclHeader),
+        documentation: "The header of the class declaration."
+      ),
       Child(
         name: "memberBlock",
         kind: .node(kind: .memberBlock),
@@ -420,9 +470,12 @@ public let DECL_NODES: [Node] = [
       ),
     ],
     childHistory: [
+      [
+        "classHeader": .extracted
+      ],
       [
         "name": .renamed(from: "identifier")
-      ]
+      ],
     ]
   ),
 
@@ -801,13 +854,12 @@ public let DECL_NODES: [Node] = [
   ),
 
   Node(
-    kind: .enumDecl,
-    base: .decl,
+    kind: .enumDeclHeader,
+    base: .declGroupHeader,
     nameForDiagnostics: "enum",
-    documentation: "A Swift `enum` declaration.",
+    documentation: "A Swift `enum` declaration header.",
     traits: [
-      "DeclGroup",
-      "NamedDecl",
+      "NamedDeclHeader",
       "WithAttributes",
       "WithGenericParameters",
       "WithModifiers",
@@ -857,6 +909,27 @@ public let DECL_NODES: [Node] = [
         documentation: "The `where` clause that applies to the generic parameters of this enum declaration.",
         isOptional: true
       ),
+    ]
+  ),
+
+  Node(
+    kind: .enumDecl,
+    base: .decl,
+    nameForDiagnostics: "enum",
+    documentation: "A Swift `enum` declaration.",
+    traits: [
+      "DeclGroup",
+      "NamedDecl",
+      "WithAttributes",
+      "WithGenericParameters",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "enumHeader",
+        kind: .node(kind: .enumDeclHeader),
+        documentation: "The header of the enum declaration."
+      ),
       Child(
         name: "memberBlock",
         kind: .node(kind: .memberBlock),
@@ -865,32 +938,30 @@ public let DECL_NODES: [Node] = [
       ),
     ],
     childHistory: [
+      [
+        "enumHeader": .extracted
+      ],
       [
         "name": .renamed(from: "identifier"),
         "genericParameterClause": .renamed(from: "genericParameters"),
-      ]
+      ],
     ]
   ),
 
   Node(
-    kind: .extensionDecl,
-    base: .decl,
+    kind: .extensionDeclHeader,
+    base: .declGroupHeader,
     nameForDiagnostics: "extension",
     documentation: """
-        An `extension` declaration.
+        An `extension` declaration header.
 
        ### Example
 
         ```swift
-        extension String {
-          var url: URL? {
-            URL(string: self)
-          }
-        }
+        extension String
         ```
       """,
     traits: [
-      "DeclGroup",
       "WithAttributes",
       "WithModifiers",
     ],
@@ -942,12 +1013,48 @@ public let DECL_NODES: [Node] = [
           "A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.",
         isOptional: true
       ),
+    ]
+  ),
+
+  Node(
+    kind: .extensionDecl,
+    base: .decl,
+    nameForDiagnostics: "extension",
+    documentation: """
+        An `extension` declaration.
+
+       ### Example
+
+        ```swift
+        extension String {
+          var url: URL? {
+            URL(string: self)
+          }
+        }
+        ```
+      """,
+    traits: [
+      "DeclGroup",
+      "WithAttributes",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "extensionHeader",
+        kind: .node(kind: .extensionDeclHeader),
+        documentation: "The header of the extension declaration."
+      ),
       Child(
         name: "memberBlock",
         kind: .node(kind: .memberBlock),
         documentation:
           "The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type."
       ),
+    ],
+    childHistory: [
+      [
+        "extensionHeader": .extracted
+      ]
     ]
   ),
 
@@ -2047,23 +2154,20 @@ public let DECL_NODES: [Node] = [
   ),
 
   Node(
-    kind: .protocolDecl,
-    base: .decl,
+    kind: .protocolDeclHeader,
+    base: .declGroupHeader,
     nameForDiagnostics: "protocol",
     documentation: """
-      A `protocol` declaration
+      A `protocol` declaration header
 
-      An example of a protocol declaration is
+      An example of a protocol declaration header is
 
       ```swift
-      protocol Example {
-        var isValid: Bool { get }
-      }
+      protocol Example
       ```
       """,
     traits: [
-      "DeclGroup",
-      "NamedDecl",
+      "NamedDeclHeader",
       "WithAttributes",
       "WithModifiers",
     ],
@@ -2111,6 +2215,36 @@ public let DECL_NODES: [Node] = [
         documentation: "The `where` clause that applies to the generic parameters of this protocol declaration.",
         isOptional: true
       ),
+    ]
+  ),
+
+  Node(
+    kind: .protocolDecl,
+    base: .decl,
+    nameForDiagnostics: "protocol",
+    documentation: """
+      A `protocol` declaration
+
+      An example of a protocol declaration is
+
+      ```swift
+      protocol Example {
+        var isValid: Bool { get }
+      }
+      ```
+      """,
+    traits: [
+      "DeclGroup",
+      "NamedDecl",
+      "WithAttributes",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "protocolHeader",
+        kind: .node(kind: .protocolDeclHeader),
+        documentation: "The header of the protocol."
+      ),
       Child(
         name: "memberBlock",
         kind: .node(kind: .memberBlock),
@@ -2118,9 +2252,12 @@ public let DECL_NODES: [Node] = [
       ),
     ],
     childHistory: [
+      [
+        "protocolHeader": .extracted
+      ],
       [
         "name": .renamed(from: "identifier")
-      ]
+      ],
     ]
   ),
 
@@ -2177,6 +2314,89 @@ public let DECL_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .structDeclHeader,
+    base: .declGroupHeader,
+    nameForDiagnostics: "struct",
+    documentation: """
+      A `struct` declaration header
+
+      An example of a struct declaration header is
+
+      ```swift
+      struct SomeStruct
+      ```
+
+      A struct declaration may include a type inheritance clause listing
+      one or more protocols the struct conforms to. The example below uses
+      Hashable and Equatable protocols.
+
+      ```swift
+      struct AdvancedStruct: Hashable, Equatable
+      ```
+
+      A struct declaration may include a generic parameter clause as well
+      as a generic where clause.
+
+      ```swift
+      struct Stack<Element>
+      ```
+      """,
+    traits: [
+      "NamedDeclHeader",
+      "WithAttributes",
+      "WithGenericParameters",
+      "WithModifiers",
+    ],
+    children: [
+      Child(
+        name: "attributes",
+        kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true),
+        nameForDiagnostics: "attributes",
+        documentation: "Attributes that are attached to the struct declaration."
+      ),
+      Child(
+        name: "modifiers",
+        kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true),
+        nameForDiagnostics: "modifiers",
+        documentation: "Modifiers like `public` that are attached to the struct declaration."
+      ),
+      Child(
+        name: "structKeyword",
+        kind: .token(choices: [.keyword(.struct)]),
+        documentation: "The `struct` keyword for this declaration."
+      ),
+      Child(
+        name: "name",
+        kind: .token(choices: [.token(.identifier)]),
+        documentation:
+          "Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it."
+      ),
+      Child(
+        name: "genericParameterClause",
+        kind: .node(kind: .genericParameterClause),
+        nameForDiagnostics: "generic parameter clause",
+        documentation: "The generic parameters, if any, of the struct declaration.",
+        isOptional: true
+      ),
+      Child(
+        name: "inheritanceClause",
+        kind: .node(kind: .inheritanceClause),
+        nameForDiagnostics: "inheritance clause",
+        documentation:
+          "The struct declaration inheritance clause describing one or more conformances for this struct declaration.",
+        isOptional: true
+      ),
+      Child(
+        name: "genericWhereClause",
+        kind: .node(kind: .genericWhereClause),
+        nameForDiagnostics: "generic where clause",
+        documentation: "The `where` clause that applies to the generic parameters of this struct declaration.",
+        isOptional: true
+      ),
+    ]
+  ),
+
   Node(
     kind: .structDecl,
     base: .decl,
@@ -2249,61 +2469,24 @@ public let DECL_NODES: [Node] = [
     ],
     children: [
       Child(
-        name: "attributes",
-        kind: .collection(kind: .attributeList, collectionElementName: "Attribute", defaultsToEmpty: true),
-        nameForDiagnostics: "attributes",
-        documentation: "Attributes that are attached to the struct declaration."
-      ),
-      Child(
-        name: "modifiers",
-        kind: .collection(kind: .declModifierList, collectionElementName: "Modifier", defaultsToEmpty: true),
-        nameForDiagnostics: "modifiers",
-        documentation: "Modifiers like `public` that are attached to the struct declaration."
-      ),
-      Child(
-        name: "structKeyword",
-        kind: .token(choices: [.keyword(.struct)]),
-        documentation: "The `struct` keyword for this declaration."
-      ),
-      Child(
-        name: "name",
-        kind: .token(choices: [.token(.identifier)]),
+        name: "structHeader",
+        kind: .node(kind: .structDeclHeader),
         documentation:
           "Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it."
       ),
-      Child(
-        name: "genericParameterClause",
-        kind: .node(kind: .genericParameterClause),
-        nameForDiagnostics: "generic parameter clause",
-        documentation: "The generic parameters, if any, of the struct declaration.",
-        isOptional: true
-      ),
-      Child(
-        name: "inheritanceClause",
-        kind: .node(kind: .inheritanceClause),
-        nameForDiagnostics: "inheritance clause",
-        documentation:
-          "The struct declaration inheritance clause describing one or more conformances for this struct declaration.",
-        isOptional: true
-      ),
-      Child(
-        name: "genericWhereClause",
-        kind: .node(kind: .genericWhereClause),
-        nameForDiagnostics: "generic where clause",
-        documentation: "The `where` clause that applies to the generic parameters of this struct declaration.",
-        isOptional: true
-      ),
       Child(
         name: "memberBlock",
         kind: .node(kind: .memberBlock),
-        documentation:
-          "The members of the struct declaration. Because struct extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type."
+        documentation: "The header of the struct declaration."
       ),
     ],
     childHistory: [
+      [
+        "structHeader": .extracted
+      ],
       [
         "name": .renamed(from: "identifier")
-      ]
+      ],
     ]
   ),
 
diff --git a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift
index 35fadbc0f2f..43d4fd0691f 100644
--- a/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift
@@ -19,6 +19,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case nonescapableTypes
   case trailingComma
   case coroutineAccessors
+  case abiAttribute
 
   /// The name of the feature, which is used in the doc comment.
   public var featureName: String {
@@ -35,6 +36,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "trailing comma"
     case .coroutineAccessors:
       return "CoroutineAccessors"
+    case .abiAttribute:
+      return "@abi attribute"
     }
   }
 
diff --git a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift
index b1f35ef6433..00085156307 100644
--- a/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift
@@ -131,6 +131,7 @@ public enum Keyword: CaseIterable {
   case _underlyingVersion
   case _UnknownLayout
   case _version
+  case abi
   case accesses
   case actor
   case addressWithNativeOwner
@@ -404,6 +405,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("_UnknownLayout")
     case ._version:
       return KeywordSpec("_version")
+    case .abi:
+      return KeywordSpec("abi", experimentalFeature: .abiAttribute)
     case .accesses:
       return KeywordSpec("accesses")
     case .actor:
diff --git a/CodeGeneration/Sources/SyntaxSupport/Node.swift b/CodeGeneration/Sources/SyntaxSupport/Node.swift
index 5c7aba135fa..6f8f313a40e 100644
--- a/CodeGeneration/Sources/SyntaxSupport/Node.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/Node.swift
@@ -69,11 +69,7 @@ public class Node: NodeChoiceConvertible {
   public var layoutNode: LayoutNode? {
     switch data {
     case .layout:
-      if kind.isBase {
-        return nil
-      } else {
-        return LayoutNode(node: self)
-      }
+      return LayoutNode(node: self)
     default:
       return nil
     }
diff --git a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift
index aca5c52aa86..f0a40af29a9 100644
--- a/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift
@@ -22,12 +22,14 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
 
   case _canImportExpr
   case _canImportVersionInfo
+  case abiAttributeArguments
   case accessorBlock
   case accessorDecl
   case accessorDeclList
   case accessorEffectSpecifiers
   case accessorParameters
   case actorDecl
+  case actorDeclHeader
   case arrayElement
   case arrayElementList
   case arrayExpr
@@ -54,6 +56,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case catchItem
   case catchItemList
   case classDecl
+  case classDeclHeader
   case classRestrictionType
   case closureCapture
   case closureCaptureClause
@@ -81,6 +84,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case conventionWitnessMethodAttributeArguments
   case copyExpr
   case decl
+  case declGroupHeader
   case declModifier
   case declModifierDetail
   case declModifierList
@@ -120,6 +124,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case enumCaseParameterClause
   case enumCaseParameterList
   case enumDecl
+  case enumDeclHeader
   case exposeAttributeArguments
   case expr
   case expressionPattern
@@ -127,6 +132,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case expressionStmt
   case exprList
   case extensionDecl
+  case extensionDeclHeader
   case fallThroughStmt
   case floatLiteralExpr
   case forceUnwrapExpr
@@ -197,6 +203,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case metatypeType
   case missing
   case missingDecl
+  case missingDeclHeader
   case missingExpr
   case missingPattern
   case missingStmt
@@ -241,6 +248,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case primaryAssociatedTypeClause
   case primaryAssociatedTypeList
   case protocolDecl
+  case protocolDeclHeader
   case regexLiteralExpr
   case repeatStmt
   case returnClause
@@ -260,6 +268,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   case stringLiteralSegmentList
   case stringSegment
   case structDecl
+  case structDeclHeader
   case subscriptCallExpr
   case subscriptDecl
   case superExpr
@@ -320,7 +329,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
   /// `true` if this is one of the `missing*` cases.
   public var isMissing: Bool {
     switch self {
-    case .missingDecl, .missingExpr, .missingPattern, .missingStmt, .missing, .missingType:
+    case .missingDecl, .missingDeclHeader, .missingExpr, .missingPattern, .missingStmt, .missing, .missingType:
       return true
     default:
       return false
@@ -329,7 +338,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
 
   public var isBase: Bool {
     switch self {
-    case .decl, .expr, .pattern, .stmt, .syntax, .syntaxCollection, .type:
+    case .decl, .declGroupHeader, .expr, .pattern, .stmt, .syntax, .syntaxCollection, .type:
       return true
     default:
       return false
@@ -340,6 +349,15 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
     return .identifier(rawValue)
   }
 
+  public var uppercasedFirstWordRawValue: String {
+    switch self {
+    case .abiAttributeArguments:
+      "ABIAttributeArguments"
+    default:
+      rawValue.withFirstCharacterUppercased
+    }
+  }
+
   public var syntaxType: TypeSyntax {
     switch self {
     case .syntax:
@@ -347,7 +365,16 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
     case .syntaxCollection:
       return "SyntaxCollection"
     default:
-      return "\(raw: rawValue.withFirstCharacterUppercased)Syntax"
+      return "\(raw: uppercasedFirstWordRawValue)Syntax"
+    }
+  }
+
+  public var baseTypeSuffix: String? {
+    switch self {
+    case .declGroupHeader:
+      return "DeclHeaderSyntax"
+    default:
+      return isBase ? syntaxType.description : nil
     }
   }
 
diff --git a/CodeGeneration/Sources/SyntaxSupport/Traits.swift b/CodeGeneration/Sources/SyntaxSupport/Traits.swift
index c9eb2828931..dc6d6b76b99 100644
--- a/CodeGeneration/Sources/SyntaxSupport/Traits.swift
+++ b/CodeGeneration/Sources/SyntaxSupport/Traits.swift
@@ -21,6 +21,7 @@ public class Trait {
   public let baseKind: SyntaxNodeKind?
   public let protocolName: TokenSyntax
   public let documentation: SwiftSyntax.Trivia
+  public let requiresInit: Bool
   public let children: [Child]
   public let childHistory: Child.History
 
@@ -28,6 +29,7 @@ public class Trait {
     traitName: String,
     baseKind: SyntaxNodeKind? = nil,
     documentation: String? = nil,
+    requiresInit: Bool = false,
     children: [Child],
     childHistory: Child.History = []
   ) {
@@ -36,6 +38,7 @@ public class Trait {
     self.baseKind = baseKind
     self.protocolName = .identifier("\(traitName)Syntax")
     self.documentation = SwiftSyntax.Trivia.docCommentTrivia(from: documentation)
+    self.requiresInit = requiresInit
     self.children = children
     self.childHistory = childHistory
   }
@@ -52,26 +55,20 @@ public let TRAITS: [Trait] = [
   Trait(
     traitName: "DeclGroup",
     baseKind: .decl,
+    requiresInit: true,
     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(
@@ -111,6 +108,14 @@ public let TRAITS: [Trait] = [
   ),
   Trait(
     traitName: "NamedDecl",
+    baseKind: .decl,
+    children: [
+      Child(name: "name", kind: .token(choices: [.token(.identifier)]))
+    ]
+  ),
+  Trait(
+    traitName: "NamedDeclHeader",
+    baseKind: .declGroupHeader,
     children: [
       Child(name: "name", kind: .token(choices: [.token(.identifier)]))
     ]
diff --git a/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift b/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift
index 954114c87bc..a9b68bf05ce 100644
--- a/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift
+++ b/CodeGeneration/Sources/Utils/SyntaxBuildableType.swift
@@ -151,7 +151,7 @@ public struct SyntaxBuildableType: Hashable {
   public var resultBuilderType: TypeSyntax {
     switch kind {
     case .node(kind: let kind):
-      return TypeSyntax("\(raw: kind.rawValue.withFirstCharacterUppercased)Builder")
+      return TypeSyntax("\(raw: kind.uppercasedFirstWordRawValue)Builder")
     case .token:
       preconditionFailure("Tokens cannot be constructed using result builders")
     }
diff --git a/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift b/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift
index 97a61847829..d02ee5cb858 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/InitSignature+Extensions.swift
@@ -28,9 +28,11 @@ extension InitSignature {
     return "init(leadingTrivia:\(renamedArguments)trailingTrivia:)"
   }
 
-  func generateInitializerDeclHeader() -> SyntaxNodeString {
+  func generateInitializerDeclHeader(isRequirement: Bool = false) -> SyntaxNodeString {
+    let stub = isRequirement ? "init?" : "public init"
+
     if children.isEmpty {
-      return "public init()"
+      return "\(raw: stub)()"
     }
 
     func createFunctionParameterSyntax(for child: Child) -> FunctionParameterSyntax {
@@ -63,19 +65,25 @@ extension InitSignature {
       )
     }
 
+    func transformParam(_ param: FunctionParameterSyntax) -> FunctionParameterSyntax {
+      isRequirement ? param.with(\.defaultValue, nil) : param
+    }
+
     let params = FunctionParameterListSyntax {
-      FunctionParameterSyntax("leadingTrivia: Trivia? = nil")
+      transformParam(FunctionParameterSyntax("leadingTrivia: Trivia? = nil"))
 
       for child in children {
-        createFunctionParameterSyntax(for: child)
+        transformParam(createFunctionParameterSyntax(for: child))
       }
 
-      FunctionParameterSyntax("trailingTrivia: Trivia? = nil")
-        .with(\.leadingTrivia, .newline)
+      transformParam(
+        FunctionParameterSyntax("trailingTrivia: Trivia? = nil")
+          .with(\.leadingTrivia, .newline)
+      )
     }
 
     return """
-      public init(
+      \(raw: stub)(
       \(params)
       )
       """
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift
index cdc29c9cad5..c376a8b1012 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/RawSyntaxNodesFile.swift
@@ -142,7 +142,7 @@ func rawSyntaxNodesFile(nodesStartingWith: [Character]) -> SourceFileSyntax {
           )
         }
 
-        if let node = node.layoutNode {
+        if !node.kind.isBase, let node = node.layoutNode {
           let params = FunctionParameterListSyntax {
             for child in node.children {
               FunctionParameterSyntax(
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift
index e308b4364e6..77cb3611dc5 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxBaseNodesFile.swift
@@ -21,7 +21,7 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       node.documentation,
       node.subtypes,
     ])
-    DeclSyntax(
+    try! ProtocolDeclSyntax(
       """
       // MARK: - \(node.kind.syntaxType)
 
@@ -31,9 +31,26 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
       ///
       ///  - Warning: Do not conform to this protocol yourself.
       \(node.apiAttributes())\
-      public protocol \(node.kind.protocolType): \(node.base.protocolType) {}
+      public protocol \(node.kind.protocolType): \(node.base.protocolType)
       """
-    )
+    ) {
+      for child in node.layoutNode?.children ?? [] {
+        // ==================================
+        // Children properties (requirements)
+        // ==================================
+
+        let childType: TypeSyntax =
+          child.kind.isNodeChoicesEmpty ? child.syntaxNodeKind.syntaxType : child.syntaxChoicesType
+        let type = child.isOptional ? TypeSyntax("\(childType)?") : TypeSyntax("\(childType)")
+
+        DeclSyntax(
+          """
+          \(child.documentation)\
+          \(child.apiAttributes) var \(child.varDeclName): \(type) { get set }
+          """
+        )
+      }
+    }
 
     DeclSyntax(
       #"""
@@ -285,6 +302,41 @@ let syntaxBaseNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
         StmtSyntax("return .choices(\(choices))")
       }
+
+      for child in node.layoutNode?.children ?? [] {
+        // =================================================
+        // Children properties (type-erased implementations)
+        // =================================================
+
+        let childType: TypeSyntax =
+          child.kind.isNodeChoicesEmpty ? child.syntaxNodeKind.syntaxType : child.syntaxChoicesType
+        let type = child.isOptional ? TypeSyntax("\(childType)?") : TypeSyntax("\(childType)")
+
+        try! VariableDeclSyntax(
+          """
+          \(child.documentation)\
+          \(child.apiAttributes)public var \(child.varDeclName): \(type)
+          """
+        ) {
+          AccessorDeclSyntax(
+            """
+            get {
+              return self.asProtocol(\(node.kind.protocolType).self).\(child.baseCallName)
+            }
+            """
+          )
+
+          AccessorDeclSyntax(
+            """
+            set(value) {
+              var existentialCopy = self.asProtocol(\(node.kind.protocolType).self)
+              existentialCopy.\(child.baseCallName) = value
+              self = \(node.kind.syntaxType)(fromProtocol: existentialCopy)
+            }
+            """
+          )
+        }
+      }
     }
 
     leafProtocolDecl(type: node.kind.leafProtocolType, inheritedType: node.kind.protocolType)
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift
index b1758f26295..5afd357d4dc 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift
@@ -60,7 +60,7 @@ let syntaxEnumFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
   for base in SYNTAX_NODES where base.kind.isBase {
     let baseKind = base.kind
-    let baseName = baseKind.rawValue.withFirstCharacterUppercased
+    let baseName = baseKind.uppercasedFirstWordRawValue
     let enumType: TypeSyntax = "\(raw: baseName)SyntaxEnum"
 
     try! EnumDeclSyntax(
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift
index 214ca0ce2c6..476b86ea16e 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxNodesFile.swift
@@ -21,7 +21,7 @@ import Utils
 /// It then only emits those syntax nodes whose base kind are that specified kind.
 func syntaxNode(nodesStartingWith: [Character]) -> SourceFileSyntax {
   SourceFileSyntax(leadingTrivia: copyrightHeader) {
-    for node in SYNTAX_NODES.compactMap(\.layoutNode)
+    for node in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode)
     where nodesStartingWith.contains(node.kind.syntaxType.description.droppingLeadingUnderscores.first!) {
       // We are actually handling this node now
       try! StructDeclSyntax(
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift
index 32989b0fd2f..6008e581a72 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxTraitsFile.swift
@@ -37,6 +37,16 @@ let syntaxTraitsFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
           """
         )
       }
+
+      if trait.requiresInit {
+        let signature = InitSignature(trait)
+        DeclSyntax(
+          """
+          \(signature.generateInitializerDocComment())
+          \(signature.generateInitializerDeclHeader(isRequirement: true))
+          """
+        )
+      }
     }
 
     try! ExtensionDeclSyntax("extension \(trait.protocolName)") {
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift
index de35ac4c8d4..0f308f7b3ef 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/BuildableNodesFile.swift
@@ -26,7 +26,7 @@ let buildableNodesFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
     """
   )
 
-  for node in SYNTAX_NODES.compactMap(\.layoutNode) {
+  for node in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode) {
     let type = node.type
 
     if let convenienceInit = try! InitSignature(node).createConvenienceBuilderInitializer() {
diff --git a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift
index 1785144c1d0..95abbe48c60 100644
--- a/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift
+++ b/CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntaxbuilder/RenamedChildrenBuilderCompatibilityFile.swift
@@ -26,7 +26,7 @@ let renamedChildrenBuilderCompatibilityFile = try! SourceFileSyntax(leadingTrivi
     """
   )
 
-  for layoutNode in SYNTAX_NODES.compactMap(\.layoutNode).filter({ !$0.childHistory.isEmpty }) {
+  for layoutNode in NON_BASE_SYNTAX_NODES.compactMap(\.layoutNode).filter({ !$0.childHistory.isEmpty }) {
     let deprecatedMembers = SYNTAX_COMPATIBILITY_LAYER.deprecatedMembers(for: layoutNode)
 
     for signature in deprecatedMembers.inits {
diff --git a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift
index c9f81c34a9b..ac15f5f2843 100644
--- a/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift
+++ b/CodeGeneration/Tests/ValidateSyntaxNodes/ValidateSyntaxNodes.swift
@@ -116,17 +116,41 @@ fileprivate extension Array where Element: Hashable, Element: Comparable {
   }
 }
 
+extension LayoutNode {
+  /// True if `self` satisfies all of the requirements of `trait`, regardless
+  /// of whether it actually declares conformance to it.
+  func canConform(to trait: Trait) -> Bool {
+    if let traitBaseKind = trait.baseKind {
+      guard traitBaseKind == self.base else {
+        return false
+      }
+    }
+
+    return trait.children.allSatisfy { traitChild in
+      self.children.contains { nodeChild in
+        traitChild.hasSameType(as: nodeChild)
+      }
+    }
+  }
+
+  /// True if `self` declares conformance to `trait`, regardless of whether
+  /// it satisfies the trait's requirements.
+  func conforms(to trait: Trait) -> Bool {
+    self.traits.contains(trait.traitName)
+  }
+}
+
 class ValidateSyntaxNodes: XCTestCase {
   /// All nodes with base kind e.g. `ExprSyntax` should end with `ExprSyntax`.
   func testBaseKindSuffix() {
     var failures: [ValidationFailure] = []
     for node in SYNTAX_NODES where node.base != .syntaxCollection {
-      if !node.kind.syntaxType.description.hasSuffix(node.base.syntaxType.description) {
+      if !node.kind.syntaxType.description.hasSuffix(node.base.baseTypeSuffix!) {
         failures.append(
           ValidationFailure(
             node: node.kind,
             message:
-              "has base kind '\(node.base.syntaxType)' but type name doesn’t have '\(node.base.syntaxType)' suffix"
+              "has base kind '\(node.base.syntaxType)' but type name doesn’t have '\(node.base.baseTypeSuffix!)' suffix"
           )
         )
       }
@@ -437,6 +461,11 @@ class ValidateSyntaxNodes: XCTestCase {
           node: .declModifier,
           message: "child 'name' only has keywords as its token choices and should thus end with 'Specifier'"
         ),
+        // An extension member for '*DeclSyntax.introducer' already existed; we're just formalizing it
+        ValidationFailure(
+          node: .declGroupHeader,
+          message: "child 'introducer' only has keywords as its token choices and should thus end with 'Specifier'"
+        ),
       ]
     )
   }
@@ -514,12 +543,7 @@ class ValidateSyntaxNodes: XCTestCase {
 
     for node in SYNTAX_NODES.compactMap(\.layoutNode) {
       for trait in TRAITS {
-        let canConformToTrait = trait.children.allSatisfy { traitChild in
-          node.children.contains { nodeChild in
-            traitChild.hasSameType(as: nodeChild)
-          }
-        }
-        if canConformToTrait && !node.traits.contains(trait.traitName) {
+        if node.canConform(to: trait) && !node.conforms(to: trait) {
           failures.append(
             ValidationFailure(
               node: node.kind,
@@ -533,7 +557,6 @@ class ValidateSyntaxNodes: XCTestCase {
     assertFailuresMatchXFails(
       failures,
       expectedFailures: [
-        ValidationFailure(node: .accessorParameters, message: "could conform to trait 'NamedDecl' but does not"),
         ValidationFailure(node: .availabilityCondition, message: "could conform to trait 'Parenthesized' but does not"),
         ValidationFailure(node: ._canImportExpr, message: "could conform to trait 'Parenthesized' but does not"),
         ValidationFailure(
@@ -542,10 +565,6 @@ class ValidateSyntaxNodes: XCTestCase {
         ),
         ValidationFailure(node: .editorPlaceholderDecl, message: "could conform to trait 'MissingNode' but does not"),
         ValidationFailure(node: .editorPlaceholderExpr, message: "could conform to trait 'MissingNode' but does not"),
-        ValidationFailure(node: .enumCaseElement, message: "could conform to trait 'NamedDecl' but does not"),
-        ValidationFailure(node: .genericParameter, message: "could conform to trait 'NamedDecl' but does not"),
-        ValidationFailure(node: .precedenceGroupName, message: "could conform to trait 'NamedDecl' but does not"),
-        ValidationFailure(node: .primaryAssociatedType, message: "could conform to trait 'NamedDecl' but does not"),
         ValidationFailure(
           node: .yieldedExpressionsClause,
           message: "could conform to trait 'Parenthesized' but does not"
@@ -717,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,
diff --git a/Sources/SwiftCompilerPluginMessageHandling/Macros.swift b/Sources/SwiftCompilerPluginMessageHandling/Macros.swift
index 0e51be77df0..7511aef7f69 100644
--- a/Sources/SwiftCompilerPluginMessageHandling/Macros.swift
+++ b/Sources/SwiftCompilerPluginMessageHandling/Macros.swift
@@ -132,7 +132,7 @@ extension PluginProviderMessageHandler {
     }
     let conformanceList = conformanceListSyntax.map {
       let placeholderStruct = sourceManager.add($0).cast(StructDeclSyntax.self)
-      return placeholderStruct.inheritanceClause!.inheritedTypes
+      return placeholderStruct.structHeader.inheritanceClause!.inheritedTypes
     }
 
     let context = PluginMacroExpansionContext(
diff --git a/Sources/SwiftLexicalLookup/LookupName.swift b/Sources/SwiftLexicalLookup/LookupName.swift
index 4530473d3bb..93d94467046 100644
--- a/Sources/SwiftLexicalLookup/LookupName.swift
+++ b/Sources/SwiftLexicalLookup/LookupName.swift
@@ -110,7 +110,7 @@ import SwiftSyntax
     case .Self(let declSyntax):
       switch Syntax(declSyntax).as(SyntaxEnum.self) {
       case .protocolDecl(let protocolDecl):
-        return protocolDecl.name.positionAfterSkippingLeadingTrivia
+        return protocolDecl.protocolHeader.name.positionAfterSkippingLeadingTrivia
       default:
         return declSyntax.positionAfterSkippingLeadingTrivia
       }
diff --git a/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift b/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift
index 81e8e649929..6d9520bfa0e 100644
--- a/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift
+++ b/Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift
@@ -391,7 +391,7 @@ import SwiftSyntax
 }
 @_spi(Experimental) extension ExtensionDeclSyntax: LookInMembersScopeSyntax {
   @_spi(Experimental) public var lookupMembersPosition: AbsolutePosition {
-    extendedType.position
+    extensionHeader.extendedType.position
   }
 
   @_spi(Experimental) public var defaultIntroducedNames: [LookupName] {
@@ -420,7 +420,8 @@ import SwiftSyntax
         + defaultLookupImplementation(identifier, at: lookUpPosition, with: config, propagateToParent: false)
         + [.lookInMembers(self)]
         + lookupInParent(identifier, at: lookUpPosition, with: config)
-    } else if !extendedType.range.contains(lookUpPosition) && genericWhereClause != nil {
+    } else if !extensionHeader.extendedType.range.contains(lookUpPosition) && extensionHeader.genericWhereClause != nil
+    {
       if inRightTypeOrSameTypeRequirement(lookUpPosition) {
         return [.lookInGenericParametersOfExtendedType(self)] + [.lookInMembers(self)]
           + defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
@@ -439,7 +440,7 @@ import SwiftSyntax
   private func inRightTypeOrSameTypeRequirement(
     _ checkedPosition: AbsolutePosition
   ) -> Bool {
-    genericWhereClause?.requirements.contains { elem in
+    extensionHeader.genericWhereClause?.requirements.contains { elem in
       switch Syntax(elem.requirement).as(SyntaxEnum.self) {
       case .conformanceRequirement(let conformanceRequirement):
         return conformanceRequirement.rightType.range.contains(checkedPosition)
@@ -612,7 +613,7 @@ import SwiftSyntax
   }
 
   @_spi(Experimental) public var lookupMembersPosition: AbsolutePosition {
-    name.positionAfterSkippingLeadingTrivia
+    protocolHeader.name.positionAfterSkippingLeadingTrivia
   }
 
   @_spi(Experimental) public var scopeDebugName: String {
@@ -644,7 +645,7 @@ import SwiftSyntax
   ) -> [LookupResult] {
     var results: [LookupResult] = []
 
-    if let primaryAssociatedTypeClause,
+    if let primaryAssociatedTypeClause = protocolHeader.primaryAssociatedTypeClause,
       primaryAssociatedTypeClause.range.contains(lookUpPosition)
     {
       results = memberBlock.lookupAssociatedTypeDeclarations(
@@ -656,7 +657,7 @@ import SwiftSyntax
 
     let lookInMembers: [LookupResult]
 
-    if !(inheritanceClause?.range.contains(lookUpPosition) ?? false) {
+    if !(protocolHeader.inheritanceClause?.range.contains(lookUpPosition) ?? false) {
       lookInMembers = [.lookInMembers(self)]
     } else {
       lookInMembers = []
diff --git a/Sources/SwiftParser/Attributes.swift b/Sources/SwiftParser/Attributes.swift
index ff3fd07596d..35fff842a31 100644
--- a/Sources/SwiftParser/Attributes.swift
+++ b/Sources/SwiftParser/Attributes.swift
@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #if swift(>=6)
-@_spi(RawSyntax) internal import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) internal import SwiftSyntax
 #else
-@_spi(RawSyntax) import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax
 #endif
 
 extension Parser {
@@ -58,6 +58,7 @@ extension Parser {
     case _typeEraser
     case _unavailableFromAsync
     case `rethrows`
+    case abi
     case attached
     case available
     case backDeployed
@@ -95,6 +96,7 @@ extension Parser {
       case TokenSpec(._typeEraser): self = ._typeEraser
       case TokenSpec(._unavailableFromAsync): self = ._unavailableFromAsync
       case TokenSpec(.`rethrows`): self = .rethrows
+      case TokenSpec(.abi) where experimentalFeatures.contains(.abiAttribute): self = .abi
       case TokenSpec(.attached): self = .attached
       case TokenSpec(.available): self = .available
       case TokenSpec(.backDeployed): self = .backDeployed
@@ -136,6 +138,7 @@ extension Parser {
       case ._typeEraser: return .keyword(._typeEraser)
       case ._unavailableFromAsync: return .keyword(._unavailableFromAsync)
       case .`rethrows`: return .keyword(.rethrows)
+      case .abi: return .keyword(.abi)
       case .attached: return .keyword(.attached)
       case .available: return .keyword(.available)
       case .backDeployed: return .keyword(.backDeployed)
@@ -176,9 +179,16 @@ extension Parser {
     case noArgument
   }
 
+  /// Parse the argument of an attribute, if it has one.
+  ///
+  /// - Parameters:
+  ///   - argumentMode: Indicates whether the attribute must, may, or may not have an argument.
+  ///   - parseArguments: Called to parse the argument list. If there is an opening parenthesis, it will have already been consumed.
+  ///   - parseMissingArguments: If provided, called instead of `parseArgument` when an argument list was required but no opening parenthesis was present.
   mutating func parseAttribute(
     argumentMode: AttributeArgumentMode,
-    parseArguments: (inout Parser) -> RawAttributeSyntax.Arguments
+    parseArguments: (inout Parser) -> RawAttributeSyntax.Arguments,
+    parseMissingArguments: ((inout Parser) -> RawAttributeSyntax.Arguments)? = nil
   ) -> RawAttributeListSyntax.Element {
     var (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
     if atSign.trailingTriviaByteLength > 0 || self.currentToken.leadingTriviaByteLength > 0 {
@@ -213,7 +223,12 @@ extension Parser {
         )
         leftParen = leftParen.tokenView.withTokenDiagnostic(tokenDiagnostic: diagnostic, arena: self.arena)
       }
-      let argument = parseArguments(&self)
+      let argument =
+        if let parseMissingArguments, leftParen.presence == .missing {
+          parseMissingArguments(&self)
+        } else {
+          parseArguments(&self)
+        }
       let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
       return .attribute(
         RawAttributeSyntax(
@@ -255,6 +270,12 @@ extension Parser {
     }
 
     switch peek(isAtAnyIn: DeclarationAttributeWithSpecialSyntax.self) {
+    case .abi:
+      return parseAttribute(argumentMode: .required) { parser in
+        return .abiArguments(parser.parseABIAttributeArguments())
+      } parseMissingArguments: { parser in
+        return .abiArguments(parser.parseABIAttributeArguments(missing: true))
+      }
     case .available, ._spi_available:
       return parseAttribute(argumentMode: .required) { parser in
         return .availability(parser.parseAvailabilityArgumentSpecList())
@@ -918,6 +939,75 @@ extension Parser {
   }
 }
 
+extension Parser {
+  mutating func parseABIAttributeArguments(missing: Bool = false) -> RawABIAttributeArgumentsSyntax {
+    let providerDecl: RawABIAttributeArgumentsSyntax.Provider
+    if missing || at(.rightParen) {
+      // There are two situations where the left paren might be missing:
+      //   1. The user just forgot the paren: `@abi var x_abi: Int) var x: Int`
+      //   2. The user forgot the whole argument list: `@abi var x: Int`
+      // Normally, we would distinguish these by seeing if whatever comes after
+      // the attribute parses as an argument. However, for @abi the argument is
+      // a decl, so in #2, we would consume the decl the attribute is attached
+      // to! This leads to a lousy diagnostic in that situation.
+      // Avoid this problem by simply returning a missing decl immediately.
+      // FIXME: Could we look ahead to find an unbalanced parenthesis?
+      providerDecl = .unsupported(
+        RawDeclSyntax(
+          RawMissingDeclSyntax(
+            attributes: self.emptyCollection(RawAttributeListSyntax.self),
+            modifiers: self.emptyCollection(RawDeclModifierListSyntax.self),
+            arena: arena
+          )
+        )
+      )
+    } else {
+      switch nextDeclarationKeyword() {
+      case .group?:
+        providerDecl = RawABIAttributeArgumentsSyntax.Provider(parseDeclarationGroupHeader())!
+
+      case .simple?, .binding?, nil:
+        providerDecl = RawABIAttributeArgumentsSyntax.Provider(parseDeclaration(in: .argumentList))!
+      }
+    }
+
+    return RawABIAttributeArgumentsSyntax(provider: providerDecl, arena: arena)
+  }
+
+  mutating func nextDeclarationKeyword() -> DeclarationKeyword? {
+    return self.withLookahead { subparser in
+      // Consume attributes.
+      var attributeProgress = LoopProgressCondition()
+      while subparser.hasProgressed(&attributeProgress) && subparser.at(.atSign) {
+        _ = subparser.consumeAttributeList()
+      }
+
+      // Consume modifiers.
+      if subparser.currentToken.isLexerClassifiedKeyword || subparser.currentToken.rawTokenKind == .identifier {
+        var modifierProgress = LoopProgressCondition()
+        while let (modifierKind, handle) = subparser.at(anyIn: DeclarationModifier.self),
+          subparser.hasProgressed(&modifierProgress)
+        {
+          if modifierKind == .class {
+            // `class` is a modifier only if it's followed by an introducer or modifier.
+            if subparser.peek(isAtAnyIn: DeclarationStart.self) == nil {
+              break
+            }
+          }
+          subparser.eat(handle)
+          if subparser.at(.leftParen) && modifierKind.canHaveParenthesizedArgument {
+            subparser.consumeAnyToken()
+            subparser.consume(to: .rightParen)
+          }
+        }
+      }
+
+      // Is the next thing a declaration introducer?
+      return subparser.at(anyIn: DeclarationKeyword.self)?.spec
+    }
+  }
+}
+
 extension Parser {
   mutating func parseBackDeployedAttributeArguments() -> RawBackDeployedAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.before))
diff --git a/Sources/SwiftParser/Declarations.swift b/Sources/SwiftParser/Declarations.swift
index 6d8845d52a0..6255305e19f 100644
--- a/Sources/SwiftParser/Declarations.swift
+++ b/Sources/SwiftParser/Declarations.swift
@@ -110,7 +110,7 @@ extension TokenConsumer {
       declStartKeyword = subparser.at(anyIn: DeclarationKeyword.self)?.0
     }
     switch declStartKeyword {
-    case .lhs(.actor):
+    case .group(.actor):
       // actor Foo {}
       if subparser.peek().rawTokenKind == .identifier {
         return true
@@ -123,16 +123,16 @@ extension TokenConsumer {
         lookahead.consumeAnyToken()
       } while lookahead.atStartOfDeclaration(isAtTopLevel: isAtTopLevel, allowInitDecl: allowInitDecl)
       return lookahead.at(.identifier)
-    case .lhs(.case):
+    case .simple(.case):
       // When 'case' appears inside a function, it's probably a switch
       // case, not an enum case declaration.
       return false
-    case .lhs(.`init`):
+    case .simple(.`init`):
       return allowInitDecl
-    case .lhs(.macro):
+    case .simple(.macro):
       // macro Foo ...
       return subparser.peek().rawTokenKind == .identifier
-    case .lhs(.pound):
+    case .simple(.pound):
       // Force parsing '#<identifier>' after attributes as a macro expansion decl.
       if hasAttribute || hasModifier {
         return true
@@ -168,11 +168,37 @@ extension Parser {
     }
   }
 
+  enum DeclarationParseContext {
+    case topLevel
+    case memberDeclList
+    case argumentList
+
+    var requiresDecl: Bool {
+      switch self {
+      case .topLevel:
+        return false
+      case .memberDeclList, .argumentList:
+        return true
+      }
+    }
+
+    var recoveryPrecedence: TokenPrecedence? {
+      switch self {
+      case .topLevel:
+        return nil
+      case .memberDeclList:
+        return .closingBrace
+      case .argumentList:
+        return .weakBracketed(closingDelimiter: .rightParen)
+      }
+    }
+  }
+
   /// Parse a declaration.
   ///
   /// If `inMemberDeclList` is `true`, we know that the next item must be a
   /// declaration and thus start with a keyword. This allows further recovery.
-  mutating func parseDeclaration(inMemberDeclList: Bool = false) -> RawDeclSyntax {
+  mutating func parseDeclaration(in context: DeclarationParseContext = .topLevel) -> RawDeclSyntax {
     // If we are at a `#if` of attributes, the `#if` directive should be
     // parsed when we're parsing the attributes.
     if self.at(.poundIf) && !self.withLookahead({ $0.consumeIfConfigOfAttributes() }) {
@@ -215,70 +241,58 @@ extension Parser {
     } else if atFunctionDeclarationWithoutFuncKeyword() {
       // We aren't at a declaration keyword and it looks like we are at a function
       // declaration. Parse a function declaration.
-      recoveryResult = (.lhs(.func), .missing(.keyword(.func)))
+      recoveryResult = (.simple(.func), .missing(.keyword(.func)))
     } else {
       // In all other cases, use standard token recovery to find the declaration
       // to parse.
       // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context)
       // while recovering to the declaration start.
-      let recoveryPrecedence = inMemberDeclList ? TokenPrecedence.closingBrace : nil
-      recoveryResult = self.canRecoverTo(anyIn: DeclarationKeyword.self, overrideRecoveryPrecedence: recoveryPrecedence)
+      recoveryResult = self.canRecoverTo(
+        anyIn: DeclarationKeyword.self,
+        overrideRecoveryPrecedence: context.recoveryPrecedence
+      )
     }
 
     switch recoveryResult {
-    case (.lhs(.import), let handle)?:
-      return RawDeclSyntax(self.parseImportDeclaration(attrs, handle))
-    case (.lhs(.class), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawClassDeclSyntax.self, attrs: attrs, introucerHandle: handle)
+    case (.group(let introducer), let handle)?:
+      let (header, shouldContinueParsing) = parseHeaderForDeclarationGroup(
+        attrs: attrs,
+        introducer: introducer,
+        introducerHandle: handle,
+        allowsMemberBlock: true
       )
-    case (.lhs(.enum), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawEnumDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
-    case (.lhs(.case), let handle)?:
+      return parseDeclarationGroup(for: header, shouldParseMemberBlock: shouldContinueParsing)
+    case (.simple(.import), let handle)?:
+      return RawDeclSyntax(self.parseImportDeclaration(attrs, handle))
+    case (.simple(.case), let handle)?:
       return RawDeclSyntax(self.parseEnumCaseDeclaration(attrs, handle))
-    case (.lhs(.struct), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawStructDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
-    case (.lhs(.protocol), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawProtocolDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
-    case (.lhs(.associatedtype), let handle)?:
+    case (.simple(.associatedtype), let handle)?:
       return RawDeclSyntax(self.parseAssociatedTypeDeclaration(attrs, handle))
-    case (.lhs(.typealias), let handle)?:
+    case (.simple(.typealias), let handle)?:
       return RawDeclSyntax(self.parseTypealiasDeclaration(attrs, handle))
-    case (.lhs(.extension), let handle)?:
-      return RawDeclSyntax(self.parseExtensionDeclaration(attrs, handle))
-    case (.lhs(.func), let handle)?:
+    case (.simple(.func), let handle)?:
       return RawDeclSyntax(self.parseFuncDeclaration(attrs, handle))
-    case (.lhs(.subscript), let handle)?:
+    case (.simple(.subscript), let handle)?:
       return RawDeclSyntax(self.parseSubscriptDeclaration(attrs, handle))
-    case (.lhs(.`init`), let handle)?:
+    case (.simple(.`init`), let handle)?:
       return RawDeclSyntax(self.parseInitializerDeclaration(attrs, handle))
-    case (.lhs(.deinit), let handle)?:
+    case (.simple(.deinit), let handle)?:
       return RawDeclSyntax(self.parseDeinitializerDeclaration(attrs, handle))
-    case (.lhs(.operator), let handle)?:
+    case (.simple(.operator), let handle)?:
       return RawDeclSyntax(self.parseOperatorDeclaration(attrs, handle))
-    case (.lhs(.precedencegroup), let handle)?:
+    case (.simple(.precedencegroup), let handle)?:
       return RawDeclSyntax(self.parsePrecedenceGroupDeclaration(attrs, handle))
-    case (.lhs(.actor), let handle)?:
-      return RawDeclSyntax(
-        self.parseNominalTypeDeclaration(for: RawActorDeclSyntax.self, attrs: attrs, introucerHandle: handle)
-      )
-    case (.lhs(.macro), let handle)?:
+    case (.simple(.macro), let handle)?:
       return RawDeclSyntax(self.parseMacroDeclaration(attrs: attrs, introducerHandle: handle))
-    case (.lhs(.pound), let handle)?:
+    case (.simple(.pound), let handle)?:
       return RawDeclSyntax(self.parseMacroExpansionDeclaration(attrs, handle))
-    case (.rhs, let handle)?:
-      return RawDeclSyntax(self.parseBindingDeclaration(attrs, handle, inMemberDeclList: inMemberDeclList))
+    case (.binding, let handle)?:
+      return RawDeclSyntax(self.parseBindingDeclaration(attrs, handle, in: context))
     case nil:
       break
     }
 
-    if inMemberDeclList {
+    if context.requiresDecl {
       let isProbablyVarDecl = self.at(.identifier, .wildcard) && self.peek(isAt: .colon, .equal, .comma)
       let isProbablyTupleDecl = self.at(.leftParen) && self.peek(isAt: .identifier, .wildcard)
 
@@ -311,6 +325,185 @@ extension Parser {
     )
   }
 
+  /// Parse the standalone header of a declaration group (a header that won't have a member block attached to it).
+  /// For a header that will have a member list attached, use ``Parser/parseHeaderForDeclarationGroup(attrs:keyword:handle:)``, which this method wraps.
+  ///
+  /// If `inMemberDeclList` is `true`, we know that the next item must be a
+  /// declaration and thus start with a keyword. This allows further recovery.
+  mutating func parseDeclarationGroupHeader(inMemberDeclList: Bool = false) -> RawDeclGroupHeaderSyntax {
+    // If we are at a `#if` of attributes, the `#if` directive should be
+    // parsed when we're parsing the attributes.
+    if self.at(.poundIf) && !self.withLookahead({ $0.consumeIfConfigOfAttributes() }) {
+      // If we're at a #if, that's not actually allowed here; parse it and add
+      // it as an unexpected node of a MissingDeclGroupHeaderSyntax.
+      let directive = self.parsePoundIfDirective { (parser, _) in
+        let parsedDecl = parser.parseDeclaration()
+        let semicolon = parser.consume(if: .semicolon)
+        return RawMemberBlockItemSyntax(
+          decl: parsedDecl,
+          semicolon: semicolon,
+          arena: parser.arena
+        )
+      } addSemicolonIfNeeded: { lastElement, newItemAtStartOfLine, parser in
+        if lastElement.semicolon == nil && !newItemAtStartOfLine {
+          return RawMemberBlockItemSyntax(
+            lastElement.unexpectedBeforeDecl,
+            decl: lastElement.decl,
+            lastElement.unexpectedBetweenDeclAndSemicolon,
+            semicolon: parser.missingToken(.semicolon),
+            lastElement.unexpectedAfterSemicolon,
+            arena: parser.arena
+          )
+        } else {
+          return nil
+        }
+      } syntax: { parser, elements in
+        return .decls(RawMemberBlockItemListSyntax(elements: elements, arena: parser.arena))
+      }
+      return RawDeclGroupHeaderSyntax(
+        RawMissingDeclHeaderSyntax(
+          RawUnexpectedNodesSyntax([directive], arena: self.arena),
+          attributes: emptyCollection(RawAttributeListSyntax.self),
+          modifiers: emptyCollection(RawDeclModifierListSyntax.self),
+          placeholder: missingToken(.identifier, text: "decl"),
+          inheritanceClause: nil,
+          genericWhereClause: nil,
+          arena: self.arena
+        )
+      )
+    }
+
+    let attrs = DeclAttributes(
+      attributes: self.parseAttributeList(),
+      modifiers: self.parseDeclModifierList()
+    )
+
+    let recoveryResult: (match: DeclGroupHeaderSyntax.IntroducerOptions, handle: RecoveryConsumptionHandle)?
+    if let atResult = self.at(anyIn: DeclGroupHeaderSyntax.IntroducerOptions.self) {
+      // We are at a keyword that starts a declaration. Parse that declaration.
+      recoveryResult = (atResult.spec, .noRecovery(atResult.handle))
+    } else {
+      // In all other cases, use standard token recovery to find the declaration
+      // to parse.
+      // If we are inside a memberDecl list, we don't want to eat closing braces (which most likely close the outer context)
+      // while recovering to the declaration start.
+      let recoveryPrecedence = inMemberDeclList ? TokenPrecedence.closingBrace : nil
+      recoveryResult = self.canRecoverTo(
+        anyIn: DeclGroupHeaderSyntax.IntroducerOptions.self,
+        overrideRecoveryPrecedence: recoveryPrecedence
+      )
+    }
+
+    if let (match, handle) = recoveryResult {
+      return parseHeaderForDeclarationGroup(
+        attrs: attrs,
+        introducer: match,
+        introducerHandle: handle,
+        allowsMemberBlock: false
+      ).0
+    }
+
+    if inMemberDeclList {
+      if self.currentToken.isEditorPlaceholder {
+        let placeholder = self.parseAnyIdentifier()
+        return RawDeclGroupHeaderSyntax(
+          RawMissingDeclHeaderSyntax(
+            attributes: attrs.attributes,
+            modifiers: attrs.modifiers,
+            placeholder: placeholder,
+            inheritanceClause: nil,
+            genericWhereClause: nil,
+            arena: self.arena
+          )
+        )
+      }
+    }
+
+    return RawDeclGroupHeaderSyntax(
+      RawMissingDeclHeaderSyntax(
+        attributes: attrs.attributes,
+        modifiers: attrs.modifiers,
+        placeholder: missingToken(.identifier, text: "decl"),
+        inheritanceClause: nil,
+        genericWhereClause: nil,
+        arena: self.arena
+      )
+    )
+  }
+
+  /// Parse the header of a declaration group that will belong to some larger construct.
+  ///
+  /// - Parameters:
+  ///   - allowsMemberBlock: If `false`, a member block is definitively *not*
+  ///     expected after this header and if one is found, it should be
+  ///     proactively consumed.
+  mutating func parseHeaderForDeclarationGroup(
+    attrs: DeclAttributes,
+    introducer: DeclGroupHeaderSyntax.IntroducerOptions,
+    introducerHandle: RecoveryConsumptionHandle,
+    allowsMemberBlock: Bool
+  ) -> (RawDeclGroupHeaderSyntax, shouldContinueParsing: Bool) {
+    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,
+          allowsMemberBlock: allowsMemberBlock
+        )
+      )
+    case .enum:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawEnumDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle,
+          allowsMemberBlock: allowsMemberBlock
+        )
+      )
+    case .struct:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawStructDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle,
+          allowsMemberBlock: allowsMemberBlock
+        )
+      )
+    case .protocol:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawProtocolDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle,
+          allowsMemberBlock: allowsMemberBlock
+        )
+      )
+    case .extension:
+      return (
+        RawDeclGroupHeaderSyntax(
+          self.parseExtensionDeclarationHeader(attrs, introducerHandle, allowsMemberBlock: allowsMemberBlock)
+        ), true
+      )
+    case .actor:
+      return eraseToRawDeclGroupHeaderSyntax(
+        self.parseNominalTypeDeclarationHeader(
+          for: RawActorDeclHeaderSyntax.self,
+          attrs: attrs,
+          introducerHandle: introducerHandle,
+          allowsMemberBlock: allowsMemberBlock
+        )
+      )
+    }
+  }
+
   /// Returns `true` if it looks like the parser is positioned at a function declaration that’s missing the `func` keyword.
   fileprivate mutating func atFunctionDeclarationWithoutFuncKeyword() -> Bool {
     var nextTokenIsLeftParenOrLeftAngle: Bool {
@@ -373,12 +566,122 @@ 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, allowsMemberBlock: true)
+    return parseDeclarationGroup(for: header)
+  }
+
+  /// Parse the header of an extension declaration.
+  mutating func parseExtensionDeclarationHeader(
+    _ attrs: DeclAttributes,
+    _ handle: RecoveryConsumptionHandle,
+    allowsMemberBlock: Bool
+  ) -> RawExtensionDeclHeaderSyntax {
     let (unexpectedBeforeExtensionKeyword, extensionKeyword) = self.eat(handle)
     let type = self.parseType()
 
@@ -395,8 +698,18 @@ extension Parser {
     } else {
       whereClause = nil
     }
-    let memberBlock = self.parseMemberBlock(introducer: extensionKeyword)
-    return RawExtensionDeclSyntax(
+
+    // If we know there shouldn't be a member block, but there is, gobble it up whole right now.
+    var trailingUnexpectedNodes: RawUnexpectedNodesSyntax?
+    if !allowsMemberBlock && self.at(.leftBrace) {
+      let forbiddenMemberBlock = parseMemberBlock(introducer: extensionKeyword)
+      trailingUnexpectedNodes = RawUnexpectedNodesSyntax(
+        [forbiddenMemberBlock],
+        arena: self.arena
+      )
+    }
+
+    return RawExtensionDeclHeaderSyntax(
       attributes: attrs.attributes,
       modifiers: attrs.modifiers,
       unexpectedBeforeExtensionKeyword,
@@ -404,7 +717,7 @@ extension Parser {
       extendedType: type,
       inheritanceClause: inheritance,
       genericWhereClause: whereClause,
-      memberBlock: memberBlock,
+      trailingUnexpectedNodes,
       arena: self.arena
     )
   }
@@ -746,7 +1059,7 @@ extension Parser {
     if self.at(.poundSourceLocation) {
       decl = RawDeclSyntax(self.parsePoundSourceLocationDirective())
     } else {
-      decl = self.parseDeclaration(inMemberDeclList: true)
+      decl = self.parseDeclaration(in: .memberDeclList)
     }
 
     let semi = self.consume(if: .semicolon)
@@ -1268,7 +1581,7 @@ extension Parser {
   mutating func parseBindingDeclaration(
     _ attrs: DeclAttributes,
     _ handle: RecoveryConsumptionHandle,
-    inMemberDeclList: Bool = false
+    in context: DeclarationParseContext = .topLevel
   ) -> RawVariableDeclSyntax {
     let (unexpectedBeforeIntroducer, introducer) = self.eat(handle)
     let hasTryBeforeIntroducer = unexpectedBeforeIntroducer?.containsToken(where: { TokenSpec(.try) ~= $0 }) ?? false
@@ -1358,7 +1671,7 @@ extension Parser {
         if (self.at(.leftBrace)
           && (initializer == nil || !self.currentToken.isAtStartOfLine
             || self.withLookahead({ $0.atStartOfGetSetAccessor() })))
-          || (inMemberDeclList && self.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) != nil
+          || (context == .memberDeclList && self.at(anyIn: AccessorDeclSyntax.AccessorSpecifierOptions.self) != nil
             && !self.at(.keyword(.`init`)))
         {
           accessors = self.parseAccessorBlock()
diff --git a/Sources/SwiftParser/Nominals.swift b/Sources/SwiftParser/Nominals.swift
index 3f9a240c8dd..d7ec2e25133 100644
--- a/Sources/SwiftParser/Nominals.swift
+++ b/Sources/SwiftParser/Nominals.swift
@@ -16,7 +16,7 @@
 @_spi(RawSyntax) import SwiftSyntax
 #endif
 
-protocol NominalTypeDeclarationTrait {
+protocol NominalTypeDeclarationHeaderTrait: DeclarationGroupHeaderTrait {
   associatedtype PrimaryOrGenerics
 
   init(
@@ -29,14 +29,14 @@ protocol NominalTypeDeclarationTrait {
     primaryOrGenerics: PrimaryOrGenerics?,
     inheritanceClause: RawInheritanceClauseSyntax?,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    memberBlock: RawMemberBlockSyntax,
+    trailingUnexpectedNodes: RawUnexpectedNodesSyntax?,
     arena: __shared SyntaxArena
   )
 
   static func parsePrimaryOrGenerics(_ parser: inout Parser) -> PrimaryOrGenerics?
 }
 
-extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait {
+extension RawProtocolDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait {
   init(
     attributes: RawAttributeListSyntax,
     modifiers: RawDeclModifierListSyntax,
@@ -47,7 +47,7 @@ extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait {
     primaryOrGenerics: RawPrimaryAssociatedTypeClauseSyntax?,
     inheritanceClause: RawInheritanceClauseSyntax?,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    memberBlock: RawMemberBlockSyntax,
+    trailingUnexpectedNodes: RawUnexpectedNodesSyntax?,
     arena: __shared SyntaxArena
   ) {
     self.init(
@@ -60,7 +60,7 @@ extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait {
       primaryAssociatedTypeClause: primaryOrGenerics,
       inheritanceClause: inheritanceClause,
       genericWhereClause: genericWhereClause,
-      memberBlock: memberBlock,
+      trailingUnexpectedNodes,
       arena: arena
     )
   }
@@ -68,9 +68,17 @@ extension RawProtocolDeclSyntax: NominalTypeDeclarationTrait {
   static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawPrimaryAssociatedTypeClauseSyntax? {
     return parser.parsePrimaryAssociatedTypes()
   }
+
+  var introducer: RawTokenSyntax {
+    return self.protocolKeyword
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawProtocolDeclSyntax {
+    RawProtocolDeclSyntax(protocolHeader: self, memberBlock: memberBlock, arena: arena)
+  }
 }
 
-extension RawClassDeclSyntax: NominalTypeDeclarationTrait {
+extension RawClassDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait {
   init(
     attributes: RawAttributeListSyntax,
     modifiers: RawDeclModifierListSyntax,
@@ -81,7 +89,7 @@ extension RawClassDeclSyntax: NominalTypeDeclarationTrait {
     primaryOrGenerics: RawGenericParameterClauseSyntax?,
     inheritanceClause: RawInheritanceClauseSyntax?,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    memberBlock: RawMemberBlockSyntax,
+    trailingUnexpectedNodes: RawUnexpectedNodesSyntax?,
     arena: __shared SyntaxArena
   ) {
     self.init(
@@ -94,7 +102,7 @@ extension RawClassDeclSyntax: NominalTypeDeclarationTrait {
       genericParameterClause: primaryOrGenerics,
       inheritanceClause: inheritanceClause,
       genericWhereClause: genericWhereClause,
-      memberBlock: memberBlock,
+      trailingUnexpectedNodes,
       arena: arena
     )
   }
@@ -102,9 +110,17 @@ extension RawClassDeclSyntax: NominalTypeDeclarationTrait {
   static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? {
     return parser.parseGenericParameters()
   }
+
+  var introducer: RawTokenSyntax {
+    return self.classKeyword
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawClassDeclSyntax {
+    RawClassDeclSyntax(classHeader: self, memberBlock: memberBlock, arena: arena)
+  }
 }
 
-extension RawActorDeclSyntax: NominalTypeDeclarationTrait {
+extension RawActorDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait {
   init(
     attributes: RawAttributeListSyntax,
     modifiers: RawDeclModifierListSyntax,
@@ -115,7 +131,7 @@ extension RawActorDeclSyntax: NominalTypeDeclarationTrait {
     primaryOrGenerics: RawGenericParameterClauseSyntax?,
     inheritanceClause: RawInheritanceClauseSyntax?,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    memberBlock: RawMemberBlockSyntax,
+    trailingUnexpectedNodes: RawUnexpectedNodesSyntax?,
     arena: __shared SyntaxArena
   ) {
     self.init(
@@ -128,7 +144,7 @@ extension RawActorDeclSyntax: NominalTypeDeclarationTrait {
       genericParameterClause: primaryOrGenerics,
       inheritanceClause: inheritanceClause,
       genericWhereClause: genericWhereClause,
-      memberBlock: memberBlock,
+      trailingUnexpectedNodes,
       arena: arena
     )
   }
@@ -136,9 +152,17 @@ extension RawActorDeclSyntax: NominalTypeDeclarationTrait {
   static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? {
     return parser.parseGenericParameters()
   }
+
+  var introducer: RawTokenSyntax {
+    return self.actorKeyword
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawActorDeclSyntax {
+    RawActorDeclSyntax(actorHeader: self, memberBlock: memberBlock, arena: arena)
+  }
 }
 
-extension RawStructDeclSyntax: NominalTypeDeclarationTrait {
+extension RawStructDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait {
   init(
     attributes: RawAttributeListSyntax,
     modifiers: RawDeclModifierListSyntax,
@@ -149,7 +173,7 @@ extension RawStructDeclSyntax: NominalTypeDeclarationTrait {
     primaryOrGenerics: RawGenericParameterClauseSyntax?,
     inheritanceClause: RawInheritanceClauseSyntax?,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    memberBlock: RawMemberBlockSyntax,
+    trailingUnexpectedNodes: RawUnexpectedNodesSyntax?,
     arena: __shared SyntaxArena
   ) {
     self.init(
@@ -162,7 +186,7 @@ extension RawStructDeclSyntax: NominalTypeDeclarationTrait {
       genericParameterClause: primaryOrGenerics,
       inheritanceClause: inheritanceClause,
       genericWhereClause: genericWhereClause,
-      memberBlock: memberBlock,
+      trailingUnexpectedNodes,
       arena: arena
     )
   }
@@ -170,9 +194,17 @@ extension RawStructDeclSyntax: NominalTypeDeclarationTrait {
   static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? {
     return parser.parseGenericParameters()
   }
+
+  var introducer: RawTokenSyntax {
+    return self.structKeyword
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawStructDeclSyntax {
+    RawStructDeclSyntax(structHeader: self, memberBlock: memberBlock, arena: arena)
+  }
 }
 
-extension RawEnumDeclSyntax: NominalTypeDeclarationTrait {
+extension RawEnumDeclHeaderSyntax: NominalTypeDeclarationHeaderTrait {
   init(
     attributes: RawAttributeListSyntax,
     modifiers: RawDeclModifierListSyntax,
@@ -183,7 +215,7 @@ extension RawEnumDeclSyntax: NominalTypeDeclarationTrait {
     primaryOrGenerics: RawGenericParameterClauseSyntax?,
     inheritanceClause: RawInheritanceClauseSyntax?,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    memberBlock: RawMemberBlockSyntax,
+    trailingUnexpectedNodes: RawUnexpectedNodesSyntax?,
     arena: __shared SyntaxArena
   ) {
     self.init(
@@ -196,7 +228,7 @@ extension RawEnumDeclSyntax: NominalTypeDeclarationTrait {
       genericParameterClause: primaryOrGenerics,
       inheritanceClause: inheritanceClause,
       genericWhereClause: genericWhereClause,
-      memberBlock: memberBlock,
+      trailingUnexpectedNodes,
       arena: arena
     )
   }
@@ -204,35 +236,42 @@ extension RawEnumDeclSyntax: NominalTypeDeclarationTrait {
   static func parsePrimaryOrGenerics(_ parser: inout Parser) -> RawGenericParameterClauseSyntax? {
     return parser.parseGenericParameters()
   }
+
+  var introducer: RawTokenSyntax {
+    return self.enumKeyword
+  }
+
+  func makeDeclaration(memberBlock: RawMemberBlockSyntax, arena: SyntaxArena) -> RawEnumDeclSyntax {
+    RawEnumDeclSyntax(enumHeader: self, memberBlock: memberBlock, arena: arena)
+  }
 }
 
 extension Parser {
-  /// Parse a nominal type decl declaration - class, struct, enum, or actor.
-  mutating func parseNominalTypeDeclaration<T>(
+  /// Parse the header of a nominal type decl declaration - class, struct, enum, or actor.
+  mutating func parseNominalTypeDeclarationHeader<T>(
     for T: T.Type,
     attrs: DeclAttributes,
-    introucerHandle: RecoveryConsumptionHandle
-  ) -> T where T: NominalTypeDeclarationTrait {
-    let (unexpectedBeforeIntroducerKeyword, introducerKeyword) = self.eat(introucerHandle)
+    introducerHandle: RecoveryConsumptionHandle,
+    allowsMemberBlock: Bool
+  ) -> (T, shouldContinueParsing: Bool) where T: NominalTypeDeclarationHeaderTrait {
+    let (unexpectedBeforeIntroducerKeyword, introducerKeyword) = self.eat(introducerHandle)
     let (unexpectedBeforeName, name) = self.expectIdentifier(keywordRecovery: true)
     if unexpectedBeforeName == nil && name.isMissing && self.atStartOfLine {
-      return T.init(
-        attributes: attrs.attributes,
-        modifiers: attrs.modifiers,
-        unexpectedBeforeIntroducerKeyword,
-        introducerKeyword: introducerKeyword,
-        unexpectedBeforeName,
-        name: name,
-        primaryOrGenerics: nil,
-        inheritanceClause: nil,
-        genericWhereClause: nil,
-        memberBlock: RawMemberBlockSyntax(
-          leftBrace: missingToken(.leftBrace),
-          members: RawMemberBlockItemListSyntax(elements: [], arena: self.arena),
-          rightBrace: missingToken(.rightBrace),
+      return (
+        T.init(
+          attributes: attrs.attributes,
+          modifiers: attrs.modifiers,
+          unexpectedBeforeIntroducerKeyword,
+          introducerKeyword: introducerKeyword,
+          unexpectedBeforeName,
+          name: name,
+          primaryOrGenerics: nil,
+          inheritanceClause: nil,
+          genericWhereClause: nil,
+          trailingUnexpectedNodes: nil,
           arena: self.arena
         ),
-        arena: self.arena
+        shouldContinueParsing: false
       )
     }
 
@@ -258,19 +297,31 @@ extension Parser {
       whereClause = nil
     }
 
-    let memberBlock = self.parseMemberBlock(introducer: introducerKeyword)
-    return T.init(
-      attributes: attrs.attributes,
-      modifiers: attrs.modifiers,
-      unexpectedBeforeIntroducerKeyword,
-      introducerKeyword: introducerKeyword,
-      unexpectedBeforeName,
-      name: name,
-      primaryOrGenerics: primaryOrGenerics,
-      inheritanceClause: inheritance,
-      genericWhereClause: whereClause,
-      memberBlock: memberBlock,
-      arena: self.arena
+    // If we know there shouldn't be a member block, but there is, gobble it up whole right now.
+    var trailingUnexpectedNodes: RawUnexpectedNodesSyntax?
+    if !allowsMemberBlock && self.at(.leftBrace) {
+      let forbiddenMemberBlock = parseMemberBlock(introducer: introducerKeyword)
+      trailingUnexpectedNodes = RawUnexpectedNodesSyntax(
+        [forbiddenMemberBlock],
+        arena: self.arena
+      )
+    }
+
+    return (
+      T.init(
+        attributes: attrs.attributes,
+        modifiers: attrs.modifiers,
+        unexpectedBeforeIntroducerKeyword,
+        introducerKeyword: introducerKeyword,
+        unexpectedBeforeName,
+        name: name,
+        primaryOrGenerics: primaryOrGenerics,
+        inheritanceClause: inheritance,
+        genericWhereClause: whereClause,
+        trailingUnexpectedNodes: trailingUnexpectedNodes,
+        arena: self.arena
+      ),
+      shouldContinueParsing: true
     )
   }
 
diff --git a/Sources/SwiftParser/TokenPrecedence.swift b/Sources/SwiftParser/TokenPrecedence.swift
index 1cc318aedfa..9e1a22cc01f 100644
--- a/Sources/SwiftParser/TokenPrecedence.swift
+++ b/Sources/SwiftParser/TokenPrecedence.swift
@@ -283,6 +283,7 @@ enum TokenPrecedence: Comparable {
       ._swift_native_objc_runtime_base,
       ._typeEraser,
       ._unavailableFromAsync,
+      .abi,
       .attached,
       .available,
       .backDeployed,
diff --git a/Sources/SwiftParser/TokenSpecSet.swift b/Sources/SwiftParser/TokenSpecSet.swift
index e2b46112829..8402d624ec1 100644
--- a/Sources/SwiftParser/TokenSpecSet.swift
+++ b/Sources/SwiftParser/TokenSpecSet.swift
@@ -267,82 +267,102 @@ enum ContextualDeclKeyword: TokenSpecSet {
   }
 }
 
-/// A `DeclarationKeyword` that is not a `ValueBindingPatternSyntax.BindingSpecifierOptions`.
-///
-/// `ValueBindingPatternSyntax.BindingSpecifierOptions` are injected into
-/// `DeclarationKeyword` via an `EitherTokenSpecSet`.
-enum PureDeclarationKeyword: TokenSpecSet {
-  case actor
-  case `associatedtype`
-  case `case`
-  case `class`
-  case `deinit`
-  case `enum`
-  case `extension`
-  case `func`
-  case `import`
-  case `init`
-  case macro
-  case `operator`
-  case `precedencegroup`
-  case `protocol`
-  case `struct`
-  case `subscript`
-  case `typealias`
-  case pound
+/// Union of the following token kind subsets:
+///  - `ValueBindingPatternSyntax.BindingSpecifierOptions`
+///  - `DeclGroupHeaderSyntax.IntroducerOptions`
+///  - `DeclarationKeyword.Simple` (containing other declaration keywords)
+enum DeclarationKeyword: TokenSpecSet {
+  /// A keyword introducing a binding declaration (a declaration which binds patterns to values).
+  case binding(Binding)
+
+  /// A keyword introducing a declaration group (a declaration with a member block).
+  case group(Group)
+
+  /// A keyword introducing a simple declaration (a declaration which is neither a group nor a binding).
+  case simple(Simple)
 
   init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
-    switch PrepareForKeywordMatch(lexeme) {
-    case TokenSpec(.actor): self = .actor
-    case TokenSpec(.macro): self = .macro
-    case TokenSpec(.associatedtype): self = .associatedtype
-    case TokenSpec(.case): self = .case
-    case TokenSpec(.class): self = .class
-    case TokenSpec(.deinit): self = .deinit
-    case TokenSpec(.enum): self = .enum
-    case TokenSpec(.extension): self = .extension
-    case TokenSpec(.func): self = .func
-    case TokenSpec(.import): self = .import
-    case TokenSpec(.`init`): self = .`init`
-    case TokenSpec(.operator): self = .operator
-    case TokenSpec(.precedencegroup): self = .precedencegroup
-    case TokenSpec(.protocol): self = .protocol
-    case TokenSpec(.struct): self = .struct
-    case TokenSpec(.subscript): self = .subscript
-    case TokenSpec(.typealias): self = .typealias
-    case TokenSpec(.pound): self = .pound
-    default: return nil
+    if let simple = Simple(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
+      self = .simple(simple)
+    } else if let group = Group(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
+      self = .group(group)
+    } else if let binding = Binding(lexeme: lexeme, experimentalFeatures: experimentalFeatures) {
+      self = .binding(binding)
+    } else {
+      return nil
     }
   }
 
   var spec: TokenSpec {
     switch self {
-    case .actor: return TokenSpec(.actor, recoveryPrecedence: .declKeyword)
-    case .associatedtype: return .keyword(.associatedtype)
-    case .case: return TokenSpec(.case, recoveryPrecedence: .declKeyword)
-    case .class: return .keyword(.class)
-    case .deinit: return .keyword(.deinit)
-    case .enum: return .keyword(.enum)
-    case .extension: return .keyword(.extension)
-    case .func: return .keyword(.func)
-    case .import: return .keyword(.import)
-    case .`init`: return .keyword(.`init`)
-    case .macro: return TokenSpec(.macro, recoveryPrecedence: .declKeyword)
-    case .operator: return .keyword(.operator)
-    case .precedencegroup: return .keyword(.precedencegroup)
-    case .protocol: return .keyword(.protocol)
-    case .struct: return .keyword(.struct)
-    case .subscript: return .keyword(.subscript)
-    case .typealias: return .keyword(.typealias)
-    case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
+    case .simple(let simple): return simple.spec
+    case .group(let group): return group.spec
+    case .binding(let binding): return binding.spec
     }
   }
+
+  static let allCases: [DeclarationKeyword] =
+    Binding.allCases.map { .binding($0) } + Group.allCases.map { .group($0) } + Simple.allCases.map { .simple($0) }
 }
 
-typealias DeclarationKeyword = EitherTokenSpecSet<
-  PureDeclarationKeyword,
-  ValueBindingPatternSyntax.BindingSpecifierOptions
->
+extension DeclarationKeyword {
+  /// Type for a keyword introducing a binding declaration (a declaration which binds patterns to values).
+  typealias Binding = ValueBindingPatternSyntax.BindingSpecifierOptions
+
+  /// Type for a keyword introducing a declaration group (a declaration with a member block).
+  typealias Group = DeclGroupHeaderSyntax.IntroducerOptions
+
+  /// Type for a keyword introducing a simple declaration (a declaration which is neither a group nor a binding).
+  enum Simple: TokenSpecSet {
+    case `associatedtype`
+    case `case`
+    case `deinit`
+    case `func`
+    case `import`
+    case `init`
+    case macro
+    case `operator`
+    case `precedencegroup`
+    case `subscript`
+    case `typealias`
+    case pound
+
+    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.macro): self = .macro
+      case TokenSpec(.associatedtype): self = .associatedtype
+      case TokenSpec(.case): self = .case
+      case TokenSpec(.deinit): self = .deinit
+      case TokenSpec(.func): self = .func
+      case TokenSpec(.import): self = .import
+      case TokenSpec(.`init`): self = .`init`
+      case TokenSpec(.operator): self = .operator
+      case TokenSpec(.precedencegroup): self = .precedencegroup
+      case TokenSpec(.subscript): self = .subscript
+      case TokenSpec(.typealias): self = .typealias
+      case TokenSpec(.pound): self = .pound
+      default: return nil
+      }
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      case .associatedtype: return .keyword(.associatedtype)
+      case .case: return TokenSpec(.case, recoveryPrecedence: .declKeyword)
+      case .deinit: return .keyword(.deinit)
+      case .func: return .keyword(.func)
+      case .import: return .keyword(.import)
+      case .`init`: return .keyword(.`init`)
+      case .macro: return TokenSpec(.macro, recoveryPrecedence: .declKeyword)
+      case .operator: return .keyword(.operator)
+      case .precedencegroup: return .keyword(.precedencegroup)
+      case .subscript: return .keyword(.subscript)
+      case .typealias: return .keyword(.typealias)
+      case .pound: return TokenSpec(.pound, recoveryPrecedence: .openingPoundIf)
+      }
+    }
+  }
+}
 
 enum DeclarationModifier: TokenSpecSet {
   case __consuming
diff --git a/Sources/SwiftParser/generated/ExperimentalFeatures.swift b/Sources/SwiftParser/generated/ExperimentalFeatures.swift
index 63fe9639d8f..ae693126061 100644
--- a/Sources/SwiftParser/generated/ExperimentalFeatures.swift
+++ b/Sources/SwiftParser/generated/ExperimentalFeatures.swift
@@ -41,4 +41,7 @@ extension Parser.ExperimentalFeatures {
 
   /// Whether to enable the parsing of CoroutineAccessors.
   public static let coroutineAccessors = Self (rawValue: 1 << 5)
+
+  /// Whether to enable the parsing of @abi attribute.
+  public static let abiAttribute = Self (rawValue: 1 << 6)
 }
diff --git a/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift b/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift
index d3a703ed22a..12af615f705 100644
--- a/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift
+++ b/Sources/SwiftParser/generated/LayoutNodes+Parsable.swift
@@ -148,6 +148,24 @@ extension CodeBlockSyntax: SyntaxParseable {
   }
 }
 
+extension DeclGroupHeaderSyntax: SyntaxParseable {
+  public static func parse(from parser: inout Parser) -> Self {
+    // Keep the parser alive so that the arena in which `raw` is allocated
+    // doesn’t get deallocated before we have a chance to create a syntax node
+    // from it. We can’t use `parser.arena` as the parameter to
+    // `Syntax(raw:arena:)` because the node might have been re-used during an
+    // incremental parse and would then live in a different arena than
+    // `parser.arena`.
+    defer {
+      withExtendedLifetime(parser) {
+      }
+    }
+    let node = parser.parseDeclarationGroupHeader()
+    let raw = RawSyntax(parser.parseRemainder(into: node))
+    return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
+  }
+}
+
 extension DeclSyntax: SyntaxParseable {
   public static func parse(from parser: inout Parser) -> Self {
     // Keep the parser alive so that the arena in which `raw` is allocated
diff --git a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift
index 0ddbdbd54c0..f1687f64374 100644
--- a/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift
+++ b/Sources/SwiftParser/generated/Parser+TokenSpecSet.swift
@@ -844,6 +844,94 @@ extension ConsumeExprSyntax {
   }
 }
 
+extension DeclGroupHeaderSyntax {
+  @_spi(Diagnostics)
+  public enum IntroducerOptions: TokenSpecSet {
+    case actor
+    case `class`
+    case `enum`
+    case `extension`
+    case `protocol`
+    case `struct`
+
+    init?(lexeme: Lexer.Lexeme, experimentalFeatures: Parser.ExperimentalFeatures) {
+      switch PrepareForKeywordMatch(lexeme) {
+      case TokenSpec(.actor):
+        self = .actor
+      case TokenSpec(.class):
+        self = .class
+      case TokenSpec(.enum):
+        self = .enum
+      case TokenSpec(.extension):
+        self = .extension
+      case TokenSpec(.protocol):
+        self = .protocol
+      case TokenSpec(.struct):
+        self = .struct
+      default:
+        return nil
+      }
+    }
+
+    public init?(token: TokenSyntax) {
+      switch token {
+      case TokenSpec(.actor):
+        self = .actor
+      case TokenSpec(.class):
+        self = .class
+      case TokenSpec(.enum):
+        self = .enum
+      case TokenSpec(.extension):
+        self = .extension
+      case TokenSpec(.protocol):
+        self = .protocol
+      case TokenSpec(.struct):
+        self = .struct
+      default:
+        return nil
+      }
+    }
+
+    var spec: TokenSpec {
+      switch self {
+      case .actor:
+        return .keyword(.actor)
+      case .class:
+        return .keyword(.class)
+      case .enum:
+        return .keyword(.enum)
+      case .extension:
+        return .keyword(.extension)
+      case .protocol:
+        return .keyword(.protocol)
+      case .struct:
+        return .keyword(.struct)
+      }
+    }
+
+    /// Returns a token that satisfies the `TokenSpec` of this case.
+    ///
+    /// If the token kind of this spec has variable text, e.g. for an identifier, this returns a token with empty text.
+    @_spi(Diagnostics)
+    public var tokenSyntax: TokenSyntax {
+      switch self {
+      case .actor:
+        return .keyword(.actor)
+      case .class:
+        return .keyword(.class)
+      case .enum:
+        return .keyword(.enum)
+      case .extension:
+        return .keyword(.extension)
+      case .protocol:
+        return .keyword(.protocol)
+      case .struct:
+        return .keyword(.struct)
+      }
+    }
+  }
+}
+
 extension DeclModifierSyntax {
   @_spi(Diagnostics)
   public enum NameOptions: TokenSpecSet {
diff --git a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift
index 13030c5143e..ce9bd9eebda 100644
--- a/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift
+++ b/Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift
@@ -415,6 +415,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       let previousToken = node.previousToken(viewMode: .sourceAccurate),
       previousToken.tokenKind.isIdentifier,
       previousToken.parent?.is(DeclSyntax.self) == true
+        || previousToken.parent?.is(DeclGroupHeaderSyntax.self) == true
         || previousToken.parent?.is(IdentifierPatternSyntax.self) == true
     {
       // If multiple identifiers are used for a declaration name, offer to join them together.
@@ -476,6 +477,22 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
         SpaceSeparatedIdentifiersError(firstToken: previousToken, additionalTokens: tokens),
         fixIts: fixIts
       )
+    } else if node.count == 1,
+      let onlyChild = node.first!.as(MemberBlockSyntax.self),
+      let parentHeader = node.parent?.as(DeclGroupHeaderSyntax.self)
+    {
+      addDiagnostic(
+        node,
+        DeclarationMemberBlockNotAllowedOnHeader(header: parentHeader),
+        fixIts: [
+          FixIt(
+            message: RemoveNodesFixIt([Syntax(onlyChild)]),
+            changes: [
+              .makeMissing(node, transferTrivia: true)
+            ]
+          )
+        ]
+      )
     } else {
       addDiagnostic(node, UnexpectedNodesError(unexpectedNodes: node), highlights: [Syntax(node)])
     }
diff --git a/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift b/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift
index f1a21255bb5..20b976f4fac 100644
--- a/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift
+++ b/Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift
@@ -17,7 +17,7 @@ public import SwiftDiagnostics
 #else
 import SwiftDiagnostics
 @_spi(Diagnostics) import SwiftParser
-@_spi(RawSyntax) import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax
 #endif
 
 fileprivate let diagnosticDomain: String = "SwiftParser"
@@ -270,6 +270,25 @@ extension DiagnosticMessage where Self == StaticParserError {
 
 // MARK: - Diagnostics (please sort alphabetically)
 
+public struct DeclarationMemberBlockNotAllowedOnHeader: ParserError {
+  public let header: DeclGroupHeaderSyntax
+
+  private var headerDescription: String {
+    header.kind.nameForDiagnostics ?? "declaration"
+  }
+
+  private var contextDescription: String {
+    if header.parent?.is(ABIAttributeArgumentsSyntax.self) ?? false {
+      return "in '@abi' attribute"
+    }
+    return "here"
+  }
+
+  public var message: String {
+    "\(headerDescription) header \(contextDescription) cannot have a member block"
+  }
+}
+
 public struct AsyncMustPrecedeThrows: ParserError {
   public let asyncKeywords: [TokenSyntax]
   public let throwsKeyword: TokenSyntax
diff --git a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift
index 1d7488f2861..07b9a284f32 100644
--- a/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift
+++ b/Sources/SwiftParserDiagnostics/generated/ChildNameForDiagnostics.swift
@@ -28,15 +28,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "parameter"
   case \AccessorParametersSyntax.name:
     return "name"
-  case \ActorDeclSyntax.attributes:
+  case \ActorDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ActorDeclSyntax.modifiers:
+  case \ActorDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ActorDeclSyntax.genericParameterClause:
+  case \ActorDeclHeaderSyntax.genericParameterClause:
     return "generic parameter clause"
-  case \ActorDeclSyntax.inheritanceClause:
+  case \ActorDeclHeaderSyntax.inheritanceClause:
     return "inheritance clause"
-  case \ActorDeclSyntax.genericWhereClause:
+  case \ActorDeclHeaderSyntax.genericWhereClause:
     return "generic where clause"
   case \ArrayElementSyntax.expression:
     return "value"
@@ -56,15 +56,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "value"
   case \BreakStmtSyntax.label:
     return "label"
-  case \ClassDeclSyntax.attributes:
+  case \ClassDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ClassDeclSyntax.modifiers:
+  case \ClassDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ClassDeclSyntax.genericParameterClause:
+  case \ClassDeclHeaderSyntax.genericParameterClause:
     return "generic parameter clause"
-  case \ClassDeclSyntax.inheritanceClause:
+  case \ClassDeclHeaderSyntax.inheritanceClause:
     return "inheritance clause"
-  case \ClassDeclSyntax.genericWhereClause:
+  case \ClassDeclHeaderSyntax.genericWhereClause:
     return "generic where clause"
   case \ClosureParameterClauseSyntax.parameters:
     return "parameters"
@@ -118,23 +118,23 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "type"
   case \EnumCaseParameterSyntax.defaultValue:
     return "default value"
-  case \EnumDeclSyntax.attributes:
+  case \EnumDeclHeaderSyntax.attributes:
     return "attributes"
-  case \EnumDeclSyntax.modifiers:
+  case \EnumDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \EnumDeclSyntax.genericParameterClause:
+  case \EnumDeclHeaderSyntax.genericParameterClause:
     return "generic parameter clause"
-  case \EnumDeclSyntax.inheritanceClause:
+  case \EnumDeclHeaderSyntax.inheritanceClause:
     return "inheritance clause"
-  case \EnumDeclSyntax.genericWhereClause:
+  case \EnumDeclHeaderSyntax.genericWhereClause:
     return "generic where clause"
-  case \ExtensionDeclSyntax.attributes:
+  case \ExtensionDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ExtensionDeclSyntax.modifiers:
+  case \ExtensionDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ExtensionDeclSyntax.inheritanceClause:
+  case \ExtensionDeclHeaderSyntax.inheritanceClause:
     return "inheritance clause"
-  case \ExtensionDeclSyntax.genericWhereClause:
+  case \ExtensionDeclHeaderSyntax.genericWhereClause:
     return "generic where clause"
   case \ForStmtSyntax.body:
     return "body"
@@ -280,15 +280,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "name"
   case \PrimaryAssociatedTypeSyntax.name:
     return "name"
-  case \ProtocolDeclSyntax.attributes:
+  case \ProtocolDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ProtocolDeclSyntax.modifiers:
+  case \ProtocolDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ProtocolDeclSyntax.primaryAssociatedTypeClause:
+  case \ProtocolDeclHeaderSyntax.primaryAssociatedTypeClause:
     return "primary associated type clause"
-  case \ProtocolDeclSyntax.inheritanceClause:
+  case \ProtocolDeclHeaderSyntax.inheritanceClause:
     return "inheritance clause"
-  case \ProtocolDeclSyntax.genericWhereClause:
+  case \ProtocolDeclHeaderSyntax.genericWhereClause:
     return "generic where clause"
   case \RepeatStmtSyntax.body:
     return "body"
@@ -306,15 +306,15 @@ private func childNameForDiagnostics(_ keyPath: AnyKeyPath) -> String? {
     return "label"
   case \SpecializeTargetFunctionArgumentSyntax.declName:
     return "declaration name"
-  case \StructDeclSyntax.attributes:
+  case \StructDeclHeaderSyntax.attributes:
     return "attributes"
-  case \StructDeclSyntax.modifiers:
+  case \StructDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \StructDeclSyntax.genericParameterClause:
+  case \StructDeclHeaderSyntax.genericParameterClause:
     return "generic parameter clause"
-  case \StructDeclSyntax.inheritanceClause:
+  case \StructDeclHeaderSyntax.inheritanceClause:
     return "inheritance clause"
-  case \StructDeclSyntax.genericWhereClause:
+  case \StructDeclHeaderSyntax.genericWhereClause:
     return "generic where clause"
   case \SubscriptCallExprSyntax.calledExpression:
     return "called expression"
diff --git a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift
index 4006f445c54..1ef0dfe502f 100644
--- a/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift
+++ b/Sources/SwiftParserDiagnostics/generated/SyntaxKindNameForDiagnostics.swift
@@ -23,10 +23,14 @@ extension SyntaxKind {
     switch self {
     case .token:
       return "token"
+    case .abiAttributeArguments:
+      return "ABI-providing declaration"
     case .accessorDecl:
       return "accessor"
     case .accessorEffectSpecifiers:
       return "accessor specifiers"
+    case .actorDeclHeader:
+      return "actor"
     case .actorDecl:
       return "actor"
     case .arrayElement:
@@ -71,6 +75,8 @@ extension SyntaxKind {
       return "'catch' clause"
     case .catchClause:
       return "'catch' clause"
+    case .classDeclHeader:
+      return "class"
     case .classDecl:
       return "class"
     case .closureCaptureClause:
@@ -159,6 +165,8 @@ extension SyntaxKind {
       return "parameter list"
     case .enumCaseParameter:
       return "parameter"
+    case .enumDeclHeader:
+      return "enum"
     case .enumDecl:
       return "enum"
     case .exposeAttributeArguments:
@@ -167,6 +175,8 @@ extension SyntaxKind {
       return "pattern"
     case .expressionStmt:
       return "expression"
+    case .extensionDeclHeader:
+      return "extension"
     case .extensionDecl:
       return "extension"
     case .fallThroughStmt:
@@ -269,6 +279,8 @@ extension SyntaxKind {
       return "member type"
     case .metatypeType:
       return "metatype"
+    case .missingDeclHeader:
+      return "declaration group header"
     case .missingDecl:
       return "declaration"
     case .missingExpr:
@@ -327,6 +339,8 @@ extension SyntaxKind {
       return "operator"
     case .primaryAssociatedTypeClause:
       return "primary associated type clause"
+    case .protocolDeclHeader:
+      return "protocol"
     case .protocolDecl:
       return "protocol"
     case .regexLiteralExpr:
@@ -353,6 +367,8 @@ extension SyntaxKind {
       return "attribute argument"
     case .stringLiteralExpr:
       return "string literal"
+    case .structDeclHeader:
+      return "struct"
     case .structDecl:
       return "struct"
     case .subscriptCallExpr:
diff --git a/Sources/SwiftSyntax/CustomTraits.swift b/Sources/SwiftSyntax/CustomTraits.swift
index f1daddf5722..8cc12cb7583 100644
--- a/Sources/SwiftSyntax/CustomTraits.swift
+++ b/Sources/SwiftSyntax/CustomTraits.swift
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-extension ActorDeclSyntax {
+extension ActorDeclHeaderSyntax {
   public var introducer: TokenSyntax {
     get {
       return actorKeyword
@@ -21,7 +21,35 @@ extension ActorDeclSyntax {
   }
 }
 
-extension ClassDeclSyntax {
+extension ActorDeclSyntax {
+  public var header: DeclGroupHeaderSyntax {
+    get {
+      return DeclGroupHeaderSyntax(actorHeader)
+    }
+    set {
+      actorHeader = newValue.cast(ActorDeclHeaderSyntax.self)
+    }
+  }
+
+  public init?(
+    leadingTrivia: Trivia? = nil,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia? = nil
+  ) {
+    guard let actorHeader = header.as(ActorDeclHeaderSyntax.self) else {
+      return nil
+    }
+    self.init(
+      leadingTrivia: leadingTrivia,
+      actorHeader: actorHeader,
+      memberBlock: memberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension ClassDeclHeaderSyntax {
   public var introducer: TokenSyntax {
     get {
       return classKeyword
@@ -32,7 +60,35 @@ extension ClassDeclSyntax {
   }
 }
 
-extension EnumDeclSyntax {
+extension ClassDeclSyntax {
+  public var header: DeclGroupHeaderSyntax {
+    get {
+      return DeclGroupHeaderSyntax(classHeader)
+    }
+    set {
+      classHeader = newValue.cast(ClassDeclHeaderSyntax.self)
+    }
+  }
+
+  public init?(
+    leadingTrivia: Trivia? = nil,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia? = nil
+  ) {
+    guard let classHeader = header.as(ClassDeclHeaderSyntax.self) else {
+      return nil
+    }
+    self.init(
+      leadingTrivia: leadingTrivia,
+      classHeader: classHeader,
+      memberBlock: memberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension EnumDeclHeaderSyntax {
   public var introducer: TokenSyntax {
     get {
       return enumKeyword
@@ -43,7 +99,35 @@ extension EnumDeclSyntax {
   }
 }
 
-extension ExtensionDeclSyntax {
+extension EnumDeclSyntax {
+  public var header: DeclGroupHeaderSyntax {
+    get {
+      return DeclGroupHeaderSyntax(enumHeader)
+    }
+    set {
+      enumHeader = newValue.cast(EnumDeclHeaderSyntax.self)
+    }
+  }
+
+  public init?(
+    leadingTrivia: Trivia? = nil,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia? = nil
+  ) {
+    guard let enumHeader = header.as(EnumDeclHeaderSyntax.self) else {
+      return nil
+    }
+    self.init(
+      leadingTrivia: leadingTrivia,
+      enumHeader: enumHeader,
+      memberBlock: memberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension ExtensionDeclHeaderSyntax {
   public var introducer: TokenSyntax {
     get {
       return extensionKeyword
@@ -54,7 +138,46 @@ extension ExtensionDeclSyntax {
   }
 }
 
-extension ProtocolDeclSyntax {
+extension ExtensionDeclSyntax {
+  public var header: DeclGroupHeaderSyntax {
+    get {
+      return DeclGroupHeaderSyntax(extensionHeader)
+    }
+    set {
+      extensionHeader = newValue.cast(ExtensionDeclHeaderSyntax.self)
+    }
+  }
+
+  public init?(
+    leadingTrivia: Trivia? = nil,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia? = nil
+  ) {
+    guard let extensionHeader = header.as(ExtensionDeclHeaderSyntax.self) else {
+      return nil
+    }
+    self.init(
+      leadingTrivia: leadingTrivia,
+      extensionHeader: extensionHeader,
+      memberBlock: memberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension MissingDeclHeaderSyntax {
+  public var introducer: TokenSyntax {
+    get {
+      return placeholder
+    }
+    set {
+      placeholder = newValue
+    }
+  }
+}
+
+extension ProtocolDeclHeaderSyntax {
   public var introducer: TokenSyntax {
     get {
       return protocolKeyword
@@ -65,7 +188,35 @@ extension ProtocolDeclSyntax {
   }
 }
 
-extension StructDeclSyntax {
+extension ProtocolDeclSyntax {
+  public var header: DeclGroupHeaderSyntax {
+    get {
+      return DeclGroupHeaderSyntax(protocolHeader)
+    }
+    set {
+      protocolHeader = newValue.cast(ProtocolDeclHeaderSyntax.self)
+    }
+  }
+
+  public init?(
+    leadingTrivia: Trivia? = nil,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia? = nil
+  ) {
+    guard let protocolHeader = header.as(ProtocolDeclHeaderSyntax.self) else {
+      return nil
+    }
+    self.init(
+      leadingTrivia: leadingTrivia,
+      protocolHeader: protocolHeader,
+      memberBlock: memberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension StructDeclHeaderSyntax {
   public var introducer: TokenSyntax {
     get {
       return structKeyword
@@ -76,6 +227,34 @@ extension StructDeclSyntax {
   }
 }
 
+extension StructDeclSyntax {
+  public var header: DeclGroupHeaderSyntax {
+    get {
+      return DeclGroupHeaderSyntax(structHeader)
+    }
+    set {
+      structHeader = newValue.cast(StructDeclHeaderSyntax.self)
+    }
+  }
+
+  public init?(
+    leadingTrivia: Trivia? = nil,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia? = nil
+  ) {
+    guard let structHeader = header.as(StructDeclHeaderSyntax.self) else {
+      return nil
+    }
+    self.init(
+      leadingTrivia: leadingTrivia,
+      structHeader: structHeader,
+      memberBlock: memberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
 //==========================================================================//
 // IMPORTANT: If you are tempted to add an extension here, please insert    //
 // it in alphabetical order above                                           //
diff --git a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md
index 10a71a658da..1904874c547 100644
--- a/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md
+++ b/Sources/SwiftSyntax/Documentation.docc/generated/SwiftSyntax.md
@@ -336,18 +336,23 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/AccessorBlockSyntax>
 - <doc:SwiftSyntax/AccessorEffectSpecifiersSyntax>
 - <doc:SwiftSyntax/AccessorParametersSyntax>
+- <doc:SwiftSyntax/ActorDeclHeaderSyntax>
 - <doc:SwiftSyntax/AvailabilityConditionSyntax>
 - <doc:SwiftSyntax/AvailabilityLabeledArgumentSyntax>
+- <doc:SwiftSyntax/ClassDeclHeaderSyntax>
 - <doc:SwiftSyntax/ClosureCaptureClauseSyntax>
 - <doc:SwiftSyntax/ClosureCaptureSpecifierSyntax>
 - <doc:SwiftSyntax/ClosureParameterClauseSyntax>
 - <doc:SwiftSyntax/ClosureSignatureSyntax>
 - <doc:SwiftSyntax/CodeBlockSyntax>
 - <doc:SwiftSyntax/ConformanceRequirementSyntax>
+- <doc:SwiftSyntax/DeclGroupHeaderSyntax>
 - <doc:SwiftSyntax/DeclModifierDetailSyntax>
 - <doc:SwiftSyntax/DeclNameArgumentsSyntax>
 - <doc:SwiftSyntax/DeinitializerEffectSpecifiersSyntax>
 - <doc:SwiftSyntax/EnumCaseParameterClauseSyntax>
+- <doc:SwiftSyntax/EnumDeclHeaderSyntax>
+- <doc:SwiftSyntax/ExtensionDeclHeaderSyntax>
 - <doc:SwiftSyntax/FunctionEffectSpecifiersSyntax>
 - <doc:SwiftSyntax/FunctionParameterClauseSyntax>
 - <doc:SwiftSyntax/FunctionSignatureSyntax>
@@ -361,15 +366,18 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/LayoutRequirementSyntax>
 - <doc:SwiftSyntax/MatchingPatternConditionSyntax>
 - <doc:SwiftSyntax/MemberBlockSyntax>
+- <doc:SwiftSyntax/MissingDeclHeaderSyntax>
 - <doc:SwiftSyntax/MissingSyntax>
 - <doc:SwiftSyntax/OperatorPrecedenceAndTypesSyntax>
 - <doc:SwiftSyntax/OptionalBindingConditionSyntax>
 - <doc:SwiftSyntax/PlatformVersionSyntax>
 - <doc:SwiftSyntax/PoundSourceLocationArgumentsSyntax>
 - <doc:SwiftSyntax/PrimaryAssociatedTypeClauseSyntax>
+- <doc:SwiftSyntax/ProtocolDeclHeaderSyntax>
 - <doc:SwiftSyntax/ReturnClauseSyntax>
 - <doc:SwiftSyntax/SameTypeRequirementSyntax>
 - <doc:SwiftSyntax/SourceFileSyntax>
+- <doc:SwiftSyntax/StructDeclHeaderSyntax>
 - <doc:SwiftSyntax/SwitchCaseLabelSyntax>
 - <doc:SwiftSyntax/SwitchDefaultLabelSyntax>
 - <doc:SwiftSyntax/ThrowsClauseSyntax>
@@ -387,6 +395,7 @@ allows Swift tools to parse, inspect, generate, and transform Swift source code.
 - <doc:SwiftSyntax/EffectSpecifiersSyntax>
 - <doc:SwiftSyntax/FreestandingMacroExpansionSyntax>
 - <doc:SwiftSyntax/NamedDeclSyntax>
+- <doc:SwiftSyntax/NamedDeclHeaderSyntax>
 - <doc:SwiftSyntax/MissingNodeSyntax>
 - <doc:SwiftSyntax/ParenthesizedSyntax>
 - <doc:SwiftSyntax/WithAttributesSyntax>
diff --git a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
index 31a6ac2cac5..9bf24844c3d 100644
--- a/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
+++ b/Sources/SwiftSyntax/generated/ChildNameForKeyPath.swift
@@ -17,6 +17,12 @@
 @_spi(RawSyntax)
 public func childName(_ keyPath: AnyKeyPath) -> String? {
   switch keyPath {
+  case \ABIAttributeArgumentsSyntax.unexpectedBeforeProvider:
+    return "unexpectedBeforeProvider"
+  case \ABIAttributeArgumentsSyntax.provider:
+    return "provider"
+  case \ABIAttributeArgumentsSyntax.unexpectedAfterProvider:
+    return "unexpectedAfterProvider"
   case \AccessorBlockSyntax.unexpectedBeforeLeftBrace:
     return "unexpectedBeforeLeftBrace"
   case \AccessorBlockSyntax.leftBrace:
@@ -81,36 +87,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "rightParen"
   case \AccessorParametersSyntax.unexpectedAfterRightParen:
     return "unexpectedAfterRightParen"
-  case \ActorDeclSyntax.unexpectedBeforeAttributes:
+  case \ActorDeclHeaderSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
-  case \ActorDeclSyntax.attributes:
+  case \ActorDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ActorDeclSyntax.unexpectedBetweenAttributesAndModifiers:
+  case \ActorDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers:
     return "unexpectedBetweenAttributesAndModifiers"
-  case \ActorDeclSyntax.modifiers:
+  case \ActorDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ActorDeclSyntax.unexpectedBetweenModifiersAndActorKeyword:
+  case \ActorDeclHeaderSyntax.unexpectedBetweenModifiersAndActorKeyword:
     return "unexpectedBetweenModifiersAndActorKeyword"
-  case \ActorDeclSyntax.actorKeyword:
+  case \ActorDeclHeaderSyntax.actorKeyword:
     return "actorKeyword"
-  case \ActorDeclSyntax.unexpectedBetweenActorKeywordAndName:
+  case \ActorDeclHeaderSyntax.unexpectedBetweenActorKeywordAndName:
     return "unexpectedBetweenActorKeywordAndName"
-  case \ActorDeclSyntax.name:
+  case \ActorDeclHeaderSyntax.name:
     return "name"
-  case \ActorDeclSyntax.unexpectedBetweenNameAndGenericParameterClause:
+  case \ActorDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause:
     return "unexpectedBetweenNameAndGenericParameterClause"
-  case \ActorDeclSyntax.genericParameterClause:
+  case \ActorDeclHeaderSyntax.genericParameterClause:
     return "genericParameterClause"
-  case \ActorDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
+  case \ActorDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
     return "unexpectedBetweenGenericParameterClauseAndInheritanceClause"
-  case \ActorDeclSyntax.inheritanceClause:
+  case \ActorDeclHeaderSyntax.inheritanceClause:
     return "inheritanceClause"
-  case \ActorDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
+  case \ActorDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
-  case \ActorDeclSyntax.genericWhereClause:
+  case \ActorDeclHeaderSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ActorDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
-    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ActorDeclHeaderSyntax.unexpectedAfterGenericWhereClause:
+    return "unexpectedAfterGenericWhereClause"
+  case \ActorDeclSyntax.unexpectedBeforeActorHeader:
+    return "unexpectedBeforeActorHeader"
+  case \ActorDeclSyntax.actorHeader:
+    return "actorHeader"
+  case \ActorDeclSyntax.unexpectedBetweenActorHeaderAndMemberBlock:
+    return "unexpectedBetweenActorHeaderAndMemberBlock"
   case \ActorDeclSyntax.memberBlock:
     return "memberBlock"
   case \ActorDeclSyntax.unexpectedAfterMemberBlock:
@@ -419,36 +431,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "trailingComma"
   case \CatchItemSyntax.unexpectedAfterTrailingComma:
     return "unexpectedAfterTrailingComma"
-  case \ClassDeclSyntax.unexpectedBeforeAttributes:
+  case \ClassDeclHeaderSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
-  case \ClassDeclSyntax.attributes:
+  case \ClassDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ClassDeclSyntax.unexpectedBetweenAttributesAndModifiers:
+  case \ClassDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers:
     return "unexpectedBetweenAttributesAndModifiers"
-  case \ClassDeclSyntax.modifiers:
+  case \ClassDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ClassDeclSyntax.unexpectedBetweenModifiersAndClassKeyword:
+  case \ClassDeclHeaderSyntax.unexpectedBetweenModifiersAndClassKeyword:
     return "unexpectedBetweenModifiersAndClassKeyword"
-  case \ClassDeclSyntax.classKeyword:
+  case \ClassDeclHeaderSyntax.classKeyword:
     return "classKeyword"
-  case \ClassDeclSyntax.unexpectedBetweenClassKeywordAndName:
+  case \ClassDeclHeaderSyntax.unexpectedBetweenClassKeywordAndName:
     return "unexpectedBetweenClassKeywordAndName"
-  case \ClassDeclSyntax.name:
+  case \ClassDeclHeaderSyntax.name:
     return "name"
-  case \ClassDeclSyntax.unexpectedBetweenNameAndGenericParameterClause:
+  case \ClassDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause:
     return "unexpectedBetweenNameAndGenericParameterClause"
-  case \ClassDeclSyntax.genericParameterClause:
+  case \ClassDeclHeaderSyntax.genericParameterClause:
     return "genericParameterClause"
-  case \ClassDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
+  case \ClassDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
     return "unexpectedBetweenGenericParameterClauseAndInheritanceClause"
-  case \ClassDeclSyntax.inheritanceClause:
+  case \ClassDeclHeaderSyntax.inheritanceClause:
     return "inheritanceClause"
-  case \ClassDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
+  case \ClassDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
-  case \ClassDeclSyntax.genericWhereClause:
+  case \ClassDeclHeaderSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ClassDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
-    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ClassDeclHeaderSyntax.unexpectedAfterGenericWhereClause:
+    return "unexpectedAfterGenericWhereClause"
+  case \ClassDeclSyntax.unexpectedBeforeClassHeader:
+    return "unexpectedBeforeClassHeader"
+  case \ClassDeclSyntax.classHeader:
+    return "classHeader"
+  case \ClassDeclSyntax.unexpectedBetweenClassHeaderAndMemberBlock:
+    return "unexpectedBetweenClassHeaderAndMemberBlock"
   case \ClassDeclSyntax.memberBlock:
     return "memberBlock"
   case \ClassDeclSyntax.unexpectedAfterMemberBlock:
@@ -1171,36 +1189,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "trailingComma"
   case \EnumCaseParameterSyntax.unexpectedAfterTrailingComma:
     return "unexpectedAfterTrailingComma"
-  case \EnumDeclSyntax.unexpectedBeforeAttributes:
+  case \EnumDeclHeaderSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
-  case \EnumDeclSyntax.attributes:
+  case \EnumDeclHeaderSyntax.attributes:
     return "attributes"
-  case \EnumDeclSyntax.unexpectedBetweenAttributesAndModifiers:
+  case \EnumDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers:
     return "unexpectedBetweenAttributesAndModifiers"
-  case \EnumDeclSyntax.modifiers:
+  case \EnumDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \EnumDeclSyntax.unexpectedBetweenModifiersAndEnumKeyword:
+  case \EnumDeclHeaderSyntax.unexpectedBetweenModifiersAndEnumKeyword:
     return "unexpectedBetweenModifiersAndEnumKeyword"
-  case \EnumDeclSyntax.enumKeyword:
+  case \EnumDeclHeaderSyntax.enumKeyword:
     return "enumKeyword"
-  case \EnumDeclSyntax.unexpectedBetweenEnumKeywordAndName:
+  case \EnumDeclHeaderSyntax.unexpectedBetweenEnumKeywordAndName:
     return "unexpectedBetweenEnumKeywordAndName"
-  case \EnumDeclSyntax.name:
+  case \EnumDeclHeaderSyntax.name:
     return "name"
-  case \EnumDeclSyntax.unexpectedBetweenNameAndGenericParameterClause:
+  case \EnumDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause:
     return "unexpectedBetweenNameAndGenericParameterClause"
-  case \EnumDeclSyntax.genericParameterClause:
+  case \EnumDeclHeaderSyntax.genericParameterClause:
     return "genericParameterClause"
-  case \EnumDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
+  case \EnumDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
     return "unexpectedBetweenGenericParameterClauseAndInheritanceClause"
-  case \EnumDeclSyntax.inheritanceClause:
+  case \EnumDeclHeaderSyntax.inheritanceClause:
     return "inheritanceClause"
-  case \EnumDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
+  case \EnumDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
-  case \EnumDeclSyntax.genericWhereClause:
+  case \EnumDeclHeaderSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \EnumDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
-    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \EnumDeclHeaderSyntax.unexpectedAfterGenericWhereClause:
+    return "unexpectedAfterGenericWhereClause"
+  case \EnumDeclSyntax.unexpectedBeforeEnumHeader:
+    return "unexpectedBeforeEnumHeader"
+  case \EnumDeclSyntax.enumHeader:
+    return "enumHeader"
+  case \EnumDeclSyntax.unexpectedBetweenEnumHeaderAndMemberBlock:
+    return "unexpectedBetweenEnumHeaderAndMemberBlock"
   case \EnumDeclSyntax.memberBlock:
     return "memberBlock"
   case \EnumDeclSyntax.unexpectedAfterMemberBlock:
@@ -1253,32 +1277,38 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "expression"
   case \ExpressionStmtSyntax.unexpectedAfterExpression:
     return "unexpectedAfterExpression"
-  case \ExtensionDeclSyntax.unexpectedBeforeAttributes:
+  case \ExtensionDeclHeaderSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
-  case \ExtensionDeclSyntax.attributes:
+  case \ExtensionDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ExtensionDeclSyntax.unexpectedBetweenAttributesAndModifiers:
+  case \ExtensionDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers:
     return "unexpectedBetweenAttributesAndModifiers"
-  case \ExtensionDeclSyntax.modifiers:
+  case \ExtensionDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ExtensionDeclSyntax.unexpectedBetweenModifiersAndExtensionKeyword:
+  case \ExtensionDeclHeaderSyntax.unexpectedBetweenModifiersAndExtensionKeyword:
     return "unexpectedBetweenModifiersAndExtensionKeyword"
-  case \ExtensionDeclSyntax.extensionKeyword:
+  case \ExtensionDeclHeaderSyntax.extensionKeyword:
     return "extensionKeyword"
-  case \ExtensionDeclSyntax.unexpectedBetweenExtensionKeywordAndExtendedType:
+  case \ExtensionDeclHeaderSyntax.unexpectedBetweenExtensionKeywordAndExtendedType:
     return "unexpectedBetweenExtensionKeywordAndExtendedType"
-  case \ExtensionDeclSyntax.extendedType:
+  case \ExtensionDeclHeaderSyntax.extendedType:
     return "extendedType"
-  case \ExtensionDeclSyntax.unexpectedBetweenExtendedTypeAndInheritanceClause:
+  case \ExtensionDeclHeaderSyntax.unexpectedBetweenExtendedTypeAndInheritanceClause:
     return "unexpectedBetweenExtendedTypeAndInheritanceClause"
-  case \ExtensionDeclSyntax.inheritanceClause:
+  case \ExtensionDeclHeaderSyntax.inheritanceClause:
     return "inheritanceClause"
-  case \ExtensionDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
+  case \ExtensionDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
-  case \ExtensionDeclSyntax.genericWhereClause:
+  case \ExtensionDeclHeaderSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ExtensionDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
-    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ExtensionDeclHeaderSyntax.unexpectedAfterGenericWhereClause:
+    return "unexpectedAfterGenericWhereClause"
+  case \ExtensionDeclSyntax.unexpectedBeforeExtensionHeader:
+    return "unexpectedBeforeExtensionHeader"
+  case \ExtensionDeclSyntax.extensionHeader:
+    return "extensionHeader"
+  case \ExtensionDeclSyntax.unexpectedBetweenExtensionHeaderAndMemberBlock:
+    return "unexpectedBetweenExtensionHeaderAndMemberBlock"
   case \ExtensionDeclSyntax.memberBlock:
     return "memberBlock"
   case \ExtensionDeclSyntax.unexpectedAfterMemberBlock:
@@ -2225,6 +2255,28 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "metatypeSpecifier"
   case \MetatypeTypeSyntax.unexpectedAfterMetatypeSpecifier:
     return "unexpectedAfterMetatypeSpecifier"
+  case \MissingDeclHeaderSyntax.unexpectedBeforeAttributes:
+    return "unexpectedBeforeAttributes"
+  case \MissingDeclHeaderSyntax.attributes:
+    return "attributes"
+  case \MissingDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers:
+    return "unexpectedBetweenAttributesAndModifiers"
+  case \MissingDeclHeaderSyntax.modifiers:
+    return "modifiers"
+  case \MissingDeclHeaderSyntax.unexpectedBetweenModifiersAndPlaceholder:
+    return "unexpectedBetweenModifiersAndPlaceholder"
+  case \MissingDeclHeaderSyntax.placeholder:
+    return "placeholder"
+  case \MissingDeclHeaderSyntax.unexpectedBetweenPlaceholderAndInheritanceClause:
+    return "unexpectedBetweenPlaceholderAndInheritanceClause"
+  case \MissingDeclHeaderSyntax.inheritanceClause:
+    return "inheritanceClause"
+  case \MissingDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
+    return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
+  case \MissingDeclHeaderSyntax.genericWhereClause:
+    return "genericWhereClause"
+  case \MissingDeclHeaderSyntax.unexpectedAfterGenericWhereClause:
+    return "unexpectedAfterGenericWhereClause"
   case \MissingDeclSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
   case \MissingDeclSyntax.attributes:
@@ -2687,36 +2739,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "trailingComma"
   case \PrimaryAssociatedTypeSyntax.unexpectedAfterTrailingComma:
     return "unexpectedAfterTrailingComma"
-  case \ProtocolDeclSyntax.unexpectedBeforeAttributes:
+  case \ProtocolDeclHeaderSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
-  case \ProtocolDeclSyntax.attributes:
+  case \ProtocolDeclHeaderSyntax.attributes:
     return "attributes"
-  case \ProtocolDeclSyntax.unexpectedBetweenAttributesAndModifiers:
+  case \ProtocolDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers:
     return "unexpectedBetweenAttributesAndModifiers"
-  case \ProtocolDeclSyntax.modifiers:
+  case \ProtocolDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \ProtocolDeclSyntax.unexpectedBetweenModifiersAndProtocolKeyword:
+  case \ProtocolDeclHeaderSyntax.unexpectedBetweenModifiersAndProtocolKeyword:
     return "unexpectedBetweenModifiersAndProtocolKeyword"
-  case \ProtocolDeclSyntax.protocolKeyword:
+  case \ProtocolDeclHeaderSyntax.protocolKeyword:
     return "protocolKeyword"
-  case \ProtocolDeclSyntax.unexpectedBetweenProtocolKeywordAndName:
+  case \ProtocolDeclHeaderSyntax.unexpectedBetweenProtocolKeywordAndName:
     return "unexpectedBetweenProtocolKeywordAndName"
-  case \ProtocolDeclSyntax.name:
+  case \ProtocolDeclHeaderSyntax.name:
     return "name"
-  case \ProtocolDeclSyntax.unexpectedBetweenNameAndPrimaryAssociatedTypeClause:
+  case \ProtocolDeclHeaderSyntax.unexpectedBetweenNameAndPrimaryAssociatedTypeClause:
     return "unexpectedBetweenNameAndPrimaryAssociatedTypeClause"
-  case \ProtocolDeclSyntax.primaryAssociatedTypeClause:
+  case \ProtocolDeclHeaderSyntax.primaryAssociatedTypeClause:
     return "primaryAssociatedTypeClause"
-  case \ProtocolDeclSyntax.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause:
+  case \ProtocolDeclHeaderSyntax.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause:
     return "unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause"
-  case \ProtocolDeclSyntax.inheritanceClause:
+  case \ProtocolDeclHeaderSyntax.inheritanceClause:
     return "inheritanceClause"
-  case \ProtocolDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
+  case \ProtocolDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
-  case \ProtocolDeclSyntax.genericWhereClause:
+  case \ProtocolDeclHeaderSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \ProtocolDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
-    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \ProtocolDeclHeaderSyntax.unexpectedAfterGenericWhereClause:
+    return "unexpectedAfterGenericWhereClause"
+  case \ProtocolDeclSyntax.unexpectedBeforeProtocolHeader:
+    return "unexpectedBeforeProtocolHeader"
+  case \ProtocolDeclSyntax.protocolHeader:
+    return "protocolHeader"
+  case \ProtocolDeclSyntax.unexpectedBetweenProtocolHeaderAndMemberBlock:
+    return "unexpectedBetweenProtocolHeaderAndMemberBlock"
   case \ProtocolDeclSyntax.memberBlock:
     return "memberBlock"
   case \ProtocolDeclSyntax.unexpectedAfterMemberBlock:
@@ -2909,36 +2967,42 @@ public func childName(_ keyPath: AnyKeyPath) -> String? {
     return "content"
   case \StringSegmentSyntax.unexpectedAfterContent:
     return "unexpectedAfterContent"
-  case \StructDeclSyntax.unexpectedBeforeAttributes:
+  case \StructDeclHeaderSyntax.unexpectedBeforeAttributes:
     return "unexpectedBeforeAttributes"
-  case \StructDeclSyntax.attributes:
+  case \StructDeclHeaderSyntax.attributes:
     return "attributes"
-  case \StructDeclSyntax.unexpectedBetweenAttributesAndModifiers:
+  case \StructDeclHeaderSyntax.unexpectedBetweenAttributesAndModifiers:
     return "unexpectedBetweenAttributesAndModifiers"
-  case \StructDeclSyntax.modifiers:
+  case \StructDeclHeaderSyntax.modifiers:
     return "modifiers"
-  case \StructDeclSyntax.unexpectedBetweenModifiersAndStructKeyword:
+  case \StructDeclHeaderSyntax.unexpectedBetweenModifiersAndStructKeyword:
     return "unexpectedBetweenModifiersAndStructKeyword"
-  case \StructDeclSyntax.structKeyword:
+  case \StructDeclHeaderSyntax.structKeyword:
     return "structKeyword"
-  case \StructDeclSyntax.unexpectedBetweenStructKeywordAndName:
+  case \StructDeclHeaderSyntax.unexpectedBetweenStructKeywordAndName:
     return "unexpectedBetweenStructKeywordAndName"
-  case \StructDeclSyntax.name:
+  case \StructDeclHeaderSyntax.name:
     return "name"
-  case \StructDeclSyntax.unexpectedBetweenNameAndGenericParameterClause:
+  case \StructDeclHeaderSyntax.unexpectedBetweenNameAndGenericParameterClause:
     return "unexpectedBetweenNameAndGenericParameterClause"
-  case \StructDeclSyntax.genericParameterClause:
+  case \StructDeclHeaderSyntax.genericParameterClause:
     return "genericParameterClause"
-  case \StructDeclSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
+  case \StructDeclHeaderSyntax.unexpectedBetweenGenericParameterClauseAndInheritanceClause:
     return "unexpectedBetweenGenericParameterClauseAndInheritanceClause"
-  case \StructDeclSyntax.inheritanceClause:
+  case \StructDeclHeaderSyntax.inheritanceClause:
     return "inheritanceClause"
-  case \StructDeclSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
+  case \StructDeclHeaderSyntax.unexpectedBetweenInheritanceClauseAndGenericWhereClause:
     return "unexpectedBetweenInheritanceClauseAndGenericWhereClause"
-  case \StructDeclSyntax.genericWhereClause:
+  case \StructDeclHeaderSyntax.genericWhereClause:
     return "genericWhereClause"
-  case \StructDeclSyntax.unexpectedBetweenGenericWhereClauseAndMemberBlock:
-    return "unexpectedBetweenGenericWhereClauseAndMemberBlock"
+  case \StructDeclHeaderSyntax.unexpectedAfterGenericWhereClause:
+    return "unexpectedAfterGenericWhereClause"
+  case \StructDeclSyntax.unexpectedBeforeStructHeader:
+    return "unexpectedBeforeStructHeader"
+  case \StructDeclSyntax.structHeader:
+    return "structHeader"
+  case \StructDeclSyntax.unexpectedBetweenStructHeaderAndMemberBlock:
+    return "unexpectedBetweenStructHeaderAndMemberBlock"
   case \StructDeclSyntax.memberBlock:
     return "memberBlock"
   case \StructDeclSyntax.unexpectedAfterMemberBlock:
diff --git a/Sources/SwiftSyntax/generated/Keyword.swift b/Sources/SwiftSyntax/generated/Keyword.swift
index 2ce15cdf90c..eefd53fe6b0 100644
--- a/Sources/SwiftSyntax/generated/Keyword.swift
+++ b/Sources/SwiftSyntax/generated/Keyword.swift
@@ -71,6 +71,10 @@ public enum Keyword: UInt8, Hashable, Sendable {
   case _underlyingVersion
   case _UnknownLayout
   case _version
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case abi
   case accesses
   case actor
   case addressWithNativeOwner
@@ -271,6 +275,8 @@ public enum Keyword: UInt8, Hashable, Sendable {
       }
     case 3:
       switch text {
+      case "abi":
+        self = .abi
       case "any":
         self = .any
       case "Any":
@@ -871,6 +877,7 @@ public enum Keyword: UInt8, Hashable, Sendable {
     "_underlyingVersion",
     "_UnknownLayout",
     "_version",
+    "abi",
     "accesses",
     "actor",
     "addressWithNativeOwner",
diff --git a/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift b/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift
index fb3cd840904..e4baf12569e 100644
--- a/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift
+++ b/Sources/SwiftSyntax/generated/RenamedChildrenCompatibility.swift
@@ -103,37 +103,235 @@ extension AccessorDeclSyntax {
 }
 
 extension ActorDeclSyntax {
-  @available(*, deprecated, renamed: "unexpectedBetweenActorKeywordAndName")
+  @available(*, deprecated, renamed: "unexpectedBeforeActorHeader")
+  public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBeforeActorHeader
+    }
+    set {
+      unexpectedBeforeActorHeader = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.attributes")
+  public var attributes: AttributeListSyntax {
+    get {
+      return actorHeader.attributes
+    }
+    set {
+      actorHeader.attributes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenAttributesAndModifiers")
+  public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
+    get {
+      return actorHeader.unexpectedBetweenAttributesAndModifiers
+    }
+    set {
+      actorHeader.unexpectedBetweenAttributesAndModifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.modifiers")
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return actorHeader.modifiers
+    }
+    set {
+      actorHeader.modifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenModifiersAndActorKeyword")
+  public var unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? {
+    get {
+      return actorHeader.unexpectedBetweenModifiersAndActorKeyword
+    }
+    set {
+      actorHeader.unexpectedBetweenModifiersAndActorKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.actorKeyword")
+  public var actorKeyword: TokenSyntax {
+    get {
+      return actorHeader.actorKeyword
+    }
+    set {
+      actorHeader.actorKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenActorKeywordAndName")
+  public var unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? {
+    get {
+      return actorHeader.unexpectedBetweenActorKeywordAndName
+    }
+    set {
+      actorHeader.unexpectedBetweenActorKeywordAndName = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.name")
+  public var name: TokenSyntax {
+    get {
+      return actorHeader.name
+    }
+    set {
+      actorHeader.name = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenNameAndGenericParameterClause")
+  public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? {
+    get {
+      return actorHeader.unexpectedBetweenNameAndGenericParameterClause
+    }
+    set {
+      actorHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.genericParameterClause")
+  public var genericParameterClause: GenericParameterClauseSyntax? {
+    get {
+      return actorHeader.genericParameterClause
+    }
+    set {
+      actorHeader.genericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause")
+  public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? {
+    get {
+      return actorHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause
+    }
+    set {
+      actorHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.inheritanceClause")
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return actorHeader.inheritanceClause
+    }
+    set {
+      actorHeader.inheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause")
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? {
+    get {
+      return actorHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause
+    }
+    set {
+      actorHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.genericWhereClause")
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return actorHeader.genericWhereClause
+    }
+    set {
+      actorHeader.genericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenActorHeaderAndMemberBlock")
+  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenActorHeaderAndMemberBlock
+    }
+    set {
+      unexpectedBetweenActorHeaderAndMemberBlock = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenActorKeywordAndName")
   public var unexpectedBetweenActorKeywordAndIdentifier: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenActorKeywordAndName
+      return actorHeader.unexpectedBetweenActorKeywordAndName
     }
     set {
-      unexpectedBetweenActorKeywordAndName = newValue
+      actorHeader.unexpectedBetweenActorKeywordAndName = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "name")
+  @available(*, deprecated, renamed: "actorHeader.name")
   public var identifier: TokenSyntax {
     get {
-      return name
+      return actorHeader.name
     }
     set {
-      name = newValue
+      actorHeader.name = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause")
+  @available(*, deprecated, renamed: "actorHeader.unexpectedBetweenNameAndGenericParameterClause")
   public var unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenNameAndGenericParameterClause
+      return actorHeader.unexpectedBetweenNameAndGenericParameterClause
     }
     set {
-      unexpectedBetweenNameAndGenericParameterClause = newValue
+      actorHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:actorKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)")
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:actorHeader:_:memberBlock:_:trailingTrivia:)")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    _ unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil,
+    actorKeyword: TokenSyntax = .keyword(.actor),
+    _ unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      actorHeader: ActorDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndActorKeyword,
+        actorKeyword: actorKeyword,
+        unexpectedBetweenActorKeywordAndName,
+        name: name,
+        unexpectedBetweenNameAndGenericParameterClause,
+        genericParameterClause: genericParameterClause,
+        unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: memberBlock,
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:actorHeader:_:memberBlock:_:trailingTrivia:)")
   @_disfavoredOverload
   public init(
     leadingTrivia: Trivia? = nil,
@@ -159,19 +357,21 @@ extension ActorDeclSyntax {
     self.init(
       leadingTrivia: leadingTrivia,
       unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndActorKeyword,
-      actorKeyword: actorKeyword,
-      unexpectedBetweenActorKeywordAndIdentifier,
-      name: identifier,
-      unexpectedBetweenIdentifierAndGenericParameterClause,
-      genericParameterClause: genericParameterClause,
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
+      actorHeader: ActorDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndActorKeyword,
+        actorKeyword: actorKeyword,
+        unexpectedBetweenActorKeywordAndIdentifier,
+        name: identifier,
+        unexpectedBetweenIdentifierAndGenericParameterClause,
+        genericParameterClause: genericParameterClause,
+        unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
       unexpectedBetweenGenericWhereClauseAndMemberBlock,
       memberBlock: memberBlock,
       unexpectedAfterMemberBlock,
@@ -1074,37 +1274,235 @@ extension _CanImportVersionInfoSyntax {
 }
 
 extension ClassDeclSyntax {
-  @available(*, deprecated, renamed: "unexpectedBetweenClassKeywordAndName")
+  @available(*, deprecated, renamed: "unexpectedBeforeClassHeader")
+  public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBeforeClassHeader
+    }
+    set {
+      unexpectedBeforeClassHeader = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.attributes")
+  public var attributes: AttributeListSyntax {
+    get {
+      return classHeader.attributes
+    }
+    set {
+      classHeader.attributes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenAttributesAndModifiers")
+  public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
+    get {
+      return classHeader.unexpectedBetweenAttributesAndModifiers
+    }
+    set {
+      classHeader.unexpectedBetweenAttributesAndModifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.modifiers")
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return classHeader.modifiers
+    }
+    set {
+      classHeader.modifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenModifiersAndClassKeyword")
+  public var unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? {
+    get {
+      return classHeader.unexpectedBetweenModifiersAndClassKeyword
+    }
+    set {
+      classHeader.unexpectedBetweenModifiersAndClassKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.classKeyword")
+  public var classKeyword: TokenSyntax {
+    get {
+      return classHeader.classKeyword
+    }
+    set {
+      classHeader.classKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenClassKeywordAndName")
+  public var unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? {
+    get {
+      return classHeader.unexpectedBetweenClassKeywordAndName
+    }
+    set {
+      classHeader.unexpectedBetweenClassKeywordAndName = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.name")
+  public var name: TokenSyntax {
+    get {
+      return classHeader.name
+    }
+    set {
+      classHeader.name = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenNameAndGenericParameterClause")
+  public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? {
+    get {
+      return classHeader.unexpectedBetweenNameAndGenericParameterClause
+    }
+    set {
+      classHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.genericParameterClause")
+  public var genericParameterClause: GenericParameterClauseSyntax? {
+    get {
+      return classHeader.genericParameterClause
+    }
+    set {
+      classHeader.genericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause")
+  public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? {
+    get {
+      return classHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause
+    }
+    set {
+      classHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.inheritanceClause")
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return classHeader.inheritanceClause
+    }
+    set {
+      classHeader.inheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause")
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? {
+    get {
+      return classHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause
+    }
+    set {
+      classHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.genericWhereClause")
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return classHeader.genericWhereClause
+    }
+    set {
+      classHeader.genericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenClassHeaderAndMemberBlock")
+  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenClassHeaderAndMemberBlock
+    }
+    set {
+      unexpectedBetweenClassHeaderAndMemberBlock = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenClassKeywordAndName")
   public var unexpectedBetweenClassKeywordAndIdentifier: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenClassKeywordAndName
+      return classHeader.unexpectedBetweenClassKeywordAndName
     }
     set {
-      unexpectedBetweenClassKeywordAndName = newValue
+      classHeader.unexpectedBetweenClassKeywordAndName = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "name")
+  @available(*, deprecated, renamed: "classHeader.name")
   public var identifier: TokenSyntax {
     get {
-      return name
+      return classHeader.name
     }
     set {
-      name = newValue
+      classHeader.name = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause")
+  @available(*, deprecated, renamed: "classHeader.unexpectedBetweenNameAndGenericParameterClause")
   public var unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenNameAndGenericParameterClause
+      return classHeader.unexpectedBetweenNameAndGenericParameterClause
     }
     set {
-      unexpectedBetweenNameAndGenericParameterClause = newValue
+      classHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:classKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)")
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:classHeader:_:memberBlock:_:trailingTrivia:)")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    _ unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil,
+    classKeyword: TokenSyntax = .keyword(.class),
+    _ unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      classHeader: ClassDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndClassKeyword,
+        classKeyword: classKeyword,
+        unexpectedBetweenClassKeywordAndName,
+        name: name,
+        unexpectedBetweenNameAndGenericParameterClause,
+        genericParameterClause: genericParameterClause,
+        unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: memberBlock,
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:classHeader:_:memberBlock:_:trailingTrivia:)")
   @_disfavoredOverload
   public init(
     leadingTrivia: Trivia? = nil,
@@ -1130,19 +1528,21 @@ extension ClassDeclSyntax {
     self.init(
       leadingTrivia: leadingTrivia,
       unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndClassKeyword,
-      classKeyword: classKeyword,
-      unexpectedBetweenClassKeywordAndIdentifier,
-      name: identifier,
-      unexpectedBetweenIdentifierAndGenericParameterClause,
-      genericParameterClause: genericParameterClause,
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
+      classHeader: ClassDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndClassKeyword,
+        classKeyword: classKeyword,
+        unexpectedBetweenClassKeywordAndIdentifier,
+        name: identifier,
+        unexpectedBetweenIdentifierAndGenericParameterClause,
+        genericParameterClause: genericParameterClause,
+        unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
       unexpectedBetweenGenericWhereClauseAndMemberBlock,
       memberBlock: memberBlock,
       unexpectedAfterMemberBlock,
@@ -2574,57 +2974,255 @@ extension EnumCaseParameterSyntax {
 }
 
 extension EnumDeclSyntax {
-  @available(*, deprecated, renamed: "unexpectedBetweenEnumKeywordAndName")
+  @available(*, deprecated, renamed: "unexpectedBeforeEnumHeader")
+  public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBeforeEnumHeader
+    }
+    set {
+      unexpectedBeforeEnumHeader = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.attributes")
+  public var attributes: AttributeListSyntax {
+    get {
+      return enumHeader.attributes
+    }
+    set {
+      enumHeader.attributes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenAttributesAndModifiers")
+  public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
+    get {
+      return enumHeader.unexpectedBetweenAttributesAndModifiers
+    }
+    set {
+      enumHeader.unexpectedBetweenAttributesAndModifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.modifiers")
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return enumHeader.modifiers
+    }
+    set {
+      enumHeader.modifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenModifiersAndEnumKeyword")
+  public var unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? {
+    get {
+      return enumHeader.unexpectedBetweenModifiersAndEnumKeyword
+    }
+    set {
+      enumHeader.unexpectedBetweenModifiersAndEnumKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.enumKeyword")
+  public var enumKeyword: TokenSyntax {
+    get {
+      return enumHeader.enumKeyword
+    }
+    set {
+      enumHeader.enumKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenEnumKeywordAndName")
+  public var unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? {
+    get {
+      return enumHeader.unexpectedBetweenEnumKeywordAndName
+    }
+    set {
+      enumHeader.unexpectedBetweenEnumKeywordAndName = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.name")
+  public var name: TokenSyntax {
+    get {
+      return enumHeader.name
+    }
+    set {
+      enumHeader.name = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenNameAndGenericParameterClause")
+  public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? {
+    get {
+      return enumHeader.unexpectedBetweenNameAndGenericParameterClause
+    }
+    set {
+      enumHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.genericParameterClause")
+  public var genericParameterClause: GenericParameterClauseSyntax? {
+    get {
+      return enumHeader.genericParameterClause
+    }
+    set {
+      enumHeader.genericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause")
+  public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? {
+    get {
+      return enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause
+    }
+    set {
+      enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.inheritanceClause")
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return enumHeader.inheritanceClause
+    }
+    set {
+      enumHeader.inheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause")
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? {
+    get {
+      return enumHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause
+    }
+    set {
+      enumHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.genericWhereClause")
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return enumHeader.genericWhereClause
+    }
+    set {
+      enumHeader.genericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenEnumHeaderAndMemberBlock")
+  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenEnumHeaderAndMemberBlock
+    }
+    set {
+      unexpectedBetweenEnumHeaderAndMemberBlock = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenEnumKeywordAndName")
   public var unexpectedBetweenEnumKeywordAndIdentifier: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenEnumKeywordAndName
+      return enumHeader.unexpectedBetweenEnumKeywordAndName
     }
     set {
-      unexpectedBetweenEnumKeywordAndName = newValue
+      enumHeader.unexpectedBetweenEnumKeywordAndName = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "name")
+  @available(*, deprecated, renamed: "enumHeader.name")
   public var identifier: TokenSyntax {
     get {
-      return name
+      return enumHeader.name
     }
     set {
-      name = newValue
+      enumHeader.name = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause")
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenNameAndGenericParameterClause")
   public var unexpectedBetweenIdentifierAndGenericParameters: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenNameAndGenericParameterClause
+      return enumHeader.unexpectedBetweenNameAndGenericParameterClause
     }
     set {
-      unexpectedBetweenNameAndGenericParameterClause = newValue
+      enumHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "genericParameterClause")
+  @available(*, deprecated, renamed: "enumHeader.genericParameterClause")
   public var genericParameters: GenericParameterClauseSyntax? {
     get {
-      return genericParameterClause
+      return enumHeader.genericParameterClause
     }
     set {
-      genericParameterClause = newValue
+      enumHeader.genericParameterClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenGenericParameterClauseAndInheritanceClause")
+  @available(*, deprecated, renamed: "enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause")
   public var unexpectedBetweenGenericParametersAndInheritanceClause: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenGenericParameterClauseAndInheritanceClause
+      return enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause
     }
     set {
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue
+      enumHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:enumKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)")
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:enumHeader:_:memberBlock:_:trailingTrivia:)")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    _ unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil,
+    enumKeyword: TokenSyntax = .keyword(.enum),
+    _ unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      enumHeader: EnumDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndEnumKeyword,
+        enumKeyword: enumKeyword,
+        unexpectedBetweenEnumKeywordAndName,
+        name: name,
+        unexpectedBetweenNameAndGenericParameterClause,
+        genericParameterClause: genericParameterClause,
+        unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: memberBlock,
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:enumHeader:_:memberBlock:_:trailingTrivia:)")
   @_disfavoredOverload
   public init(
     leadingTrivia: Trivia? = nil,
@@ -2650,19 +3248,21 @@ extension EnumDeclSyntax {
     self.init(
       leadingTrivia: leadingTrivia,
       unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndEnumKeyword,
-      enumKeyword: enumKeyword,
-      unexpectedBetweenEnumKeywordAndIdentifier,
-      name: identifier,
-      unexpectedBetweenIdentifierAndGenericParameters,
-      genericParameterClause: genericParameters,
-      unexpectedBetweenGenericParametersAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
+      enumHeader: EnumDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndEnumKeyword,
+        enumKeyword: enumKeyword,
+        unexpectedBetweenEnumKeywordAndIdentifier,
+        name: identifier,
+        unexpectedBetweenIdentifierAndGenericParameters,
+        genericParameterClause: genericParameters,
+        unexpectedBetweenGenericParametersAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
       unexpectedBetweenGenericWhereClauseAndMemberBlock,
       memberBlock: memberBlock,
       unexpectedAfterMemberBlock,
@@ -2737,6 +3337,182 @@ extension ExpressionSegmentSyntax {
   }
 }
 
+extension ExtensionDeclSyntax {
+  @available(*, deprecated, renamed: "unexpectedBeforeExtensionHeader")
+  public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBeforeExtensionHeader
+    }
+    set {
+      unexpectedBeforeExtensionHeader = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.attributes")
+  public var attributes: AttributeListSyntax {
+    get {
+      return extensionHeader.attributes
+    }
+    set {
+      extensionHeader.attributes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenAttributesAndModifiers")
+  public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
+    get {
+      return extensionHeader.unexpectedBetweenAttributesAndModifiers
+    }
+    set {
+      extensionHeader.unexpectedBetweenAttributesAndModifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.modifiers")
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return extensionHeader.modifiers
+    }
+    set {
+      extensionHeader.modifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenModifiersAndExtensionKeyword")
+  public var unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? {
+    get {
+      return extensionHeader.unexpectedBetweenModifiersAndExtensionKeyword
+    }
+    set {
+      extensionHeader.unexpectedBetweenModifiersAndExtensionKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.extensionKeyword")
+  public var extensionKeyword: TokenSyntax {
+    get {
+      return extensionHeader.extensionKeyword
+    }
+    set {
+      extensionHeader.extensionKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenExtensionKeywordAndExtendedType")
+  public var unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? {
+    get {
+      return extensionHeader.unexpectedBetweenExtensionKeywordAndExtendedType
+    }
+    set {
+      extensionHeader.unexpectedBetweenExtensionKeywordAndExtendedType = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.extendedType")
+  public var extendedType: TypeSyntax {
+    get {
+      return extensionHeader.extendedType
+    }
+    set {
+      extensionHeader.extendedType = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenExtendedTypeAndInheritanceClause")
+  public var unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? {
+    get {
+      return extensionHeader.unexpectedBetweenExtendedTypeAndInheritanceClause
+    }
+    set {
+      extensionHeader.unexpectedBetweenExtendedTypeAndInheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.inheritanceClause")
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return extensionHeader.inheritanceClause
+    }
+    set {
+      extensionHeader.inheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause")
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? {
+    get {
+      return extensionHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause
+    }
+    set {
+      extensionHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "extensionHeader.genericWhereClause")
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return extensionHeader.genericWhereClause
+    }
+    set {
+      extensionHeader.genericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenExtensionHeaderAndMemberBlock")
+  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenExtensionHeaderAndMemberBlock
+    }
+    set {
+      unexpectedBetweenExtensionHeaderAndMemberBlock = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:extensionHeader:_:memberBlock:_:trailingTrivia:)")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    _ unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil,
+    extensionKeyword: TokenSyntax = .keyword(.extension),
+    _ unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil,
+    extendedType: some TypeSyntaxProtocol,
+    _ unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      extensionHeader: ExtensionDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndExtensionKeyword,
+        extensionKeyword: extensionKeyword,
+        unexpectedBetweenExtensionKeywordAndExtendedType,
+        extendedType: extendedType,
+        unexpectedBetweenExtendedTypeAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: memberBlock,
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
 extension FloatLiteralExprSyntax {
   @available(*, deprecated, renamed: "unexpectedBeforeLiteral")
   public var unexpectedBeforeFloatingDigits: UnexpectedNodesSyntax? {
@@ -6278,125 +7054,323 @@ extension PrimaryAssociatedTypeClauseSyntax {
     }
   }
 
-  @available(*, deprecated, renamed: "leftAngle")
-  public var leftAngleBracket: TokenSyntax {
+  @available(*, deprecated, renamed: "leftAngle")
+  public var leftAngleBracket: TokenSyntax {
+    get {
+      return leftAngle
+    }
+    set {
+      leftAngle = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes")
+  public var unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes
+    }
+    set {
+      unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "primaryAssociatedTypes")
+  public var primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax {
+    get {
+      return primaryAssociatedTypes
+    }
+    set {
+      primaryAssociatedTypes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenPrimaryAssociatedTypesAndRightAngle")
+  public var unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenPrimaryAssociatedTypesAndRightAngle
+    }
+    set {
+      unexpectedBetweenPrimaryAssociatedTypesAndRightAngle = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "rightAngle")
+  public var rightAngleBracket: TokenSyntax {
+    get {
+      return rightAngle
+    }
+    set {
+      rightAngle = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedAfterRightAngle")
+  public var unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedAfterRightAngle
+    }
+    set {
+      unexpectedAfterRightAngle = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:leftAngle:_:primaryAssociatedTypes:_:rightAngle:_:trailingTrivia:)")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil,
+    leftAngleBracket: TokenSyntax = .leftAngleToken(),
+    _ unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? = nil,
+    primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax,
+    _ unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? = nil,
+    rightAngleBracket: TokenSyntax = .rightAngleToken(),
+    _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeLeftAngleBracket,
+      leftAngle: leftAngleBracket,
+      unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList,
+      primaryAssociatedTypes: primaryAssociatedTypeList,
+      unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket,
+      rightAngle: rightAngleBracket,
+      unexpectedAfterRightAngleBracket,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension ProtocolDeclSyntax {
+  @available(*, deprecated, renamed: "unexpectedBeforeProtocolHeader")
+  public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBeforeProtocolHeader
+    }
+    set {
+      unexpectedBeforeProtocolHeader = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.attributes")
+  public var attributes: AttributeListSyntax {
+    get {
+      return protocolHeader.attributes
+    }
+    set {
+      protocolHeader.attributes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenAttributesAndModifiers")
+  public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
+    get {
+      return protocolHeader.unexpectedBetweenAttributesAndModifiers
+    }
+    set {
+      protocolHeader.unexpectedBetweenAttributesAndModifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.modifiers")
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return protocolHeader.modifiers
+    }
+    set {
+      protocolHeader.modifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenModifiersAndProtocolKeyword")
+  public var unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? {
+    get {
+      return protocolHeader.unexpectedBetweenModifiersAndProtocolKeyword
+    }
+    set {
+      protocolHeader.unexpectedBetweenModifiersAndProtocolKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.protocolKeyword")
+  public var protocolKeyword: TokenSyntax {
+    get {
+      return protocolHeader.protocolKeyword
+    }
+    set {
+      protocolHeader.protocolKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenProtocolKeywordAndName")
+  public var unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? {
+    get {
+      return protocolHeader.unexpectedBetweenProtocolKeywordAndName
+    }
+    set {
+      protocolHeader.unexpectedBetweenProtocolKeywordAndName = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.name")
+  public var name: TokenSyntax {
+    get {
+      return protocolHeader.name
+    }
+    set {
+      protocolHeader.name = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause")
+  public var unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? {
+    get {
+      return protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause
+    }
+    set {
+      protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "protocolHeader.primaryAssociatedTypeClause")
+  public var primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? {
     get {
-      return leftAngle
+      return protocolHeader.primaryAssociatedTypeClause
     }
     set {
-      leftAngle = newValue
+      protocolHeader.primaryAssociatedTypeClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes")
-  public var unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? {
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause")
+  public var unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes
+      return protocolHeader.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause
     }
     set {
-      unexpectedBetweenLeftAngleAndPrimaryAssociatedTypes = newValue
+      protocolHeader.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "primaryAssociatedTypes")
-  public var primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax {
+  @available(*, deprecated, renamed: "protocolHeader.inheritanceClause")
+  public var inheritanceClause: InheritanceClauseSyntax? {
     get {
-      return primaryAssociatedTypes
+      return protocolHeader.inheritanceClause
     }
     set {
-      primaryAssociatedTypes = newValue
+      protocolHeader.inheritanceClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenPrimaryAssociatedTypesAndRightAngle")
-  public var unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? {
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause")
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenPrimaryAssociatedTypesAndRightAngle
+      return protocolHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause
     }
     set {
-      unexpectedBetweenPrimaryAssociatedTypesAndRightAngle = newValue
+      protocolHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "rightAngle")
-  public var rightAngleBracket: TokenSyntax {
+  @available(*, deprecated, renamed: "protocolHeader.genericWhereClause")
+  public var genericWhereClause: GenericWhereClauseSyntax? {
     get {
-      return rightAngle
+      return protocolHeader.genericWhereClause
     }
     set {
-      rightAngle = newValue
+      protocolHeader.genericWhereClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedAfterRightAngle")
-  public var unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? {
+  @available(*, deprecated, renamed: "unexpectedBetweenProtocolHeaderAndMemberBlock")
+  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
     get {
-      return unexpectedAfterRightAngle
+      return unexpectedBetweenProtocolHeaderAndMemberBlock
     }
     set {
-      unexpectedAfterRightAngle = newValue
+      unexpectedBetweenProtocolHeaderAndMemberBlock = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "init(leadingTrivia:_:leftAngle:_:primaryAssociatedTypes:_:rightAngle:_:trailingTrivia:)")
-  @_disfavoredOverload
-  public init(
-    leadingTrivia: Trivia? = nil,
-    _ unexpectedBeforeLeftAngleBracket: UnexpectedNodesSyntax? = nil,
-    leftAngleBracket: TokenSyntax = .leftAngleToken(),
-    _ unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList: UnexpectedNodesSyntax? = nil,
-    primaryAssociatedTypeList: PrimaryAssociatedTypeListSyntax,
-    _ unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket: UnexpectedNodesSyntax? = nil,
-    rightAngleBracket: TokenSyntax = .rightAngleToken(),
-    _ unexpectedAfterRightAngleBracket: UnexpectedNodesSyntax? = nil,
-    trailingTrivia: Trivia? = nil
-  ) {
-    self.init(
-      leadingTrivia: leadingTrivia,
-      unexpectedBeforeLeftAngleBracket,
-      leftAngle: leftAngleBracket,
-      unexpectedBetweenLeftAngleBracketAndPrimaryAssociatedTypeList,
-      primaryAssociatedTypes: primaryAssociatedTypeList,
-      unexpectedBetweenPrimaryAssociatedTypeListAndRightAngleBracket,
-      rightAngle: rightAngleBracket,
-      unexpectedAfterRightAngleBracket,
-      trailingTrivia: trailingTrivia
-    )
-  }
-}
-
-extension ProtocolDeclSyntax {
-  @available(*, deprecated, renamed: "unexpectedBetweenProtocolKeywordAndName")
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenProtocolKeywordAndName")
   public var unexpectedBetweenProtocolKeywordAndIdentifier: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenProtocolKeywordAndName
+      return protocolHeader.unexpectedBetweenProtocolKeywordAndName
     }
     set {
-      unexpectedBetweenProtocolKeywordAndName = newValue
+      protocolHeader.unexpectedBetweenProtocolKeywordAndName = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "name")
+  @available(*, deprecated, renamed: "protocolHeader.name")
   public var identifier: TokenSyntax {
     get {
-      return name
+      return protocolHeader.name
     }
     set {
-      name = newValue
+      protocolHeader.name = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenNameAndPrimaryAssociatedTypeClause")
+  @available(*, deprecated, renamed: "protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause")
   public var unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenNameAndPrimaryAssociatedTypeClause
+      return protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause
     }
     set {
-      unexpectedBetweenNameAndPrimaryAssociatedTypeClause = newValue
+      protocolHeader.unexpectedBetweenNameAndPrimaryAssociatedTypeClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:protocolKeyword:_:name:_:primaryAssociatedTypeClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)")
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:protocolHeader:_:memberBlock:_:trailingTrivia:)")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    _ unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil,
+    protocolKeyword: TokenSyntax = .keyword(.protocol),
+    _ unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    _ unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil,
+    primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil,
+    _ unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      protocolHeader: ProtocolDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndProtocolKeyword,
+        protocolKeyword: protocolKeyword,
+        unexpectedBetweenProtocolKeywordAndName,
+        name: name,
+        unexpectedBetweenNameAndPrimaryAssociatedTypeClause,
+        primaryAssociatedTypeClause: primaryAssociatedTypeClause,
+        unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: memberBlock,
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:protocolHeader:_:memberBlock:_:trailingTrivia:)")
   @_disfavoredOverload
   public init(
     leadingTrivia: Trivia? = nil,
@@ -6422,19 +7396,21 @@ extension ProtocolDeclSyntax {
     self.init(
       leadingTrivia: leadingTrivia,
       unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndProtocolKeyword,
-      protocolKeyword: protocolKeyword,
-      unexpectedBetweenProtocolKeywordAndIdentifier,
-      name: identifier,
-      unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause,
-      primaryAssociatedTypeClause: primaryAssociatedTypeClause,
-      unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
+      protocolHeader: ProtocolDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndProtocolKeyword,
+        protocolKeyword: protocolKeyword,
+        unexpectedBetweenProtocolKeywordAndIdentifier,
+        name: identifier,
+        unexpectedBetweenIdentifierAndPrimaryAssociatedTypeClause,
+        primaryAssociatedTypeClause: primaryAssociatedTypeClause,
+        unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
       unexpectedBetweenGenericWhereClauseAndMemberBlock,
       memberBlock: memberBlock,
       unexpectedAfterMemberBlock,
@@ -7139,37 +8115,235 @@ extension StringLiteralExprSyntax {
 }
 
 extension StructDeclSyntax {
-  @available(*, deprecated, renamed: "unexpectedBetweenStructKeywordAndName")
+  @available(*, deprecated, renamed: "unexpectedBeforeStructHeader")
+  public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBeforeStructHeader
+    }
+    set {
+      unexpectedBeforeStructHeader = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.attributes")
+  public var attributes: AttributeListSyntax {
+    get {
+      return structHeader.attributes
+    }
+    set {
+      structHeader.attributes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenAttributesAndModifiers")
+  public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
+    get {
+      return structHeader.unexpectedBetweenAttributesAndModifiers
+    }
+    set {
+      structHeader.unexpectedBetweenAttributesAndModifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.modifiers")
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return structHeader.modifiers
+    }
+    set {
+      structHeader.modifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenModifiersAndStructKeyword")
+  public var unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? {
+    get {
+      return structHeader.unexpectedBetweenModifiersAndStructKeyword
+    }
+    set {
+      structHeader.unexpectedBetweenModifiersAndStructKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.structKeyword")
+  public var structKeyword: TokenSyntax {
+    get {
+      return structHeader.structKeyword
+    }
+    set {
+      structHeader.structKeyword = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenStructKeywordAndName")
+  public var unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? {
+    get {
+      return structHeader.unexpectedBetweenStructKeywordAndName
+    }
+    set {
+      structHeader.unexpectedBetweenStructKeywordAndName = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.name")
+  public var name: TokenSyntax {
+    get {
+      return structHeader.name
+    }
+    set {
+      structHeader.name = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenNameAndGenericParameterClause")
+  public var unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? {
+    get {
+      return structHeader.unexpectedBetweenNameAndGenericParameterClause
+    }
+    set {
+      structHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.genericParameterClause")
+  public var genericParameterClause: GenericParameterClauseSyntax? {
+    get {
+      return structHeader.genericParameterClause
+    }
+    set {
+      structHeader.genericParameterClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause")
+  public var unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? {
+    get {
+      return structHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause
+    }
+    set {
+      structHeader.unexpectedBetweenGenericParameterClauseAndInheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.inheritanceClause")
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return structHeader.inheritanceClause
+    }
+    set {
+      structHeader.inheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause")
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? {
+    get {
+      return structHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause
+    }
+    set {
+      structHeader.unexpectedBetweenInheritanceClauseAndGenericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.genericWhereClause")
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return structHeader.genericWhereClause
+    }
+    set {
+      structHeader.genericWhereClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "unexpectedBetweenStructHeaderAndMemberBlock")
+  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return unexpectedBetweenStructHeaderAndMemberBlock
+    }
+    set {
+      unexpectedBetweenStructHeaderAndMemberBlock = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenStructKeywordAndName")
   public var unexpectedBetweenStructKeywordAndIdentifier: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenStructKeywordAndName
+      return structHeader.unexpectedBetweenStructKeywordAndName
     }
     set {
-      unexpectedBetweenStructKeywordAndName = newValue
+      structHeader.unexpectedBetweenStructKeywordAndName = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "name")
+  @available(*, deprecated, renamed: "structHeader.name")
   public var identifier: TokenSyntax {
     get {
-      return name
+      return structHeader.name
     }
     set {
-      name = newValue
+      structHeader.name = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "unexpectedBetweenNameAndGenericParameterClause")
+  @available(*, deprecated, renamed: "structHeader.unexpectedBetweenNameAndGenericParameterClause")
   public var unexpectedBetweenIdentifierAndGenericParameterClause: UnexpectedNodesSyntax? {
     get {
-      return unexpectedBetweenNameAndGenericParameterClause
+      return structHeader.unexpectedBetweenNameAndGenericParameterClause
     }
     set {
-      unexpectedBetweenNameAndGenericParameterClause = newValue
+      structHeader.unexpectedBetweenNameAndGenericParameterClause = newValue
     }
   }
 
-  @available(*, deprecated, renamed: "init(leadingTrivia:_:attributes:_:modifiers:_:structKeyword:_:name:_:genericParameterClause:_:inheritanceClause:_:genericWhereClause:_:memberBlock:_:trailingTrivia:)")
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:structHeader:_:memberBlock:_:trailingTrivia:)")
+  @_disfavoredOverload
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    _ unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil,
+    structKeyword: TokenSyntax = .keyword(.struct),
+    _ unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    _ unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    _ unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      structHeader: StructDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndStructKeyword,
+        structKeyword: structKeyword,
+        unexpectedBetweenStructKeywordAndName,
+        name: name,
+        unexpectedBetweenNameAndGenericParameterClause,
+        genericParameterClause: genericParameterClause,
+        unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: memberBlock,
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+
+  @available(*, deprecated, renamed: "init(leadingTrivia:_:structHeader:_:memberBlock:_:trailingTrivia:)")
   @_disfavoredOverload
   public init(
     leadingTrivia: Trivia? = nil,
@@ -7195,19 +8369,21 @@ extension StructDeclSyntax {
     self.init(
       leadingTrivia: leadingTrivia,
       unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndStructKeyword,
-      structKeyword: structKeyword,
-      unexpectedBetweenStructKeywordAndIdentifier,
-      name: identifier,
-      unexpectedBetweenIdentifierAndGenericParameterClause,
-      genericParameterClause: genericParameterClause,
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
+      structHeader: StructDeclHeaderSyntax(
+        attributes: attributes,
+        unexpectedBetweenAttributesAndModifiers,
+        modifiers: modifiers,
+        unexpectedBetweenModifiersAndStructKeyword,
+        structKeyword: structKeyword,
+        unexpectedBetweenStructKeywordAndIdentifier,
+        name: identifier,
+        unexpectedBetweenIdentifierAndGenericParameterClause,
+        genericParameterClause: genericParameterClause,
+        unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+        inheritanceClause: inheritanceClause,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+        genericWhereClause: genericWhereClause
+      ),
       unexpectedBetweenGenericWhereClauseAndMemberBlock,
       memberBlock: memberBlock,
       unexpectedAfterMemberBlock,
@@ -8560,6 +9736,58 @@ extension YieldedExpressionsClauseSyntax {
   }
 }
 
+extension DeclGroupSyntax {
+  @available(*, deprecated, renamed: "header.attributes")
+  public var attributes: AttributeListSyntax {
+    get {
+      return header.attributes
+    }
+    set {
+      header.attributes = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "header.modifiers")
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return header.modifiers
+    }
+    set {
+      header.modifiers = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "header.introducer")
+  public var introducer: TokenSyntax {
+    get {
+      return header.introducer
+    }
+    set {
+      header.introducer = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "header.inheritanceClause")
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return header.inheritanceClause
+    }
+    set {
+      header.inheritanceClause = newValue
+    }
+  }
+
+  @available(*, deprecated, renamed: "header.genericWhereClause")
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return header.genericWhereClause
+    }
+    set {
+      header.genericWhereClause = newValue
+    }
+  }
+}
+
 extension FreestandingMacroExpansionSyntax {
   @available(*, deprecated, renamed: "pound")
   public var poundToken: TokenSyntax {
diff --git a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
index 6b4a238d8cf..03b3d1fb137 100644
--- a/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxAnyVisitor.swift
@@ -56,6 +56,20 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  override open func visit(_ node: ABIAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  override open func visitPost(_ node: ABIAttributeArgumentsSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: AccessorBlockSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
@@ -96,6 +110,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: ActorDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: ActorDeclHeaderSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: ActorDeclSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
@@ -320,6 +342,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: ClassDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: ClassDeclHeaderSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: ClassDeclSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
@@ -846,6 +876,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: EnumDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: EnumDeclHeaderSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: EnumDeclSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
@@ -894,6 +932,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: ExtensionDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: ExtensionDeclHeaderSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: ExtensionDeclSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
@@ -1464,6 +1510,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: MissingDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: MissingDeclHeaderSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: MissingDeclSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
@@ -1816,6 +1870,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: ProtocolDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: ProtocolDeclHeaderSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: ProtocolDeclSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
@@ -1960,6 +2022,14 @@ open class SyntaxAnyVisitor: SyntaxVisitor {
     visitAnyPost(node._syntaxNode)
   }
 
+  override open func visit(_ node: StructDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return visitAny(node._syntaxNode)
+  }
+
+  override open func visitPost(_ node: StructDeclHeaderSyntax) {
+    visitAnyPost(node._syntaxNode)
+  }
+
   override open func visit(_ node: StructDeclSyntax) -> SyntaxVisitorContinueKind {
     return visitAny(node._syntaxNode)
   }
diff --git a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
index 4341ca1bc2f..c2a94ff35ae 100644
--- a/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxBaseNodes.swift
@@ -12,6 +12,379 @@
 //
 //===----------------------------------------------------------------------===//
 
+// MARK: - DeclGroupHeaderSyntax
+
+/// Protocol to which all ``DeclGroupHeaderSyntax`` nodes conform.
+///
+/// Extension point to add common methods to all ``DeclGroupHeaderSyntax`` nodes.
+///
+///  - Warning: Do not conform to this protocol yourself.
+public protocol DeclGroupHeaderSyntaxProtocol: SyntaxProtocol {
+ var attributes: AttributeListSyntax {
+    get
+    set
+  }
+
+  /// Modifiers like `public` that are attached to the actor declaration.
+   var modifiers: DeclModifierListSyntax {
+    get
+    set
+  }
+
+  /// The token that introduces this declaration, eg. `class` for a class declaration.
+  ///
+  /// ### Tokens
+  /// 
+  /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds:
+  ///  - `actor`
+  ///  - `class`
+  ///  - `enum`
+  ///  - `extension`
+  ///  - `protocol`
+  ///  - `struct`
+   var introducer: TokenSyntax {
+    get
+    set
+  }
+
+ var inheritanceClause: InheritanceClauseSyntax? {
+    get
+    set
+  }
+
+  /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.
+   var genericWhereClause: GenericWhereClauseSyntax? {
+    get
+    set
+  }
+}
+
+/// Extension of ``DeclGroupHeaderSyntaxProtocol`` to provide casting methods.
+///
+/// These methods enable casting between syntax node types within the same
+/// base node protocol hierarchy (e.g., ``DeclSyntaxProtocol``).
+///
+/// While ``SyntaxProtocol`` offers general casting methods (``SyntaxProtocol.as(_:)``, 
+/// ``SyntaxProtocol.is(_:)``, and ``SyntaxProtocol.cast(_:)``), these often aren't
+/// appropriate for use on types conforming to a specific base node protocol
+/// like ``DeclGroupHeaderSyntaxProtocol``. That's because at this level,
+/// we know that the cast to another base node type (e.g., ``DeclSyntaxProtocol``
+/// when working with ``ExprSyntaxProtocol``) is guaranteed to fail.
+///
+/// To guide developers toward correct usage, this extension provides overloads
+/// of these casting methods that are restricted to the same base node type.
+/// Furthermore, it marks the inherited casting methods from ``SyntaxProtocol`` as 
+/// deprecated, indicating that they will always fail when used in this context.
+extension DeclGroupHeaderSyntaxProtocol {
+  /// Checks if the current syntax node can be cast to a given specialized syntax type.
+  ///
+  /// - Returns: `true` if the node can be cast, `false` otherwise.
+  public func `is`<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
+    return self.as(syntaxType) != nil
+  }
+
+
+  /// Attempts to cast the current syntax node to a given specialized syntax type.
+  ///
+  /// - Returns: An instance of the specialized type, or `nil` if the cast fails.
+  public func `as`<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
+    return S.init(self)
+  }
+
+
+  /// Force-casts the current syntax node to a given specialized syntax type.
+  ///
+  /// - Returns: An instance of the specialized type.
+  ///
+  /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+  public func cast<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> S {
+    return self.as(S.self)!
+  }
+
+
+  /// Checks if the current syntax node can be upcast to its base node type (``DeclGroupHeaderSyntax``).
+  ///
+  /// - Returns: `true` since the node can always be upcast to its base node.
+  @available(*, deprecated, message: "This cast will always succeed")
+  public func `is`(_ syntaxType: DeclGroupHeaderSyntax.Type) -> Bool {
+    return true
+  }
+
+
+  /// Attempts to upcast the current syntax node to its base node type (``DeclGroupHeaderSyntax``).
+  ///
+  /// - Returns: The base node created from the current syntax node, as the node can always be upcast to its base type.
+  @available(*, deprecated, message: "Use `DeclGroupHeaderSyntax.init` for upcasting")
+  public func `as`(_ syntaxType: DeclGroupHeaderSyntax.Type) -> DeclGroupHeaderSyntax? {
+    return DeclGroupHeaderSyntax(self)
+  }
+
+
+  /// Force-upcast the current syntax node to its base node type (``DeclGroupHeaderSyntax``).
+  ///
+  /// - Returns: The base node created from the current syntax node, as the node can always be upcast to its base type.
+  @available(*, deprecated, message: "Use `DeclGroupHeaderSyntax.init` for upcasting")
+  public func cast(_ syntaxType: DeclGroupHeaderSyntax.Type) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(self)
+  }
+
+
+  /// Checks if the current syntax node can be cast to a given node type from a base node protocol hierarchy other
+  /// than ``DeclGroupHeaderSyntaxProtocol``.
+  ///
+  /// - Returns: `true` if the node can be cast, `false` otherwise.
+  ///
+  /// - Note: In most cases, this is comparing a ``DeclGroupHeaderSyntaxProtocol`` to a node that is not a
+  ///   ``DeclGroupHeaderSyntaxProtocol``, which will always fail. If the `syntaxType` argument is a generic type,
+  ///   constrain it to ``DeclGroupHeaderSyntaxProtocol`` instead of ``SyntaxProtocol``.
+  @available(*, deprecated, message: "Type argument should be part of the 'DeclGroupHeaderSyntaxProtocol' hierarchy")
+  public func `is`<S: SyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
+    return self.as(syntaxType) != nil
+  }
+
+
+  /// Attempts to cast the current syntax node to a given node type from the a base node protocol hierarchy other than
+  /// ``DeclGroupHeaderSyntaxProtocol``.
+  ///
+  /// - Returns: An instance of the specialized type, or `nil` if the cast fails.
+  ///
+  /// - Note: In most cases, this is casting a ``DeclGroupHeaderSyntaxProtocol`` to a node that is not a
+  ///   ``DeclGroupHeaderSyntaxProtocol``, which will always fail. If the `syntaxType` argument is a generic type,
+  ///   constrain it to ``DeclGroupHeaderSyntaxProtocol`` instead of ``SyntaxProtocol``.
+  @available(*, deprecated, message: "Type argument should be part of the 'DeclGroupHeaderSyntaxProtocol' hierarchy")
+  public func `as`<S: SyntaxProtocol>(_ syntaxType: S.Type) -> S? {
+    return S.init(self)
+  }
+
+
+  /// Force-casts the current syntax node to a given node type from a base node protocol hierarchy other than
+  /// ``DeclGroupHeaderSyntaxProtocol``.
+  ///
+  /// - Returns: An instance of the specialized type.
+  ///
+  /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+  ///
+  /// - Note: In most cases, this is casting a ``DeclGroupHeaderSyntaxProtocol`` to a node that is not a
+  ///   ``DeclGroupHeaderSyntaxProtocol``, which will always fail. If the `syntaxType` argument is a generic type,
+  ///   constrain it to ``DeclGroupHeaderSyntaxProtocol`` instead of ``SyntaxProtocol``.
+  @available(*, deprecated, message: "Type argument should be part of the 'DeclGroupHeaderSyntaxProtocol' hierarchy")
+  public func cast<S: SyntaxProtocol>(_ syntaxType: S.Type) -> S {
+    return self.as(S.self)!
+  }
+}
+
+extension Syntax {
+  /// Check whether the non-type erased version of this syntax node conforms to
+  /// DeclGroupHeaderSyntaxProtocol.
+  ///
+  ///  - Note:  This will incur an existential conversion.
+  public func isProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> Bool {
+    return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to
+  /// DeclGroupHeaderSyntaxProtocol. Otherwise return nil.
+  ///
+  ///  - Note:  This will incur an existential conversion.
+  public func asProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> DeclGroupHeaderSyntaxProtocol? {
+    return self.asProtocol(SyntaxProtocol.self) as? DeclGroupHeaderSyntaxProtocol
+  }
+}
+
+/// ### Subtypes
+/// 
+/// - ``ActorDeclHeaderSyntax``
+/// - ``ClassDeclHeaderSyntax``
+/// - ``EnumDeclHeaderSyntax``
+/// - ``ExtensionDeclHeaderSyntax``
+/// - ``MissingDeclHeaderSyntax``
+/// - ``ProtocolDeclHeaderSyntax``
+/// - ``StructDeclHeaderSyntax``
+public struct DeclGroupHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable {
+  public let _syntaxNode: Syntax
+
+  /// Create a ``DeclGroupHeaderSyntax`` node from a specialized syntax node.
+  public init(_ syntax: __shared some DeclGroupHeaderSyntaxProtocol) {
+    // We know this cast is going to succeed. Go through init(_: SyntaxData)
+    // to do a sanity check and verify the kind matches in debug builds and get
+    // maximum performance in release builds.
+    self = Syntax(syntax).cast(Self.self)
+  }
+
+  /// Create a ``DeclGroupHeaderSyntax`` node from a specialized optional syntax node.
+  public init?(_ syntax: __shared (some DeclGroupHeaderSyntaxProtocol)?) {
+    guard let syntax = syntax else {
+      return nil
+    }
+    self.init(syntax)
+  }
+
+  public init(fromProtocol syntax: __shared DeclGroupHeaderSyntaxProtocol) {
+    // We know this cast is going to succeed. Go through init(_: SyntaxData)
+    // to do a sanity check and verify the kind matches in debug builds and get
+    // maximum performance in release builds.
+    self = Syntax(syntax).cast(Self.self)
+  }
+
+  /// Create a ``DeclGroupHeaderSyntax`` node from a specialized optional syntax node.
+  public init?(fromProtocol syntax: __shared DeclGroupHeaderSyntaxProtocol?) {
+    guard let syntax = syntax else {
+      return nil
+    }
+    self.init(fromProtocol: syntax)
+  }
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    switch node.raw.kind {
+    case .actorDeclHeader, .classDeclHeader, .enumDeclHeader, .extensionDeclHeader, .missingDeclHeader, .protocolDeclHeader, .structDeclHeader:
+      self._syntaxNode = node._syntaxNode
+    default:
+      return nil
+    }
+  }
+
+  /// Syntax nodes always conform to `DeclGroupHeaderSyntaxProtocol`. This API is just
+  /// added for consistency.
+  ///
+  ///  - Note:  This will incur an existential conversion.
+  @available(*, deprecated, message: "Expression always evaluates to true")
+  public func isProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> Bool {
+    return true
+  }
+
+  /// Return the non-type erased version of this syntax node.
+  ///
+  ///  - Note:  This will incur an existential conversion.
+  public func asProtocol(_: DeclGroupHeaderSyntaxProtocol.Protocol) -> DeclGroupHeaderSyntaxProtocol {
+    return Syntax(self).asProtocol(DeclGroupHeaderSyntaxProtocol.self)!
+  }
+
+  public static var structure: SyntaxNodeStructure {
+    return .choices([
+      .node(ActorDeclHeaderSyntax.self),
+      .node(ClassDeclHeaderSyntax.self),
+      .node(EnumDeclHeaderSyntax.self),
+      .node(ExtensionDeclHeaderSyntax.self),
+      .node(MissingDeclHeaderSyntax.self),
+      .node(ProtocolDeclHeaderSyntax.self),
+      .node(StructDeclHeaderSyntax.self)
+    ])
+  }
+
+  public var attributes: AttributeListSyntax {
+    get {
+      return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).attributes
+    }
+    set(value) {
+      var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self)
+      existentialCopy.attributes = value
+      self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy)
+    }
+  }
+
+  /// Modifiers like `public` that are attached to the actor declaration.
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).modifiers
+    }
+    set(value) {
+      var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self)
+      existentialCopy.modifiers = value
+      self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy)
+    }
+  }
+
+  /// The token that introduces this declaration, eg. `class` for a class declaration.
+  ///
+  /// ### Tokens
+  /// 
+  /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds:
+  ///  - `actor`
+  ///  - `class`
+  ///  - `enum`
+  ///  - `extension`
+  ///  - `protocol`
+  ///  - `struct`
+  public var introducer: TokenSyntax {
+    get {
+      return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).introducer
+    }
+    set(value) {
+      var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self)
+      existentialCopy.introducer = value
+      self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy)
+    }
+  }
+
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).inheritanceClause
+    }
+    set(value) {
+      var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self)
+      existentialCopy.inheritanceClause = value
+      self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy)
+    }
+  }
+
+  /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return self.asProtocol(DeclGroupHeaderSyntaxProtocol.self).genericWhereClause
+    }
+    set(value) {
+      var existentialCopy = self.asProtocol(DeclGroupHeaderSyntaxProtocol.self)
+      existentialCopy.genericWhereClause = value
+      self = DeclGroupHeaderSyntax(fromProtocol: existentialCopy)
+    }
+  }
+}
+
+/// Protocol that syntax nodes conform to if they don't have any semantic subtypes.
+/// These are syntax nodes that are not considered base nodes for other syntax types.
+///
+/// Syntax nodes conforming to this protocol have their inherited casting methods
+/// deprecated to prevent incorrect casting.
+public protocol _LeafDeclGroupHeaderSyntaxNodeProtocol: DeclGroupHeaderSyntaxProtocol {}
+
+extension _LeafDeclGroupHeaderSyntaxNodeProtocol {
+  /// Checks if the current leaf syntax node can be cast to a different specified type.
+  ///
+  /// - Returns: `false` since the leaf node cannot be cast to a different specified type.
+  ///
+  /// - Note: This method overloads the general `is` method and is marked as deprecated to produce a warning,
+  ///         informing the user that the cast will always fail.
+  @available(*, deprecated, message: "This cast will always fail")
+  public func `is`<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> Bool {
+    return false
+  }
+
+
+  /// Attempts to cast the current leaf syntax node to a different specified type.
+  ///
+  /// - Returns: `nil` since the leaf node cannot be cast to a different specified type.
+  ///
+  /// - Note: This method overloads the general `as` method and is marked as deprecated to produce a warning,
+  ///         informing the user that the cast will always fail.
+  @available(*, deprecated, message: "This cast will always fail")
+  public func `as`<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
+    return nil
+  }
+
+
+  /// Force-casts the current leaf syntax node to a different specified type.
+  ///
+  /// - Returns: This method will always trigger a runtime crash and never return.
+  ///
+  /// - Note: This method overloads the general `cast` method and is marked as deprecated to produce a warning,
+  ///         informing the user that the cast will always fail.
+  /// - Warning: Invoking this method will lead to a fatal error.
+  @available(*, deprecated, message: "This cast will always fail")
+  public func cast<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> S {
+    fatalError("\(Self.self) cannot be cast to \(S.self)")
+  }
+}
+
 // MARK: - DeclSyntax
 
 /// Protocol to which all ``DeclSyntax`` nodes conform.
@@ -1517,11 +1890,13 @@ extension Syntax {
   public static var structure: SyntaxNodeStructure {
     return .choices([
       .node(TokenSyntax.self),
+      .node(ABIAttributeArgumentsSyntax.self),
       .node(AccessorBlockSyntax.self),
       .node(AccessorDeclListSyntax.self),
       .node(AccessorDeclSyntax.self),
       .node(AccessorEffectSpecifiersSyntax.self),
       .node(AccessorParametersSyntax.self),
+      .node(ActorDeclHeaderSyntax.self),
       .node(ActorDeclSyntax.self),
       .node(ArrayElementListSyntax.self),
       .node(ArrayElementSyntax.self),
@@ -1550,6 +1925,7 @@ extension Syntax {
       .node(CatchClauseSyntax.self),
       .node(CatchItemListSyntax.self),
       .node(CatchItemSyntax.self),
+      .node(ClassDeclHeaderSyntax.self),
       .node(ClassDeclSyntax.self),
       .node(ClassRestrictionTypeSyntax.self),
       .node(ClosureCaptureClauseSyntax.self),
@@ -1615,12 +1991,14 @@ extension Syntax {
       .node(EnumCaseParameterClauseSyntax.self),
       .node(EnumCaseParameterListSyntax.self),
       .node(EnumCaseParameterSyntax.self),
+      .node(EnumDeclHeaderSyntax.self),
       .node(EnumDeclSyntax.self),
       .node(ExposeAttributeArgumentsSyntax.self),
       .node(ExprListSyntax.self),
       .node(ExpressionPatternSyntax.self),
       .node(ExpressionSegmentSyntax.self),
       .node(ExpressionStmtSyntax.self),
+      .node(ExtensionDeclHeaderSyntax.self),
       .node(ExtensionDeclSyntax.self),
       .node(FallThroughStmtSyntax.self),
       .node(FloatLiteralExprSyntax.self),
@@ -1690,6 +2068,7 @@ extension Syntax {
       .node(MemberBlockSyntax.self),
       .node(MemberTypeSyntax.self),
       .node(MetatypeTypeSyntax.self),
+      .node(MissingDeclHeaderSyntax.self),
       .node(MissingDeclSyntax.self),
       .node(MissingExprSyntax.self),
       .node(MissingPatternSyntax.self),
@@ -1734,6 +2113,7 @@ extension Syntax {
       .node(PrimaryAssociatedTypeClauseSyntax.self),
       .node(PrimaryAssociatedTypeListSyntax.self),
       .node(PrimaryAssociatedTypeSyntax.self),
+      .node(ProtocolDeclHeaderSyntax.self),
       .node(ProtocolDeclSyntax.self),
       .node(RegexLiteralExprSyntax.self),
       .node(RepeatStmtSyntax.self),
@@ -1752,6 +2132,7 @@ extension Syntax {
       .node(StringLiteralExprSyntax.self),
       .node(StringLiteralSegmentListSyntax.self),
       .node(StringSegmentSyntax.self),
+      .node(StructDeclHeaderSyntax.self),
       .node(StructDeclSyntax.self),
       .node(SubscriptCallExprSyntax.self),
       .node(SubscriptDeclSyntax.self),
diff --git a/Sources/SwiftSyntax/generated/SyntaxCollections.swift b/Sources/SwiftSyntax/generated/SyntaxCollections.swift
index 096d0512165..4723f9facae 100644
--- a/Sources/SwiftSyntax/generated/SyntaxCollections.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxCollections.swift
@@ -76,17 +76,18 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
 /// ### Contained in
 /// 
 ///  - ``AccessorDeclSyntax``.``AccessorDeclSyntax/attributes``
-///  - ``ActorDeclSyntax``.``ActorDeclSyntax/attributes``
+///  - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/attributes``
 ///  - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/attributes``
 ///  - ``AttributedTypeSyntax``.``AttributedTypeSyntax/attributes``
-///  - ``ClassDeclSyntax``.``ClassDeclSyntax/attributes``
+///  - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/attributes``
 ///  - ``ClosureParameterSyntax``.``ClosureParameterSyntax/attributes``
 ///  - ``ClosureSignatureSyntax``.``ClosureSignatureSyntax/attributes``
+///  - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/attributes``
 ///  - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/attributes``
 ///  - ``EditorPlaceholderDeclSyntax``.``EditorPlaceholderDeclSyntax/attributes``
 ///  - ``EnumCaseDeclSyntax``.``EnumCaseDeclSyntax/attributes``
-///  - ``EnumDeclSyntax``.``EnumDeclSyntax/attributes``
-///  - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/attributes``
+///  - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/attributes``
+///  - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/attributes``
 ///  - ``FunctionDeclSyntax``.``FunctionDeclSyntax/attributes``
 ///  - ``FunctionParameterSyntax``.``FunctionParameterSyntax/attributes``
 ///  - ``GenericParameterSyntax``.``GenericParameterSyntax/attributes``
@@ -95,10 +96,11 @@ public struct ArrayElementListSyntax: SyntaxCollection, SyntaxHashable {
 ///  - ``InitializerDeclSyntax``.``InitializerDeclSyntax/attributes``
 ///  - ``MacroDeclSyntax``.``MacroDeclSyntax/attributes``
 ///  - ``MacroExpansionDeclSyntax``.``MacroExpansionDeclSyntax/attributes``
+///  - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/attributes``
 ///  - ``MissingDeclSyntax``.``MissingDeclSyntax/attributes``
 ///  - ``PrecedenceGroupDeclSyntax``.``PrecedenceGroupDeclSyntax/attributes``
-///  - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/attributes``
-///  - ``StructDeclSyntax``.``StructDeclSyntax/attributes``
+///  - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/attributes``
+///  - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/attributes``
 ///  - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/attributes``
 ///  - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/attributes``
 ///  - ``VariableDeclSyntax``.``VariableDeclSyntax/attributes``
@@ -422,26 +424,28 @@ public struct ConditionElementListSyntax: SyntaxCollection, SyntaxHashable {
 ///
 /// ### Contained in
 /// 
-///  - ``ActorDeclSyntax``.``ActorDeclSyntax/modifiers``
+///  - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/modifiers``
 ///  - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/modifiers``
-///  - ``ClassDeclSyntax``.``ClassDeclSyntax/modifiers``
+///  - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/modifiers``
 ///  - ``ClosureParameterSyntax``.``ClosureParameterSyntax/modifiers``
+///  - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/modifiers``
 ///  - ``DeinitializerDeclSyntax``.``DeinitializerDeclSyntax/modifiers``
 ///  - ``EditorPlaceholderDeclSyntax``.``EditorPlaceholderDeclSyntax/modifiers``
 ///  - ``EnumCaseDeclSyntax``.``EnumCaseDeclSyntax/modifiers``
 ///  - ``EnumCaseParameterSyntax``.``EnumCaseParameterSyntax/modifiers``
-///  - ``EnumDeclSyntax``.``EnumDeclSyntax/modifiers``
-///  - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/modifiers``
+///  - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/modifiers``
+///  - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/modifiers``
 ///  - ``FunctionDeclSyntax``.``FunctionDeclSyntax/modifiers``
 ///  - ``FunctionParameterSyntax``.``FunctionParameterSyntax/modifiers``
 ///  - ``ImportDeclSyntax``.``ImportDeclSyntax/modifiers``
 ///  - ``InitializerDeclSyntax``.``InitializerDeclSyntax/modifiers``
 ///  - ``MacroDeclSyntax``.``MacroDeclSyntax/modifiers``
 ///  - ``MacroExpansionDeclSyntax``.``MacroExpansionDeclSyntax/modifiers``
+///  - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/modifiers``
 ///  - ``MissingDeclSyntax``.``MissingDeclSyntax/modifiers``
 ///  - ``PrecedenceGroupDeclSyntax``.``PrecedenceGroupDeclSyntax/modifiers``
-///  - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/modifiers``
-///  - ``StructDeclSyntax``.``StructDeclSyntax/modifiers``
+///  - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/modifiers``
+///  - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/modifiers``
 ///  - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/modifiers``
 ///  - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/modifiers``
 ///  - ``VariableDeclSyntax``.``VariableDeclSyntax/modifiers``
diff --git a/Sources/SwiftSyntax/generated/SyntaxEnum.swift b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
index fef31916caa..ed5f7498e78 100644
--- a/Sources/SwiftSyntax/generated/SyntaxEnum.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxEnum.swift
@@ -15,11 +15,16 @@
 /// Enum to exhaustively switch over all different syntax nodes.
 public enum SyntaxEnum: Sendable {
   case token(TokenSyntax)
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case abiAttributeArguments(ABIAttributeArgumentsSyntax)
   case accessorBlock(AccessorBlockSyntax)
   case accessorDeclList(AccessorDeclListSyntax)
   case accessorDecl(AccessorDeclSyntax)
   case accessorEffectSpecifiers(AccessorEffectSpecifiersSyntax)
   case accessorParameters(AccessorParametersSyntax)
+  case actorDeclHeader(ActorDeclHeaderSyntax)
   case actorDecl(ActorDeclSyntax)
   case arrayElementList(ArrayElementListSyntax)
   case arrayElement(ArrayElementSyntax)
@@ -48,6 +53,7 @@ public enum SyntaxEnum: Sendable {
   case catchClause(CatchClauseSyntax)
   case catchItemList(CatchItemListSyntax)
   case catchItem(CatchItemSyntax)
+  case classDeclHeader(ClassDeclHeaderSyntax)
   case classDecl(ClassDeclSyntax)
   case classRestrictionType(ClassRestrictionTypeSyntax)
   case closureCaptureClause(ClosureCaptureClauseSyntax)
@@ -116,12 +122,14 @@ public enum SyntaxEnum: Sendable {
   case enumCaseParameterClause(EnumCaseParameterClauseSyntax)
   case enumCaseParameterList(EnumCaseParameterListSyntax)
   case enumCaseParameter(EnumCaseParameterSyntax)
+  case enumDeclHeader(EnumDeclHeaderSyntax)
   case enumDecl(EnumDeclSyntax)
   case exposeAttributeArguments(ExposeAttributeArgumentsSyntax)
   case exprList(ExprListSyntax)
   case expressionPattern(ExpressionPatternSyntax)
   case expressionSegment(ExpressionSegmentSyntax)
   case expressionStmt(ExpressionStmtSyntax)
+  case extensionDeclHeader(ExtensionDeclHeaderSyntax)
   case extensionDecl(ExtensionDeclSyntax)
   case fallThroughStmt(FallThroughStmtSyntax)
   case floatLiteralExpr(FloatLiteralExprSyntax)
@@ -200,6 +208,7 @@ public enum SyntaxEnum: Sendable {
   case memberBlock(MemberBlockSyntax)
   case memberType(MemberTypeSyntax)
   case metatypeType(MetatypeTypeSyntax)
+  case missingDeclHeader(MissingDeclHeaderSyntax)
   case missingDecl(MissingDeclSyntax)
   case missingExpr(MissingExprSyntax)
   case missingPattern(MissingPatternSyntax)
@@ -244,6 +253,7 @@ public enum SyntaxEnum: Sendable {
   case primaryAssociatedTypeClause(PrimaryAssociatedTypeClauseSyntax)
   case primaryAssociatedTypeList(PrimaryAssociatedTypeListSyntax)
   case primaryAssociatedType(PrimaryAssociatedTypeSyntax)
+  case protocolDeclHeader(ProtocolDeclHeaderSyntax)
   case protocolDecl(ProtocolDeclSyntax)
   case regexLiteralExpr(RegexLiteralExprSyntax)
   case repeatStmt(RepeatStmtSyntax)
@@ -262,6 +272,7 @@ public enum SyntaxEnum: Sendable {
   case stringLiteralExpr(StringLiteralExprSyntax)
   case stringLiteralSegmentList(StringLiteralSegmentListSyntax)
   case stringSegment(StringSegmentSyntax)
+  case structDeclHeader(StructDeclHeaderSyntax)
   case structDecl(StructDeclSyntax)
   case subscriptCallExpr(SubscriptCallExprSyntax)
   case subscriptDecl(SubscriptDeclSyntax)
@@ -321,6 +332,8 @@ extension Syntax {
     switch raw.kind {
     case .token:
       return .token(TokenSyntax(self)!)
+    case .abiAttributeArguments:
+      return .abiAttributeArguments(ABIAttributeArgumentsSyntax(self)!)
     case .accessorBlock:
       return .accessorBlock(AccessorBlockSyntax(self)!)
     case .accessorDeclList:
@@ -331,6 +344,8 @@ extension Syntax {
       return .accessorEffectSpecifiers(AccessorEffectSpecifiersSyntax(self)!)
     case .accessorParameters:
       return .accessorParameters(AccessorParametersSyntax(self)!)
+    case .actorDeclHeader:
+      return .actorDeclHeader(ActorDeclHeaderSyntax(self)!)
     case .actorDecl:
       return .actorDecl(ActorDeclSyntax(self)!)
     case .arrayElementList:
@@ -387,6 +402,8 @@ extension Syntax {
       return .catchItemList(CatchItemListSyntax(self)!)
     case .catchItem:
       return .catchItem(CatchItemSyntax(self)!)
+    case .classDeclHeader:
+      return .classDeclHeader(ClassDeclHeaderSyntax(self)!)
     case .classDecl:
       return .classDecl(ClassDeclSyntax(self)!)
     case .classRestrictionType:
@@ -517,6 +534,8 @@ extension Syntax {
       return .enumCaseParameterList(EnumCaseParameterListSyntax(self)!)
     case .enumCaseParameter:
       return .enumCaseParameter(EnumCaseParameterSyntax(self)!)
+    case .enumDeclHeader:
+      return .enumDeclHeader(EnumDeclHeaderSyntax(self)!)
     case .enumDecl:
       return .enumDecl(EnumDeclSyntax(self)!)
     case .exposeAttributeArguments:
@@ -529,6 +548,8 @@ extension Syntax {
       return .expressionSegment(ExpressionSegmentSyntax(self)!)
     case .expressionStmt:
       return .expressionStmt(ExpressionStmtSyntax(self)!)
+    case .extensionDeclHeader:
+      return .extensionDeclHeader(ExtensionDeclHeaderSyntax(self)!)
     case .extensionDecl:
       return .extensionDecl(ExtensionDeclSyntax(self)!)
     case .fallThroughStmt:
@@ -667,6 +688,8 @@ extension Syntax {
       return .memberType(MemberTypeSyntax(self)!)
     case .metatypeType:
       return .metatypeType(MetatypeTypeSyntax(self)!)
+    case .missingDeclHeader:
+      return .missingDeclHeader(MissingDeclHeaderSyntax(self)!)
     case .missingDecl:
       return .missingDecl(MissingDeclSyntax(self)!)
     case .missingExpr:
@@ -755,6 +778,8 @@ extension Syntax {
       return .primaryAssociatedTypeList(PrimaryAssociatedTypeListSyntax(self)!)
     case .primaryAssociatedType:
       return .primaryAssociatedType(PrimaryAssociatedTypeSyntax(self)!)
+    case .protocolDeclHeader:
+      return .protocolDeclHeader(ProtocolDeclHeaderSyntax(self)!)
     case .protocolDecl:
       return .protocolDecl(ProtocolDeclSyntax(self)!)
     case .regexLiteralExpr:
@@ -791,6 +816,8 @@ extension Syntax {
       return .stringLiteralSegmentList(StringLiteralSegmentListSyntax(self)!)
     case .stringSegment:
       return .stringSegment(StringSegmentSyntax(self)!)
+    case .structDeclHeader:
+      return .structDeclHeader(StructDeclHeaderSyntax(self)!)
     case .structDecl:
       return .structDecl(StructDeclSyntax(self)!)
     case .subscriptCallExpr:
@@ -891,6 +918,41 @@ extension Syntax {
   }
 }
 
+/// Enum to exhaustively switch over all different DeclGroupHeader syntax nodes.
+public enum DeclGroupHeaderSyntaxEnum {
+  case actorDeclHeader(ActorDeclHeaderSyntax)
+  case classDeclHeader(ClassDeclHeaderSyntax)
+  case enumDeclHeader(EnumDeclHeaderSyntax)
+  case extensionDeclHeader(ExtensionDeclHeaderSyntax)
+  case missingDeclHeader(MissingDeclHeaderSyntax)
+  case protocolDeclHeader(ProtocolDeclHeaderSyntax)
+  case structDeclHeader(StructDeclHeaderSyntax)
+}
+
+extension DeclGroupHeaderSyntax {
+  /// Get an enum that can be used to exhaustively switch over all DeclGroupHeader syntax nodes.
+  public func `as`(_: DeclGroupHeaderSyntaxEnum.Type) -> DeclGroupHeaderSyntaxEnum {
+    switch raw.kind {
+    case .actorDeclHeader:
+      return .actorDeclHeader(ActorDeclHeaderSyntax(self)!)
+    case .classDeclHeader:
+      return .classDeclHeader(ClassDeclHeaderSyntax(self)!)
+    case .enumDeclHeader:
+      return .enumDeclHeader(EnumDeclHeaderSyntax(self)!)
+    case .extensionDeclHeader:
+      return .extensionDeclHeader(ExtensionDeclHeaderSyntax(self)!)
+    case .missingDeclHeader:
+      return .missingDeclHeader(MissingDeclHeaderSyntax(self)!)
+    case .protocolDeclHeader:
+      return .protocolDeclHeader(ProtocolDeclHeaderSyntax(self)!)
+    case .structDeclHeader:
+      return .structDeclHeader(StructDeclHeaderSyntax(self)!)
+    default:
+      preconditionFailure("unknown DeclGroupHeader syntax kind")
+    }
+  }
+}
+
 /// Enum to exhaustively switch over all different Decl syntax nodes.
 public enum DeclSyntaxEnum {
   case accessorDecl(AccessorDeclSyntax)
diff --git a/Sources/SwiftSyntax/generated/SyntaxKind.swift b/Sources/SwiftSyntax/generated/SyntaxKind.swift
index e8efa17158f..c054531153c 100644
--- a/Sources/SwiftSyntax/generated/SyntaxKind.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxKind.swift
@@ -15,11 +15,16 @@
 /// Enumerates the known kinds of Syntax represented in the Syntax tree.
 public enum SyntaxKind: Sendable {
   case token
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  case abiAttributeArguments
   case accessorBlock
   case accessorDeclList
   case accessorDecl
   case accessorEffectSpecifiers
   case accessorParameters
+  case actorDeclHeader
   case actorDecl
   case arrayElementList
   case arrayElement
@@ -48,6 +53,7 @@ public enum SyntaxKind: Sendable {
   case catchClause
   case catchItemList
   case catchItem
+  case classDeclHeader
   case classDecl
   case classRestrictionType
   case closureCaptureClause
@@ -116,12 +122,14 @@ public enum SyntaxKind: Sendable {
   case enumCaseParameterClause
   case enumCaseParameterList
   case enumCaseParameter
+  case enumDeclHeader
   case enumDecl
   case exposeAttributeArguments
   case exprList
   case expressionPattern
   case expressionSegment
   case expressionStmt
+  case extensionDeclHeader
   case extensionDecl
   case fallThroughStmt
   case floatLiteralExpr
@@ -200,6 +208,7 @@ public enum SyntaxKind: Sendable {
   case memberBlock
   case memberType
   case metatypeType
+  case missingDeclHeader
   case missingDecl
   case missingExpr
   case missingPattern
@@ -244,6 +253,7 @@ public enum SyntaxKind: Sendable {
   case primaryAssociatedTypeClause
   case primaryAssociatedTypeList
   case primaryAssociatedType
+  case protocolDeclHeader
   case protocolDecl
   case regexLiteralExpr
   case repeatStmt
@@ -262,6 +272,7 @@ public enum SyntaxKind: Sendable {
   case stringLiteralExpr
   case stringLiteralSegmentList
   case stringSegment
+  case structDeclHeader
   case structDecl
   case subscriptCallExpr
   case subscriptDecl
@@ -429,6 +440,8 @@ public enum SyntaxKind: Sendable {
       return true
     case .missingDecl:
       return true
+    case .missingDeclHeader:
+      return true
     case .missingExpr:
       return true
     case .missingPattern:
@@ -446,6 +459,8 @@ public enum SyntaxKind: Sendable {
     switch self {
     case .token:
       return TokenSyntax.self
+    case .abiAttributeArguments:
+      return ABIAttributeArgumentsSyntax.self
     case .accessorBlock:
       return AccessorBlockSyntax.self
     case .accessorDeclList:
@@ -456,6 +471,8 @@ public enum SyntaxKind: Sendable {
       return AccessorEffectSpecifiersSyntax.self
     case .accessorParameters:
       return AccessorParametersSyntax.self
+    case .actorDeclHeader:
+      return ActorDeclHeaderSyntax.self
     case .actorDecl:
       return ActorDeclSyntax.self
     case .arrayElementList:
@@ -512,6 +529,8 @@ public enum SyntaxKind: Sendable {
       return CatchItemListSyntax.self
     case .catchItem:
       return CatchItemSyntax.self
+    case .classDeclHeader:
+      return ClassDeclHeaderSyntax.self
     case .classDecl:
       return ClassDeclSyntax.self
     case .classRestrictionType:
@@ -642,6 +661,8 @@ public enum SyntaxKind: Sendable {
       return EnumCaseParameterListSyntax.self
     case .enumCaseParameter:
       return EnumCaseParameterSyntax.self
+    case .enumDeclHeader:
+      return EnumDeclHeaderSyntax.self
     case .enumDecl:
       return EnumDeclSyntax.self
     case .exposeAttributeArguments:
@@ -654,6 +675,8 @@ public enum SyntaxKind: Sendable {
       return ExpressionSegmentSyntax.self
     case .expressionStmt:
       return ExpressionStmtSyntax.self
+    case .extensionDeclHeader:
+      return ExtensionDeclHeaderSyntax.self
     case .extensionDecl:
       return ExtensionDeclSyntax.self
     case .fallThroughStmt:
@@ -792,6 +815,8 @@ public enum SyntaxKind: Sendable {
       return MemberTypeSyntax.self
     case .metatypeType:
       return MetatypeTypeSyntax.self
+    case .missingDeclHeader:
+      return MissingDeclHeaderSyntax.self
     case .missingDecl:
       return MissingDeclSyntax.self
     case .missingExpr:
@@ -880,6 +905,8 @@ public enum SyntaxKind: Sendable {
       return PrimaryAssociatedTypeListSyntax.self
     case .primaryAssociatedType:
       return PrimaryAssociatedTypeSyntax.self
+    case .protocolDeclHeader:
+      return ProtocolDeclHeaderSyntax.self
     case .protocolDecl:
       return ProtocolDeclSyntax.self
     case .regexLiteralExpr:
@@ -916,6 +943,8 @@ public enum SyntaxKind: Sendable {
       return StringLiteralSegmentListSyntax.self
     case .stringSegment:
       return StringSegmentSyntax.self
+    case .structDeclHeader:
+      return StructDeclHeaderSyntax.self
     case .structDecl:
       return StructDeclSyntax.self
     case .subscriptCallExpr:
diff --git a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
index ade68592503..00a12488406 100644
--- a/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxRewriter.swift
@@ -106,6 +106,16 @@ open class SyntaxRewriter {
     return rewritten.cast(T.self)
   }
 
+  /// Visit a `ABIAttributeArgumentsSyntax`.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visit(_ node: ABIAttributeArgumentsSyntax) -> ABIAttributeArgumentsSyntax {
+    return visitChildren(node._syntaxNode).cast(ABIAttributeArgumentsSyntax.self)
+  }
+
   /// Visit a ``AccessorBlockSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -141,6 +151,13 @@ open class SyntaxRewriter {
     return visitChildren(node._syntaxNode).cast(AccessorParametersSyntax.self)
   }
 
+  /// Visit a ``ActorDeclHeaderSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: ActorDeclHeaderSyntax) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ActorDeclHeaderSyntax.self))
+  }
+
   /// Visit a ``ActorDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -337,6 +354,13 @@ open class SyntaxRewriter {
     return visitChildren(node._syntaxNode).cast(CatchItemSyntax.self)
   }
 
+  /// Visit a ``ClassDeclHeaderSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: ClassDeclHeaderSyntax) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ClassDeclHeaderSyntax.self))
+  }
+
   /// Visit a ``ClassDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -795,6 +819,13 @@ open class SyntaxRewriter {
     return visitChildren(node._syntaxNode).cast(EnumCaseParameterSyntax.self)
   }
 
+  /// Visit a ``EnumDeclHeaderSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: EnumDeclHeaderSyntax) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(EnumDeclHeaderSyntax.self))
+  }
+
   /// Visit a ``EnumDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -837,6 +868,13 @@ open class SyntaxRewriter {
     return StmtSyntax(visitChildren(node._syntaxNode).cast(ExpressionStmtSyntax.self))
   }
 
+  /// Visit a ``ExtensionDeclHeaderSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: ExtensionDeclHeaderSyntax) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ExtensionDeclHeaderSyntax.self))
+  }
+
   /// Visit a ``ExtensionDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -1329,6 +1367,13 @@ open class SyntaxRewriter {
     return TypeSyntax(visitChildren(node._syntaxNode).cast(MetatypeTypeSyntax.self))
   }
 
+  /// Visit a ``MissingDeclHeaderSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: MissingDeclHeaderSyntax) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(MissingDeclHeaderSyntax.self))
+  }
+
   /// Visit a ``MissingDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -1637,6 +1682,13 @@ open class SyntaxRewriter {
     return visitChildren(node._syntaxNode).cast(PrimaryAssociatedTypeSyntax.self)
   }
 
+  /// Visit a ``ProtocolDeclHeaderSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: ProtocolDeclHeaderSyntax) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(ProtocolDeclHeaderSyntax.self))
+  }
+
   /// Visit a ``ProtocolDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -1763,6 +1815,13 @@ open class SyntaxRewriter {
     return visitChildren(node._syntaxNode).cast(StringSegmentSyntax.self)
   }
 
+  /// Visit a ``StructDeclHeaderSyntax``.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  open func visit(_ node: StructDeclHeaderSyntax) -> DeclGroupHeaderSyntax {
+    return DeclGroupHeaderSyntax(visitChildren(node._syntaxNode).cast(StructDeclHeaderSyntax.self))
+  }
+
   /// Visit a ``StructDeclSyntax``.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2102,6 +2161,15 @@ open class SyntaxRewriter {
     return visitChildren(node._syntaxNode).cast(YieldedExpressionsClauseSyntax.self)
   }
 
+  /// Visit any DeclGroupHeaderSyntax node.
+  ///   - Parameter node: the node that is being visited
+  ///   - Returns: the rewritten node
+  public func visit(_ node: DeclGroupHeaderSyntax) -> DeclGroupHeaderSyntax {
+    var node: Syntax = Syntax(node)
+    dispatchVisit(&node)
+    return node.cast(DeclGroupHeaderSyntax.self)
+  }
+
   /// Visit any DeclSyntax node.
   ///   - Parameter node: the node that is being visited
   ///   - Returns: the rewritten node
@@ -2191,6 +2259,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, TokenSyntax.self, self.visit)
       }
+    case .abiAttributeArguments:
+      return {
+        self.visitImpl(&$0, ABIAttributeArgumentsSyntax.self, self.visit)
+      }
     case .accessorBlock:
       return {
         self.visitImpl(&$0, AccessorBlockSyntax.self, self.visit)
@@ -2211,6 +2283,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, AccessorParametersSyntax.self, self.visit)
       }
+    case .actorDeclHeader:
+      return {
+        self.visitImpl(&$0, ActorDeclHeaderSyntax.self, self.visit)
+      }
     case .actorDecl:
       return {
         self.visitImpl(&$0, ActorDeclSyntax.self, self.visit)
@@ -2323,6 +2399,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, CatchItemSyntax.self, self.visit)
       }
+    case .classDeclHeader:
+      return {
+        self.visitImpl(&$0, ClassDeclHeaderSyntax.self, self.visit)
+      }
     case .classDecl:
       return {
         self.visitImpl(&$0, ClassDeclSyntax.self, self.visit)
@@ -2583,6 +2663,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, EnumCaseParameterSyntax.self, self.visit)
       }
+    case .enumDeclHeader:
+      return {
+        self.visitImpl(&$0, EnumDeclHeaderSyntax.self, self.visit)
+      }
     case .enumDecl:
       return {
         self.visitImpl(&$0, EnumDeclSyntax.self, self.visit)
@@ -2607,6 +2691,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, ExpressionStmtSyntax.self, self.visit)
       }
+    case .extensionDeclHeader:
+      return {
+        self.visitImpl(&$0, ExtensionDeclHeaderSyntax.self, self.visit)
+      }
     case .extensionDecl:
       return {
         self.visitImpl(&$0, ExtensionDeclSyntax.self, self.visit)
@@ -2883,6 +2971,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, MetatypeTypeSyntax.self, self.visit)
       }
+    case .missingDeclHeader:
+      return {
+        self.visitImpl(&$0, MissingDeclHeaderSyntax.self, self.visit)
+      }
     case .missingDecl:
       return {
         self.visitImpl(&$0, MissingDeclSyntax.self, self.visit)
@@ -3059,6 +3151,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, PrimaryAssociatedTypeSyntax.self, self.visit)
       }
+    case .protocolDeclHeader:
+      return {
+        self.visitImpl(&$0, ProtocolDeclHeaderSyntax.self, self.visit)
+      }
     case .protocolDecl:
       return {
         self.visitImpl(&$0, ProtocolDeclSyntax.self, self.visit)
@@ -3131,6 +3227,10 @@ open class SyntaxRewriter {
       return {
         self.visitImpl(&$0, StringSegmentSyntax.self, self.visit)
       }
+    case .structDeclHeader:
+      return {
+        self.visitImpl(&$0, StructDeclHeaderSyntax.self, self.visit)
+      }
     case .structDecl:
       return {
         self.visitImpl(&$0, StructDeclSyntax.self, self.visit)
@@ -3333,6 +3433,8 @@ open class SyntaxRewriter {
     switch node.raw.kind {
     case .token:
       return visitImpl(&node, TokenSyntax.self, visit)
+    case .abiAttributeArguments:
+      return visitImpl(&node, ABIAttributeArgumentsSyntax.self, visit)
     case .accessorBlock:
       return visitImpl(&node, AccessorBlockSyntax.self, visit)
     case .accessorDeclList:
@@ -3343,6 +3445,8 @@ open class SyntaxRewriter {
       return visitImpl(&node, AccessorEffectSpecifiersSyntax.self, visit)
     case .accessorParameters:
       return visitImpl(&node, AccessorParametersSyntax.self, visit)
+    case .actorDeclHeader:
+      return visitImpl(&node, ActorDeclHeaderSyntax.self, visit)
     case .actorDecl:
       return visitImpl(&node, ActorDeclSyntax.self, visit)
     case .arrayElementList:
@@ -3399,6 +3503,8 @@ open class SyntaxRewriter {
       return visitImpl(&node, CatchItemListSyntax.self, visit)
     case .catchItem:
       return visitImpl(&node, CatchItemSyntax.self, visit)
+    case .classDeclHeader:
+      return visitImpl(&node, ClassDeclHeaderSyntax.self, visit)
     case .classDecl:
       return visitImpl(&node, ClassDeclSyntax.self, visit)
     case .classRestrictionType:
@@ -3529,6 +3635,8 @@ open class SyntaxRewriter {
       return visitImpl(&node, EnumCaseParameterListSyntax.self, visit)
     case .enumCaseParameter:
       return visitImpl(&node, EnumCaseParameterSyntax.self, visit)
+    case .enumDeclHeader:
+      return visitImpl(&node, EnumDeclHeaderSyntax.self, visit)
     case .enumDecl:
       return visitImpl(&node, EnumDeclSyntax.self, visit)
     case .exposeAttributeArguments:
@@ -3541,6 +3649,8 @@ open class SyntaxRewriter {
       return visitImpl(&node, ExpressionSegmentSyntax.self, visit)
     case .expressionStmt:
       return visitImpl(&node, ExpressionStmtSyntax.self, visit)
+    case .extensionDeclHeader:
+      return visitImpl(&node, ExtensionDeclHeaderSyntax.self, visit)
     case .extensionDecl:
       return visitImpl(&node, ExtensionDeclSyntax.self, visit)
     case .fallThroughStmt:
@@ -3679,6 +3789,8 @@ open class SyntaxRewriter {
       return visitImpl(&node, MemberTypeSyntax.self, visit)
     case .metatypeType:
       return visitImpl(&node, MetatypeTypeSyntax.self, visit)
+    case .missingDeclHeader:
+      return visitImpl(&node, MissingDeclHeaderSyntax.self, visit)
     case .missingDecl:
       return visitImpl(&node, MissingDeclSyntax.self, visit)
     case .missingExpr:
@@ -3767,6 +3879,8 @@ open class SyntaxRewriter {
       return visitImpl(&node, PrimaryAssociatedTypeListSyntax.self, visit)
     case .primaryAssociatedType:
       return visitImpl(&node, PrimaryAssociatedTypeSyntax.self, visit)
+    case .protocolDeclHeader:
+      return visitImpl(&node, ProtocolDeclHeaderSyntax.self, visit)
     case .protocolDecl:
       return visitImpl(&node, ProtocolDeclSyntax.self, visit)
     case .regexLiteralExpr:
@@ -3803,6 +3917,8 @@ open class SyntaxRewriter {
       return visitImpl(&node, StringLiteralSegmentListSyntax.self, visit)
     case .stringSegment:
       return visitImpl(&node, StringSegmentSyntax.self, visit)
+    case .structDeclHeader:
+      return visitImpl(&node, StructDeclHeaderSyntax.self, visit)
     case .structDecl:
       return visitImpl(&node, StructDeclSyntax.self, visit)
     case .subscriptCallExpr:
diff --git a/Sources/SwiftSyntax/generated/SyntaxTraits.swift b/Sources/SwiftSyntax/generated/SyntaxTraits.swift
index 68f8ad515c9..8dc1d2b5541 100644
--- a/Sources/SwiftSyntax/generated/SyntaxTraits.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxTraits.swift
@@ -62,47 +62,28 @@ extension SyntaxProtocol {
 // MARK: - DeclGroupSyntax
 
 public protocol DeclGroupSyntax: SyntaxProtocol, DeclSyntaxProtocol {
-  var attributes: AttributeListSyntax {
-    get
-    set
-  }
-
-  var modifiers: DeclModifierListSyntax {
+  /// The header of the declaration.
+  var header: DeclGroupHeaderSyntax {
     get
     set
   }
 
-  /// The token that introduces this declaration, eg. `class` for a class declaration.
-  ///
-  /// ### Tokens
-  /// 
-  /// For syntax trees generated by the parser, this is guaranteed to be one of the following kinds:
-  ///  - `actor`
-  ///  - `class`
-  ///  - `enum`
-  ///  - `extension`
-  ///  - `protocol`
-  ///  - `struct`
-  var introducer: TokenSyntax {
-    get
-    set
-  }
-
-  var inheritanceClause: InheritanceClauseSyntax? {
+  var memberBlock: MemberBlockSyntax {
     get
     set
   }
 
-  /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.
-  var genericWhereClause: GenericWhereClauseSyntax? {
-    get
-    set
-  }
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - header: The header of the declaration.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
 
-  var memberBlock: MemberBlockSyntax {
-    get
-    set
-  }
+  init?(
+    leadingTrivia: Trivia? ,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia?
+  )
 }
 
 extension DeclGroupSyntax {
@@ -278,7 +259,7 @@ extension SyntaxProtocol {
 
 // MARK: - NamedDeclSyntax
 
-public protocol NamedDeclSyntax: SyntaxProtocol {
+public protocol NamedDeclSyntax: SyntaxProtocol, DeclSyntaxProtocol {
   /// ### Tokens
   /// 
   /// For syntax trees generated by the parser, this is guaranteed to be `<identifier>`.
@@ -315,6 +296,45 @@ extension SyntaxProtocol {
   }
 }
 
+// MARK: - NamedDeclHeaderSyntax
+
+public protocol NamedDeclHeaderSyntax: SyntaxProtocol, DeclGroupHeaderSyntaxProtocol {
+  /// ### Tokens
+  /// 
+  /// For syntax trees generated by the parser, this is guaranteed to be `<identifier>`.
+  var name: TokenSyntax {
+    get
+    set
+  }
+}
+
+extension NamedDeclHeaderSyntax {
+  /// Without this function, the `with` function defined on `SyntaxProtocol`
+  /// does not work on existentials of this protocol type.
+  @_disfavoredOverload
+  public func with<T>(_ keyPath: WritableKeyPath<NamedDeclHeaderSyntax, T>, _ newChild: T) -> NamedDeclHeaderSyntax {
+    var copy: NamedDeclHeaderSyntax = self
+    copy[keyPath: keyPath] = newChild
+    return copy
+  }
+}
+
+extension SyntaxProtocol {
+  /// Check whether the non-type erased version of this syntax node conforms to
+  /// `NamedDeclHeaderSyntax`.
+  /// Note that this will incur an existential conversion.
+  public func isProtocol(_: NamedDeclHeaderSyntax.Protocol) -> Bool {
+    return self.asProtocol(NamedDeclHeaderSyntax.self) != nil
+  }
+
+  /// Return the non-type erased version of this syntax node if it conforms to
+  /// `NamedDeclHeaderSyntax`. Otherwise return `nil`.
+  /// Note that this will incur an existential conversion.
+  public func asProtocol(_: NamedDeclHeaderSyntax.Protocol) -> NamedDeclHeaderSyntax? {
+    return Syntax(self).asProtocol(SyntaxProtocol.self) as? NamedDeclHeaderSyntax
+  }
+}
+
 // MARK: - MissingNodeSyntax
 
 /// Represents a layout node that is missing in the source file.
@@ -679,6 +699,8 @@ extension AccessorEffectSpecifiersSyntax: EffectSpecifiersSyntax {}
 
 extension AccessorParametersSyntax: ParenthesizedSyntax {}
 
+extension ActorDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
+
 extension ActorDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
 
 extension ArrayElementSyntax: WithTrailingCommaSyntax {}
@@ -693,6 +715,8 @@ extension CatchClauseSyntax: WithCodeBlockSyntax {}
 
 extension CatchItemSyntax: WithTrailingCommaSyntax {}
 
+extension ClassDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
+
 extension ClassDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
 
 extension ClosureCaptureSyntax: WithTrailingCommaSyntax {}
@@ -711,6 +735,8 @@ extension CodeBlockSyntax: BracedSyntax, WithStatementsSyntax {}
 
 extension ConditionElementSyntax: WithTrailingCommaSyntax {}
 
+extension DeclGroupHeaderSyntax: WithAttributesSyntax, WithModifiersSyntax {}
+
 extension DeclModifierDetailSyntax: ParenthesizedSyntax {}
 
 extension DeclNameArgumentsSyntax: ParenthesizedSyntax {}
@@ -739,10 +765,14 @@ extension EnumCaseParameterClauseSyntax: ParenthesizedSyntax {}
 
 extension EnumCaseParameterSyntax: WithTrailingCommaSyntax, WithModifiersSyntax {}
 
+extension EnumDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
+
 extension EnumDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
 
 extension ExpressionSegmentSyntax: ParenthesizedSyntax {}
 
+extension ExtensionDeclHeaderSyntax: WithAttributesSyntax, WithModifiersSyntax {}
+
 extension ExtensionDeclSyntax: DeclGroupSyntax, WithAttributesSyntax, WithModifiersSyntax {}
 
 extension ForStmtSyntax: WithCodeBlockSyntax {}
@@ -787,6 +817,8 @@ extension MacroExpansionExprSyntax: FreestandingMacroExpansionSyntax {}
 
 extension MemberBlockSyntax: BracedSyntax {}
 
+extension MissingDeclHeaderSyntax: MissingNodeSyntax, WithAttributesSyntax, WithModifiersSyntax {}
+
 extension MissingDeclSyntax: MissingNodeSyntax, WithAttributesSyntax, WithModifiersSyntax {}
 
 extension MissingExprSyntax: MissingNodeSyntax {}
@@ -813,6 +845,8 @@ extension PrecedenceGroupNameSyntax: WithTrailingCommaSyntax {}
 
 extension PrimaryAssociatedTypeSyntax: WithTrailingCommaSyntax {}
 
+extension ProtocolDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithModifiersSyntax {}
+
 extension ProtocolDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithModifiersSyntax {}
 
 extension RepeatStmtSyntax: WithCodeBlockSyntax {}
@@ -821,6 +855,8 @@ extension SourceFileSyntax: WithStatementsSyntax {}
 
 extension SpecializeTargetFunctionArgumentSyntax: WithTrailingCommaSyntax {}
 
+extension StructDeclHeaderSyntax: NamedDeclHeaderSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
+
 extension StructDeclSyntax: DeclGroupSyntax, NamedDeclSyntax, WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
 
 extension SubscriptDeclSyntax: WithAttributesSyntax, WithGenericParametersSyntax, WithModifiersSyntax {}
diff --git a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
index 67092f4ac60..98d4898ab87 100644
--- a/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
+++ b/Sources/SwiftSyntax/generated/SyntaxVisitor.swift
@@ -38,6 +38,24 @@ open class SyntaxVisitor {
     visit(&syntaxNode)
   }
 
+  /// Visiting `ABIAttributeArgumentsSyntax` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visit(_ node: ABIAttributeArgumentsSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting `ABIAttributeArgumentsSyntax` and its descendants.
+  ///   - node: the node we just finished visiting.
+  #if compiler(>=5.8)
+  @_spi(ExperimentalLanguageFeatures)
+  #endif
+  open func visitPost(_ node: ABIAttributeArgumentsSyntax) {
+  }
+
   /// Visiting ``AccessorBlockSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -98,6 +116,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: AccessorParametersSyntax) {
   }
 
+  /// Visiting ``ActorDeclHeaderSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: ActorDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting ``ActorDeclHeaderSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: ActorDeclHeaderSyntax) {
+  }
+
   /// Visiting ``ActorDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -434,6 +464,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: CatchItemSyntax) {
   }
 
+  /// Visiting ``ClassDeclHeaderSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: ClassDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting ``ClassDeclHeaderSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: ClassDeclHeaderSyntax) {
+  }
+
   /// Visiting ``ClassDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -1220,6 +1262,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: EnumCaseParameterSyntax) {
   }
 
+  /// Visiting ``EnumDeclHeaderSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: EnumDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting ``EnumDeclHeaderSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: EnumDeclHeaderSyntax) {
+  }
+
   /// Visiting ``EnumDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -1292,6 +1346,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: ExpressionStmtSyntax) {
   }
 
+  /// Visiting ``ExtensionDeclHeaderSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: ExtensionDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting ``ExtensionDeclHeaderSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: ExtensionDeclHeaderSyntax) {
+  }
+
   /// Visiting ``ExtensionDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -2138,6 +2204,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: MetatypeTypeSyntax) {
   }
 
+  /// Visiting ``MissingDeclHeaderSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: MissingDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting ``MissingDeclHeaderSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: MissingDeclHeaderSyntax) {
+  }
+
   /// Visiting ``MissingDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -2666,6 +2744,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: PrimaryAssociatedTypeSyntax) {
   }
 
+  /// Visiting ``ProtocolDeclHeaderSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: ProtocolDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting ``ProtocolDeclHeaderSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: ProtocolDeclHeaderSyntax) {
+  }
+
   /// Visiting ``ProtocolDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -2882,6 +2972,18 @@ open class SyntaxVisitor {
   open func visitPost(_ node: StringSegmentSyntax) {
   }
 
+  /// Visiting ``StructDeclHeaderSyntax`` specifically.
+  ///   - Parameter node: the node we are visiting.
+  ///   - Returns: how should we continue visiting.
+  open func visit(_ node: StructDeclHeaderSyntax) -> SyntaxVisitorContinueKind {
+    return .visitChildren
+  }
+
+  /// The function called after visiting ``StructDeclHeaderSyntax`` and its descendants.
+  ///   - node: the node we just finished visiting.
+  open func visitPost(_ node: StructDeclHeaderSyntax) {
+  }
+
   /// Visiting ``StructDeclSyntax`` specifically.
   ///   - Parameter node: the node we are visiting.
   ///   - Returns: how should we continue visiting.
@@ -3535,6 +3637,10 @@ open class SyntaxVisitor {
         // No children to visit.
         self.visitPost(node)
       }
+    case .abiAttributeArguments:
+      return {
+        self.visitImpl(&$0, ABIAttributeArgumentsSyntax.self, self.visit, self.visitPost)
+      }
     case .accessorBlock:
       return {
         self.visitImpl(&$0, AccessorBlockSyntax.self, self.visit, self.visitPost)
@@ -3555,6 +3661,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, AccessorParametersSyntax.self, self.visit, self.visitPost)
       }
+    case .actorDeclHeader:
+      return {
+        self.visitImpl(&$0, ActorDeclHeaderSyntax.self, self.visit, self.visitPost)
+      }
     case .actorDecl:
       return {
         self.visitImpl(&$0, ActorDeclSyntax.self, self.visit, self.visitPost)
@@ -3667,6 +3777,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, CatchItemSyntax.self, self.visit, self.visitPost)
       }
+    case .classDeclHeader:
+      return {
+        self.visitImpl(&$0, ClassDeclHeaderSyntax.self, self.visit, self.visitPost)
+      }
     case .classDecl:
       return {
         self.visitImpl(&$0, ClassDeclSyntax.self, self.visit, self.visitPost)
@@ -3927,6 +4041,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, EnumCaseParameterSyntax.self, self.visit, self.visitPost)
       }
+    case .enumDeclHeader:
+      return {
+        self.visitImpl(&$0, EnumDeclHeaderSyntax.self, self.visit, self.visitPost)
+      }
     case .enumDecl:
       return {
         self.visitImpl(&$0, EnumDeclSyntax.self, self.visit, self.visitPost)
@@ -3951,6 +4069,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, ExpressionStmtSyntax.self, self.visit, self.visitPost)
       }
+    case .extensionDeclHeader:
+      return {
+        self.visitImpl(&$0, ExtensionDeclHeaderSyntax.self, self.visit, self.visitPost)
+      }
     case .extensionDecl:
       return {
         self.visitImpl(&$0, ExtensionDeclSyntax.self, self.visit, self.visitPost)
@@ -4227,6 +4349,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, MetatypeTypeSyntax.self, self.visit, self.visitPost)
       }
+    case .missingDeclHeader:
+      return {
+        self.visitImpl(&$0, MissingDeclHeaderSyntax.self, self.visit, self.visitPost)
+      }
     case .missingDecl:
       return {
         self.visitImpl(&$0, MissingDeclSyntax.self, self.visit, self.visitPost)
@@ -4403,6 +4529,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, PrimaryAssociatedTypeSyntax.self, self.visit, self.visitPost)
       }
+    case .protocolDeclHeader:
+      return {
+        self.visitImpl(&$0, ProtocolDeclHeaderSyntax.self, self.visit, self.visitPost)
+      }
     case .protocolDecl:
       return {
         self.visitImpl(&$0, ProtocolDeclSyntax.self, self.visit, self.visitPost)
@@ -4475,6 +4605,10 @@ open class SyntaxVisitor {
       return {
         self.visitImpl(&$0, StringSegmentSyntax.self, self.visit, self.visitPost)
       }
+    case .structDeclHeader:
+      return {
+        self.visitImpl(&$0, StructDeclHeaderSyntax.self, self.visit, self.visitPost)
+      }
     case .structDecl:
       return {
         self.visitImpl(&$0, StructDeclSyntax.self, self.visit, self.visitPost)
@@ -4681,6 +4815,8 @@ open class SyntaxVisitor {
       _ = visit(node)
       // No children to visit.
       visitPost(node)
+    case .abiAttributeArguments:
+      visitImpl(&node, ABIAttributeArgumentsSyntax.self, visit, visitPost)
     case .accessorBlock:
       visitImpl(&node, AccessorBlockSyntax.self, visit, visitPost)
     case .accessorDeclList:
@@ -4691,6 +4827,8 @@ open class SyntaxVisitor {
       visitImpl(&node, AccessorEffectSpecifiersSyntax.self, visit, visitPost)
     case .accessorParameters:
       visitImpl(&node, AccessorParametersSyntax.self, visit, visitPost)
+    case .actorDeclHeader:
+      visitImpl(&node, ActorDeclHeaderSyntax.self, visit, visitPost)
     case .actorDecl:
       visitImpl(&node, ActorDeclSyntax.self, visit, visitPost)
     case .arrayElementList:
@@ -4747,6 +4885,8 @@ open class SyntaxVisitor {
       visitImpl(&node, CatchItemListSyntax.self, visit, visitPost)
     case .catchItem:
       visitImpl(&node, CatchItemSyntax.self, visit, visitPost)
+    case .classDeclHeader:
+      visitImpl(&node, ClassDeclHeaderSyntax.self, visit, visitPost)
     case .classDecl:
       visitImpl(&node, ClassDeclSyntax.self, visit, visitPost)
     case .classRestrictionType:
@@ -4877,6 +5017,8 @@ open class SyntaxVisitor {
       visitImpl(&node, EnumCaseParameterListSyntax.self, visit, visitPost)
     case .enumCaseParameter:
       visitImpl(&node, EnumCaseParameterSyntax.self, visit, visitPost)
+    case .enumDeclHeader:
+      visitImpl(&node, EnumDeclHeaderSyntax.self, visit, visitPost)
     case .enumDecl:
       visitImpl(&node, EnumDeclSyntax.self, visit, visitPost)
     case .exposeAttributeArguments:
@@ -4889,6 +5031,8 @@ open class SyntaxVisitor {
       visitImpl(&node, ExpressionSegmentSyntax.self, visit, visitPost)
     case .expressionStmt:
       visitImpl(&node, ExpressionStmtSyntax.self, visit, visitPost)
+    case .extensionDeclHeader:
+      visitImpl(&node, ExtensionDeclHeaderSyntax.self, visit, visitPost)
     case .extensionDecl:
       visitImpl(&node, ExtensionDeclSyntax.self, visit, visitPost)
     case .fallThroughStmt:
@@ -5027,6 +5171,8 @@ open class SyntaxVisitor {
       visitImpl(&node, MemberTypeSyntax.self, visit, visitPost)
     case .metatypeType:
       visitImpl(&node, MetatypeTypeSyntax.self, visit, visitPost)
+    case .missingDeclHeader:
+      visitImpl(&node, MissingDeclHeaderSyntax.self, visit, visitPost)
     case .missingDecl:
       visitImpl(&node, MissingDeclSyntax.self, visit, visitPost)
     case .missingExpr:
@@ -5115,6 +5261,8 @@ open class SyntaxVisitor {
       visitImpl(&node, PrimaryAssociatedTypeListSyntax.self, visit, visitPost)
     case .primaryAssociatedType:
       visitImpl(&node, PrimaryAssociatedTypeSyntax.self, visit, visitPost)
+    case .protocolDeclHeader:
+      visitImpl(&node, ProtocolDeclHeaderSyntax.self, visit, visitPost)
     case .protocolDecl:
       visitImpl(&node, ProtocolDeclSyntax.self, visit, visitPost)
     case .regexLiteralExpr:
@@ -5151,6 +5299,8 @@ open class SyntaxVisitor {
       visitImpl(&node, StringLiteralSegmentListSyntax.self, visit, visitPost)
     case .stringSegment:
       visitImpl(&node, StringSegmentSyntax.self, visit, visitPost)
+    case .structDeclHeader:
+      visitImpl(&node, StructDeclHeaderSyntax.self, visit, visitPost)
     case .structDecl:
       visitImpl(&node, StructDeclSyntax.self, visit, visitPost)
     case .subscriptCallExpr:
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift
index 33b11426d6c..cf1c03e5dce 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesAB.swift
@@ -12,6 +12,143 @@
 //
 //===----------------------------------------------------------------------===//
 
+#if compiler(>=5.8)
+@_spi(ExperimentalLanguageFeatures)
+#endif
+@_spi(RawSyntax)
+public struct RawABIAttributeArgumentsSyntax: RawSyntaxNodeProtocol {
+  public enum Provider: RawSyntaxNodeProtocol {
+    case associatedType(RawAssociatedTypeDeclSyntax)
+    case declGroup(RawDeclGroupHeaderSyntax)
+    case deinitializer(RawDeinitializerDeclSyntax)
+    case enumCase(RawEnumCaseDeclSyntax)
+    case function(RawFunctionDeclSyntax)
+    case initializer(RawInitializerDeclSyntax)
+    case `subscript`(RawSubscriptDeclSyntax)
+    case typeAlias(RawTypeAliasDeclSyntax)
+    case variable(RawVariableDeclSyntax)
+    case unsupported(RawDeclSyntax)
+
+    public static func isKindOf(_ raw: RawSyntax) -> Bool {
+      RawAssociatedTypeDeclSyntax.isKindOf(raw) || RawDeclGroupHeaderSyntax.isKindOf(raw) || RawDeinitializerDeclSyntax.isKindOf(raw) || RawEnumCaseDeclSyntax.isKindOf(raw) || RawFunctionDeclSyntax.isKindOf(raw) || RawInitializerDeclSyntax.isKindOf(raw) || RawSubscriptDeclSyntax.isKindOf(raw) || RawTypeAliasDeclSyntax.isKindOf(raw) || RawVariableDeclSyntax.isKindOf(raw) || RawDeclSyntax.isKindOf(raw)
+    }
+
+    public var raw: RawSyntax {
+      switch self {
+      case .associatedType(let node):
+        return node.raw
+      case .declGroup(let node):
+        return node.raw
+      case .deinitializer(let node):
+        return node.raw
+      case .enumCase(let node):
+        return node.raw
+      case .function(let node):
+        return node.raw
+      case .initializer(let node):
+        return node.raw
+      case .subscript(let node):
+        return node.raw
+      case .typeAlias(let node):
+        return node.raw
+      case .variable(let node):
+        return node.raw
+      case .unsupported(let node):
+        return node.raw
+      }
+    }
+
+    public init?(_ node: __shared some RawSyntaxNodeProtocol) {
+      if let node = node.as(RawAssociatedTypeDeclSyntax.self) {
+        self = .associatedType(node)
+      } else if let node = node.as(RawDeclGroupHeaderSyntax.self) {
+        self = .declGroup(node)
+      } else if let node = node.as(RawDeinitializerDeclSyntax.self) {
+        self = .deinitializer(node)
+      } else if let node = node.as(RawEnumCaseDeclSyntax.self) {
+        self = .enumCase(node)
+      } else if let node = node.as(RawFunctionDeclSyntax.self) {
+        self = .function(node)
+      } else if let node = node.as(RawInitializerDeclSyntax.self) {
+        self = .initializer(node)
+      } else if let node = node.as(RawSubscriptDeclSyntax.self) {
+        self = .subscript(node)
+      } else if let node = node.as(RawTypeAliasDeclSyntax.self) {
+        self = .typeAlias(node)
+      } else if let node = node.as(RawVariableDeclSyntax.self) {
+        self = .variable(node)
+      } else if let node = node.as(RawDeclSyntax.self) {
+        self = .unsupported(node)
+      } else {
+        return nil
+      }
+    }
+
+    public init(declGroup: some RawDeclGroupHeaderSyntaxNodeProtocol) {
+      self = .declGroup(RawDeclGroupHeaderSyntax(declGroup))
+    }
+
+    public init(unsupported: some RawDeclSyntaxNodeProtocol) {
+      self = .unsupported(RawDeclSyntax(unsupported))
+    }
+  }
+
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .abiAttributeArguments
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeProvider: RawUnexpectedNodesSyntax? = nil,
+    provider: Provider,
+    _ unexpectedAfterProvider: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .abiAttributeArguments, uninitializedCount: 3, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeProvider?.raw
+      layout[1] = provider.raw
+      layout[2] = unexpectedAfterProvider?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeProvider: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var provider: RawSyntax {
+    layoutView.children[1]!
+  }
+
+  public var unexpectedAfterProvider: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawAccessorBlockSyntax: RawSyntaxNodeProtocol {
   public enum Accessors: RawSyntaxNodeProtocol {
@@ -443,14 +580,14 @@ public struct RawAccessorParametersSyntax: RawSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol {
+public struct RawActorDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .actorDecl
+    return raw.kind == .actorDeclHeader
   }
 
   public var raw: RawSyntax
@@ -486,13 +623,11 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol {
     inheritanceClause: RawInheritanceClauseSyntax?,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
-    memberBlock: RawMemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .actorDecl, uninitializedCount: 17, arena: arena) { layout in
+      kind: .actorDeclHeader, uninitializedCount: 15, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes.raw
@@ -508,9 +643,7 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol {
       layout[11] = inheritanceClause?.raw
       layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw
       layout[13] = genericWhereClause?.raw
-      layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw
-      layout[15] = memberBlock.raw
-      layout[16] = unexpectedAfterMemberBlock?.raw
+      layout[14] = unexpectedAfterGenericWhereClause?.raw
     }
     self.init(unchecked: raw)
   }
@@ -571,16 +704,78 @@ public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol {
     layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
     layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+}
+
+@_spi(RawSyntax)
+public struct RawActorDeclSyntax: RawDeclSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .actorDecl
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeActorHeader: RawUnexpectedNodesSyntax? = nil,
+    actorHeader: RawActorDeclHeaderSyntax,
+    _ unexpectedBetweenActorHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    memberBlock: RawMemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .actorDecl, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeActorHeader?.raw
+      layout[1] = actorHeader.raw
+      layout[2] = unexpectedBetweenActorHeaderAndMemberBlock?.raw
+      layout[3] = memberBlock.raw
+      layout[4] = unexpectedAfterMemberBlock?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeActorHeader: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var actorHeader: RawActorDeclHeaderSyntax {
+    layoutView.children[1].map(RawActorDeclHeaderSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenActorHeaderAndMemberBlock: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 
   public var memberBlock: RawMemberBlockSyntax {
-    layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))!
+    layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))!
   }
 
   public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1322,9 +1517,12 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
     case unavailableFromAsyncArguments(RawUnavailableFromAsyncAttributeArgumentsSyntax)
     case effectsArguments(RawEffectsAttributeArgumentListSyntax)
     case documentationArguments(RawDocumentationAttributeArgumentListSyntax)
+    /// - Note: Requires experimental feature `abiAttribute`.
+    @_spi(ExperimentalLanguageFeatures)
+    case abiArguments(RawABIAttributeArgumentsSyntax)
 
     public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      RawLabeledExprListSyntax.isKindOf(raw) || RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilityArgumentListSyntax.isKindOf(raw) || RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) || RawObjCSelectorPieceListSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) || RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) || RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) || RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) || RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) || RawEffectsAttributeArgumentListSyntax.isKindOf(raw) || RawDocumentationAttributeArgumentListSyntax.isKindOf(raw)
+      RawLabeledExprListSyntax.isKindOf(raw) || RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilityArgumentListSyntax.isKindOf(raw) || RawSpecializeAttributeArgumentListSyntax.isKindOf(raw) || RawObjCSelectorPieceListSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeAttributeArgumentsSyntax.isKindOf(raw) || RawBackDeployedAttributeArgumentsSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInAttributeArgumentsSyntax.isKindOf(raw) || RawUnderscorePrivateAttributeArgumentsSyntax.isKindOf(raw) || RawDynamicReplacementAttributeArgumentsSyntax.isKindOf(raw) || RawUnavailableFromAsyncAttributeArgumentsSyntax.isKindOf(raw) || RawEffectsAttributeArgumentListSyntax.isKindOf(raw) || RawDocumentationAttributeArgumentListSyntax.isKindOf(raw) || RawABIAttributeArgumentsSyntax.isKindOf(raw)
     }
 
     public var raw: RawSyntax {
@@ -1369,6 +1567,8 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
         return node.raw
       case .documentationArguments(let node):
         return node.raw
+      case .abiArguments(let node):
+        return node.raw
       }
     }
 
@@ -1413,6 +1613,8 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
         self = .effectsArguments(node)
       } else if let node = node.as(RawDocumentationAttributeArgumentListSyntax.self) {
         self = .documentationArguments(node)
+      } else if let node = node.as(RawABIAttributeArgumentsSyntax.self) {
+        self = .abiArguments(node)
       } else {
         return nil
       }
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift
index 8e4a50643d6..80e85d82b31 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesC.swift
@@ -477,14 +477,14 @@ public struct RawCatchItemSyntax: RawSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol {
+public struct RawClassDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .classDecl
+    return raw.kind == .classDeclHeader
   }
 
   public var raw: RawSyntax
@@ -520,13 +520,11 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol {
     inheritanceClause: RawInheritanceClauseSyntax?,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
-    memberBlock: RawMemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .classDecl, uninitializedCount: 17, arena: arena) { layout in
+      kind: .classDeclHeader, uninitializedCount: 15, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes.raw
@@ -542,9 +540,7 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol {
       layout[11] = inheritanceClause?.raw
       layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw
       layout[13] = genericWhereClause?.raw
-      layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw
-      layout[15] = memberBlock.raw
-      layout[16] = unexpectedAfterMemberBlock?.raw
+      layout[14] = unexpectedAfterGenericWhereClause?.raw
     }
     self.init(unchecked: raw)
   }
@@ -605,16 +601,78 @@ public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol {
     layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
     layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+}
+
+@_spi(RawSyntax)
+public struct RawClassDeclSyntax: RawDeclSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .classDecl
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeClassHeader: RawUnexpectedNodesSyntax? = nil,
+    classHeader: RawClassDeclHeaderSyntax,
+    _ unexpectedBetweenClassHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    memberBlock: RawMemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .classDecl, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeClassHeader?.raw
+      layout[1] = classHeader.raw
+      layout[2] = unexpectedBetweenClassHeaderAndMemberBlock?.raw
+      layout[3] = memberBlock.raw
+      layout[4] = unexpectedAfterMemberBlock?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeClassHeader: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var classHeader: RawClassDeclHeaderSyntax {
+    layoutView.children[1].map(RawClassDeclHeaderSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenClassHeaderAndMemberBlock: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 
   public var memberBlock: RawMemberBlockSyntax {
-    layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))!
+    layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))!
   }
 
   public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift
index 9f181d4a185..b342367479d 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesD.swift
@@ -12,9 +12,51 @@
 //
 //===----------------------------------------------------------------------===//
 
+@_spi(RawSyntax)
+public protocol RawDeclGroupHeaderSyntaxNodeProtocol: RawSyntaxNodeProtocol {}
+
 @_spi(RawSyntax)
 public protocol RawDeclSyntaxNodeProtocol: RawSyntaxNodeProtocol {}
 
+@_spi(RawSyntax)
+public struct RawDeclGroupHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    switch raw.kind {
+    case .actorDeclHeader, .classDeclHeader, .enumDeclHeader, .extensionDeclHeader, .missingDeclHeader, .protocolDeclHeader, .structDeclHeader:
+      return true
+    default:
+      return false
+    }
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(_ other: some RawDeclGroupHeaderSyntaxNodeProtocol) {
+    self.init(unchecked: other.raw)
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawDeclModifierDetailSyntax: RawSyntaxNodeProtocol {
   @_spi(RawSyntax)
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift
index 376db16d670..f6381bb740f 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesEF.swift
@@ -706,14 +706,14 @@ public struct RawEnumCaseParameterSyntax: RawSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol {
+public struct RawEnumDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .enumDecl
+    return raw.kind == .enumDeclHeader
   }
 
   public var raw: RawSyntax
@@ -749,13 +749,11 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol {
     inheritanceClause: RawInheritanceClauseSyntax?,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
-    memberBlock: RawMemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .enumDecl, uninitializedCount: 17, arena: arena) { layout in
+      kind: .enumDeclHeader, uninitializedCount: 15, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes.raw
@@ -771,9 +769,7 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol {
       layout[11] = inheritanceClause?.raw
       layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw
       layout[13] = genericWhereClause?.raw
-      layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw
-      layout[15] = memberBlock.raw
-      layout[16] = unexpectedAfterMemberBlock?.raw
+      layout[14] = unexpectedAfterGenericWhereClause?.raw
     }
     self.init(unchecked: raw)
   }
@@ -834,16 +830,78 @@ public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol {
     layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
     layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+}
+
+@_spi(RawSyntax)
+public struct RawEnumDeclSyntax: RawDeclSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .enumDecl
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeEnumHeader: RawUnexpectedNodesSyntax? = nil,
+    enumHeader: RawEnumDeclHeaderSyntax,
+    _ unexpectedBetweenEnumHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    memberBlock: RawMemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .enumDecl, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeEnumHeader?.raw
+      layout[1] = enumHeader.raw
+      layout[2] = unexpectedBetweenEnumHeaderAndMemberBlock?.raw
+      layout[3] = memberBlock.raw
+      layout[4] = unexpectedAfterMemberBlock?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeEnumHeader: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var enumHeader: RawEnumDeclHeaderSyntax {
+    layoutView.children[1].map(RawEnumDeclHeaderSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenEnumHeaderAndMemberBlock: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 
   public var memberBlock: RawMemberBlockSyntax {
-    layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))!
+    layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))!
   }
 
   public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
@@ -1241,14 +1299,14 @@ public struct RawExpressionStmtSyntax: RawStmtSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol {
+public struct RawExtensionDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .extensionDecl
+    return raw.kind == .extensionDeclHeader
   }
 
   public var raw: RawSyntax
@@ -1282,13 +1340,11 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol {
     inheritanceClause: RawInheritanceClauseSyntax?,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
-    memberBlock: RawMemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .extensionDecl, uninitializedCount: 15, arena: arena) { layout in
+      kind: .extensionDeclHeader, uninitializedCount: 13, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes.raw
@@ -1302,9 +1358,7 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol {
       layout[9] = inheritanceClause?.raw
       layout[10] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw
       layout[11] = genericWhereClause?.raw
-      layout[12] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw
-      layout[13] = memberBlock.raw
-      layout[14] = unexpectedAfterMemberBlock?.raw
+      layout[12] = unexpectedAfterGenericWhereClause?.raw
     }
     self.init(unchecked: raw)
   }
@@ -1357,16 +1411,78 @@ public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol {
     layoutView.children[11].map(RawGenericWhereClauseSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
     layoutView.children[12].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+}
+
+@_spi(RawSyntax)
+public struct RawExtensionDeclSyntax: RawDeclSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .extensionDecl
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeExtensionHeader: RawUnexpectedNodesSyntax? = nil,
+    extensionHeader: RawExtensionDeclHeaderSyntax,
+    _ unexpectedBetweenExtensionHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    memberBlock: RawMemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .extensionDecl, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeExtensionHeader?.raw
+      layout[1] = extensionHeader.raw
+      layout[2] = unexpectedBetweenExtensionHeaderAndMemberBlock?.raw
+      layout[3] = memberBlock.raw
+      layout[4] = unexpectedAfterMemberBlock?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeExtensionHeader: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var extensionHeader: RawExtensionDeclHeaderSyntax {
+    layoutView.children[1].map(RawExtensionDeclHeaderSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenExtensionHeaderAndMemberBlock: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 
   public var memberBlock: RawMemberBlockSyntax {
-    layoutView.children[13].map(RawMemberBlockSyntax.init(raw:))!
+    layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))!
   }
 
   public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? {
-    layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
index ea8497a3da5..2e5f92bfb14 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesJKLMN.swift
@@ -2158,6 +2158,112 @@ public struct RawMetatypeTypeSyntax: RawTypeSyntaxNodeProtocol {
   }
 }
 
+@_spi(RawSyntax)
+public struct RawMissingDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .missingDeclHeader
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? = nil,
+    attributes: RawAttributeListSyntax,
+    _ unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? = nil,
+    modifiers: RawDeclModifierListSyntax,
+    _ unexpectedBetweenModifiersAndPlaceholder: RawUnexpectedNodesSyntax? = nil,
+    placeholder: RawTokenSyntax,
+    _ unexpectedBetweenPlaceholderAndInheritanceClause: RawUnexpectedNodesSyntax? = nil,
+    inheritanceClause: RawInheritanceClauseSyntax?,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
+    genericWhereClause: RawGenericWhereClauseSyntax?,
+    _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .missingDeclHeader, uninitializedCount: 11, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeAttributes?.raw
+      layout[1] = attributes.raw
+      layout[2] = unexpectedBetweenAttributesAndModifiers?.raw
+      layout[3] = modifiers.raw
+      layout[4] = unexpectedBetweenModifiersAndPlaceholder?.raw
+      layout[5] = placeholder.raw
+      layout[6] = unexpectedBetweenPlaceholderAndInheritanceClause?.raw
+      layout[7] = inheritanceClause?.raw
+      layout[8] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw
+      layout[9] = genericWhereClause?.raw
+      layout[10] = unexpectedAfterGenericWhereClause?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeAttributes: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var attributes: RawAttributeListSyntax {
+    layoutView.children[1].map(RawAttributeListSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenAttributesAndModifiers: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var modifiers: RawDeclModifierListSyntax {
+    layoutView.children[3].map(RawDeclModifierListSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenModifiersAndPlaceholder: RawUnexpectedNodesSyntax? {
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var placeholder: RawTokenSyntax {
+    layoutView.children[5].map(RawTokenSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenPlaceholderAndInheritanceClause: RawUnexpectedNodesSyntax? {
+    layoutView.children[6].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var inheritanceClause: RawInheritanceClauseSyntax? {
+    layoutView.children[7].map(RawInheritanceClauseSyntax.init(raw:))
+  }
+
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? {
+    layoutView.children[8].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var genericWhereClause: RawGenericWhereClauseSyntax? {
+    layoutView.children[9].map(RawGenericWhereClauseSyntax.init(raw:))
+  }
+
+  public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
+    layoutView.children[10].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+}
+
 @_spi(RawSyntax)
 public struct RawMissingDeclSyntax: RawDeclSyntaxNodeProtocol {
   @_spi(RawSyntax)
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift
index e36fb1f30ce..dab4bc4cf20 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesOP.swift
@@ -2675,14 +2675,14 @@ public struct RawPrimaryAssociatedTypeSyntax: RawSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol {
+public struct RawProtocolDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .protocolDecl
+    return raw.kind == .protocolDeclHeader
   }
 
   public var raw: RawSyntax
@@ -2718,13 +2718,11 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol {
     inheritanceClause: RawInheritanceClauseSyntax?,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
-    memberBlock: RawMemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .protocolDecl, uninitializedCount: 17, arena: arena) { layout in
+      kind: .protocolDeclHeader, uninitializedCount: 15, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes.raw
@@ -2740,9 +2738,7 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol {
       layout[11] = inheritanceClause?.raw
       layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw
       layout[13] = genericWhereClause?.raw
-      layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw
-      layout[15] = memberBlock.raw
-      layout[16] = unexpectedAfterMemberBlock?.raw
+      layout[14] = unexpectedAfterGenericWhereClause?.raw
     }
     self.init(unchecked: raw)
   }
@@ -2803,15 +2799,77 @@ public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol {
     layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
     layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+}
+
+@_spi(RawSyntax)
+public struct RawProtocolDeclSyntax: RawDeclSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .protocolDecl
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeProtocolHeader: RawUnexpectedNodesSyntax? = nil,
+    protocolHeader: RawProtocolDeclHeaderSyntax,
+    _ unexpectedBetweenProtocolHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    memberBlock: RawMemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .protocolDecl, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeProtocolHeader?.raw
+      layout[1] = protocolHeader.raw
+      layout[2] = unexpectedBetweenProtocolHeaderAndMemberBlock?.raw
+      layout[3] = memberBlock.raw
+      layout[4] = unexpectedAfterMemberBlock?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeProtocolHeader: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var protocolHeader: RawProtocolDeclHeaderSyntax {
+    layoutView.children[1].map(RawProtocolDeclHeaderSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenProtocolHeaderAndMemberBlock: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 
   public var memberBlock: RawMemberBlockSyntax {
-    layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))!
+    layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))!
   }
 
   public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift
index a2574cdd83e..91d0057f52c 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxNodesQRS.swift
@@ -1405,14 +1405,14 @@ public struct RawStringSegmentSyntax: RawSyntaxNodeProtocol {
 }
 
 @_spi(RawSyntax)
-public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol {
+public struct RawStructDeclHeaderSyntax: RawDeclGroupHeaderSyntaxNodeProtocol {
   @_spi(RawSyntax)
   public var layoutView: RawSyntaxLayoutView {
     return raw.layoutView!
   }
 
   public static func isKindOf(_ raw: RawSyntax) -> Bool {
-    return raw.kind == .structDecl
+    return raw.kind == .structDeclHeader
   }
 
   public var raw: RawSyntax
@@ -1448,13 +1448,11 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol {
     inheritanceClause: RawInheritanceClauseSyntax?,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     genericWhereClause: RawGenericWhereClauseSyntax?,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
-    memberBlock: RawMemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? = nil,
     arena: __shared SyntaxArena
   ) {
     let raw = RawSyntax.makeLayout(
-      kind: .structDecl, uninitializedCount: 17, arena: arena) { layout in
+      kind: .structDeclHeader, uninitializedCount: 15, arena: arena) { layout in
       layout.initialize(repeating: nil)
       layout[0] = unexpectedBeforeAttributes?.raw
       layout[1] = attributes.raw
@@ -1470,9 +1468,7 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol {
       layout[11] = inheritanceClause?.raw
       layout[12] = unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw
       layout[13] = genericWhereClause?.raw
-      layout[14] = unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw
-      layout[15] = memberBlock.raw
-      layout[16] = unexpectedAfterMemberBlock?.raw
+      layout[14] = unexpectedAfterGenericWhereClause?.raw
     }
     self.init(unchecked: raw)
   }
@@ -1533,16 +1529,78 @@ public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol {
     layoutView.children[13].map(RawGenericWhereClauseSyntax.init(raw:))
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: RawUnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: RawUnexpectedNodesSyntax? {
     layoutView.children[14].map(RawUnexpectedNodesSyntax.init(raw:))
   }
+}
+
+@_spi(RawSyntax)
+public struct RawStructDeclSyntax: RawDeclSyntaxNodeProtocol {
+  @_spi(RawSyntax)
+  public var layoutView: RawSyntaxLayoutView {
+    return raw.layoutView!
+  }
+
+  public static func isKindOf(_ raw: RawSyntax) -> Bool {
+    return raw.kind == .structDecl
+  }
+
+  public var raw: RawSyntax
+
+  init(raw: RawSyntax) {
+    precondition(Self.isKindOf(raw))
+    self.raw = raw
+  }
+
+  private init(unchecked raw: RawSyntax) {
+    self.raw = raw
+  }
+
+  public init?(_ other: some RawSyntaxNodeProtocol) {
+    guard Self.isKindOf(other.raw) else {
+      return nil
+    }
+    self.init(unchecked: other.raw)
+  }
+
+  public init(
+    _ unexpectedBeforeStructHeader: RawUnexpectedNodesSyntax? = nil,
+    structHeader: RawStructDeclHeaderSyntax,
+    _ unexpectedBetweenStructHeaderAndMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    memberBlock: RawMemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? = nil,
+    arena: __shared SyntaxArena
+  ) {
+    let raw = RawSyntax.makeLayout(
+      kind: .structDecl, uninitializedCount: 5, arena: arena) { layout in
+      layout.initialize(repeating: nil)
+      layout[0] = unexpectedBeforeStructHeader?.raw
+      layout[1] = structHeader.raw
+      layout[2] = unexpectedBetweenStructHeaderAndMemberBlock?.raw
+      layout[3] = memberBlock.raw
+      layout[4] = unexpectedAfterMemberBlock?.raw
+    }
+    self.init(unchecked: raw)
+  }
+
+  public var unexpectedBeforeStructHeader: RawUnexpectedNodesSyntax? {
+    layoutView.children[0].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
+
+  public var structHeader: RawStructDeclHeaderSyntax {
+    layoutView.children[1].map(RawStructDeclHeaderSyntax.init(raw:))!
+  }
+
+  public var unexpectedBetweenStructHeaderAndMemberBlock: RawUnexpectedNodesSyntax? {
+    layoutView.children[2].map(RawUnexpectedNodesSyntax.init(raw:))
+  }
 
   public var memberBlock: RawMemberBlockSyntax {
-    layoutView.children[15].map(RawMemberBlockSyntax.init(raw:))!
+    layoutView.children[3].map(RawMemberBlockSyntax.init(raw:))!
   }
 
   public var unexpectedAfterMemberBlock: RawUnexpectedNodesSyntax? {
-    layoutView.children[16].map(RawUnexpectedNodesSyntax.init(raw:))
+    layoutView.children[4].map(RawUnexpectedNodesSyntax.init(raw:))
   }
 }
 
diff --git a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
index a5430c16f4a..6970aeb1c53 100644
--- a/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
+++ b/Sources/SwiftSyntax/generated/raw/RawSyntaxValidation.swift
@@ -209,6 +209,12 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
   switch kind {
   case .token:
     assertionFailure("validateLayout for .token kind is not supported")
+  case .abiAttributeArguments:
+    assert(layout.count == 3)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertAnyHasNoError(kind, 1, [
+      verify(layout[1], as: RawSyntax.self)])
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
   case .accessorBlock:
     assert(layout.count == 7)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -270,8 +276,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.rightParen)]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
-  case .actorDecl:
-    assert(layout.count == 17)
+  case .actorDeclHeader:
+    assert(layout.count == 15)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
@@ -287,8 +293,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self))
     assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self))
-    assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self))
+  case .actorDecl:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawActorDeclHeaderSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .arrayElementList:
     for (index, element) in layout.enumerated() {
       assertNoError(kind, index, verify(element, as: RawArrayElementSyntax.self))
@@ -516,8 +527,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
-  case .classDecl:
-    assert(layout.count == 17)
+  case .classDeclHeader:
+    assert(layout.count == 15)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
@@ -533,8 +544,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self))
     assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self))
-    assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self))
+  case .classDecl:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawClassDeclHeaderSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .classRestrictionType:
     assert(layout.count == 3)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -1105,8 +1121,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 13, verify(layout[13], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
     assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self))
-  case .enumDecl:
-    assert(layout.count == 17)
+  case .enumDeclHeader:
+    assert(layout.count == 15)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
@@ -1122,8 +1138,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self))
     assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self))
-    assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self))
+  case .enumDecl:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawEnumDeclHeaderSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .exposeAttributeArguments:
     assert(layout.count == 7)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -1160,8 +1181,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawExprSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-  case .extensionDecl:
-    assert(layout.count == 15)
+  case .extensionDeclHeader:
+    assert(layout.count == 13)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
@@ -1175,8 +1196,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 11, verify(layout[11], as: RawGenericWhereClauseSyntax?.self))
     assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 13, verify(layout[13], as: RawMemberBlockSyntax.self))
-    assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self))
+  case .extensionDecl:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawExtensionDeclHeaderSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .fallThroughStmt:
     assert(layout.count == 3)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -1858,6 +1884,19 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.keyword("Type"), .keyword("Protocol")]))
     assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
+  case .missingDeclHeader:
+    assert(layout.count == 11)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawDeclModifierListSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 5, verify(layout[5], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.identifier)]))
+    assertNoError(kind, 6, verify(layout[6], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 7, verify(layout[7], as: RawInheritanceClauseSyntax?.self))
+    assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 9, verify(layout[9], as: RawGenericWhereClauseSyntax?.self))
+    assertNoError(kind, 10, verify(layout[10], as: RawUnexpectedNodesSyntax?.self))
   case .missingDecl:
     assert(layout.count == 7)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -2201,8 +2240,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 3, verify(layout[3], as: RawTokenSyntax?.self, tokenChoices: [.tokenKind(.comma)]))
     assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
-  case .protocolDecl:
-    assert(layout.count == 17)
+  case .protocolDeclHeader:
+    assert(layout.count == 15)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
@@ -2218,8 +2257,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self))
     assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self))
-    assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self))
+  case .protocolDecl:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawProtocolDeclHeaderSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .regexLiteralExpr:
     assert(layout.count == 11)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
@@ -2370,8 +2414,8 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawTokenSyntax.self, tokenChoices: [.tokenKind(.stringSegment)]))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
-  case .structDecl:
-    assert(layout.count == 17)
+  case .structDeclHeader:
+    assert(layout.count == 15)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 1, verify(layout[1], as: RawAttributeListSyntax.self))
     assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
@@ -2387,8 +2431,13 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
     assertNoError(kind, 12, verify(layout[12], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 13, verify(layout[13], as: RawGenericWhereClauseSyntax?.self))
     assertNoError(kind, 14, verify(layout[14], as: RawUnexpectedNodesSyntax?.self))
-    assertNoError(kind, 15, verify(layout[15], as: RawMemberBlockSyntax.self))
-    assertNoError(kind, 16, verify(layout[16], as: RawUnexpectedNodesSyntax?.self))
+  case .structDecl:
+    assert(layout.count == 5)
+    assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 1, verify(layout[1], as: RawStructDeclHeaderSyntax.self))
+    assertNoError(kind, 2, verify(layout[2], as: RawUnexpectedNodesSyntax?.self))
+    assertNoError(kind, 3, verify(layout[3], as: RawMemberBlockSyntax.self))
+    assertNoError(kind, 4, verify(layout[4], as: RawUnexpectedNodesSyntax?.self))
   case .subscriptCallExpr:
     assert(layout.count == 13)
     assertNoError(kind, 0, verify(layout[0], as: RawUnexpectedNodesSyntax?.self))
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift
index f6519df7524..67484165711 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesAB.swift
@@ -12,6 +12,426 @@
 //
 //===----------------------------------------------------------------------===//
 
+// MARK: - ABIAttributeArgumentsSyntax
+
+/// The arguments of the '@abi' attribute
+///
+/// - Note: Requires experimental feature `abiAttribute`.
+///
+/// ### Children
+/// 
+///  - `provider`: (``AssociatedTypeDeclSyntax`` | ``DeclGroupHeaderSyntax`` | ``DeinitializerDeclSyntax`` | ``EnumCaseDeclSyntax`` | ``FunctionDeclSyntax`` | ``InitializerDeclSyntax`` | ``SubscriptDeclSyntax`` | ``TypeAliasDeclSyntax`` | ``VariableDeclSyntax`` | ``DeclSyntax``)
+///
+/// ### Contained in
+/// 
+///  - ``AttributeSyntax``.``AttributeSyntax/arguments``
+#if compiler(>=5.8)
+@_spi(ExperimentalLanguageFeatures)
+#endif
+public struct ABIAttributeArgumentsSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
+  public enum Provider: SyntaxChildChoices, SyntaxHashable {
+    case associatedType(AssociatedTypeDeclSyntax)
+    case declGroup(DeclGroupHeaderSyntax)
+    case deinitializer(DeinitializerDeclSyntax)
+    case enumCase(EnumCaseDeclSyntax)
+    case function(FunctionDeclSyntax)
+    case initializer(InitializerDeclSyntax)
+    case `subscript`(SubscriptDeclSyntax)
+    case typeAlias(TypeAliasDeclSyntax)
+    case variable(VariableDeclSyntax)
+    case unsupported(DeclSyntax)
+
+    public var _syntaxNode: Syntax {
+      switch self {
+      case .associatedType(let node):
+        return node._syntaxNode
+      case .declGroup(let node):
+        return node._syntaxNode
+      case .deinitializer(let node):
+        return node._syntaxNode
+      case .enumCase(let node):
+        return node._syntaxNode
+      case .function(let node):
+        return node._syntaxNode
+      case .initializer(let node):
+        return node._syntaxNode
+      case .subscript(let node):
+        return node._syntaxNode
+      case .typeAlias(let node):
+        return node._syntaxNode
+      case .variable(let node):
+        return node._syntaxNode
+      case .unsupported(let node):
+        return node._syntaxNode
+      }
+    }
+
+    public init(_ node: AssociatedTypeDeclSyntax) {
+      self = .associatedType(node)
+    }
+
+    public init(_ node: some DeclGroupHeaderSyntaxProtocol) {
+      self = .declGroup(DeclGroupHeaderSyntax(node))
+    }
+
+    public init(_ node: DeinitializerDeclSyntax) {
+      self = .deinitializer(node)
+    }
+
+    public init(_ node: EnumCaseDeclSyntax) {
+      self = .enumCase(node)
+    }
+
+    public init(_ node: FunctionDeclSyntax) {
+      self = .function(node)
+    }
+
+    public init(_ node: InitializerDeclSyntax) {
+      self = .initializer(node)
+    }
+
+    public init(_ node: SubscriptDeclSyntax) {
+      self = .subscript(node)
+    }
+
+    public init(_ node: TypeAliasDeclSyntax) {
+      self = .typeAlias(node)
+    }
+
+    public init(_ node: VariableDeclSyntax) {
+      self = .variable(node)
+    }
+
+    public init(_ node: some DeclSyntaxProtocol) {
+      self = .unsupported(DeclSyntax(node))
+    }
+
+    public init?(_ node: __shared some SyntaxProtocol) {
+      if let node = node.as(AssociatedTypeDeclSyntax.self) {
+        self = .associatedType(node)
+      } else if let node = node.as(DeclGroupHeaderSyntax.self) {
+        self = .declGroup(node)
+      } else if let node = node.as(DeinitializerDeclSyntax.self) {
+        self = .deinitializer(node)
+      } else if let node = node.as(EnumCaseDeclSyntax.self) {
+        self = .enumCase(node)
+      } else if let node = node.as(FunctionDeclSyntax.self) {
+        self = .function(node)
+      } else if let node = node.as(InitializerDeclSyntax.self) {
+        self = .initializer(node)
+      } else if let node = node.as(SubscriptDeclSyntax.self) {
+        self = .subscript(node)
+      } else if let node = node.as(TypeAliasDeclSyntax.self) {
+        self = .typeAlias(node)
+      } else if let node = node.as(VariableDeclSyntax.self) {
+        self = .variable(node)
+      } else if let node = node.as(DeclSyntax.self) {
+        self = .unsupported(node)
+      } else {
+        return nil
+      }
+    }
+
+    public static var structure: SyntaxNodeStructure {
+      return .choices([
+        .node(AssociatedTypeDeclSyntax.self),
+        .node(DeclGroupHeaderSyntax.self),
+        .node(DeinitializerDeclSyntax.self),
+        .node(EnumCaseDeclSyntax.self),
+        .node(FunctionDeclSyntax.self),
+        .node(InitializerDeclSyntax.self),
+        .node(SubscriptDeclSyntax.self),
+        .node(TypeAliasDeclSyntax.self),
+        .node(VariableDeclSyntax.self),
+        .node(DeclSyntax.self)
+      ])
+    }
+
+    /// Checks if the current syntax node can be cast to ``AssociatedTypeDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: AssociatedTypeDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``AssociatedTypeDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``AssociatedTypeDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: AssociatedTypeDeclSyntax.Type) -> AssociatedTypeDeclSyntax? {
+      return AssociatedTypeDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``AssociatedTypeDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``AssociatedTypeDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: AssociatedTypeDeclSyntax.Type) -> AssociatedTypeDeclSyntax {
+      return self.as(AssociatedTypeDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to the type conforming to the ``DeclGroupHeaderSyntaxProtocol`` protocol.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: (some DeclGroupHeaderSyntaxProtocol).Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to the type conforming to the ``DeclGroupHeaderSyntaxProtocol`` protocol.
+    ///
+    /// - Returns: An instance of the specialized type, or `nil` if the cast fails.
+    public func `as`<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
+      return S.init(self)
+    }
+
+    /// Force-casts the current syntax node to the type conforming to the ``DeclGroupHeaderSyntaxProtocol`` protocol.
+    ///
+    /// - Returns: An instance of the specialized type.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast<S: DeclGroupHeaderSyntaxProtocol>(_ syntaxType: S.Type) -> S {
+      return self.as(S.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to ``DeinitializerDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: DeinitializerDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``DeinitializerDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``DeinitializerDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: DeinitializerDeclSyntax.Type) -> DeinitializerDeclSyntax? {
+      return DeinitializerDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``DeinitializerDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``DeinitializerDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: DeinitializerDeclSyntax.Type) -> DeinitializerDeclSyntax {
+      return self.as(DeinitializerDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to ``EnumCaseDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: EnumCaseDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``EnumCaseDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``EnumCaseDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: EnumCaseDeclSyntax.Type) -> EnumCaseDeclSyntax? {
+      return EnumCaseDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``EnumCaseDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``EnumCaseDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: EnumCaseDeclSyntax.Type) -> EnumCaseDeclSyntax {
+      return self.as(EnumCaseDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to ``FunctionDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: FunctionDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``FunctionDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``FunctionDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: FunctionDeclSyntax.Type) -> FunctionDeclSyntax? {
+      return FunctionDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``FunctionDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``FunctionDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: FunctionDeclSyntax.Type) -> FunctionDeclSyntax {
+      return self.as(FunctionDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to ``InitializerDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: InitializerDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``InitializerDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``InitializerDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: InitializerDeclSyntax.Type) -> InitializerDeclSyntax? {
+      return InitializerDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``InitializerDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``InitializerDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: InitializerDeclSyntax.Type) -> InitializerDeclSyntax {
+      return self.as(InitializerDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to ``SubscriptDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: SubscriptDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``SubscriptDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``SubscriptDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: SubscriptDeclSyntax.Type) -> SubscriptDeclSyntax? {
+      return SubscriptDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``SubscriptDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``SubscriptDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: SubscriptDeclSyntax.Type) -> SubscriptDeclSyntax {
+      return self.as(SubscriptDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to ``TypeAliasDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: TypeAliasDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``TypeAliasDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``TypeAliasDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: TypeAliasDeclSyntax.Type) -> TypeAliasDeclSyntax? {
+      return TypeAliasDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``TypeAliasDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``TypeAliasDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: TypeAliasDeclSyntax.Type) -> TypeAliasDeclSyntax {
+      return self.as(TypeAliasDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to ``VariableDeclSyntax``.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: VariableDeclSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to ``VariableDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``VariableDeclSyntax``, or `nil` if the cast fails.
+    public func `as`(_ syntaxType: VariableDeclSyntax.Type) -> VariableDeclSyntax? {
+      return VariableDeclSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to ``VariableDeclSyntax``.
+    ///
+    /// - Returns: An instance of ``VariableDeclSyntax``.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast(_ syntaxType: VariableDeclSyntax.Type) -> VariableDeclSyntax {
+      return self.as(VariableDeclSyntax.self)!
+    }
+
+    /// Checks if the current syntax node can be cast to the type conforming to the ``DeclSyntaxProtocol`` protocol.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    public func `is`(_ syntaxType: (some DeclSyntaxProtocol).Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to the type conforming to the ``DeclSyntaxProtocol`` protocol.
+    ///
+    /// - Returns: An instance of the specialized type, or `nil` if the cast fails.
+    public func `as`<S: DeclSyntaxProtocol>(_ syntaxType: S.Type) -> S? {
+      return S.init(self)
+    }
+
+    /// Force-casts the current syntax node to the type conforming to the ``DeclSyntaxProtocol`` protocol.
+    ///
+    /// - Returns: An instance of the specialized type.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    public func cast<S: DeclSyntaxProtocol>(_ syntaxType: S.Type) -> S {
+      return self.as(S.self)!
+    }
+  }
+
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .abiAttributeArguments else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeProvider: UnexpectedNodesSyntax? = nil,
+    provider: Provider,
+    _ unexpectedAfterProvider: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (unexpectedBeforeProvider, provider, unexpectedAfterProvider))) { (arena, _) in
+      let layout: [RawSyntax?] = [unexpectedBeforeProvider?.raw, provider.raw, unexpectedAfterProvider?.raw]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.abiAttributeArguments,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeProvider: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ABIAttributeArgumentsSyntax.self)
+    }
+  }
+
+  public var provider: Provider {
+    get {
+      return Syntax(self).child(at: 1)!.cast(Provider.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ABIAttributeArgumentsSyntax.self)
+    }
+  }
+
+  public var unexpectedAfterProvider: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ABIAttributeArgumentsSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeProvider, \Self.provider, \Self.unexpectedAfterProvider])
+}
+
 // MARK: - AccessorBlockSyntax
 
 /// ### Children
@@ -781,7 +1201,7 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn
   ])
 }
 
-// MARK: - ActorDeclSyntax
+// MARK: - ActorDeclHeaderSyntax
 
 /// ### Children
 /// 
@@ -792,12 +1212,15 @@ public struct AccessorParametersSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyn
 ///  - `genericParameterClause`: ``GenericParameterClauseSyntax``?
 ///  - `inheritanceClause`: ``InheritanceClauseSyntax``?
 ///  - `genericWhereClause`: ``GenericWhereClauseSyntax``?
-///  - `memberBlock`: ``MemberBlockSyntax``
-public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+///
+/// ### Contained in
+/// 
+///  - ``ActorDeclSyntax``.``ActorDeclSyntax/actorHeader``
+public struct ActorDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
   public init?(_ node: __shared some SyntaxProtocol) {
-    guard node.raw.kind == .actorDecl else {
+    guard node.raw.kind == .actorDeclHeader else {
       return nil
     }
     self._syntaxNode = node._syntaxNode
@@ -827,9 +1250,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
     inheritanceClause: InheritanceClauseSyntax? = nil,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
     genericWhereClause: GenericWhereClauseSyntax? = nil,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
-    memberBlock: MemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil,
     trailingTrivia: Trivia? = nil
   ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
@@ -849,9 +1270,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       inheritanceClause,
       unexpectedBetweenInheritanceClauseAndGenericWhereClause,
       genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
-      memberBlock,
-      unexpectedAfterMemberBlock
+      unexpectedAfterGenericWhereClause
     ))) { (arena, _) in
       let layout: [RawSyntax?] = [
         unexpectedBeforeAttributes?.raw,
@@ -868,12 +1287,10 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
         inheritanceClause?.raw,
         unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw,
         genericWhereClause?.raw,
-        unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw,
-        memberBlock.raw,
-        unexpectedAfterMemberBlock?.raw
+        unexpectedAfterGenericWhereClause?.raw
       ]
       let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.actorDecl,
+        kind: SyntaxKind.actorDeclHeader,
         from: layout,
         arena: arena,
         leadingTrivia: leadingTrivia,
@@ -888,7 +1305,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -897,7 +1314,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -909,7 +1326,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
   /// - returns: A copy of the receiver with the provided `Attribute`
   ///            appended to its `attributes` collection.
   @available(*, deprecated, message: "Use node.attributes.append(newElement) instead")
-  public func addAttribute(_ element: Syntax) -> ActorDeclSyntax {
+  public func addAttribute(_ element: Syntax) -> ActorDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[1] {
@@ -925,7 +1342,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ActorDeclSyntax.self)
+      .cast(ActorDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
@@ -933,7 +1350,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -943,7 +1360,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -955,7 +1372,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
   /// - returns: A copy of the receiver with the provided `Modifier`
   ///            appended to its `modifiers` collection.
   @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead")
-  public func addModifier(_ element: DeclModifierSyntax) -> ActorDeclSyntax {
+  public func addModifier(_ element: DeclModifierSyntax) -> ActorDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[3] {
@@ -971,7 +1388,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ActorDeclSyntax.self)
+      .cast(ActorDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? {
@@ -979,7 +1396,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -993,7 +1410,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1002,7 +1419,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1016,7 +1433,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 7)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1025,7 +1442,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1035,7 +1452,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1044,7 +1461,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1053,7 +1470,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1062,7 +1479,7 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1072,34 +1489,16 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
-    }
-  }
-
-  public var memberBlock: MemberBlockSyntax {
-    get {
-      return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
-    }
-  }
-
-  public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
-    get {
-      return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclHeaderSyntax.self)
     }
   }
 
@@ -1118,7 +1517,116 @@ public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
     \Self.inheritanceClause,
     \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
     \Self.genericWhereClause,
-    \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock,
+    \Self.unexpectedAfterGenericWhereClause
+  ])
+}
+
+// MARK: - ActorDeclSyntax
+
+/// ### Children
+/// 
+///  - `actorHeader`: ``ActorDeclHeaderSyntax``
+///  - `memberBlock`: ``MemberBlockSyntax``
+public struct ActorDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .actorDecl else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - actorHeader: The header of the actor declaration.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeActorHeader: UnexpectedNodesSyntax? = nil,
+    actorHeader: ActorDeclHeaderSyntax,
+    _ unexpectedBetweenActorHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (
+      unexpectedBeforeActorHeader,
+      actorHeader,
+      unexpectedBetweenActorHeaderAndMemberBlock,
+      memberBlock,
+      unexpectedAfterMemberBlock
+    ))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpectedBeforeActorHeader?.raw,
+        actorHeader.raw,
+        unexpectedBetweenActorHeaderAndMemberBlock?.raw,
+        memberBlock.raw,
+        unexpectedAfterMemberBlock?.raw
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.actorDecl,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeActorHeader: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+    }
+  }
+
+  /// The header of the actor declaration.
+  public var actorHeader: ActorDeclHeaderSyntax {
+    get {
+      return Syntax(self).child(at: 1)!.cast(ActorDeclHeaderSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenActorHeaderAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+    }
+  }
+
+  public var memberBlock: MemberBlockSyntax {
+    get {
+      return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ActorDeclSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([
+    \Self.unexpectedBeforeActorHeader,
+    \Self.actorHeader,
+    \Self.unexpectedBetweenActorHeaderAndMemberBlock,
     \Self.memberBlock,
     \Self.unexpectedAfterMemberBlock
   ])
@@ -2291,7 +2799,7 @@ public struct AssociatedTypeDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _Lea
 ///  - `atSign`: `@`
 ///  - `attributeName`: ``TypeSyntax``
 ///  - `leftParen`: `(`?
-///  - `arguments`: (``LabeledExprListSyntax`` | ``TokenSyntax`` | ``StringLiteralExprSyntax`` | ``AvailabilityArgumentListSyntax`` | ``SpecializeAttributeArgumentListSyntax`` | ``ObjCSelectorPieceListSyntax`` | ``ImplementsAttributeArgumentsSyntax`` | ``DifferentiableAttributeArgumentsSyntax`` | ``DerivativeAttributeArgumentsSyntax`` | ``BackDeployedAttributeArgumentsSyntax`` | ``ConventionAttributeArgumentsSyntax`` | ``ConventionWitnessMethodAttributeArgumentsSyntax`` | ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` | ``ExposeAttributeArgumentsSyntax`` | ``OriginallyDefinedInAttributeArgumentsSyntax`` | ``UnderscorePrivateAttributeArgumentsSyntax`` | ``DynamicReplacementAttributeArgumentsSyntax`` | ``UnavailableFromAsyncAttributeArgumentsSyntax`` | ``EffectsAttributeArgumentListSyntax`` | ``DocumentationAttributeArgumentListSyntax``)?
+///  - `arguments`: (``LabeledExprListSyntax`` | ``TokenSyntax`` | ``StringLiteralExprSyntax`` | ``AvailabilityArgumentListSyntax`` | ``SpecializeAttributeArgumentListSyntax`` | ``ObjCSelectorPieceListSyntax`` | ``ImplementsAttributeArgumentsSyntax`` | ``DifferentiableAttributeArgumentsSyntax`` | ``DerivativeAttributeArgumentsSyntax`` | ``BackDeployedAttributeArgumentsSyntax`` | ``ConventionAttributeArgumentsSyntax`` | ``ConventionWitnessMethodAttributeArgumentsSyntax`` | ``OpaqueReturnTypeOfAttributeArgumentsSyntax`` | ``ExposeAttributeArgumentsSyntax`` | ``OriginallyDefinedInAttributeArgumentsSyntax`` | ``UnderscorePrivateAttributeArgumentsSyntax`` | ``DynamicReplacementAttributeArgumentsSyntax`` | ``UnavailableFromAsyncAttributeArgumentsSyntax`` | ``EffectsAttributeArgumentListSyntax`` | ``DocumentationAttributeArgumentListSyntax`` | `ABIAttributeArgumentsSyntax`)?
 ///  - `rightParen`: `)`?
 ///
 /// ### Contained in
@@ -2320,6 +2828,9 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
     case unavailableFromAsyncArguments(UnavailableFromAsyncAttributeArgumentsSyntax)
     case effectsArguments(EffectsAttributeArgumentListSyntax)
     case documentationArguments(DocumentationAttributeArgumentListSyntax)
+    /// - Note: Requires experimental feature `abiAttribute`.
+    @_spi(ExperimentalLanguageFeatures)
+    case abiArguments(ABIAttributeArgumentsSyntax)
 
     public var _syntaxNode: Syntax {
       switch self {
@@ -2363,6 +2874,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
         return node._syntaxNode
       case .documentationArguments(let node):
         return node._syntaxNode
+      case .abiArguments(let node):
+        return node._syntaxNode
       }
     }
 
@@ -2446,6 +2959,12 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
       self = .documentationArguments(node)
     }
 
+    /// - Note: Requires experimental feature `abiAttribute`.
+    @_spi(ExperimentalLanguageFeatures)
+    public init(_ node: ABIAttributeArgumentsSyntax) {
+      self = .abiArguments(node)
+    }
+
     public init?(_ node: __shared some SyntaxProtocol) {
       if let node = node.as(LabeledExprListSyntax.self) {
         self = .argumentList(node)
@@ -2487,6 +3006,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
         self = .effectsArguments(node)
       } else if let node = node.as(DocumentationAttributeArgumentListSyntax.self) {
         self = .documentationArguments(node)
+      } else if let node = node.as(ABIAttributeArgumentsSyntax.self) {
+        self = .abiArguments(node)
       } else {
         return nil
       }
@@ -2513,7 +3034,8 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
         .node(DynamicReplacementAttributeArgumentsSyntax.self),
         .node(UnavailableFromAsyncAttributeArgumentsSyntax.self),
         .node(EffectsAttributeArgumentListSyntax.self),
-        .node(DocumentationAttributeArgumentListSyntax.self)
+        .node(DocumentationAttributeArgumentListSyntax.self),
+        .node(ABIAttributeArgumentsSyntax.self)
       ])
     }
 
@@ -2956,6 +3478,34 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
     public func cast(_ syntaxType: DocumentationAttributeArgumentListSyntax.Type) -> DocumentationAttributeArgumentListSyntax {
       return self.as(DocumentationAttributeArgumentListSyntax.self)!
     }
+
+    /// Checks if the current syntax node can be cast to `ABIAttributeArgumentsSyntax`.
+    ///
+    /// - Returns: `true` if the node can be cast, `false` otherwise.
+    /// - Note: Requires experimental feature `abiAttribute`.
+    @_spi(ExperimentalLanguageFeatures)
+    public func `is`(_ syntaxType: ABIAttributeArgumentsSyntax.Type) -> Bool {
+      return self.as(syntaxType) != nil
+    }
+
+    /// Attempts to cast the current syntax node to `ABIAttributeArgumentsSyntax`.
+    ///
+    /// - Returns: An instance of `ABIAttributeArgumentsSyntax`, or `nil` if the cast fails.
+    /// - Note: Requires experimental feature `abiAttribute`.
+    @_spi(ExperimentalLanguageFeatures)
+    public func `as`(_ syntaxType: ABIAttributeArgumentsSyntax.Type) -> ABIAttributeArgumentsSyntax? {
+      return ABIAttributeArgumentsSyntax.init(self)
+    }
+
+    /// Force-casts the current syntax node to `ABIAttributeArgumentsSyntax`.
+    ///
+    /// - Returns: An instance of `ABIAttributeArgumentsSyntax`.
+    /// - Warning: This function will crash if the cast is not possible. Use `as` to safely attempt a cast.
+    /// - Note: Requires experimental feature `abiAttribute`.
+    @_spi(ExperimentalLanguageFeatures)
+    public func cast(_ syntaxType: ABIAttributeArgumentsSyntax.Type) -> ABIAttributeArgumentsSyntax {
+      return self.as(ABIAttributeArgumentsSyntax.self)!
+    }
   }
 
   public let _syntaxNode: Syntax
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift
index a80eedea2ac..e1cd175003f 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesC.swift
@@ -705,31 +705,15 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
   ])
 }
 
-// MARK: - ClassDeclSyntax
+// MARK: - ClassDeclHeaderSyntax
 
-/// A `class` declaration
+/// A `class` declaration header
 /// 
-/// An example of a class declaration is
+/// An example of a class declaration header is
 /// 
 /// ```swift
-/// class SomeClass {
-///   let someMember: String
-/// 
-///   init(someMember: String) {
-///     self.someMember = someMember
-///   }
-/// 
-///   func foo() {
-///     print(someMember)
-///   }
-/// 
-///   static func bar() -> Int {
-///     return 1
-///   }
-/// }
+/// class SomeClass
 /// ```
-/// 
-/// A class declaration may be declared without any members.
 ///
 /// ### Children
 /// 
@@ -740,12 +724,15 @@ public struct CatchItemSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodePr
 ///  - `genericParameterClause`: ``GenericParameterClauseSyntax``?
 ///  - `inheritanceClause`: ``InheritanceClauseSyntax``?
 ///  - `genericWhereClause`: ``GenericWhereClauseSyntax``?
-///  - `memberBlock`: ``MemberBlockSyntax``
-public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+///
+/// ### Contained in
+/// 
+///  - ``ClassDeclSyntax``.``ClassDeclSyntax/classHeader``
+public struct ClassDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
   public init?(_ node: __shared some SyntaxProtocol) {
-    guard node.raw.kind == .classDecl else {
+    guard node.raw.kind == .classDeclHeader else {
       return nil
     }
     self._syntaxNode = node._syntaxNode
@@ -760,7 +747,6 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
   ///   - genericParameterClause: The generic parameters, if any, of the class declaration.
   ///   - inheritanceClause: The inheritance clause describing one or more conformances for this class declaration.
   ///   - genericWhereClause: The `where` clause that applies to the generic parameters of this class declaration.
-  ///   - memberBlock: The members of the class declaration. As class extension declarations may declare additional members, the contents of this member block isn't guaranteed to be a complete list of members for this type.
   ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   public init(
     leadingTrivia: Trivia? = nil,
@@ -778,9 +764,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
     inheritanceClause: InheritanceClauseSyntax? = nil,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
     genericWhereClause: GenericWhereClauseSyntax? = nil,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
-    memberBlock: MemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil,
     trailingTrivia: Trivia? = nil
   ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
@@ -800,9 +784,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       inheritanceClause,
       unexpectedBetweenInheritanceClauseAndGenericWhereClause,
       genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
-      memberBlock,
-      unexpectedAfterMemberBlock
+      unexpectedAfterGenericWhereClause
     ))) { (arena, _) in
       let layout: [RawSyntax?] = [
         unexpectedBeforeAttributes?.raw,
@@ -819,12 +801,10 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
         inheritanceClause?.raw,
         unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw,
         genericWhereClause?.raw,
-        unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw,
-        memberBlock.raw,
-        unexpectedAfterMemberBlock?.raw
+        unexpectedAfterGenericWhereClause?.raw
       ]
       let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.classDecl,
+        kind: SyntaxKind.classDeclHeader,
         from: layout,
         arena: arena,
         leadingTrivia: leadingTrivia,
@@ -839,7 +819,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -849,7 +829,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -861,7 +841,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
   /// - returns: A copy of the receiver with the provided `Attribute`
   ///            appended to its `attributes` collection.
   @available(*, deprecated, message: "Use node.attributes.append(newElement) instead")
-  public func addAttribute(_ element: Syntax) -> ClassDeclSyntax {
+  public func addAttribute(_ element: Syntax) -> ClassDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[1] {
@@ -877,7 +857,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ClassDeclSyntax.self)
+      .cast(ClassDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
@@ -885,7 +865,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -895,7 +875,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -907,7 +887,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
   /// - returns: A copy of the receiver with the provided `Modifier`
   ///            appended to its `modifiers` collection.
   @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead")
-  public func addModifier(_ element: DeclModifierSyntax) -> ClassDeclSyntax {
+  public func addModifier(_ element: DeclModifierSyntax) -> ClassDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[3] {
@@ -923,7 +903,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ClassDeclSyntax.self)
+      .cast(ClassDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? {
@@ -931,7 +911,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -945,7 +925,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -954,7 +934,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -968,7 +948,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 7)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -977,7 +957,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -987,7 +967,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -996,7 +976,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -1006,7 +986,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -1015,7 +995,7 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
@@ -1025,54 +1005,170 @@ public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynt
       return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
     }
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclHeaderSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([
+    \Self.unexpectedBeforeAttributes,
+    \Self.attributes,
+    \Self.unexpectedBetweenAttributesAndModifiers,
+    \Self.modifiers,
+    \Self.unexpectedBetweenModifiersAndClassKeyword,
+    \Self.classKeyword,
+    \Self.unexpectedBetweenClassKeywordAndName,
+    \Self.name,
+    \Self.unexpectedBetweenNameAndGenericParameterClause,
+    \Self.genericParameterClause,
+    \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+    \Self.inheritanceClause,
+    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+    \Self.genericWhereClause,
+    \Self.unexpectedAfterGenericWhereClause
+  ])
+}
+
+// MARK: - ClassDeclSyntax
+
+/// A `class` declaration
+/// 
+/// An example of a class declaration is
+/// 
+/// ```swift
+/// class SomeClass {
+///   let someMember: String
+/// 
+///   init(someMember: String) {
+///     self.someMember = someMember
+///   }
+/// 
+///   func foo() {
+///     print(someMember)
+///   }
+/// 
+///   static func bar() -> Int {
+///     return 1
+///   }
+/// }
+/// ```
+/// 
+/// A class declaration may be declared without any members.
+///
+/// ### Children
+/// 
+///  - `classHeader`: ``ClassDeclHeaderSyntax``
+///  - `memberBlock`: ``MemberBlockSyntax``
+public struct ClassDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .classDecl else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - classHeader: The header of the class declaration.
+  ///   - memberBlock: The members of the class declaration. As class extension declarations may declare additional members, the contents of this member block isn't guaranteed to be a complete list of members for this type.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeClassHeader: UnexpectedNodesSyntax? = nil,
+    classHeader: ClassDeclHeaderSyntax,
+    _ unexpectedBetweenClassHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (
+      unexpectedBeforeClassHeader,
+      classHeader,
+      unexpectedBetweenClassHeaderAndMemberBlock,
+      memberBlock,
+      unexpectedAfterMemberBlock
+    ))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpectedBeforeClassHeader?.raw,
+        classHeader.raw,
+        unexpectedBetweenClassHeaderAndMemberBlock?.raw,
+        memberBlock.raw,
+        unexpectedAfterMemberBlock?.raw
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.classDecl,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeClassHeader: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+    }
+  }
+
+  /// The header of the class declaration.
+  public var classHeader: ClassDeclHeaderSyntax {
+    get {
+      return Syntax(self).child(at: 1)!.cast(ClassDeclHeaderSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenClassHeaderAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
     }
   }
 
   /// The members of the class declaration. As class extension declarations may declare additional members, the contents of this member block isn't guaranteed to be a complete list of members for this type.
   public var memberBlock: MemberBlockSyntax {
     get {
-      return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self)
+      return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
     }
   }
 
   public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
     get {
-      return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self)
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ClassDeclSyntax.self)
     }
   }
 
   public static let structure: SyntaxNodeStructure = .layout([
-    \Self.unexpectedBeforeAttributes,
-    \Self.attributes,
-    \Self.unexpectedBetweenAttributesAndModifiers,
-    \Self.modifiers,
-    \Self.unexpectedBetweenModifiersAndClassKeyword,
-    \Self.classKeyword,
-    \Self.unexpectedBetweenClassKeywordAndName,
-    \Self.name,
-    \Self.unexpectedBetweenNameAndGenericParameterClause,
-    \Self.genericParameterClause,
-    \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-    \Self.inheritanceClause,
-    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-    \Self.genericWhereClause,
-    \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock,
+    \Self.unexpectedBeforeClassHeader,
+    \Self.classHeader,
+    \Self.unexpectedBetweenClassHeaderAndMemberBlock,
     \Self.memberBlock,
     \Self.unexpectedAfterMemberBlock
   ])
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift
index 9be2ca37f77..62b86397ef2 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesEF.swift
@@ -1216,9 +1216,9 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt
   ])
 }
 
-// MARK: - EnumDeclSyntax
+// MARK: - EnumDeclHeaderSyntax
 
-/// A Swift `enum` declaration.
+/// A Swift `enum` declaration header.
 ///
 /// ### Children
 /// 
@@ -1229,12 +1229,15 @@ public struct EnumCaseParameterSyntax: SyntaxProtocol, SyntaxHashable, _LeafSynt
 ///  - `genericParameterClause`: ``GenericParameterClauseSyntax``?
 ///  - `inheritanceClause`: ``InheritanceClauseSyntax``?
 ///  - `genericWhereClause`: ``GenericWhereClauseSyntax``?
-///  - `memberBlock`: ``MemberBlockSyntax``
-public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+///
+/// ### Contained in
+/// 
+///  - ``EnumDeclSyntax``.``EnumDeclSyntax/enumHeader``
+public struct EnumDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
   public init?(_ node: __shared some SyntaxProtocol) {
-    guard node.raw.kind == .enumDecl else {
+    guard node.raw.kind == .enumDeclHeader else {
       return nil
     }
     self._syntaxNode = node._syntaxNode
@@ -1249,7 +1252,6 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
   ///   - genericParameterClause: The generic parameters, if any, for this enum declaration.
   ///   - inheritanceClause: The inheritance clause describing conformances or raw values for this enum declaration.
   ///   - genericWhereClause: The `where` clause that applies to the generic parameters of this enum declaration.
-  ///   - memberBlock: The cases and other members associated with this enum declaration. Because enum extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type.
   ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   public init(
     leadingTrivia: Trivia? = nil,
@@ -1267,9 +1269,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
     inheritanceClause: InheritanceClauseSyntax? = nil,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
     genericWhereClause: GenericWhereClauseSyntax? = nil,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
-    memberBlock: MemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil,
     trailingTrivia: Trivia? = nil
   ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
@@ -1289,9 +1289,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       inheritanceClause,
       unexpectedBetweenInheritanceClauseAndGenericWhereClause,
       genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
-      memberBlock,
-      unexpectedAfterMemberBlock
+      unexpectedAfterGenericWhereClause
     ))) { (arena, _) in
       let layout: [RawSyntax?] = [
         unexpectedBeforeAttributes?.raw,
@@ -1308,12 +1306,10 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
         inheritanceClause?.raw,
         unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw,
         genericWhereClause?.raw,
-        unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw,
-        memberBlock.raw,
-        unexpectedAfterMemberBlock?.raw
+        unexpectedAfterGenericWhereClause?.raw
       ]
       let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.enumDecl,
+        kind: SyntaxKind.enumDeclHeader,
         from: layout,
         arena: arena,
         leadingTrivia: leadingTrivia,
@@ -1328,7 +1324,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1338,7 +1334,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1350,7 +1346,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
   /// - returns: A copy of the receiver with the provided `Attribute`
   ///            appended to its `attributes` collection.
   @available(*, deprecated, message: "Use node.attributes.append(newElement) instead")
-  public func addAttribute(_ element: Syntax) -> EnumDeclSyntax {
+  public func addAttribute(_ element: Syntax) -> EnumDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[1] {
@@ -1366,7 +1362,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(EnumDeclSyntax.self)
+      .cast(EnumDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
@@ -1374,7 +1370,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1384,7 +1380,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1396,7 +1392,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
   /// - returns: A copy of the receiver with the provided `Modifier`
   ///            appended to its `modifiers` collection.
   @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead")
-  public func addModifier(_ element: DeclModifierSyntax) -> EnumDeclSyntax {
+  public func addModifier(_ element: DeclModifierSyntax) -> EnumDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[3] {
@@ -1412,7 +1408,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(EnumDeclSyntax.self)
+      .cast(EnumDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? {
@@ -1420,7 +1416,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1434,7 +1430,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1443,7 +1439,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1457,7 +1453,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 7)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1466,7 +1462,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1476,7 +1472,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1485,7 +1481,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1495,7 +1491,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1504,7 +1500,7 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
@@ -1514,54 +1510,148 @@ public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSynta
       return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
     }
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclHeaderSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([
+    \Self.unexpectedBeforeAttributes,
+    \Self.attributes,
+    \Self.unexpectedBetweenAttributesAndModifiers,
+    \Self.modifiers,
+    \Self.unexpectedBetweenModifiersAndEnumKeyword,
+    \Self.enumKeyword,
+    \Self.unexpectedBetweenEnumKeywordAndName,
+    \Self.name,
+    \Self.unexpectedBetweenNameAndGenericParameterClause,
+    \Self.genericParameterClause,
+    \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+    \Self.inheritanceClause,
+    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+    \Self.genericWhereClause,
+    \Self.unexpectedAfterGenericWhereClause
+  ])
+}
+
+// MARK: - EnumDeclSyntax
+
+/// A Swift `enum` declaration.
+///
+/// ### Children
+/// 
+///  - `enumHeader`: ``EnumDeclHeaderSyntax``
+///  - `memberBlock`: ``MemberBlockSyntax``
+public struct EnumDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .enumDecl else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - enumHeader: The header of the enum declaration.
+  ///   - memberBlock: The cases and other members associated with this enum declaration. Because enum extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeEnumHeader: UnexpectedNodesSyntax? = nil,
+    enumHeader: EnumDeclHeaderSyntax,
+    _ unexpectedBetweenEnumHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (
+      unexpectedBeforeEnumHeader,
+      enumHeader,
+      unexpectedBetweenEnumHeaderAndMemberBlock,
+      memberBlock,
+      unexpectedAfterMemberBlock
+    ))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpectedBeforeEnumHeader?.raw,
+        enumHeader.raw,
+        unexpectedBetweenEnumHeaderAndMemberBlock?.raw,
+        memberBlock.raw,
+        unexpectedAfterMemberBlock?.raw
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.enumDecl,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeEnumHeader: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+    }
+  }
+
+  /// The header of the enum declaration.
+  public var enumHeader: EnumDeclHeaderSyntax {
+    get {
+      return Syntax(self).child(at: 1)!.cast(EnumDeclHeaderSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenEnumHeaderAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
     }
   }
 
   /// The cases and other members associated with this enum declaration. Because enum extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type.
   public var memberBlock: MemberBlockSyntax {
     get {
-      return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self)
+      return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
     }
   }
 
   public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
     get {
-      return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self)
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(EnumDeclSyntax.self)
     }
   }
 
   public static let structure: SyntaxNodeStructure = .layout([
-    \Self.unexpectedBeforeAttributes,
-    \Self.attributes,
-    \Self.unexpectedBetweenAttributesAndModifiers,
-    \Self.modifiers,
-    \Self.unexpectedBetweenModifiersAndEnumKeyword,
-    \Self.enumKeyword,
-    \Self.unexpectedBetweenEnumKeywordAndName,
-    \Self.name,
-    \Self.unexpectedBetweenNameAndGenericParameterClause,
-    \Self.genericParameterClause,
-    \Self.unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-    \Self.inheritanceClause,
-    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-    \Self.genericWhereClause,
-    \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock,
+    \Self.unexpectedBeforeEnumHeader,
+    \Self.enumHeader,
+    \Self.unexpectedBetweenEnumHeaderAndMemberBlock,
     \Self.memberBlock,
     \Self.unexpectedAfterMemberBlock
   ])
@@ -2103,18 +2193,14 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm
   public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeExpression, \Self.expression, \Self.unexpectedAfterExpression])
 }
 
-// MARK: - ExtensionDeclSyntax
+// MARK: - ExtensionDeclHeaderSyntax
 
-///   An `extension` declaration.
+///   An `extension` declaration header.
 /// 
 ///  ### Example
 /// 
 ///   ```swift
-///   extension String {
-///     var url: URL? {
-///       URL(string: self)
-///     }
-///   }
+///   extension String
 ///   ```
 ///
 /// ### Children
@@ -2125,12 +2211,15 @@ public struct ExpressionStmtSyntax: StmtSyntaxProtocol, SyntaxHashable, _LeafStm
 ///  - `extendedType`: ``TypeSyntax``
 ///  - `inheritanceClause`: ``InheritanceClauseSyntax``?
 ///  - `genericWhereClause`: ``GenericWhereClauseSyntax``?
-///  - `memberBlock`: ``MemberBlockSyntax``
-public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+///
+/// ### Contained in
+/// 
+///  - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/extensionHeader``
+public struct ExtensionDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
   public init?(_ node: __shared some SyntaxProtocol) {
-    guard node.raw.kind == .extensionDecl else {
+    guard node.raw.kind == .extensionDeclHeader else {
       return nil
     }
     self._syntaxNode = node._syntaxNode
@@ -2144,7 +2233,6 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
   ///   - extendedType: The extended `type` for which the extension is added.
   ///   - inheritanceClause: The inheritance clause describing one or more conformances for this extension declaration.
   ///   - genericWhereClause: A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.
-  ///   - memberBlock: The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type.
   ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   public init(
     leadingTrivia: Trivia? = nil,
@@ -2160,9 +2248,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
     inheritanceClause: InheritanceClauseSyntax? = nil,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
     genericWhereClause: GenericWhereClauseSyntax? = nil,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
-    memberBlock: MemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil,
     trailingTrivia: Trivia? = nil
   ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
@@ -2180,9 +2266,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       inheritanceClause,
       unexpectedBetweenInheritanceClauseAndGenericWhereClause,
       genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
-      memberBlock,
-      unexpectedAfterMemberBlock
+      unexpectedAfterGenericWhereClause
     ))) { (arena, _) in
       let layout: [RawSyntax?] = [
         unexpectedBeforeAttributes?.raw,
@@ -2197,12 +2281,10 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
         inheritanceClause?.raw,
         unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw,
         genericWhereClause?.raw,
-        unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw,
-        memberBlock.raw,
-        unexpectedAfterMemberBlock?.raw
+        unexpectedAfterGenericWhereClause?.raw
       ]
       let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.extensionDecl,
+        kind: SyntaxKind.extensionDeclHeader,
         from: layout,
         arena: arena,
         leadingTrivia: leadingTrivia,
@@ -2217,7 +2299,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2235,7 +2317,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2247,7 +2329,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
   /// - returns: A copy of the receiver with the provided `Attribute`
   ///            appended to its `attributes` collection.
   @available(*, deprecated, message: "Use node.attributes.append(newElement) instead")
-  public func addAttribute(_ element: Syntax) -> ExtensionDeclSyntax {
+  public func addAttribute(_ element: Syntax) -> ExtensionDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[1] {
@@ -2263,7 +2345,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ExtensionDeclSyntax.self)
+      .cast(ExtensionDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
@@ -2271,7 +2353,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2281,7 +2363,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2293,7 +2375,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
   /// - returns: A copy of the receiver with the provided `Modifier`
   ///            appended to its `modifiers` collection.
   @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead")
-  public func addModifier(_ element: DeclModifierSyntax) -> ExtensionDeclSyntax {
+  public func addModifier(_ element: DeclModifierSyntax) -> ExtensionDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[3] {
@@ -2309,7 +2391,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ExtensionDeclSyntax.self)
+      .cast(ExtensionDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? {
@@ -2317,7 +2399,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2331,7 +2413,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2340,7 +2422,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2350,7 +2432,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 7)!.cast(TypeSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2359,7 +2441,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2369,7 +2451,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 9)?.cast(InheritanceClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2378,7 +2460,7 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
@@ -2388,52 +2470,156 @@ public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDecl
       return Syntax(self).child(at: 11)?.cast(GenericWhereClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
     }
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclHeaderSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([
+    \Self.unexpectedBeforeAttributes,
+    \Self.attributes,
+    \Self.unexpectedBetweenAttributesAndModifiers,
+    \Self.modifiers,
+    \Self.unexpectedBetweenModifiersAndExtensionKeyword,
+    \Self.extensionKeyword,
+    \Self.unexpectedBetweenExtensionKeywordAndExtendedType,
+    \Self.extendedType,
+    \Self.unexpectedBetweenExtendedTypeAndInheritanceClause,
+    \Self.inheritanceClause,
+    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+    \Self.genericWhereClause,
+    \Self.unexpectedAfterGenericWhereClause
+  ])
+}
+
+// MARK: - ExtensionDeclSyntax
+
+///   An `extension` declaration.
+/// 
+///  ### Example
+/// 
+///   ```swift
+///   extension String {
+///     var url: URL? {
+///       URL(string: self)
+///     }
+///   }
+///   ```
+///
+/// ### Children
+/// 
+///  - `extensionHeader`: ``ExtensionDeclHeaderSyntax``
+///  - `memberBlock`: ``MemberBlockSyntax``
+public struct ExtensionDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .extensionDecl else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - extensionHeader: The header of the extension declaration.
+  ///   - memberBlock: The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeExtensionHeader: UnexpectedNodesSyntax? = nil,
+    extensionHeader: ExtensionDeclHeaderSyntax,
+    _ unexpectedBetweenExtensionHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (
+      unexpectedBeforeExtensionHeader,
+      extensionHeader,
+      unexpectedBetweenExtensionHeaderAndMemberBlock,
+      memberBlock,
+      unexpectedAfterMemberBlock
+    ))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpectedBeforeExtensionHeader?.raw,
+        extensionHeader.raw,
+        unexpectedBetweenExtensionHeaderAndMemberBlock?.raw,
+        memberBlock.raw,
+        unexpectedAfterMemberBlock?.raw
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.extensionDecl,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeExtensionHeader: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+    }
+  }
+
+  /// The header of the extension declaration.
+  public var extensionHeader: ExtensionDeclHeaderSyntax {
+    get {
+      return Syntax(self).child(at: 1)!.cast(ExtensionDeclHeaderSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenExtensionHeaderAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
     }
   }
 
   /// The members of the extension declaration. As this is an extension, the contents of this member block isn't guaranteed to be a complete list of members for this type.
   public var memberBlock: MemberBlockSyntax {
     get {
-      return Syntax(self).child(at: 13)!.cast(MemberBlockSyntax.self)
+      return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
     }
   }
 
   public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
     get {
-      return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self)
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ExtensionDeclSyntax.self)
     }
   }
 
   public static let structure: SyntaxNodeStructure = .layout([
-    \Self.unexpectedBeforeAttributes,
-    \Self.attributes,
-    \Self.unexpectedBetweenAttributesAndModifiers,
-    \Self.modifiers,
-    \Self.unexpectedBetweenModifiersAndExtensionKeyword,
-    \Self.extensionKeyword,
-    \Self.unexpectedBetweenExtensionKeywordAndExtendedType,
-    \Self.extendedType,
-    \Self.unexpectedBetweenExtendedTypeAndInheritanceClause,
-    \Self.inheritanceClause,
-    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-    \Self.genericWhereClause,
-    \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock,
+    \Self.unexpectedBeforeExtensionHeader,
+    \Self.extensionHeader,
+    \Self.unexpectedBetweenExtensionHeaderAndMemberBlock,
     \Self.memberBlock,
     \Self.unexpectedAfterMemberBlock
   ])
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift
index 435fb46b38d..e2d3ecab57f 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesGHI.swift
@@ -319,14 +319,14 @@ public struct GenericArgumentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntax
 ///
 /// ### Contained in
 /// 
-///  - ``ActorDeclSyntax``.``ActorDeclSyntax/genericParameterClause``
-///  - ``ClassDeclSyntax``.``ClassDeclSyntax/genericParameterClause``
-///  - ``EnumDeclSyntax``.``EnumDeclSyntax/genericParameterClause``
+///  - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/genericParameterClause``
+///  - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/genericParameterClause``
+///  - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/genericParameterClause``
 ///  - ``FunctionDeclSyntax``.``FunctionDeclSyntax/genericParameterClause``
 ///  - ``InitializerDeclSyntax``.``InitializerDeclSyntax/genericParameterClause``
 ///  - ``MacroDeclSyntax``.``MacroDeclSyntax/genericParameterClause``
 ///  - ``NamedOpaqueReturnTypeSyntax``.``NamedOpaqueReturnTypeSyntax/genericParameterClause``
-///  - ``StructDeclSyntax``.``StructDeclSyntax/genericParameterClause``
+///  - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/genericParameterClause``
 ///  - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/genericParameterClause``
 ///  - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/genericParameterClause``
 public struct GenericParameterClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
@@ -1136,19 +1136,21 @@ public struct GenericSpecializationExprSyntax: ExprSyntaxProtocol, SyntaxHashabl
 ///
 /// ### Contained in
 /// 
-///  - ``ActorDeclSyntax``.``ActorDeclSyntax/genericWhereClause``
+///  - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/genericWhereClause``
 ///  - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/genericWhereClause``
-///  - ``ClassDeclSyntax``.``ClassDeclSyntax/genericWhereClause``
+///  - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/genericWhereClause``
+///  - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/genericWhereClause``
 ///  - ``DifferentiableAttributeArgumentsSyntax``.``DifferentiableAttributeArgumentsSyntax/genericWhereClause``
-///  - ``EnumDeclSyntax``.``EnumDeclSyntax/genericWhereClause``
-///  - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/genericWhereClause``
+///  - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/genericWhereClause``
+///  - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/genericWhereClause``
 ///  - ``FunctionDeclSyntax``.``FunctionDeclSyntax/genericWhereClause``
 ///  - ``GenericParameterClauseSyntax``.``GenericParameterClauseSyntax/genericWhereClause``
 ///  - ``InitializerDeclSyntax``.``InitializerDeclSyntax/genericWhereClause``
 ///  - ``MacroDeclSyntax``.``MacroDeclSyntax/genericWhereClause``
-///  - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/genericWhereClause``
+///  - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/genericWhereClause``
+///  - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/genericWhereClause``
 ///  - ``SpecializeAttributeArgumentListSyntax``
-///  - ``StructDeclSyntax``.``StructDeclSyntax/genericWhereClause``
+///  - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/genericWhereClause``
 ///  - ``SubscriptDeclSyntax``.``SubscriptDeclSyntax/genericWhereClause``
 ///  - ``TypeAliasDeclSyntax``.``TypeAliasDeclSyntax/genericWhereClause``
 public struct GenericWhereClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
@@ -3427,13 +3429,15 @@ public struct InfixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Leaf
 ///
 /// ### Contained in
 /// 
-///  - ``ActorDeclSyntax``.``ActorDeclSyntax/inheritanceClause``
+///  - ``ActorDeclHeaderSyntax``.``ActorDeclHeaderSyntax/inheritanceClause``
 ///  - ``AssociatedTypeDeclSyntax``.``AssociatedTypeDeclSyntax/inheritanceClause``
-///  - ``ClassDeclSyntax``.``ClassDeclSyntax/inheritanceClause``
-///  - ``EnumDeclSyntax``.``EnumDeclSyntax/inheritanceClause``
-///  - ``ExtensionDeclSyntax``.``ExtensionDeclSyntax/inheritanceClause``
-///  - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/inheritanceClause``
-///  - ``StructDeclSyntax``.``StructDeclSyntax/inheritanceClause``
+///  - ``ClassDeclHeaderSyntax``.``ClassDeclHeaderSyntax/inheritanceClause``
+///  - ``DeclGroupHeaderSyntax``.``DeclGroupHeaderSyntax/inheritanceClause``
+///  - ``EnumDeclHeaderSyntax``.``EnumDeclHeaderSyntax/inheritanceClause``
+///  - ``ExtensionDeclHeaderSyntax``.``ExtensionDeclHeaderSyntax/inheritanceClause``
+///  - ``MissingDeclHeaderSyntax``.``MissingDeclHeaderSyntax/inheritanceClause``
+///  - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/inheritanceClause``
+///  - ``StructDeclHeaderSyntax``.``StructDeclHeaderSyntax/inheritanceClause``
 public struct InheritanceClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
index 9f48aab9adf..619ba52ef5f 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesJKLMN.swift
@@ -4050,6 +4050,266 @@ public struct MetatypeTypeSyntax: TypeSyntaxProtocol, SyntaxHashable, _LeafTypeS
   ])
 }
 
+// MARK: - MissingDeclHeaderSyntax
+
+/// In case the source code is missing a declaration group header, this node stands in place of the missing header.
+///
+/// ### Children
+/// 
+///  - `attributes`: ``AttributeListSyntax``
+///  - `modifiers`: ``DeclModifierListSyntax``
+///  - `placeholder`: `<identifier>`
+///  - `inheritanceClause`: ``InheritanceClauseSyntax``?
+///  - `genericWhereClause`: ``GenericWhereClauseSyntax``?
+public struct MissingDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol {
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .missingDeclHeader else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - attributes: If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.
+  ///   - modifiers: If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.
+  ///   - placeholder: A placeholder, i.e. `<#decl#>`, that can be inserted into the source code to represent the missing declaration.
+  ///   - genericWhereClause: A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    _ unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    _ unexpectedBetweenModifiersAndPlaceholder: UnexpectedNodesSyntax? = nil,
+    placeholder: TokenSyntax,
+    _ unexpectedBetweenPlaceholderAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (
+      unexpectedBeforeAttributes,
+      attributes,
+      unexpectedBetweenAttributesAndModifiers,
+      modifiers,
+      unexpectedBetweenModifiersAndPlaceholder,
+      placeholder,
+      unexpectedBetweenPlaceholderAndInheritanceClause,
+      inheritanceClause,
+      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+      genericWhereClause,
+      unexpectedAfterGenericWhereClause
+    ))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpectedBeforeAttributes?.raw,
+        attributes.raw,
+        unexpectedBetweenAttributesAndModifiers?.raw,
+        modifiers.raw,
+        unexpectedBetweenModifiersAndPlaceholder?.raw,
+        placeholder.raw,
+        unexpectedBetweenPlaceholderAndInheritanceClause?.raw,
+        inheritanceClause?.raw,
+        unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw,
+        genericWhereClause?.raw,
+        unexpectedAfterGenericWhereClause?.raw
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.missingDeclHeader,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeAttributes: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  /// If there were standalone attributes without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.
+  public var attributes: AttributeListSyntax {
+    get {
+      return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  /// Adds the provided `element` to the node's `attributes`
+  /// collection.
+  ///
+  /// - param element: The new `Attribute` to add to the node's
+  ///                  `attributes` collection.
+  /// - returns: A copy of the receiver with the provided `Attribute`
+  ///            appended to its `attributes` collection.
+  @available(*, deprecated, message: "Use node.attributes.append(newElement) instead")
+  public func addAttribute(_ element: Syntax) -> MissingDeclHeaderSyntax {
+    var collection: RawSyntax
+    let arena = SyntaxArena()
+    if let col = raw.layoutView!.children[1] {
+      collection = col.layoutView!.appending(element.raw, arena: arena)
+    } else {
+      collection = RawSyntax.makeLayout(kind: SyntaxKind.attributeList,
+                                        from: [element.raw], arena: arena)
+    }
+    return Syntax(self)
+      .replacingChild(
+        at: 1,
+        with: collection,
+        rawNodeArena: arena,
+        allocationArena: arena
+      )
+      .cast(MissingDeclHeaderSyntax.self)
+  }
+
+  public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  /// If there were standalone modifiers without a declaration to attach them to, the ``MissingDeclSyntax`` will contain these.
+  public var modifiers: DeclModifierListSyntax {
+    get {
+      return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  /// Adds the provided `element` to the node's `modifiers`
+  /// collection.
+  ///
+  /// - param element: The new `Modifier` to add to the node's
+  ///                  `modifiers` collection.
+  /// - returns: A copy of the receiver with the provided `Modifier`
+  ///            appended to its `modifiers` collection.
+  @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead")
+  public func addModifier(_ element: DeclModifierSyntax) -> MissingDeclHeaderSyntax {
+    var collection: RawSyntax
+    let arena = SyntaxArena()
+    if let col = raw.layoutView!.children[3] {
+      collection = col.layoutView!.appending(element.raw, arena: arena)
+    } else {
+      collection = RawSyntax.makeLayout(kind: SyntaxKind.declModifierList,
+                                        from: [element.raw], arena: arena)
+    }
+    return Syntax(self)
+      .replacingChild(
+        at: 3,
+        with: collection,
+        rawNodeArena: arena,
+        allocationArena: arena
+      )
+      .cast(MissingDeclHeaderSyntax.self)
+  }
+
+  public var unexpectedBetweenModifiersAndPlaceholder: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  /// A placeholder, i.e. `<#decl#>`, that can be inserted into the source code to represent the missing declaration.
+  /// 
+  /// This token should always have `presence = .missing`.
+  ///
+  /// ### Tokens
+  /// 
+  /// For syntax trees generated by the parser, this is guaranteed to be `<identifier>`.
+  public var placeholder: TokenSyntax {
+    get {
+      return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenPlaceholderAndInheritanceClause: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  public var inheritanceClause: InheritanceClauseSyntax? {
+    get {
+      return Syntax(self).child(at: 7)?.cast(InheritanceClauseSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  /// A `where` clause that places additional constraints on generic parameters like `where Element: Hashable`.
+  public var genericWhereClause: GenericWhereClauseSyntax? {
+    get {
+      return Syntax(self).child(at: 9)?.cast(GenericWhereClauseSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(MissingDeclHeaderSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([
+    \Self.unexpectedBeforeAttributes,
+    \Self.attributes,
+    \Self.unexpectedBetweenAttributesAndModifiers,
+    \Self.modifiers,
+    \Self.unexpectedBetweenModifiersAndPlaceholder,
+    \Self.placeholder,
+    \Self.unexpectedBetweenPlaceholderAndInheritanceClause,
+    \Self.inheritanceClause,
+    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+    \Self.genericWhereClause,
+    \Self.unexpectedAfterGenericWhereClause
+  ])
+}
+
 // MARK: - MissingDeclSyntax
 
 /// In case the source code is missing a declaration, this node stands in place of the missing declaration.
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift
index f137e4e5989..3baf488d246 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesOP.swift
@@ -4032,7 +4032,7 @@ public struct PrefixOperatorExprSyntax: ExprSyntaxProtocol, SyntaxHashable, _Lea
 ///
 /// ### Contained in
 /// 
-///  - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/primaryAssociatedTypeClause``
+///  - ``ProtocolDeclHeaderSyntax``.``ProtocolDeclHeaderSyntax/primaryAssociatedTypeClause``
 public struct PrimaryAssociatedTypeClauseSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
@@ -4314,16 +4314,14 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
   ])
 }
 
-// MARK: - ProtocolDeclSyntax
+// MARK: - ProtocolDeclHeaderSyntax
 
-/// A `protocol` declaration
+/// A `protocol` declaration header
 /// 
-/// An example of a protocol declaration is
+/// An example of a protocol declaration header is
 /// 
 /// ```swift
-/// protocol Example {
-///   var isValid: Bool { get }
-/// }
+/// protocol Example
 /// ```
 ///
 /// ### Children
@@ -4335,12 +4333,15 @@ public struct PrimaryAssociatedTypeSyntax: SyntaxProtocol, SyntaxHashable, _Leaf
 ///  - `primaryAssociatedTypeClause`: ``PrimaryAssociatedTypeClauseSyntax``?
 ///  - `inheritanceClause`: ``InheritanceClauseSyntax``?
 ///  - `genericWhereClause`: ``GenericWhereClauseSyntax``?
-///  - `memberBlock`: ``MemberBlockSyntax``
-public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+///
+/// ### Contained in
+/// 
+///  - ``ProtocolDeclSyntax``.``ProtocolDeclSyntax/protocolHeader``
+public struct ProtocolDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
   public init?(_ node: __shared some SyntaxProtocol) {
-    guard node.raw.kind == .protocolDecl else {
+    guard node.raw.kind == .protocolDeclHeader else {
       return nil
     }
     self._syntaxNode = node._syntaxNode
@@ -4355,7 +4356,6 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
   ///   - primaryAssociatedTypeClause: The primary associated type for the protocol.
   ///   - inheritanceClause: The inheritance clause describing one or more conformances for this protocol declaration.
   ///   - genericWhereClause: The `where` clause that applies to the generic parameters of this protocol declaration.
-  ///   - memberBlock: The members of the protocol declaration.
   ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   public init(
     leadingTrivia: Trivia? = nil,
@@ -4373,9 +4373,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
     inheritanceClause: InheritanceClauseSyntax? = nil,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
     genericWhereClause: GenericWhereClauseSyntax? = nil,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
-    memberBlock: MemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil,
     trailingTrivia: Trivia? = nil
   ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
@@ -4395,9 +4393,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       inheritanceClause,
       unexpectedBetweenInheritanceClauseAndGenericWhereClause,
       genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
-      memberBlock,
-      unexpectedAfterMemberBlock
+      unexpectedAfterGenericWhereClause
     ))) { (arena, _) in
       let layout: [RawSyntax?] = [
         unexpectedBeforeAttributes?.raw,
@@ -4414,12 +4410,10 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
         inheritanceClause?.raw,
         unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw,
         genericWhereClause?.raw,
-        unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw,
-        memberBlock.raw,
-        unexpectedAfterMemberBlock?.raw
+        unexpectedAfterGenericWhereClause?.raw
       ]
       let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.protocolDecl,
+        kind: SyntaxKind.protocolDeclHeader,
         from: layout,
         arena: arena,
         leadingTrivia: leadingTrivia,
@@ -4434,7 +4428,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4444,7 +4438,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4456,7 +4450,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
   /// - returns: A copy of the receiver with the provided `Attribute`
   ///            appended to its `attributes` collection.
   @available(*, deprecated, message: "Use node.attributes.append(newElement) instead")
-  public func addAttribute(_ element: Syntax) -> ProtocolDeclSyntax {
+  public func addAttribute(_ element: Syntax) -> ProtocolDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[1] {
@@ -4472,7 +4466,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ProtocolDeclSyntax.self)
+      .cast(ProtocolDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
@@ -4480,7 +4474,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4490,7 +4484,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4502,7 +4496,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
   /// - returns: A copy of the receiver with the provided `Modifier`
   ///            appended to its `modifiers` collection.
   @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead")
-  public func addModifier(_ element: DeclModifierSyntax) -> ProtocolDeclSyntax {
+  public func addModifier(_ element: DeclModifierSyntax) -> ProtocolDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[3] {
@@ -4518,7 +4512,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(ProtocolDeclSyntax.self)
+      .cast(ProtocolDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? {
@@ -4526,7 +4520,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4540,7 +4534,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4549,7 +4543,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4563,7 +4557,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 7)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4572,7 +4566,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4582,7 +4576,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 9)?.cast(PrimaryAssociatedTypeClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4591,7 +4585,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4601,7 +4595,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4610,7 +4604,7 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
@@ -4620,54 +4614,156 @@ public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclS
       return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
     }
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclHeaderSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([
+    \Self.unexpectedBeforeAttributes,
+    \Self.attributes,
+    \Self.unexpectedBetweenAttributesAndModifiers,
+    \Self.modifiers,
+    \Self.unexpectedBetweenModifiersAndProtocolKeyword,
+    \Self.protocolKeyword,
+    \Self.unexpectedBetweenProtocolKeywordAndName,
+    \Self.name,
+    \Self.unexpectedBetweenNameAndPrimaryAssociatedTypeClause,
+    \Self.primaryAssociatedTypeClause,
+    \Self.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause,
+    \Self.inheritanceClause,
+    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+    \Self.genericWhereClause,
+    \Self.unexpectedAfterGenericWhereClause
+  ])
+}
+
+// MARK: - ProtocolDeclSyntax
+
+/// A `protocol` declaration
+/// 
+/// An example of a protocol declaration is
+/// 
+/// ```swift
+/// protocol Example {
+///   var isValid: Bool { get }
+/// }
+/// ```
+///
+/// ### Children
+/// 
+///  - `protocolHeader`: ``ProtocolDeclHeaderSyntax``
+///  - `memberBlock`: ``MemberBlockSyntax``
+public struct ProtocolDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .protocolDecl else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - protocolHeader: The header of the protocol.
+  ///   - memberBlock: The members of the protocol declaration.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeProtocolHeader: UnexpectedNodesSyntax? = nil,
+    protocolHeader: ProtocolDeclHeaderSyntax,
+    _ unexpectedBetweenProtocolHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (
+      unexpectedBeforeProtocolHeader,
+      protocolHeader,
+      unexpectedBetweenProtocolHeaderAndMemberBlock,
+      memberBlock,
+      unexpectedAfterMemberBlock
+    ))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpectedBeforeProtocolHeader?.raw,
+        protocolHeader.raw,
+        unexpectedBetweenProtocolHeaderAndMemberBlock?.raw,
+        memberBlock.raw,
+        unexpectedAfterMemberBlock?.raw
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.protocolDecl,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeProtocolHeader: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+    }
+  }
+
+  /// The header of the protocol.
+  public var protocolHeader: ProtocolDeclHeaderSyntax {
+    get {
+      return Syntax(self).child(at: 1)!.cast(ProtocolDeclHeaderSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenProtocolHeaderAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
     }
   }
 
   /// The members of the protocol declaration.
   public var memberBlock: MemberBlockSyntax {
     get {
-      return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self)
+      return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
     }
   }
 
   public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
     get {
-      return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self)
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(ProtocolDeclSyntax.self)
     }
   }
 
   public static let structure: SyntaxNodeStructure = .layout([
-    \Self.unexpectedBeforeAttributes,
-    \Self.attributes,
-    \Self.unexpectedBetweenAttributesAndModifiers,
-    \Self.modifiers,
-    \Self.unexpectedBetweenModifiersAndProtocolKeyword,
-    \Self.protocolKeyword,
-    \Self.unexpectedBetweenProtocolKeywordAndName,
-    \Self.name,
-    \Self.unexpectedBetweenNameAndPrimaryAssociatedTypeClause,
-    \Self.primaryAssociatedTypeClause,
-    \Self.unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause,
-    \Self.inheritanceClause,
-    \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-    \Self.genericWhereClause,
-    \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock,
+    \Self.unexpectedBeforeProtocolHeader,
+    \Self.protocolHeader,
+    \Self.unexpectedBetweenProtocolHeaderAndMemberBlock,
     \Self.memberBlock,
     \Self.unexpectedAfterMemberBlock
   ])
diff --git a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift
index 87750e981a9..74932b91ccb 100644
--- a/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift
+++ b/Sources/SwiftSyntax/generated/syntaxNodes/SyntaxNodesQRS.swift
@@ -2173,64 +2173,29 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo
   public static let structure: SyntaxNodeStructure = .layout([\Self.unexpectedBeforeContent, \Self.content, \Self.unexpectedAfterContent])
 }
 
-// MARK: - StructDeclSyntax
+// MARK: - StructDeclHeaderSyntax
 
-/// A `struct` declaration
-/// 
-/// An example of a struct declaration is
-/// 
-/// ```swift
-/// struct SomeStruct {
-///   let someMember: String
-///   var anotherMember: Int
-/// 
-///   func foo() {
-///     print(someMember)
-///   }
-/// 
-///   mutating func bar() {
-///     anotherMember = 42
-///   }
-/// }
-/// ```
+/// A `struct` declaration header
 /// 
-/// A struct declaration may be declared without any members.
+/// An example of a struct declaration header is
 /// 
 /// ```swift
-/// struct EmptyStruct {
-/// 
-/// }
+/// struct SomeStruct
 /// ```
 /// 
 /// A struct declaration may include a type inheritance clause listing
-/// one or more protocols the struct conforms to.
-/// 
-/// The example below uses Hashable and Equatable protocols whose members
-/// are automatically synthesized by the compiler if the struct contains
-/// stored members that are themselves `Hashable` and `Equatable`.
+/// one or more protocols the struct conforms to. The example below uses
+/// Hashable and Equatable protocols.
 /// 
 /// ```swift
-/// struct AdvancedStruct: Hashable, Equatable {
-///   let someMember: String
-///   var anotherMember: Int
-/// }
+/// struct AdvancedStruct: Hashable, Equatable
 /// ```
 /// 
 /// A struct declaration may include a generic parameter clause as well
 /// as a generic where clause.
 /// 
 /// ```swift
-/// struct Stack<Element> {
-///   var items: [Element] = []
-/// 
-///   mutating func push(_ item: Element) {
-///     items.append(item)
-///   }
-/// 
-///   mutating func pop() -> Element {
-///     return items.removeLast()
-///   }
-/// }
+/// struct Stack<Element>
 /// ```
 ///
 /// ### Children
@@ -2242,12 +2207,15 @@ public struct StringSegmentSyntax: SyntaxProtocol, SyntaxHashable, _LeafSyntaxNo
 ///  - `genericParameterClause`: ``GenericParameterClauseSyntax``?
 ///  - `inheritanceClause`: ``InheritanceClauseSyntax``?
 ///  - `genericWhereClause`: ``GenericWhereClauseSyntax``?
-///  - `memberBlock`: ``MemberBlockSyntax``
-public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+///
+/// ### Contained in
+/// 
+///  - ``StructDeclSyntax``.``StructDeclSyntax/structHeader``
+public struct StructDeclHeaderSyntax: DeclGroupHeaderSyntaxProtocol, SyntaxHashable, _LeafDeclGroupHeaderSyntaxNodeProtocol {
   public let _syntaxNode: Syntax
 
   public init?(_ node: __shared some SyntaxProtocol) {
-    guard node.raw.kind == .structDecl else {
+    guard node.raw.kind == .structDeclHeader else {
       return nil
     }
     self._syntaxNode = node._syntaxNode
@@ -2262,7 +2230,6 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
   ///   - genericParameterClause: The generic parameters, if any, of the struct declaration.
   ///   - inheritanceClause: The struct declaration inheritance clause describing one or more conformances for this struct declaration.
   ///   - genericWhereClause: The `where` clause that applies to the generic parameters of this struct declaration.
-  ///   - memberBlock: The members of the struct declaration. Because struct extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type.
   ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
   public init(
     leadingTrivia: Trivia? = nil,
@@ -2280,9 +2247,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
     inheritanceClause: InheritanceClauseSyntax? = nil,
     _ unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
     genericWhereClause: GenericWhereClauseSyntax? = nil,
-    _ unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
-    memberBlock: MemberBlockSyntax,
-    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    _ unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? = nil,
     trailingTrivia: Trivia? = nil
   ) {
     // Extend the lifetime of all parameters so their arenas don't get destroyed
@@ -2302,9 +2267,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       inheritanceClause,
       unexpectedBetweenInheritanceClauseAndGenericWhereClause,
       genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
-      memberBlock,
-      unexpectedAfterMemberBlock
+      unexpectedAfterGenericWhereClause
     ))) { (arena, _) in
       let layout: [RawSyntax?] = [
         unexpectedBeforeAttributes?.raw,
@@ -2321,12 +2284,10 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
         inheritanceClause?.raw,
         unexpectedBetweenInheritanceClauseAndGenericWhereClause?.raw,
         genericWhereClause?.raw,
-        unexpectedBetweenGenericWhereClauseAndMemberBlock?.raw,
-        memberBlock.raw,
-        unexpectedAfterMemberBlock?.raw
+        unexpectedAfterGenericWhereClause?.raw
       ]
       let raw = RawSyntax.makeLayout(
-        kind: SyntaxKind.structDecl,
+        kind: SyntaxKind.structDeclHeader,
         from: layout,
         arena: arena,
         leadingTrivia: leadingTrivia,
@@ -2341,7 +2302,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2351,7 +2312,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 1)!.cast(AttributeListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2363,7 +2324,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
   /// - returns: A copy of the receiver with the provided `Attribute`
   ///            appended to its `attributes` collection.
   @available(*, deprecated, message: "Use node.attributes.append(newElement) instead")
-  public func addAttribute(_ element: Syntax) -> StructDeclSyntax {
+  public func addAttribute(_ element: Syntax) -> StructDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[1] {
@@ -2379,7 +2340,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(StructDeclSyntax.self)
+      .cast(StructDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? {
@@ -2387,7 +2348,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2397,7 +2358,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 3)!.cast(DeclModifierListSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2409,7 +2370,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
   /// - returns: A copy of the receiver with the provided `Modifier`
   ///            appended to its `modifiers` collection.
   @available(*, deprecated, message: "Use node.modifiers.append(newElement) instead")
-  public func addModifier(_ element: DeclModifierSyntax) -> StructDeclSyntax {
+  public func addModifier(_ element: DeclModifierSyntax) -> StructDeclHeaderSyntax {
     var collection: RawSyntax
     let arena = SyntaxArena()
     if let col = raw.layoutView!.children[3] {
@@ -2425,7 +2386,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
         rawNodeArena: arena,
         allocationArena: arena
       )
-      .cast(StructDeclSyntax.self)
+      .cast(StructDeclHeaderSyntax.self)
   }
 
   public var unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? {
@@ -2433,7 +2394,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2447,7 +2408,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 5)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 5, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2456,7 +2417,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 6)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 6, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2470,7 +2431,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 7)!.cast(TokenSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 7, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2479,7 +2440,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 8)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 8, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2489,7 +2450,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 9)?.cast(GenericParameterClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 9, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2498,7 +2459,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 10)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 10, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2508,7 +2469,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 11)?.cast(InheritanceClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 11, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2517,7 +2478,7 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 12)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 12, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2527,35 +2488,16 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
       return Syntax(self).child(at: 13)?.cast(GenericWhereClauseSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 13, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
-  public var unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? {
+  public var unexpectedAfterGenericWhereClause: UnexpectedNodesSyntax? {
     get {
       return Syntax(self).child(at: 14)?.cast(UnexpectedNodesSyntax.self)
     }
     set(value) {
-      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
-    }
-  }
-
-  /// The members of the struct declaration. Because struct extension declarations may declare additional members the contents of this member block isn't guaranteed to be a complete list of members for this type.
-  public var memberBlock: MemberBlockSyntax {
-    get {
-      return Syntax(self).child(at: 15)!.cast(MemberBlockSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 15, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
-    }
-  }
-
-  public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
-    get {
-      return Syntax(self).child(at: 16)?.cast(UnexpectedNodesSyntax.self)
-    }
-    set(value) {
-      self = Syntax(self).replacingChild(at: 16, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+      self = Syntax(self).replacingChild(at: 14, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclHeaderSyntax.self)
     }
   }
 
@@ -2574,7 +2516,176 @@ public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyn
     \Self.inheritanceClause,
     \Self.unexpectedBetweenInheritanceClauseAndGenericWhereClause,
     \Self.genericWhereClause,
-    \Self.unexpectedBetweenGenericWhereClauseAndMemberBlock,
+    \Self.unexpectedAfterGenericWhereClause
+  ])
+}
+
+// MARK: - StructDeclSyntax
+
+/// A `struct` declaration
+/// 
+/// An example of a struct declaration is
+/// 
+/// ```swift
+/// struct SomeStruct {
+///   let someMember: String
+///   var anotherMember: Int
+/// 
+///   func foo() {
+///     print(someMember)
+///   }
+/// 
+///   mutating func bar() {
+///     anotherMember = 42
+///   }
+/// }
+/// ```
+/// 
+/// A struct declaration may be declared without any members.
+/// 
+/// ```swift
+/// struct EmptyStruct {
+/// 
+/// }
+/// ```
+/// 
+/// A struct declaration may include a type inheritance clause listing
+/// one or more protocols the struct conforms to.
+/// 
+/// The example below uses Hashable and Equatable protocols whose members
+/// are automatically synthesized by the compiler if the struct contains
+/// stored members that are themselves `Hashable` and `Equatable`.
+/// 
+/// ```swift
+/// struct AdvancedStruct: Hashable, Equatable {
+///   let someMember: String
+///   var anotherMember: Int
+/// }
+/// ```
+/// 
+/// A struct declaration may include a generic parameter clause as well
+/// as a generic where clause.
+/// 
+/// ```swift
+/// struct Stack<Element> {
+///   var items: [Element] = []
+/// 
+///   mutating func push(_ item: Element) {
+///     items.append(item)
+///   }
+/// 
+///   mutating func pop() -> Element {
+///     return items.removeLast()
+///   }
+/// }
+/// ```
+///
+/// ### Children
+/// 
+///  - `structHeader`: ``StructDeclHeaderSyntax``
+///  - `memberBlock`: ``MemberBlockSyntax``
+public struct StructDeclSyntax: DeclSyntaxProtocol, SyntaxHashable, _LeafDeclSyntaxNodeProtocol {
+  public let _syntaxNode: Syntax
+
+  public init?(_ node: __shared some SyntaxProtocol) {
+    guard node.raw.kind == .structDecl else {
+      return nil
+    }
+    self._syntaxNode = node._syntaxNode
+  }
+
+  /// - Parameters:
+  ///   - leadingTrivia: Trivia to be prepended to the leading trivia of the node’s first token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  ///   - structHeader: Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it.
+  ///   - memberBlock: The header of the struct declaration.
+  ///   - trailingTrivia: Trivia to be appended to the trailing trivia of the node’s last token. If the node is empty, there is no token to attach the trivia to and the parameter is ignored.
+  public init(
+    leadingTrivia: Trivia? = nil,
+    _ unexpectedBeforeStructHeader: UnexpectedNodesSyntax? = nil,
+    structHeader: StructDeclHeaderSyntax,
+    _ unexpectedBetweenStructHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    memberBlock: MemberBlockSyntax,
+    _ unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    trailingTrivia: Trivia? = nil
+  ) {
+    // Extend the lifetime of all parameters so their arenas don't get destroyed
+    // before they can be added as children of the new arena.
+    self = withExtendedLifetime((SyntaxArena(), (
+      unexpectedBeforeStructHeader,
+      structHeader,
+      unexpectedBetweenStructHeaderAndMemberBlock,
+      memberBlock,
+      unexpectedAfterMemberBlock
+    ))) { (arena, _) in
+      let layout: [RawSyntax?] = [
+        unexpectedBeforeStructHeader?.raw,
+        structHeader.raw,
+        unexpectedBetweenStructHeaderAndMemberBlock?.raw,
+        memberBlock.raw,
+        unexpectedAfterMemberBlock?.raw
+      ]
+      let raw = RawSyntax.makeLayout(
+        kind: SyntaxKind.structDecl,
+        from: layout,
+        arena: arena,
+        leadingTrivia: leadingTrivia,
+        trailingTrivia: trailingTrivia
+      )
+      return Syntax.forRoot(raw, rawNodeArena: arena).cast(Self.self)
+    }
+  }
+
+  public var unexpectedBeforeStructHeader: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 0)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 0, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+    }
+  }
+
+  /// Declares the name of this struct. If the name matches a reserved keyword use backticks to escape it.
+  public var structHeader: StructDeclHeaderSyntax {
+    get {
+      return Syntax(self).child(at: 1)!.cast(StructDeclHeaderSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 1, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedBetweenStructHeaderAndMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 2)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 2, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+    }
+  }
+
+  /// The header of the struct declaration.
+  public var memberBlock: MemberBlockSyntax {
+    get {
+      return Syntax(self).child(at: 3)!.cast(MemberBlockSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 3, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+    }
+  }
+
+  public var unexpectedAfterMemberBlock: UnexpectedNodesSyntax? {
+    get {
+      return Syntax(self).child(at: 4)?.cast(UnexpectedNodesSyntax.self)
+    }
+    set(value) {
+      self = Syntax(self).replacingChild(at: 4, with: Syntax(value), arena: SyntaxArena()).cast(StructDeclSyntax.self)
+    }
+  }
+
+  public static let structure: SyntaxNodeStructure = .layout([
+    \Self.unexpectedBeforeStructHeader,
+    \Self.structHeader,
+    \Self.unexpectedBetweenStructHeaderAndMemberBlock,
     \Self.memberBlock,
     \Self.unexpectedAfterMemberBlock
   ])
diff --git a/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift b/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift
index abf3d4a0f45..4889916c27b 100644
--- a/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift
+++ b/Sources/SwiftSyntaxBuilder/Syntax+StringInterpolation.swift
@@ -184,6 +184,22 @@ public struct SyntaxStringInterpolationInvalidNodeTypeError: Error, CustomString
   }
 }
 
+/// Describes an error when building a syntax node with string interpolation resulted in an unexpected node type.
+public struct SyntaxStringInterpolationInvalidHeaderForNodeTypeError: Error, CustomStringConvertible {
+  let declType: SyntaxProtocol.Type
+  let headerType: SyntaxProtocol.Type
+
+  /// Initialize the invalid node type error providing an expected type, and the actual node that resulted.
+  public init<S: SyntaxProtocol>(declType: SyntaxProtocol.Type, headerNode: S) {
+    self.declType = declType
+    self.headerType = type(of: headerNode)
+  }
+
+  public var description: String {
+    return "Attempted to construct an \(declType) declaration with a header of mismatched type \(headerType)"
+  }
+}
+
 /// A string interpolation error based on a ``SwiftDiagnostics/Diagnostic``.
 struct SyntaxStringInterpolationDiagnosticError: Error, CustomStringConvertible {
   let diagnostics: [Diagnostic]
diff --git a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift
index 6d0f2dae993..9f3796e1ec7 100644
--- a/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift
+++ b/Sources/SwiftSyntaxBuilder/SyntaxNodeWithBody.swift
@@ -177,32 +177,27 @@ public protocol HasTrailingMemberDeclBlock {
   ///
   /// Throws an error if `header` defines a different node type than the type the initializer is called on. E.g. if calling `try StructDeclSyntax("class MyClass") {}`
   init(
-    _ header: SyntaxNodeString,
+    _ header: DeclGroupHeaderSyntax,
     @MemberBlockItemListBuilder membersBuilder: () throws -> MemberBlockItemListSyntax
   ) throws
 }
 
-extension HasTrailingMemberDeclBlock where Self: DeclSyntaxProtocol {
+extension HasTrailingMemberDeclBlock where Self: DeclGroupSyntax {
   public init(
-    _ header: SyntaxNodeString,
+    _ header: DeclGroupHeaderSyntax,
     @MemberBlockItemListBuilder membersBuilder: () throws -> MemberBlockItemListSyntax
   ) throws {
-    // If the type provides a custom `SyntaxParseable` implementation, use that. Otherwise construct it as a
-    // `DeclSyntax`.
-    let decl: DeclSyntax
-    var stringInterpolation = SyntaxStringInterpolation(literalCapacity: 1, interpolationCount: 1)
-    stringInterpolation.appendInterpolation(header)
-    stringInterpolation.appendLiteral(" {}")
-    if let parsableType = Self.self as? SyntaxParseable.Type {
-      decl = parsableType.init(stringInterpolation: stringInterpolation).cast(DeclSyntax.self)
-    } else {
-      decl = DeclSyntax(stringInterpolation: stringInterpolation)
+    guard
+      let newSelf = Self(
+        leadingTrivia: nil,
+        header: header,
+        memberBlock: try MemberBlockSyntax(members: membersBuilder()),
+        trailingTrivia: nil
+      )
+    else {
+      throw SyntaxStringInterpolationInvalidHeaderForNodeTypeError(declType: Self.self, headerNode: header)
     }
-    guard let castedDecl = decl.as(Self.self) else {
-      throw SyntaxStringInterpolationInvalidNodeTypeError(expectedType: Self.self, actualNode: decl)
-    }
-    self = castedDecl
-    self.memberBlock = try MemberBlockSyntax(members: membersBuilder())
+    self = newSelf
   }
 }
 
diff --git a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift
index 964df2e93cc..0ce6e1b3ed4 100644
--- a/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift
+++ b/Sources/SwiftSyntaxBuilder/generated/BuildableNodes.swift
@@ -63,42 +63,18 @@ extension ActorDeclSyntax {
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
     leadingTrivia: Trivia? = nil,
-    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
-    attributes: AttributeListSyntax = [],
-    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
-    modifiers: DeclModifierListSyntax = [],
-    unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil,
-    actorKeyword: TokenSyntax = .keyword(.actor),
-    unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? = nil,
-    name: TokenSyntax,
-    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
-    genericParameterClause: GenericParameterClauseSyntax? = nil,
-    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
-    inheritanceClause: InheritanceClauseSyntax? = nil,
-    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
-    genericWhereClause: GenericWhereClauseSyntax? = nil,
-    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedBeforeActorHeader: UnexpectedNodesSyntax? = nil,
+    actorHeader: ActorDeclHeaderSyntax,
+    unexpectedBetweenActorHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
     unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
     @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
     trailingTrivia: Trivia? = nil
   ) rethrows {
     try self.init(
       leadingTrivia: leadingTrivia,
-      unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndActorKeyword,
-      actorKeyword: actorKeyword,
-      unexpectedBetweenActorKeywordAndName,
-      name: name,
-      unexpectedBetweenNameAndGenericParameterClause,
-      genericParameterClause: genericParameterClause,
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      unexpectedBeforeActorHeader,
+      actorHeader: actorHeader,
+      unexpectedBetweenActorHeaderAndMemberBlock,
       memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
       unexpectedAfterMemberBlock,
       trailingTrivia: trailingTrivia
@@ -164,42 +140,18 @@ extension ClassDeclSyntax {
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
     leadingTrivia: Trivia? = nil,
-    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
-    attributes: AttributeListSyntax = [],
-    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
-    modifiers: DeclModifierListSyntax = [],
-    unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil,
-    classKeyword: TokenSyntax = .keyword(.class),
-    unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? = nil,
-    name: TokenSyntax,
-    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
-    genericParameterClause: GenericParameterClauseSyntax? = nil,
-    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
-    inheritanceClause: InheritanceClauseSyntax? = nil,
-    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
-    genericWhereClause: GenericWhereClauseSyntax? = nil,
-    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedBeforeClassHeader: UnexpectedNodesSyntax? = nil,
+    classHeader: ClassDeclHeaderSyntax,
+    unexpectedBetweenClassHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
     unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
     @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
     trailingTrivia: Trivia? = nil
   ) rethrows {
     try self.init(
       leadingTrivia: leadingTrivia,
-      unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndClassKeyword,
-      classKeyword: classKeyword,
-      unexpectedBetweenClassKeywordAndName,
-      name: name,
-      unexpectedBetweenNameAndGenericParameterClause,
-      genericParameterClause: genericParameterClause,
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      unexpectedBeforeClassHeader,
+      classHeader: classHeader,
+      unexpectedBetweenClassHeaderAndMemberBlock,
       memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
       unexpectedAfterMemberBlock,
       trailingTrivia: trailingTrivia
@@ -445,42 +397,18 @@ extension EnumDeclSyntax {
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
     leadingTrivia: Trivia? = nil,
-    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
-    attributes: AttributeListSyntax = [],
-    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
-    modifiers: DeclModifierListSyntax = [],
-    unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil,
-    enumKeyword: TokenSyntax = .keyword(.enum),
-    unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? = nil,
-    name: TokenSyntax,
-    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
-    genericParameterClause: GenericParameterClauseSyntax? = nil,
-    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
-    inheritanceClause: InheritanceClauseSyntax? = nil,
-    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
-    genericWhereClause: GenericWhereClauseSyntax? = nil,
-    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedBeforeEnumHeader: UnexpectedNodesSyntax? = nil,
+    enumHeader: EnumDeclHeaderSyntax,
+    unexpectedBetweenEnumHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
     unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
     @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
     trailingTrivia: Trivia? = nil
   ) rethrows {
     try self.init(
       leadingTrivia: leadingTrivia,
-      unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndEnumKeyword,
-      enumKeyword: enumKeyword,
-      unexpectedBetweenEnumKeywordAndName,
-      name: name,
-      unexpectedBetweenNameAndGenericParameterClause,
-      genericParameterClause: genericParameterClause,
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      unexpectedBeforeEnumHeader,
+      enumHeader: enumHeader,
+      unexpectedBetweenEnumHeaderAndMemberBlock,
       memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
       unexpectedAfterMemberBlock,
       trailingTrivia: trailingTrivia
@@ -527,38 +455,18 @@ extension ExtensionDeclSyntax {
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
     leadingTrivia: Trivia? = nil,
-    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
-    attributes: AttributeListSyntax = [],
-    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
-    modifiers: DeclModifierListSyntax = [],
-    unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil,
-    extensionKeyword: TokenSyntax = .keyword(.extension),
-    unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil,
-    extendedType: TypeSyntaxProtocol,
-    unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil,
-    inheritanceClause: InheritanceClauseSyntax? = nil,
-    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
-    genericWhereClause: GenericWhereClauseSyntax? = nil,
-    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedBeforeExtensionHeader: UnexpectedNodesSyntax? = nil,
+    extensionHeader: ExtensionDeclHeaderSyntax,
+    unexpectedBetweenExtensionHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
     unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
     @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
     trailingTrivia: Trivia? = nil
   ) rethrows {
     try self.init(
       leadingTrivia: leadingTrivia,
-      unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndExtensionKeyword,
-      extensionKeyword: extensionKeyword,
-      unexpectedBetweenExtensionKeywordAndExtendedType,
-      extendedType: TypeSyntax(fromProtocol: extendedType),
-      unexpectedBetweenExtendedTypeAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      unexpectedBeforeExtensionHeader,
+      extensionHeader: extensionHeader,
+      unexpectedBetweenExtensionHeaderAndMemberBlock,
       memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
       unexpectedAfterMemberBlock,
       trailingTrivia: trailingTrivia
@@ -1115,42 +1023,18 @@ extension ProtocolDeclSyntax {
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
     leadingTrivia: Trivia? = nil,
-    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
-    attributes: AttributeListSyntax = [],
-    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
-    modifiers: DeclModifierListSyntax = [],
-    unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil,
-    protocolKeyword: TokenSyntax = .keyword(.protocol),
-    unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? = nil,
-    name: TokenSyntax,
-    unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil,
-    primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil,
-    unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
-    inheritanceClause: InheritanceClauseSyntax? = nil,
-    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
-    genericWhereClause: GenericWhereClauseSyntax? = nil,
-    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedBeforeProtocolHeader: UnexpectedNodesSyntax? = nil,
+    protocolHeader: ProtocolDeclHeaderSyntax,
+    unexpectedBetweenProtocolHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
     unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
     @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
     trailingTrivia: Trivia? = nil
   ) rethrows {
     try self.init(
       leadingTrivia: leadingTrivia,
-      unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndProtocolKeyword,
-      protocolKeyword: protocolKeyword,
-      unexpectedBetweenProtocolKeywordAndName,
-      name: name,
-      unexpectedBetweenNameAndPrimaryAssociatedTypeClause,
-      primaryAssociatedTypeClause: primaryAssociatedTypeClause,
-      unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      unexpectedBeforeProtocolHeader,
+      protocolHeader: protocolHeader,
+      unexpectedBetweenProtocolHeaderAndMemberBlock,
       memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
       unexpectedAfterMemberBlock,
       trailingTrivia: trailingTrivia
@@ -1239,42 +1123,18 @@ extension StructDeclSyntax {
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
     leadingTrivia: Trivia? = nil,
-    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
-    attributes: AttributeListSyntax = [],
-    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
-    modifiers: DeclModifierListSyntax = [],
-    unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil,
-    structKeyword: TokenSyntax = .keyword(.struct),
-    unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? = nil,
-    name: TokenSyntax,
-    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
-    genericParameterClause: GenericParameterClauseSyntax? = nil,
-    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
-    inheritanceClause: InheritanceClauseSyntax? = nil,
-    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
-    genericWhereClause: GenericWhereClauseSyntax? = nil,
-    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedBeforeStructHeader: UnexpectedNodesSyntax? = nil,
+    structHeader: StructDeclHeaderSyntax,
+    unexpectedBetweenStructHeaderAndMemberBlock: UnexpectedNodesSyntax? = nil,
     unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
     @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
     trailingTrivia: Trivia? = nil
   ) rethrows {
     try self.init(
       leadingTrivia: leadingTrivia,
-      unexpectedBeforeAttributes,
-      attributes: attributes,
-      unexpectedBetweenAttributesAndModifiers,
-      modifiers: modifiers,
-      unexpectedBetweenModifiersAndStructKeyword,
-      structKeyword: structKeyword,
-      unexpectedBetweenStructKeywordAndName,
-      name: name,
-      unexpectedBetweenNameAndGenericParameterClause,
-      genericParameterClause: genericParameterClause,
-      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
-      inheritanceClause: inheritanceClause,
-      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
-      genericWhereClause: genericWhereClause,
-      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      unexpectedBeforeStructHeader,
+      structHeader: structHeader,
+      unexpectedBetweenStructHeaderAndMemberBlock,
       memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
       unexpectedAfterMemberBlock,
       trailingTrivia: trailingTrivia
diff --git a/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift b/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift
index 7cfa6227fb2..15b3ca14519 100644
--- a/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift
+++ b/Sources/SwiftSyntaxBuilder/generated/RenamedChildrenBuilderCompatibility.swift
@@ -62,7 +62,56 @@ extension AccessorDeclSyntax {
 }
 
 extension ActorDeclSyntax {
-  @available(*, deprecated, message: "Use an initializer with name argument(s).")
+  @available(*, deprecated, message: "Use an initializer with actorHeader argument(s).")
+  @_disfavoredOverload
+  /// A convenience initializer that allows initializing syntax collections using result builders
+  public init(
+    leadingTrivia: Trivia? = nil,
+    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    unexpectedBetweenModifiersAndActorKeyword: UnexpectedNodesSyntax? = nil,
+    actorKeyword: TokenSyntax = .keyword(.actor),
+    unexpectedBetweenActorKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
+    trailingTrivia: Trivia? = nil
+  ) rethrows {
+    try self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      attributes: attributes,
+      unexpectedBetweenAttributesAndModifiers,
+      modifiers: modifiers,
+      unexpectedBetweenModifiersAndActorKeyword,
+      actorKeyword: actorKeyword,
+      unexpectedBetweenActorKeywordAndName,
+      name: name,
+      unexpectedBetweenNameAndGenericParameterClause,
+      genericParameterClause: genericParameterClause,
+      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+      inheritanceClause: inheritanceClause,
+      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+      genericWhereClause: genericWhereClause,
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension ActorDeclSyntax {
+  @available(*, deprecated, message: "Use an initializer with actorHeader argument(s).")
   @_disfavoredOverload
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
@@ -140,7 +189,56 @@ extension ArrayExprSyntax {
 }
 
 extension ClassDeclSyntax {
-  @available(*, deprecated, message: "Use an initializer with name argument(s).")
+  @available(*, deprecated, message: "Use an initializer with classHeader argument(s).")
+  @_disfavoredOverload
+  /// A convenience initializer that allows initializing syntax collections using result builders
+  public init(
+    leadingTrivia: Trivia? = nil,
+    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    unexpectedBetweenModifiersAndClassKeyword: UnexpectedNodesSyntax? = nil,
+    classKeyword: TokenSyntax = .keyword(.class),
+    unexpectedBetweenClassKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
+    trailingTrivia: Trivia? = nil
+  ) rethrows {
+    try self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      attributes: attributes,
+      unexpectedBetweenAttributesAndModifiers,
+      modifiers: modifiers,
+      unexpectedBetweenModifiersAndClassKeyword,
+      classKeyword: classKeyword,
+      unexpectedBetweenClassKeywordAndName,
+      name: name,
+      unexpectedBetweenNameAndGenericParameterClause,
+      genericParameterClause: genericParameterClause,
+      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+      inheritanceClause: inheritanceClause,
+      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+      genericWhereClause: genericWhereClause,
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension ClassDeclSyntax {
+  @available(*, deprecated, message: "Use an initializer with classHeader argument(s).")
   @_disfavoredOverload
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
@@ -189,7 +287,56 @@ extension ClassDeclSyntax {
 }
 
 extension EnumDeclSyntax {
-  @available(*, deprecated, message: "Use an initializer with name, genericParameterClause argument(s).")
+  @available(*, deprecated, message: "Use an initializer with enumHeader argument(s).")
+  @_disfavoredOverload
+  /// A convenience initializer that allows initializing syntax collections using result builders
+  public init(
+    leadingTrivia: Trivia? = nil,
+    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    unexpectedBetweenModifiersAndEnumKeyword: UnexpectedNodesSyntax? = nil,
+    enumKeyword: TokenSyntax = .keyword(.enum),
+    unexpectedBetweenEnumKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
+    trailingTrivia: Trivia? = nil
+  ) rethrows {
+    try self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      attributes: attributes,
+      unexpectedBetweenAttributesAndModifiers,
+      modifiers: modifiers,
+      unexpectedBetweenModifiersAndEnumKeyword,
+      enumKeyword: enumKeyword,
+      unexpectedBetweenEnumKeywordAndName,
+      name: name,
+      unexpectedBetweenNameAndGenericParameterClause,
+      genericParameterClause: genericParameterClause,
+      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+      inheritanceClause: inheritanceClause,
+      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+      genericWhereClause: genericWhereClause,
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension EnumDeclSyntax {
+  @available(*, deprecated, message: "Use an initializer with enumHeader argument(s).")
   @_disfavoredOverload
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
@@ -274,6 +421,51 @@ extension ExpressionSegmentSyntax {
   }
 }
 
+extension ExtensionDeclSyntax {
+  @available(*, deprecated, message: "Use an initializer with extensionHeader argument(s).")
+  @_disfavoredOverload
+  /// A convenience initializer that allows initializing syntax collections using result builders
+  public init(
+    leadingTrivia: Trivia? = nil,
+    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    unexpectedBetweenModifiersAndExtensionKeyword: UnexpectedNodesSyntax? = nil,
+    extensionKeyword: TokenSyntax = .keyword(.extension),
+    unexpectedBetweenExtensionKeywordAndExtendedType: UnexpectedNodesSyntax? = nil,
+    extendedType: TypeSyntaxProtocol,
+    unexpectedBetweenExtendedTypeAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
+    trailingTrivia: Trivia? = nil
+  ) rethrows {
+    try self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      attributes: attributes,
+      unexpectedBetweenAttributesAndModifiers,
+      modifiers: modifiers,
+      unexpectedBetweenModifiersAndExtensionKeyword,
+      extensionKeyword: extensionKeyword,
+      unexpectedBetweenExtensionKeywordAndExtendedType,
+      extendedType: TypeSyntax(fromProtocol: extendedType),
+      unexpectedBetweenExtendedTypeAndInheritanceClause,
+      inheritanceClause: inheritanceClause,
+      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+      genericWhereClause: genericWhereClause,
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
 extension ForStmtSyntax {
   @available(*, deprecated, message: "Use an initializer with sequence argument(s).")
   @_disfavoredOverload
@@ -700,7 +892,56 @@ extension MacroExpansionExprSyntax {
 }
 
 extension ProtocolDeclSyntax {
-  @available(*, deprecated, message: "Use an initializer with name argument(s).")
+  @available(*, deprecated, message: "Use an initializer with protocolHeader argument(s).")
+  @_disfavoredOverload
+  /// A convenience initializer that allows initializing syntax collections using result builders
+  public init(
+    leadingTrivia: Trivia? = nil,
+    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    unexpectedBetweenModifiersAndProtocolKeyword: UnexpectedNodesSyntax? = nil,
+    protocolKeyword: TokenSyntax = .keyword(.protocol),
+    unexpectedBetweenProtocolKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    unexpectedBetweenNameAndPrimaryAssociatedTypeClause: UnexpectedNodesSyntax? = nil,
+    primaryAssociatedTypeClause: PrimaryAssociatedTypeClauseSyntax? = nil,
+    unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
+    trailingTrivia: Trivia? = nil
+  ) rethrows {
+    try self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      attributes: attributes,
+      unexpectedBetweenAttributesAndModifiers,
+      modifiers: modifiers,
+      unexpectedBetweenModifiersAndProtocolKeyword,
+      protocolKeyword: protocolKeyword,
+      unexpectedBetweenProtocolKeywordAndName,
+      name: name,
+      unexpectedBetweenNameAndPrimaryAssociatedTypeClause,
+      primaryAssociatedTypeClause: primaryAssociatedTypeClause,
+      unexpectedBetweenPrimaryAssociatedTypeClauseAndInheritanceClause,
+      inheritanceClause: inheritanceClause,
+      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+      genericWhereClause: genericWhereClause,
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension ProtocolDeclSyntax {
+  @available(*, deprecated, message: "Use an initializer with protocolHeader argument(s).")
   @_disfavoredOverload
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
@@ -778,7 +1019,56 @@ extension SourceFileSyntax {
 }
 
 extension StructDeclSyntax {
-  @available(*, deprecated, message: "Use an initializer with name argument(s).")
+  @available(*, deprecated, message: "Use an initializer with structHeader argument(s).")
+  @_disfavoredOverload
+  /// A convenience initializer that allows initializing syntax collections using result builders
+  public init(
+    leadingTrivia: Trivia? = nil,
+    unexpectedBeforeAttributes: UnexpectedNodesSyntax? = nil,
+    attributes: AttributeListSyntax = [],
+    unexpectedBetweenAttributesAndModifiers: UnexpectedNodesSyntax? = nil,
+    modifiers: DeclModifierListSyntax = [],
+    unexpectedBetweenModifiersAndStructKeyword: UnexpectedNodesSyntax? = nil,
+    structKeyword: TokenSyntax = .keyword(.struct),
+    unexpectedBetweenStructKeywordAndName: UnexpectedNodesSyntax? = nil,
+    name: TokenSyntax,
+    unexpectedBetweenNameAndGenericParameterClause: UnexpectedNodesSyntax? = nil,
+    genericParameterClause: GenericParameterClauseSyntax? = nil,
+    unexpectedBetweenGenericParameterClauseAndInheritanceClause: UnexpectedNodesSyntax? = nil,
+    inheritanceClause: InheritanceClauseSyntax? = nil,
+    unexpectedBetweenInheritanceClauseAndGenericWhereClause: UnexpectedNodesSyntax? = nil,
+    genericWhereClause: GenericWhereClauseSyntax? = nil,
+    unexpectedBetweenGenericWhereClauseAndMemberBlock: UnexpectedNodesSyntax? = nil,
+    unexpectedAfterMemberBlock: UnexpectedNodesSyntax? = nil,
+    @MemberBlockItemListBuilder memberBlockBuilder: () throws -> MemberBlockItemListSyntax,
+    trailingTrivia: Trivia? = nil
+  ) rethrows {
+    try self.init(
+      leadingTrivia: leadingTrivia,
+      unexpectedBeforeAttributes,
+      attributes: attributes,
+      unexpectedBetweenAttributesAndModifiers,
+      modifiers: modifiers,
+      unexpectedBetweenModifiersAndStructKeyword,
+      structKeyword: structKeyword,
+      unexpectedBetweenStructKeywordAndName,
+      name: name,
+      unexpectedBetweenNameAndGenericParameterClause,
+      genericParameterClause: genericParameterClause,
+      unexpectedBetweenGenericParameterClauseAndInheritanceClause,
+      inheritanceClause: inheritanceClause,
+      unexpectedBetweenInheritanceClauseAndGenericWhereClause,
+      genericWhereClause: genericWhereClause,
+      unexpectedBetweenGenericWhereClauseAndMemberBlock,
+      memberBlock: MemberBlockSyntax(members: memberBlockBuilder()),
+      unexpectedAfterMemberBlock,
+      trailingTrivia: trailingTrivia
+    )
+  }
+}
+
+extension StructDeclSyntax {
+  @available(*, deprecated, message: "Use an initializer with structHeader argument(s).")
   @_disfavoredOverload
   /// A convenience initializer that allows initializing syntax collections using result builders
   public init(
diff --git a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift
index 0db493dbdf4..5452d63eb0e 100644
--- a/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift
+++ b/Sources/SwiftSyntaxBuilder/generated/SyntaxExpressibleByStringInterpolationConformances.swift
@@ -60,6 +60,12 @@ extension CodeBlockSyntax: SyntaxExpressibleByStringInterpolation {}
 extension CodeBlockSyntax: Swift.ExpressibleByStringInterpolation {}
 #endif
 
+extension DeclGroupHeaderSyntax: SyntaxExpressibleByStringInterpolation {}
+
+#if compiler(>=6)
+extension DeclGroupHeaderSyntax: Swift.ExpressibleByStringInterpolation {}
+#endif
+
 extension DeclSyntax: SyntaxExpressibleByStringInterpolation {}
 
 #if compiler(>=6)
diff --git a/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift b/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift
index a0c54cab223..f4f813db79b 100644
--- a/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift
+++ b/Sources/SwiftSyntaxMacroExpansion/MacroSystem.swift
@@ -1490,7 +1490,7 @@ private extension SyntaxProtocol {
   var syntacticQualifiedTypeContext: TypeSyntax? {
     if let ext = self.as(ExtensionDeclSyntax.self) {
       // Don't handle nested 'extension' cases - they are invalid anyway.
-      return ext.extendedType.trimmed
+      return ext.extensionHeader.extendedType.trimmed
     }
 
     let base = self.parent?.syntacticQualifiedTypeContext
diff --git a/Tests/SwiftParserTest/AttributeTests.swift b/Tests/SwiftParserTest/AttributeTests.swift
index 882839b06ce..8631d1ae25e 100644
--- a/Tests/SwiftParserTest/AttributeTests.swift
+++ b/Tests/SwiftParserTest/AttributeTests.swift
@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-@_spi(RawSyntax) import SwiftParser
-@_spi(RawSyntax) import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftParser
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax
 import XCTest
 
 final class AttributeTests: ParserTestCase {
@@ -965,6 +965,272 @@ final class AttributeTests: ParserTestCase {
     )
   }
 
+  func testABIAttribute() {
+    func abiAttr(_ provider: ABIAttributeArgumentsSyntax.Provider) -> AttributeListSyntax.Element {
+      return .attribute(
+        AttributeSyntax(
+          attributeName: TypeSyntax("abi"),
+          leftParen: .leftParenToken(),
+          arguments: .abiArguments(
+            ABIAttributeArgumentsSyntax(
+              provider: provider
+            )
+          ),
+          rightParen: .rightParenToken()
+        )
+      )
+    }
+
+    assertParse(
+      """
+      @abi(func fn() -> Int)
+      func fn1() -> Int { }
+      """,
+      substructure: FunctionDeclSyntax(
+        attributes: [
+          abiAttr(
+            .function(
+              FunctionDeclSyntax(
+                name: "fn",
+                signature: FunctionSignatureSyntax(
+                  parameterClause: FunctionParameterClauseSyntax {},
+                  returnClause: ReturnClauseSyntax(type: TypeSyntax("Int"))
+                ),
+                body: nil
+              )
+            )
+          )
+        ],
+        name: "fn1",
+        signature: FunctionSignatureSyntax(
+          parameterClause: FunctionParameterClauseSyntax {},
+          returnClause: ReturnClauseSyntax(type: TypeSyntax("Int"))
+        )
+      ) {},
+      experimentalFeatures: [.abiAttribute]
+    )
+
+    assertParse(
+      """
+      @abi(associatedtype AssocTy)
+      associatedtype AssocTy
+
+      @abi(actor Actor)
+      actor Actor {}
+
+      @abi(class Class)
+      class Class {}
+
+      @abi(enum Enum)
+      enum Enum {}
+
+      @abi(extension Extension)
+      extension Extension {}
+
+      @abi(protocol Protocol)
+      protocol Protocol {}
+
+      @abi(struct Struct)
+      struct Struct {}
+
+      @abi(deinit)
+      deinit {}
+
+      enum EnumCaseDeclNotParsedAtTopLevel {
+        @abi(case someCase)
+        case someCase
+      }
+
+      @abi(func fn())
+      func fn()
+
+      @abi(init())
+      init() {}
+
+      @abi(subscript(i: Int) -> Element)
+      subscript(i: Int) -> Element {}
+
+      @abi(typealias Typealias = @escaping () -> Void)
+      typealias Typealias = () -> Void
+
+      @abi(let c1, c2)
+      let c1, c2
+
+      @abi(var v1, v2)
+      var v1, v2
+      """,
+      experimentalFeatures: [.abiAttribute]
+    )
+
+    assertParse(
+      """
+      @abi(1️⃣<#fnord#>)
+      func placeholder() {}
+      """,
+      substructure: abiAttr(
+        .unsupported(
+          DeclSyntax(
+            MissingDeclSyntax(placeholder: .identifier("<#fnord#>"))
+          )
+        )
+      ),
+      diagnostics: [
+        DiagnosticSpec(locationMarker: "1️⃣", message: "editor placeholder in source file")
+      ],
+      experimentalFeatures: [.abiAttribute]
+    )
+
+    assertParse(
+      """
+      @abi(1️⃣import Fnord)
+      func invalidDecl() {}
+      """,
+      substructure: abiAttr(
+        .unsupported(
+          DeclSyntax(
+            ImportDeclSyntax(
+              path: [ImportPathComponentSyntax(name: "Fnord")]
+            )
+          )
+        )
+      ),
+      experimentalFeatures: [.abiAttribute]
+    )
+
+    assertParse(
+      """
+      @abi(class Sub: Super, Proto where Assoc: OtherProto)
+      class Sub: Super, Proto where Assoc: OtherProto {}
+      """,
+      experimentalFeatures: [.abiAttribute]
+    )
+
+    // Invalid, but diagnosed in ASTGen
+    assertParse(
+      """
+      @abi(associatedtype AssocTy = T)
+      associatedtype AssocTy
+
+      @abi(deinit {})
+      deinit {}
+
+      enum EnumCaseDeclNotParsedAtTopLevel {
+        @abi(case someCase = 42)
+        case someCase
+      }
+
+      @abi(func fn() {})
+      func fn()
+
+      @abi(init() {})
+      init() {}
+
+      @abi(subscript(i: Int) -> Element { get {} set {} })
+      subscript(i: Int) -> Element {}
+
+      @abi(let c1 = 1, c2 = 2)
+      let c1, c2
+
+      @abi(var v1 = 1, v2 = 2)
+      var v1, v2
+
+      @abi(var v3 { get {} set {} })
+      var v3
+      """,
+      experimentalFeatures: [.abiAttribute]
+    )
+
+    // Caught here
+    assertParse(
+      """
+      @abi(class Sub: Super, Proto where Assoc: OtherProto 1️⃣{})
+      class Sub: Super, Proto where Assoc: OtherProto {}
+
+      @abi(var 2️⃣)
+      var v1
+
+      @abi4️⃣(var v23️⃣
+      var v2
+
+      @abi(5️⃣)
+      func fn2() {}
+
+      @abi6️⃣
+      func fn3() {}
+
+      // Suboptimal:
+      @abi7️⃣ func fn4_abi()8️⃣)
+      func fn4() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "class header in '@abi' attribute cannot have a member block",
+          fixIts: ["remove member block"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "expected pattern in variable",
+          fixIts: ["insert pattern"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "3️⃣",
+          message: "expected ')' to end attribute",
+          notes: [
+            NoteSpec(
+              locationMarker: "4️⃣",
+              message: "to match this opening '('"
+            )
+          ],
+          fixIts: ["insert ')'"]
+        ),
+        // FIXME: Custom fix-it with copy of decl it's attached to
+        DiagnosticSpec(
+          locationMarker: "5️⃣",
+          message: "expected argument for '@abi' attribute",
+          fixIts: ["insert attribute argument"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "6️⃣",
+          message: "expected '(', ABI-providing declaration, and ')' in attribute",
+          fixIts: ["insert '(', ABI-providing declaration, and ')'"]
+        ),
+        // FIXME: Suboptimal diagnosis
+        DiagnosticSpec(
+          locationMarker: "7️⃣",
+          message: "expected '(', ABI-providing declaration, and ')' in attribute",
+          fixIts: ["insert '(', ABI-providing declaration, and ')'"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "8️⃣",
+          message: "unexpected code ')' before function"
+        ),
+      ],
+      // FIXME: Would love to have the fix-it delete the space before the close paren on the first line
+      fixedSource: """
+        @abi(class Sub: Super, Proto where Assoc: OtherProto )
+        class Sub: Super, Proto where Assoc: OtherProto {}
+
+        @abi(var <#pattern#>)
+        var v1
+
+        @abi(var v2)
+        var v2
+
+        @abi(<#declaration#>)
+        func fn2() {}
+
+        @abi(<#declaration#>)
+        func fn3() {}
+
+        // Suboptimal:
+        @abi(<#declaration#>) func fn4_abi())
+        func fn4() {}
+        """,
+      experimentalFeatures: [.abiAttribute]
+    )
+  }
+
   func testSpaceBetweenAtAndAttribute() {
     assertParse(
       "@1️⃣ custom func foo() {}",
diff --git a/Tests/SwiftParserTest/DeclarationTests.swift b/Tests/SwiftParserTest/DeclarationTests.swift
index 345ca2739e9..c4c7113f702 100644
--- a/Tests/SwiftParserTest/DeclarationTests.swift
+++ b/Tests/SwiftParserTest/DeclarationTests.swift
@@ -2337,8 +2337,10 @@ final class DeclarationTests: ParserTestCase {
         CodeBlockItemSyntax(
           item: .init(
             ClassDeclSyntax(
-              classKeyword: .keyword(.class),
-              name: .identifier("A"),
+              classHeader: ClassDeclHeaderSyntax(
+                classKeyword: .keyword(.class),
+                name: .identifier("A")
+              ),
               memberBlock: MemberBlockSyntax(
                 leftBrace: .leftBraceToken(),
                 members: MemberBlockItemListSyntax(),
@@ -2351,8 +2353,10 @@ final class DeclarationTests: ParserTestCase {
         CodeBlockItemSyntax(
           item: .init(
             ClassDeclSyntax(
-              classKeyword: .keyword(.class),
-              name: .identifier("B"),
+              classHeader: .init(
+                classKeyword: .keyword(.class),
+                name: .identifier("B")
+              ),
               memberBlock: MemberBlockSyntax(
                 leftBrace: .leftBraceToken(),
                 members: MemberBlockItemListSyntax(),
diff --git a/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift b/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift
index 69b56b06e9f..f3794787ebc 100644
--- a/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift
+++ b/Tests/SwiftParserTest/translated/HashbangLibraryTests.swift
@@ -31,14 +31,16 @@ final class HashbangLibraryTests: ParserTestCase {
             item: .decl(
               DeclSyntax(
                 ClassDeclSyntax(
-                  classKeyword: .keyword(
-                    .class,
-                    leadingTrivia: [
-                      .newlines(1)
-                    ],
-                    trailingTrivia: .space
+                  classHeader: ClassDeclHeaderSyntax(
+                    classKeyword: .keyword(
+                      .class,
+                      leadingTrivia: [
+                        .newlines(1)
+                      ],
+                      trailingTrivia: .space
+                    ),
+                    name: .identifier("Foo", trailingTrivia: .space)
                   ),
-                  name: .identifier("Foo", trailingTrivia: .space),
                   memberBlock: MemberBlockSyntax(
                     members: MemberBlockItemListSyntax([])
                   )
diff --git a/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift b/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift
index 1f217e35e31..14b947435ef 100644
--- a/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift
+++ b/Tests/SwiftSyntaxBuilderTest/ClassDeclSyntaxTests.swift
@@ -35,7 +35,7 @@ final class ClassDeclSyntaxTests: XCTestCase {
   }
 
   func testThrowableClass() throws {
-    let buildable = try ClassDeclSyntax(name: .identifier("Foo")) {
+    let buildable = try ClassDeclSyntax(classHeader: .init(name: .identifier("Foo"))) {
       try FunctionDeclSyntax("func foo() -> String") {
         StmtSyntax(#"return "hello world""#)
       }
@@ -54,7 +54,7 @@ final class ClassDeclSyntaxTests: XCTestCase {
   }
 
   func testNodeWithoutAnchorPointInResultBuilder() throws {
-    let buildable = ClassDeclSyntax(name: .identifier("Foo")) {
+    let buildable = ClassDeclSyntax(classHeader: .init(name: .identifier("Foo"))) {
       DeclSyntax(
         """
           func foo() -> String {
diff --git a/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift b/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift
index 7ebd79605f1..1239d762d51 100644
--- a/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift
+++ b/Tests/SwiftSyntaxBuilderTest/EnumCaseElementTests.swift
@@ -19,12 +19,14 @@ final class EnumCaseElementTests: XCTestCase {
     let leadingTrivia = Trivia.unexpectedText("␣")
     let buildable = EnumDeclSyntax(
       leadingTrivia: leadingTrivia,
-      name: "Greeting",
-      inheritanceClause: InheritanceClauseSyntax {
-        InheritedTypeSyntax(type: TypeSyntax("String"))
-        InheritedTypeSyntax(type: TypeSyntax("Codable"))
-        InheritedTypeSyntax(type: TypeSyntax("Equatable"))
-      }
+      enumHeader: .init(
+        name: "Greeting",
+        inheritanceClause: InheritanceClauseSyntax {
+          InheritedTypeSyntax(type: TypeSyntax("String"))
+          InheritedTypeSyntax(type: TypeSyntax("Codable"))
+          InheritedTypeSyntax(type: TypeSyntax("Equatable"))
+        }
+      )
     ) {
       MemberBlockItemSyntax(
         decl: EnumCaseDeclSyntax {
diff --git a/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift b/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift
index 8cb9ea1a7e4..ed3a418567c 100644
--- a/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift
+++ b/Tests/SwiftSyntaxBuilderTest/ExtensionDeclTests.swift
@@ -36,7 +36,7 @@ final class ExtensionDeclTests: XCTestCase {
     }
     let members = MemberBlockItemListSyntax(keywords.map { MemberBlockItemSyntax(decl: $0) })
     let buildable = ExtensionDeclSyntax(
-      extendedType: TypeSyntax("TokenSyntax"),
+      extensionHeader: .init(extendedType: TypeSyntax("TokenSyntax")),
       memberBlock: MemberBlockSyntax(members: members)
     )
 
diff --git a/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift b/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift
index 9e6b10c9835..436eb67fba4 100644
--- a/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift
+++ b/Tests/SwiftSyntaxBuilderTest/SourceFileTests.swift
@@ -20,8 +20,10 @@ final class SourceFileTests: XCTestCase {
       DeclSyntax("import Foundation")
       DeclSyntax("import UIKit")
       ClassDeclSyntax(
-        classKeyword: .keyword(.class),
-        name: "SomeViewController",
+        classHeader: .init(
+          classKeyword: .keyword(.class),
+          name: "SomeViewController"
+        ),
         memberBlockBuilder: {
           DeclSyntax("let tableView: UITableView")
         }
diff --git a/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift b/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift
index 4194894c0e8..53a2eea23f4 100644
--- a/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift
+++ b/Tests/SwiftSyntaxBuilderTest/StringInterpolationTests.swift
@@ -349,7 +349,7 @@ final class StringInterpolationTests: XCTestCase {
   }
 
   func testStringInterpolationInBuilder() {
-    let ext = ExtensionDeclSyntax(extendedType: TypeSyntax("MyType")) {
+    let ext = ExtensionDeclSyntax(extensionHeader: .init(extendedType: TypeSyntax("MyType"))) {
       DeclSyntax(
         """
         ///
diff --git a/Tests/SwiftSyntaxBuilderTest/StructTests.swift b/Tests/SwiftSyntaxBuilderTest/StructTests.swift
index 94d2e09dc20..e2f1ad41cef 100644
--- a/Tests/SwiftSyntaxBuilderTest/StructTests.swift
+++ b/Tests/SwiftSyntaxBuilderTest/StructTests.swift
@@ -17,7 +17,7 @@ import XCTest
 final class StructTests: XCTestCase {
   func testEmptyStruct() {
     let leadingTrivia = Trivia.unexpectedText("␣")
-    let buildable = StructDeclSyntax(leadingTrivia: leadingTrivia, name: "TestStruct") {}
+    let buildable = StructDeclSyntax(leadingTrivia: leadingTrivia, structHeader: .init(name: "TestStruct")) {}
 
     assertBuildResult(
       buildable,
@@ -44,8 +44,10 @@ final class StructTests: XCTestCase {
         .docLineComment("/// with multi line comment where the newline is a CR"),
         .carriageReturns(1),
       ],
-      structKeyword: .keyword(.struct),
-      name: "CarriateReturnsStruct",
+      structHeader: .init(
+        structKeyword: .keyword(.struct),
+        name: "CarriateReturnsStruct"
+      ),
       memberBlock: MemberBlockSyntax(members: [])
     )
     let carriageReturnFormFeedsStruct = StructDeclSyntax(
@@ -55,8 +57,10 @@ final class StructTests: XCTestCase {
         .docLineComment("/// with multi line comment where the newline is a CRLF"),
         .carriageReturnLineFeeds(1),
       ],
-      structKeyword: .keyword(.struct),
-      name: "CarriageReturnFormFeedsStruct",
+      structHeader: .init(
+        structKeyword: .keyword(.struct),
+        name: "CarriageReturnFormFeedsStruct"
+      ),
       memberBlock: MemberBlockSyntax(members: [])
     )
     let testStruct = try StructDeclSyntax("public struct TestStruct") {
@@ -87,7 +91,7 @@ final class StructTests: XCTestCase {
   }
 
   func testControlWithLoopAndIf() {
-    let myStruct = StructDeclSyntax(name: "MyStruct") {
+    let myStruct = StructDeclSyntax(structHeader: .init(name: "MyStruct")) {
       for i in 0..<5 {
         if i.isMultiple(of: 2) {
           VariableDeclSyntax(bindingSpecifier: .keyword(.let)) {
diff --git a/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift b/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift
index 533a2a4d19f..8f77c925334 100644
--- a/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift
+++ b/Tests/SwiftSyntaxMacroExpansionTest/LexicalContextTests.swift
@@ -134,7 +134,7 @@ extension SyntaxProtocol {
     // Extensions
     if let extensionDecl = self.as(ExtensionDeclSyntax.self) {
       // FIXME: It would be nice to be able to switch on type syntax...
-      let extendedType = extensionDecl.extendedType
+      let extendedType = extensionDecl.extensionHeader.extendedType
       if let simple = extendedType.as(IdentifierTypeSyntax.self) {
         return simple.name.trimmedDescription
       }
diff --git a/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift b/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift
index 48f1fcc7aaf..4aa93d57a67 100644
--- a/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift
+++ b/Tests/SwiftSyntaxMacroExpansionTest/MemberMacroTests.swift
@@ -450,7 +450,7 @@ final class MemberMacroTests: XCTestCase {
                   // This doesn't account for other attributes that *could* be present in the
                   // attribute list, but for this test it will be fine.
                   .replace(
-                    oldNode: Syntax(declaration.attributes),
+                    oldNode: Syntax(declaration.header.attributes),
                     newNode: Syntax(AttributeListSyntax())
                   )
                 ]
diff --git a/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift b/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift
index 862f3e0f3f7..b5ad9d84b60 100644
--- a/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift
+++ b/Tests/SwiftSyntaxMacrosTestSupportTests/AssertionsTests.swift
@@ -33,7 +33,7 @@ final class AssertionsTests: XCTestCase {
       if let structDecl = declaration.as(StructDeclSyntax.self) {
         context.diagnose(
           .init(
-            node: structDecl.structKeyword,
+            node: structDecl.structHeader.structKeyword,
             message: OnlyStruct()
           )
         )
@@ -52,11 +52,11 @@ final class AssertionsTests: XCTestCase {
       if let structDecl = declaration.as(StructDeclSyntax.self) {
         context.diagnose(
           .init(
-            node: structDecl.structKeyword,
+            node: structDecl.structHeader.structKeyword,
             message: OnlyStruct(),
             highlights: [
-              Syntax(structDecl.structKeyword),
-              Syntax(structDecl.name),
+              Syntax(structDecl.structHeader.structKeyword),
+              Syntax(structDecl.structHeader.name),
             ]
           )
         )
diff --git a/Tests/SwiftSyntaxTest/RawSyntaxTests.swift b/Tests/SwiftSyntaxTest/RawSyntaxTests.swift
index 67a6074dc1a..502fbaa94f8 100644
--- a/Tests/SwiftSyntaxTest/RawSyntaxTests.swift
+++ b/Tests/SwiftSyntaxTest/RawSyntaxTests.swift
@@ -52,7 +52,7 @@ fileprivate func cannedStructDecl(arena: ParsingSyntaxArena) -> RawStructDeclSyn
     rightBrace: rBrace,
     arena: arena
   )
-  return RawStructDeclSyntax(
+  let header = RawStructDeclHeaderSyntax(
     attributes: RawAttributeListSyntax(elements: [], arena: arena),
     modifiers: RawDeclModifierListSyntax(elements: [], arena: arena),
     structKeyword: structKW,
@@ -60,6 +60,10 @@ fileprivate func cannedStructDecl(arena: ParsingSyntaxArena) -> RawStructDeclSyn
     genericParameterClause: nil,
     inheritanceClause: nil,
     genericWhereClause: nil,
+    arena: arena
+  )
+  return RawStructDeclSyntax(
+    structHeader: header,
     memberBlock: memberBlock,
     arena: arena
   )
@@ -83,8 +87,8 @@ final class RawSyntaxTests: XCTestCase {
   func testAccessor() {
     withExtendedLifetime(ParsingSyntaxArena(parseTriviaFunction: dummyParseToken)) { arena in
       let structDecl = cannedStructDecl(arena: arena)
-      XCTAssertEqual(structDecl.name.tokenKind, .identifier)
-      XCTAssertEqual(structDecl.structKeyword.tokenText, "struct")
+      XCTAssertEqual(structDecl.structHeader.name.tokenKind, .identifier)
+      XCTAssertEqual(structDecl.structHeader.structKeyword.tokenText, "struct")
       XCTAssertEqual(structDecl.memberBlock.leftBrace.tokenText, "{")
       XCTAssertEqual(structDecl.memberBlock.members.elements.count, 0)
 
diff --git a/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift b/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift
index bde8943a31f..47a077aa204 100644
--- a/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift
+++ b/Tests/SwiftSyntaxTest/SyntaxCreationTests.swift
@@ -23,8 +23,10 @@ fileprivate func cannedStructDecl() -> StructDeclSyntax {
     rightBrace: rBrace
   )
   return StructDeclSyntax(
-    structKeyword: structKW,
-    name: fooID,
+    structHeader: .init(
+      structKeyword: structKW,
+      name: fooID
+    ),
     memberBlock: memberBlock
   )
 }
@@ -46,7 +48,7 @@ class SyntaxCreationTests: XCTestCase {
     let forType = TokenSyntax.identifier("`for`", trailingTrivia: .space)
     let newBrace = TokenSyntax.rightBraceToken(leadingTrivia: .newlines(2))
 
-    let renamed = structDecl.with(\.name, forType)
+    let renamed = structDecl.with(\.structHeader.name, forType)
       .with(
         \.memberBlock,
         structDecl.memberBlock
diff --git a/Tests/SwiftSyntaxTest/SyntaxTests.swift b/Tests/SwiftSyntaxTest/SyntaxTests.swift
index 42e569153cb..c56bdf079b7 100644
--- a/Tests/SwiftSyntaxTest/SyntaxTests.swift
+++ b/Tests/SwiftSyntaxTest/SyntaxTests.swift
@@ -40,8 +40,10 @@ class SyntaxTests: XCTestCase {
 
   public func testDetached() {
     let s = StructDeclSyntax(
-      structKeyword: .keyword(.struct),
-      name: .identifier("someStruct"),
+      structHeader: .init(
+        structKeyword: .keyword(.struct),
+        name: .identifier("someStruct")
+      ),
       memberBlock: MemberBlockSyntax(leftBrace: .leftBraceToken(), members: [], rightBrace: .rightBraceToken())
     )