[Macros] Add a request to get the resolved constraint types in the 'conformances:'

list of an attached extension macro attribute.

Author: hborla

include/swift/AST/TypeCheckRequests.h

@@ -3336,6 +3336,25 @@ class ResolveMacroRequest
   void noteCycleStep(DiagnosticEngine &diags) const;
 };
 
+/// Returns the resolved constraint types that an extension macro
+/// adds conformances to.
+class ResolveExtensionMacroConformances
+    : public SimpleRequest<ResolveExtensionMacroConformances,
+                           ArrayRef<Type>(const MacroRoleAttr *, const Decl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  ArrayRef<Type> evaluate(Evaluator &evaluator,
+                          const MacroRoleAttr *, const Decl *) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class ResolveTypeEraserTypeRequest
     : public SimpleRequest<ResolveTypeEraserTypeRequest,
                            Type (ProtocolDecl *, TypeEraserAttr *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -360,6 +360,9 @@ SWIFT_REQUEST(TypeChecker, ResolveImplicitMemberRequest,
 SWIFT_REQUEST(TypeChecker, ResolveMacroRequest,
               ConcreteDeclRef(UnresolvedMacroReference, const Decl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ResolveExtensionMacroConformances,
+              ArrayRef<Type>(const MacroRoleAttr *, const Decl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeEraserTypeRequest,
               Type(ProtocolDecl *, TypeEraserAttr *),
               SeparatelyCached, NoLocationInfo)

lib/AST/Decl.cpp

@@ -10702,8 +10702,13 @@ void MacroDecl::getIntroducedConformances(
   if (!attr)
     return;
 
-  for (auto repr : attr->getConformances()) {
-    auto constraint = repr->getInstanceType();
+  auto &ctx = getASTContext();
+  auto constraintTypes = evaluateOrDefault(
+      ctx.evaluator,
+      ResolveExtensionMacroConformances{attr, this},
+      {});
+
+  for (auto constraint : constraintTypes) {
     assert(constraint->isConstraintType());
 
     std::function<void(Type)> addConstraint =

lib/Sema/TypeCheckAttr.cpp

@@ -7136,31 +7136,10 @@ void AttributeChecker::visitMacroRoleAttr(MacroRoleAttr *attr) {
   }
   }
 
-  for (auto *typeExpr : attr->getConformances()) {
-    if (auto *typeRepr = typeExpr->getTypeRepr()) {
-      auto *dc = D->getDeclContext();
-      auto resolved =
-          TypeResolution::forInterface(
-              dc, TypeResolverContext::GenericRequirement,
-              /*unboundTyOpener*/ nullptr,
-              /*placeholderHandler*/ nullptr,
-              /*packElementOpener*/ nullptr)
-          .resolveType(typeRepr);
-
-      if (resolved->is<ErrorType>()) {
-        attr->setInvalid();
-        continue;
-      }
-
-      if (!resolved->isConstraintType()) {
-        diagnoseAndRemoveAttr(attr, diag::extension_macro_invalid_conformance,
-                              resolved);
-        continue;
-      }
-
-      typeExpr->setType(MetatypeType::get(resolved));
-    }
-  }
+  (void)evaluateOrDefault(
+      Ctx.evaluator,
+      ResolveExtensionMacroConformances{attr, D},
+      {});
 }
 
 namespace {

lib/Sema/TypeCheckMacros.cpp

@@ -17,6 +17,7 @@
 #include "TypeCheckMacros.h"
 #include "../AST/InlinableText.h"
 #include "TypeChecker.h"
+#include "TypeCheckType.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -1675,6 +1676,43 @@ ConcreteDeclRef ResolveMacroRequest::evaluate(Evaluator &evaluator,
   return macroExpansion->getMacroRef();
 }
 
+ArrayRef<Type>
+ResolveExtensionMacroConformances::evaluate(Evaluator &evaluator,
+                                            const MacroRoleAttr *attr,
+                                            const Decl *decl) const {
+  auto *dc = decl->getDeclContext();
+  auto &ctx = dc->getASTContext();
+
+  SmallVector<Type, 2> protocols;
+  for (auto *typeExpr : attr->getConformances()) {
+    if (auto *typeRepr = typeExpr->getTypeRepr()) {
+      auto resolved =
+          TypeResolution::forInterface(
+              dc, TypeResolverContext::GenericRequirement,
+              /*unboundTyOpener*/ nullptr,
+              /*placeholderHandler*/ nullptr,
+              /*packElementOpener*/ nullptr)
+          .resolveType(typeRepr);
+
+      if (resolved->is<ErrorType>())
+        continue;
+
+      if (!resolved->isConstraintType()) {
+        diagnoseAndRemoveAttr(
+            decl, attr,
+            diag::extension_macro_invalid_conformance,
+            resolved);
+        continue;
+      }
+
+      typeExpr->setType(MetatypeType::get(resolved));
+      protocols.push_back(resolved);
+    }
+  }
+
+  return ctx.AllocateCopy(protocols);
+}
+
 // MARK: for IDE.
 
 SourceFile *swift::evaluateAttachedMacro(MacroDecl *macro, Decl *attachedTo,

test/Macros/Inputs/macro_expand_conformances_other.swift

@@ -1,3 +1,6 @@
 struct STest {
   var x = requireEquatable(S())
 }
+
+@ConformanceViaExtension
+class Child: Parent {}

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -1253,6 +1253,30 @@ public struct EquatableMacro: ConformanceMacro {
   }
 }
 
+public struct ConformanceViaExtensionMacro: ExtensionMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo decl: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
+    in context: some MacroExpansionContext
+  ) throws -> [ExtensionDeclSyntax] {
+    if (protocols.isEmpty) {
+      return []
+    }
+
+    let decl: DeclSyntax =
+      """
+      extension \(raw: type.trimmedDescription): MyProtocol {
+      }
+      """
+
+    return [
+      decl.cast(ExtensionDeclSyntax.self)
+    ]
+  }
+}
+
 public struct HashableMacro: ConformanceMacro {
   public static func expansion(
     of node: AttributeSyntax,

test/Macros/macro_expand_conformances_multi.swift

@@ -4,7 +4,7 @@
 // RUN: %host-build-swift -swift-version 5 -emit-library -o %t/%target-library-name(MacroDefinition) -module-name=MacroDefinition %S/Inputs/syntax_macro_definitions.swift -g -no-toolchain-stdlib-rpath
 
 // Make sure we see the conformances from another file.
-// RUN: %target-typecheck-verify-swift -swift-version 5 -load-plugin-library %t/%target-library-name(MacroDefinition) -module-name MacroUser -swift-version 5 -primary-file %S/Inputs/macro_expand_conformances_other.swift -DDISABLE_TOP_LEVEL_CODE
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature ExtensionMacros -swift-version 5 -load-plugin-library %t/%target-library-name(MacroDefinition) -module-name MacroUser -swift-version 5 -primary-file %S/Inputs/macro_expand_conformances_other.swift -DDISABLE_TOP_LEVEL_CODE
 
 @attached(conformance)
 macro Equatable() = #externalMacro(module: "MacroDefinition", type: "EquatableMacro")
@@ -24,3 +24,10 @@ func requireHashable(_ value: some Hashable) {
 @Equatable
 struct S {}
 
+protocol MyProtocol {}
+
+@attached(extension, conformances: MyProtocol)
+macro ConformanceViaExtension() = #externalMacro(module: "MacroDefinition", type: "ConformanceViaExtensionMacro")
+
+@ConformanceViaExtension
+class Parent {}