Rework HasTrailingMemberDeclBlock

`DeclGroup` now requires an initializer that can build a group from a header and member block. With that in place, we can reimplement `HasTrailingMemberDeclBlock` to avoid reparsing anything. Which is kind of neat.

Author: beccadax

CodeGeneration/Sources/SyntaxSupport/CompatibilityLayer.swift

@@ -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))
       }

CodeGeneration/Sources/SyntaxSupport/Traits.swift

@@ -21,13 +21,15 @@ 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
 
   init(
     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,6 +55,7 @@ public let TRAITS: [Trait] = [
   Trait(
     traitName: "DeclGroup",
     baseKind: .decl,
+    requiresInit: true,
     children: [
       Child(
         name: "header",

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)
       )
       """

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)") {

Sources/SwiftSyntax/CustomTraits.swift

@@ -30,6 +30,23 @@ extension ActorDeclSyntax {
       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 {
@@ -52,6 +69,23 @@ extension ClassDeclSyntax {
       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 {
@@ -74,6 +108,23 @@ extension EnumDeclSyntax {
       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 {
@@ -96,6 +147,23 @@ extension ExtensionDeclSyntax {
       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 {
@@ -129,6 +197,23 @@ extension ProtocolDeclSyntax {
       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 {
@@ -151,6 +236,23 @@ extension StructDeclSyntax {
       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
+    )
+  }
 }
 
 //==========================================================================//

Sources/SwiftSyntax/generated/SyntaxTraits.swift

@@ -72,6 +72,18 @@ public protocol DeclGroupSyntax: SyntaxProtocol, DeclSyntaxProtocol {
     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.
+
+  init?(
+    leadingTrivia: Trivia? ,
+    header: some DeclGroupHeaderSyntaxProtocol,
+    memberBlock: MemberBlockSyntax,
+    trailingTrivia: Trivia?
+  )
 }
 
 extension DeclGroupSyntax {

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]

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
   }
 }