DougGregor
diff --git a/‎Sources/SwiftSyntaxMacros/MacroSystem.swift
Lines changed: 47 additions & 1 deletion b/‎Sources/SwiftSyntaxMacros/MacroSystem.swift
Lines changed: 47 additions & 1 deletion
diff --git a/‎Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift
Lines changed: 47 additions & 0 deletions b/‎Tests/SwiftSyntaxMacrosTest/MacroSystemTests.swift
Lines changed: 47 additions & 0 deletions
@@ -178,14 +178,23 @@ class MacroApplication<Context: MacroExpansionContext>: SyntaxRewriter {
       let newItem = visit(item.item)
       newItems.append(item.with(\.item, newItem))
 
-      // Expand any peer declarations triggered by macros used as attributes.
+      // Expand any peer declarations or conformances triggered by macros used
+      // as attributes.
       if case let .decl(decl) = item.item {
         let peers = expandPeers(of: decl)
         newItems.append(
           contentsOf: peers.map {
             newDecl in CodeBlockItemSyntax(item: .decl(newDecl))
           }
         )
+
+        if let declGroup = decl.asProtocol(DeclGroupSyntax.self) {
+          newItems.append(
+            contentsOf: expandConformances(of: declGroup).map {
+              newDecl in CodeBlockItemSyntax(item: .decl(newDecl))
+            }
+          )
+        }
       }
     }
 
@@ -394,6 +403,43 @@ extension MacroApplication {
     return peers
   }
 
+  // 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 identifier: String
+    if let identified = decl.asProtocol(IdentifiedDeclSyntax.self) {
+      identifier = identified.identifier.text
+    } else if let ext = decl.as(ExtensionDeclSyntax.self) {
+      identifier = ext.extendedType.trimmedDescription
+    } 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 \(raw: identifier): \(type) { }
+            """
+          if let whereClause {
+            ext = DeclSyntax((ext.as(ExtensionDeclSyntax.self))!.with(\.genericWhereClause, whereClause))
+          }
+
+          extensions.append(DeclSyntax(ext))
+        }
+      } catch {
+        context.addDiagnostics(from: error, node: attribute)
+      }
+    }
+
+    return extensions
+  }
+
   /// Expands any attached custom attributes that refer to member declaration macros,
   /// and returns result of adding those members to the given declaration.
   private func expandMembers<Decl: DeclGroupSyntax & DeclSyntaxProtocol>(
 
@@ -672,6 +672,16 @@ public struct DeclsFromStringsMacro: DeclarationMacro {
   }
 }
 
+public struct SendableConformanceMacro: ConformanceMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingConformancesOf declaration: some DeclGroupSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
+    return [("Sendable", nil)]
+  }
+}
+
 public struct DeclsFromStringsMacroNoAttrs: DeclarationMacro {
   public static var propagateFreestandingMacroAttributes: Bool { false }
   public static var propagateFreestandingMacroModifiers: Bool { false }
@@ -715,6 +725,7 @@ public let testMacros: [String: Macro.Type] = [
   "wrapStoredProperties": WrapStoredProperties.self,
   "customTypeWrapper": CustomTypeWrapperMacro.self,
   "unwrap": UnwrapMacro.self,
+  "AddSendable": SendableConformanceMacro.self,
 ]
 
 final class MacroSystemTests: XCTestCase {
@@ -1156,4 +1167,40 @@ final class MacroSystemTests: XCTestCase {
     )
 
   }
+
+  func testConformanceExpansion() {
+    assertMacroExpansion(
+      """
+      @AddSendable
+      struct MyType {
+      }
+      """,
+      expandedSource: """
+
+        struct MyType {
+        }
+        extension MyType: Sendable {
+        }
+        """,
+      macros: testMacros,
+      indentationWidth: indentationWidth
+    )
+
+    assertMacroExpansion(
+      """
+      @AddSendable
+      extension A.B {
+      }
+      """,
+      expandedSource: """
+
+        extension A.B {
+        }
+        extension A.B: Sendable {
+        }
+        """,
+      macros: testMacros,
+      indentationWidth: indentationWidth
+    )
+  }
 }