[Macros] ConformanceMacro refines ExtensionMacro.

This changes the ConformanceMacro protocol to refine ExtensionMacro, and provide
a default implementation of ExtensionMacro.expansion that calls the conformance
expansion method. This way, conformance macros and extension macros can share the
same expansion code path.

Author: hborla

Sources/SwiftSyntaxMacroExpansion/MacroExpansion.swift

@@ -266,42 +266,6 @@ public func expandAttachedMacroWithoutCollapsing<Context: MacroExpansionContext>
         $0.formattedExpansion(definition.formatMode)
       }
 
-    case (let attachedMacro as ConformanceMacro.Type, .conformance):
-      guard let declGroup = declarationNode.asProtocol(DeclGroupSyntax.self) else {
-        // Compiler error: type mismatch.
-        throw MacroExpansionError.declarationNotDeclGroup
-      }
-      guard let identified = declarationNode.asProtocol(IdentifiedDeclSyntax.self)
-      else {
-        // Compiler error: type mismatch.
-        throw MacroExpansionError.declarationNotIdentified
-      }
-
-      // Local function to expand a conformance macro once we've opened up
-      // the existential.
-      func expandConformanceMacro(
-        _ node: some DeclGroupSyntax
-      ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
-        return try attachedMacro.expansion(
-          of: attributeNode,
-          providingConformancesOf: node,
-          in: context
-        )
-      }
-
-      let conformances = try _openExistential(
-        declGroup,
-        do: expandConformanceMacro
-      )
-
-      // Form a buffer of extension declarations to return to the caller.
-      return conformances.map { typeSyntax, whereClause in
-        let typeName = identified.identifier.trimmedDescription
-        let protocolName = typeSyntax.trimmedDescription
-        let whereClause = whereClause?.trimmedDescription ?? ""
-        return "extension \(typeName) : \(protocolName) \(whereClause) {}"
-      }
-
     case (let attachedMacro as ExtensionMacro.Type, .extension):
       guard let declGroup = declarationNode.asProtocol(DeclGroupSyntax.self) else {
         // Compiler error: type mismatch.

Sources/SwiftSyntaxMacros/MacroProtocols/ConformanceMacro.swift

@@ -14,7 +14,7 @@ import SwiftSyntax
 
 /// Describes a macro that can add conformances to the declaration it's
 /// attached to.
-public protocol ConformanceMacro: AttachedMacro {
+public protocol ConformanceMacro: ExtensionMacro {
   /// Expand an attached conformance macro to produce a set of conformances.
   ///
   /// - Parameters:
@@ -31,3 +31,37 @@ public protocol ConformanceMacro: AttachedMacro {
     in context: some MacroExpansionContext
   ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)]
 }
+
+extension ConformanceMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    in context: some MacroExpansionContext
+  ) throws -> [ExtensionDeclSyntax] {
+
+    let newConformances = try expansion(
+      of: node,
+      providingConformancesOf: declaration,
+      in: context
+    )
+
+    var extensions: [ExtensionDeclSyntax] = []
+    for (proto, whereClause) in newConformances {
+      let decl: DeclSyntax =
+      """
+      extension \(type.trimmed): \(proto) {}
+      """
+
+      var extensionDecl = decl.cast(ExtensionDeclSyntax.self)
+
+      if let whereClause {
+        extensionDecl = extensionDecl.with(\.genericWhereClause, whereClause)
+      }
+
+      extensions.append(extensionDecl)
+    }
+
+    return extensions
+  }
+}

Sources/SwiftSyntaxMacros/MacroSystem.swift

@@ -115,7 +115,6 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
           || macro is MemberMacro.Type
           || macro is AccessorMacro.Type
           || macro is MemberAttributeMacro.Type
-          || macro is ConformanceMacro.Type
           || macro is ExtensionMacro.Type)
       }
 
@@ -192,7 +191,7 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
 
         if let declGroup = decl.asProtocol(DeclGroupSyntax.self) {
           newItems.append(
-            contentsOf: expandConformances(of: declGroup).map {
+            contentsOf: expandExtensions(of: declGroup).map {
               newDecl in CodeBlockItemSyntax(item: .decl(newDecl))
             }
           )
@@ -408,45 +407,25 @@ extension MacroApplication {
   // If any of the custom attributes associated with the given declaration
   // refer to conformance macros, expand them and return the resulting
   // set of extension declarations.
-  private func expandConformances(of decl: DeclGroupSyntax) -> [DeclSyntax] {
-    let extendedType: Syntax
+  private func expandExtensions(of decl: DeclGroupSyntax) -> [DeclSyntax] {
+    let extendedType: TypeSyntax
     if let identified = decl.asProtocol(IdentifiedDeclSyntax.self) {
-      extendedType = Syntax(identified.identifier.trimmed)
+      extendedType = "\(identified.identifier.trimmed)"
     } else if let ext = decl.as(ExtensionDeclSyntax.self) {
-      extendedType = Syntax(ext.extendedType.trimmed)
+      extendedType = "\(ext.extendedType.trimmed)"
     } else {
       return []
     }
 
     var extensions: [DeclSyntax] = []
-    let macroAttributes = getMacroAttributes(attachedTo: decl.as(DeclSyntax.self)!, ofType: ConformanceMacro.Type.self)
-    for (attribute, conformanceMacro) in macroAttributes {
-      do {
-        let newConformances = try conformanceMacro.expansion(of: attribute, providingConformancesOf: decl, in: context)
-
-        for (type, whereClause) in newConformances {
-          var ext: DeclSyntax = """
-            extension \(extendedType): \(type) { }
-            """
-          if let whereClause {
-            ext = DeclSyntax((ext.cast(ExtensionDeclSyntax.self)).with(\.genericWhereClause, whereClause))
-          }
-
-          extensions.append(DeclSyntax(ext))
-        }
-      } catch {
-        context.addDiagnostics(from: error, node: attribute)
-      }
-    }
 
     let extensionMacroAttrs = getMacroAttributes(attachedTo: decl.as(DeclSyntax.self)!, ofType: ExtensionMacro.Type.self)
-    let extendedTypeSyntax = TypeSyntax("\(extendedType.trimmed)")
     for (attribute, extensionMacro) in extensionMacroAttrs {
       do {
         let newExtensions = try extensionMacro.expansion(
           of: attribute,
           attachedTo: decl,
-          providingExtensionsOf: extendedTypeSyntax,
+          providingExtensionsOf: extendedType,
           in: context
         )