[Macros] Allow extension macros to suppress conformances that are already

stated in the original source.

If an extension macro can introduce protocol conformances, macro expansion
will check which of those protocols already have a stated conformance in the
original source. The protocols that don't will be passed as arguments to
extension macro expansion, indicating to the macro that it should only add
conformances to those protocols.

Author: hborla

include/swift/AST/Decl.h

@@ -8598,6 +8598,15 @@ class MacroDecl : public GenericContext, public ValueDecl {
   void getIntroducedNames(MacroRole role, ValueDecl *attachedTo,
                           SmallVectorImpl<DeclName> &names) const;
 
+  /// Populate the \c conformances vector with the protocols that
+  /// this macro generates conformances to.
+  ///
+  /// Only extension macros can add conformances; no results will
+  /// be added if this macro does not contain an extension role.
+  void getIntroducedConformances(
+      NominalTypeDecl *attachedTo,
+      SmallVectorImpl<ProtocolDecl *> &conformances) const;
+
   /// Returns a DeclName that represents arbitrary names.
   static DeclName getArbitraryName() {
     return DeclName();

include/swift/AST/DeclContext.h

@@ -155,6 +155,10 @@ enum class ConformanceEntryKind : unsigned {
 
   /// Implied by an explicitly-specified conformance.
   Implied,
+
+  /// The conformance is generated by a macro that has not been
+  /// expanded yet.
+  PreMacroExpansion,
 };
 
 /// Describes the kind of conformance lookup desired.
@@ -168,6 +172,9 @@ enum class ConformanceLookupKind : unsigned {
   /// All conformances except structurally-derived conformances, of which
   /// Sendable is the only one.
   NonStructural,
+  /// Exclude conformances added by a macro that has not been expanded
+  /// yet.
+  ExcludeUnexpandedMacros,
 };
 
 /// Describes a diagnostic for a conflict between two protocol

include/swift/AST/DiagnosticsSema.def

@@ -2836,7 +2836,8 @@ NOTE(declared_protocol_conformance_here,none,
      "%select{%0 inherits conformance to protocol %2 from superclass|"
      "%0 declares conformance to protocol %2|"
      "%0 implicitly conforms to protocol %2 (via conformance to %3)|"
-     "%0 implicitly conforms to protocol %2}1 here",
+     "%0 implicitly conforms to protocol %2 |"
+     "conformance to %2 generated by macro }1 here",
      (Type, unsigned, Identifier, Identifier))
 
 ERROR(witness_unavailable,none,
@@ -7266,6 +7267,9 @@ ERROR(global_arbitrary_name,none,
 ERROR(local_extension_macro,none,
       "local type cannot have attached extension macro",
       ())
+ERROR(extension_macro_invalid_conformance,none,
+      "invalid protocol conformance %0 in extension macro",
+      (Type))
 
 ERROR(macro_resolve_circular_reference, none,
       "circular reference resolving %select{freestanding|attached}0 macro %1",

include/swift/AST/ProtocolConformance.h

@@ -441,7 +441,7 @@ class NormalProtocolConformance : public RootProtocolConformance,
   ///
   /// This should never be Inherited: that is handled by
   /// InheritedProtocolConformance.
-  llvm::PointerIntPair<NormalProtocolConformance *, 2, ConformanceEntryKind>
+  llvm::PointerIntPair<NormalProtocolConformance *, 3, ConformanceEntryKind>
       SourceKindAndImplyingConformance = {nullptr,
                                           ConformanceEntryKind::Explicit};
 

lib/AST/ConformanceLookupTable.cpp

@@ -43,6 +43,9 @@ DeclContext *ConformanceLookupTable::ConformanceSource::getDeclContext() const {
 
   case ConformanceEntryKind::Synthesized:
     return getSynthesizedDeclContext();
+
+  case ConformanceEntryKind::PreMacroExpansion:
+    return getMacroGeneratedDeclContext();
   }
 
   llvm_unreachable("Unhandled ConformanceEntryKind in switch.");
@@ -104,6 +107,10 @@ void ConformanceLookupTable::ConformanceEntry::dump(raw_ostream &os,
   case ConformanceEntryKind::Synthesized:
     os << " synthesized";
     break;
+
+  case ConformanceEntryKind::PreMacroExpansion:
+    os << " unexpanded macro";
+    break;
   }
 
   if (auto conf = getConformance()) {
@@ -282,10 +289,8 @@ void ConformanceLookupTable::updateLookupTable(NominalTypeDecl *nominal,
           addInheritedProtocols(nominal,
                                 ConformanceSource::forExplicit(nominal));
 
-          // Expand extension macros.
-          ASTContext &ctx = nominal->getASTContext();
-          (void)evaluateOrDefault(
-              ctx.evaluator, ExpandExtensionMacros{nominal}, { });
+          addMacroGeneratedProtocols(
+              nominal, ConformanceSource::forUnexpandedMacro(nominal));
         },
         [&](ExtensionDecl *ext,
             ArrayRef<ConformanceConstructionInfo> protos) {
@@ -441,6 +446,7 @@ bool ConformanceLookupTable::addProtocol(ProtocolDecl *protocol, SourceLoc loc,
       switch (existingEntry->getKind()) {
       case ConformanceEntryKind::Explicit:
       case ConformanceEntryKind::Inherited:
+      case ConformanceEntryKind::PreMacroExpansion:
         return false;
 
       case ConformanceEntryKind::Implied:
@@ -491,6 +497,20 @@ void ConformanceLookupTable::addInheritedProtocols(
   }
 }
 
+void ConformanceLookupTable::addMacroGeneratedProtocols(
+    NominalTypeDecl *nominal, ConformanceSource source) {
+  nominal->forEachAttachedMacro(
+      MacroRole::Extension,
+      [&](CustomAttr *attr, MacroDecl *macro) {
+        SmallVector<ProtocolDecl *, 2> conformances;
+        macro->getIntroducedConformances(nominal, conformances);
+
+        for (auto *protocol : conformances) {
+          addProtocol(protocol, attr->getLocation(), source);
+        }
+      });
+}
+
 void ConformanceLookupTable::expandImpliedConformances(NominalTypeDecl *nominal,
                                                        DeclContext *dc) {
   // Note: recursive type-checking implies that AllConformances
@@ -530,6 +550,7 @@ static bool isReplaceable(ConformanceEntryKind kind) {
   switch (kind) {
   case ConformanceEntryKind::Implied:
   case ConformanceEntryKind::Synthesized:
+  case ConformanceEntryKind::PreMacroExpansion:
     return true;
 
   case ConformanceEntryKind::Explicit:
@@ -558,6 +579,23 @@ ConformanceLookupTable::Ordering ConformanceLookupTable::compareConformances(
             : Ordering::After);
   }
 
+  ConformanceEntryKind lhsKind = lhs->getRankingKind();
+  ConformanceEntryKind rhsKind = rhs->getRankingKind();
+
+  // Pre-expanded macro conformances are always superseded by
+  // conformances written in source. If the conformance is not
+  // written in the original source, the pre-expanded conformance
+  // will be superseded by the conformance in the macro expansion
+  // buffer.
+  if (lhsKind == ConformanceEntryKind::PreMacroExpansion ||
+      rhsKind == ConformanceEntryKind::PreMacroExpansion) {
+    if (lhsKind != rhsKind) {
+      return (lhs->getKind() < rhs->getKind()
+              ? Ordering::Before
+              : Ordering::After);
+    }
+  }
+
   // If one entry is fixed and the other is not, we have our answer.
   if (lhs->isFixed() != rhs->isFixed()) {
     auto isReplaceableOrMarker = [](ConformanceEntry *entry) -> bool {
@@ -580,9 +618,6 @@ ConformanceLookupTable::Ordering ConformanceLookupTable::compareConformances(
     return lhs->isFixed() ? Ordering::Before : Ordering::After;
   }
 
-  ConformanceEntryKind lhsKind = lhs->getRankingKind();
-  ConformanceEntryKind rhsKind = rhs->getRankingKind();
-
   if (lhsKind != ConformanceEntryKind::Implied ||
       rhsKind != ConformanceEntryKind::Implied) {
     // If both conformances are non-replaceable, diagnose the

lib/AST/ConformanceLookupTable.h

@@ -83,13 +83,15 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
   /// Describes the "source" of a conformance, indicating where the
   /// conformance came from.
   class ConformanceSource {
-    llvm::PointerIntPair<void *, 2, ConformanceEntryKind> Storage;
+    void *Storage;
+
+    ConformanceEntryKind Kind;
 
     /// The location of the "unchecked" attribute, if there is one.
     SourceLoc uncheckedLoc;
 
     ConformanceSource(void *ptr, ConformanceEntryKind kind) 
-      : Storage(ptr, kind) { }
+      : Storage(ptr), Kind(kind) { }
 
   public:
     /// Create an inherited conformance.
@@ -126,6 +128,10 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
       return ConformanceSource(dc, ConformanceEntryKind::Synthesized);
     }
 
+    static ConformanceSource forUnexpandedMacro(DeclContext *dc) {
+      return ConformanceSource(dc, ConformanceEntryKind::PreMacroExpansion);
+    }
+
     /// Return a new conformance source with the given location of "@unchecked".
     ConformanceSource withUncheckedLoc(SourceLoc uncheckedLoc) {
       ConformanceSource result(*this);
@@ -135,7 +141,7 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
     }
 
     /// Retrieve the kind of conformance formed from this source.
-    ConformanceEntryKind getKind() const { return Storage.getInt(); }
+    ConformanceEntryKind getKind() const { return Kind; }
 
     /// Retrieve kind of the conformance for ranking purposes.
     ///
@@ -148,6 +154,7 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
       case ConformanceEntryKind::Explicit:
       case ConformanceEntryKind::Inherited:
       case ConformanceEntryKind::Synthesized:
+      case ConformanceEntryKind::PreMacroExpansion:
         return kind;
 
       case ConformanceEntryKind::Implied:
@@ -169,28 +176,33 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
     /// for the inheriting class.
     ClassDecl *getInheritingClass() const {
       assert(getKind() == ConformanceEntryKind::Inherited);
-      return static_cast<ClassDecl *>(Storage.getPointer());      
+      return static_cast<ClassDecl *>(Storage);
     }
 
     /// For an explicit conformance, retrieve the declaration context
     /// that specifies the conformance.
     DeclContext *getExplicitDeclContext() const {
       assert(getKind() == ConformanceEntryKind::Explicit);
-      return static_cast<DeclContext *>(Storage.getPointer());      
+      return static_cast<DeclContext *>(Storage);
+    }
+
+    DeclContext *getMacroGeneratedDeclContext() const {
+      assert(getKind() == ConformanceEntryKind::PreMacroExpansion);
+      return static_cast<DeclContext *>(Storage);
     }
 
     /// For a synthesized conformance, retrieve the nominal type decl
     /// that will receive the conformance.
     ConformanceEntry *getImpliedSource() const {
       assert(getKind() == ConformanceEntryKind::Implied);
-      return static_cast<ConformanceEntry *>(Storage.getPointer());
+      return static_cast<ConformanceEntry *>(Storage);
     }
 
     /// For a synthesized conformance, retrieve the nominal type decl
     /// that will receive the conformance.
     DeclContext *getSynthesizedDeclContext() const {
       assert(getKind() == ConformanceEntryKind::Synthesized);
-      return static_cast<DeclContext *>(Storage.getPointer());
+      return static_cast<DeclContext *>(Storage);
     }
 
     /// Get the declaration context that this conformance will be
@@ -226,6 +238,10 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
 
     /// Whether this conformance is already "fixed" and cannot be superseded.
     bool isFixed() const {
+      // A conformance from an unexpanded macro can always be superseded.
+      if (getKind() == ConformanceEntryKind::PreMacroExpansion)
+        return true;
+
       // If a conformance has been assigned, it cannot be superseded.
       if (getConformance())
         return true;
@@ -235,6 +251,7 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
       case ConformanceEntryKind::Explicit:
       case ConformanceEntryKind::Implied:
       case ConformanceEntryKind::Synthesized:
+      case ConformanceEntryKind::PreMacroExpansion:
         return false;
 
       case ConformanceEntryKind::Inherited:
@@ -341,6 +358,11 @@ class ConformanceLookupTable : public ASTAllocated<ConformanceLookupTable> {
       llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
       ConformanceSource source);
 
+  /// Add the protocols added by attached extension macros that are not
+  /// yet expanded.
+  void addMacroGeneratedProtocols(
+      NominalTypeDecl *nominal, ConformanceSource source);
+
   /// Expand the implied conformances for the given DeclContext.
   void expandImpliedConformances(NominalTypeDecl *nominal, DeclContext *dc);
 

lib/AST/Decl.cpp

@@ -10695,6 +10695,38 @@ void MacroDecl::getIntroducedNames(MacroRole role, ValueDecl *attachedTo,
   }
 }
 
+void MacroDecl::getIntroducedConformances(
+    NominalTypeDecl *attachedTo,
+    SmallVectorImpl<ProtocolDecl *> &conformances) const {
+  auto *attr = getMacroRoleAttr(MacroRole::Extension);
+  if (!attr)
+    return;
+
+  for (auto repr : attr->getConformances()) {
+    auto constraint = repr->getInstanceType();
+    assert(constraint->isConstraintType());
+
+    std::function<void(Type)> addConstraint =
+        [&](Type constraint) -> void {
+          if (auto *proto = constraint->getAs<ParameterizedProtocolType>()) {
+            conformances.push_back(proto->getProtocol());
+            return;
+          } else if (auto *proto = constraint->getAs<ProtocolType>()) {
+            conformances.push_back(proto->getDecl());
+            return;
+          }
+
+          auto *composition =
+              constraint->castTo<ProtocolCompositionType>();
+          for (auto constraint : composition->getMembers()) {
+            addConstraint(constraint);
+          }
+        };
+
+    addConstraint(constraint);
+  }
+}
+
 MacroDefinition MacroDecl::getDefinition() const {
   return evaluateOrDefault(
       getASTContext().evaluator,

lib/AST/Module.cpp

@@ -1961,6 +1961,17 @@ LookupConformanceInModuleRequest::evaluate(
   if (!nominal || isa<ProtocolDecl>(nominal))
     return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
+  // Expand conformances added by extension macros.
+  //
+  // FIXME: This expansion should only be done if the
+  // extension macro can generate a conformance to the
+  // given protocol, but conformance macros do not specify
+  // that information upfront.
+  (void)evaluateOrDefault(
+      ctx.evaluator,
+      ExpandExtensionMacros{nominal},
+      { });
+
   // Find the (unspecialized) conformance.
   SmallVector<ProtocolConformance *, 2> conformances;
   if (!nominal->lookupConformance(protocol, conformances)) {

lib/AST/ProtocolConformance.cpp

@@ -1302,6 +1302,7 @@ IterableDeclContext::getLocalConformances(ConformanceLookupKind lookupKind)
            switch (conformance->getSourceKind()) {
            case ConformanceEntryKind::Explicit:
            case ConformanceEntryKind::Synthesized:
+           case ConformanceEntryKind::PreMacroExpansion:
              return true;
            case ConformanceEntryKind::Implied:
            case ConformanceEntryKind::Inherited:
@@ -1313,6 +1314,7 @@ IterableDeclContext::getLocalConformances(ConformanceLookupKind lookupKind)
            case ConformanceEntryKind::Explicit:
            case ConformanceEntryKind::Synthesized:
            case ConformanceEntryKind::Implied:
+           case ConformanceEntryKind::PreMacroExpansion:
              return true;
            case ConformanceEntryKind::Inherited:
              return false;
@@ -1321,13 +1323,25 @@ IterableDeclContext::getLocalConformances(ConformanceLookupKind lookupKind)
          case ConformanceLookupKind::All:
          case ConformanceLookupKind::NonStructural:
            return true;
+
+          case ConformanceLookupKind::ExcludeUnexpandedMacros:
+           switch (conformance->getSourceKind()) {
+           case ConformanceEntryKind::PreMacroExpansion:
+             return false;
+           case ConformanceEntryKind::Explicit:
+           case ConformanceEntryKind::Synthesized:
+           case ConformanceEntryKind::Implied:
+           case ConformanceEntryKind::Inherited:
+             return true;
+           }
          }
       });
 
   // If we want to add structural conformances, do so now.
   switch (lookupKind) {
     case ConformanceLookupKind::All:
-    case ConformanceLookupKind::NonInherited: {
+    case ConformanceLookupKind::NonInherited:
+    case ConformanceLookupKind::ExcludeUnexpandedMacros: {
       // Look for a Sendable conformance globally. If it is synthesized
       // and matches this declaration context, use it.
       auto dc = getAsGenericContext();