Merge pull request #67977 from DougGregor/extension-macro-conformances-and-witnesses

[Macros] Fix handling of extension macro conformances and witnesses

Author: DougGregor

include/swift/AST/DeclContext.h

@@ -175,9 +175,6 @@ 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/ProtocolConformance.h

@@ -552,6 +552,8 @@ class NormalProtocolConformance : public RootProtocolConformance,
     assert((sourceKind == ConformanceEntryKind::Implied) ==
                (bool)implyingConformance &&
            "an implied conformance needs something that implies it");
+    assert(sourceKind != ConformanceEntryKind::PreMacroExpansion &&
+           "cannot create conformance pre-macro-expansion");
     SourceKindAndImplyingConformance = {implyingConformance, sourceKind};
   }
 

lib/AST/ConformanceLookupTable.cpp

@@ -892,6 +892,16 @@ ConformanceLookupTable::getConformance(NominalTypeDecl *nominal,
   if (!conformingDC)
     return nullptr;
 
+  // Never produce a conformance for a pre-macro-expansion conformance. They
+  // are placeholders that will be superseded.
+  if (entry->getKind() == ConformanceEntryKind::PreMacroExpansion) {
+    if (auto supersedingEntry = entry->SupersededBy) {
+      return getConformance(nominal, supersedingEntry);
+    }
+
+    return nullptr;
+  }
+
   auto *conformingNominal = conformingDC->getSelfNominalTypeDecl();
 
   // Form the conformance.
@@ -929,6 +939,16 @@ ConformanceLookupTable::getConformance(NominalTypeDecl *nominal,
           ? conformingNominal->getLoc()
           : cast<ExtensionDecl>(conformingDC)->getLoc();
 
+    NormalProtocolConformance *implyingConf = nullptr;
+    if (entry->Source.getKind() == ConformanceEntryKind::Implied) {
+      auto implyingEntry = entry->Source.getImpliedSource();
+      auto origImplyingConf = getConformance(conformingNominal, implyingEntry);
+      if (!origImplyingConf)
+        return nullptr;
+
+      implyingConf = origImplyingConf->getRootNormalConformance();
+    }
+
     // Create or find the normal conformance.
     auto normalConf =
         ctx.getNormalConformance(conformingType, protocol, conformanceLoc,
@@ -939,12 +959,6 @@ ConformanceLookupTable::getConformance(NominalTypeDecl *nominal,
     // early return at the start of this function.
     entry->Conformance = normalConf;
 
-    NormalProtocolConformance *implyingConf = nullptr;
-    if (entry->Source.getKind() == ConformanceEntryKind::Implied) {
-      auto implyingEntry = entry->Source.getImpliedSource();
-      implyingConf = getConformance(conformingNominal, implyingEntry)
-                         ->getRootNormalConformance();
-    }
     normalConf->setSourceKindAndImplyingConformance(entry->Source.getKind(),
                                                     implyingConf);
 

lib/AST/NameLookup.cpp

@@ -1757,6 +1757,17 @@ namespace {
   };
 }
 
+/// Given an extension declaration, return the extended nominal type if the
+/// extension was produced by expanding an extension or conformance macro from
+/// the nominal declaration itself.
+static NominalTypeDecl *nominalForExpandedExtensionDecl(ExtensionDecl *ext) {
+  if (!ext->isInMacroExpansionInContext())
+    return nullptr;
+
+
+  return ext->getSelfNominalTypeDecl();
+}
+
 PotentialMacroExpansions PotentialMacroExpansionsInContextRequest::evaluate(
     Evaluator &evaluator, TypeOrExtensionDecl container) const {
   /// The implementation here needs to be kept in sync with
@@ -1767,6 +1778,15 @@ PotentialMacroExpansions PotentialMacroExpansionsInContextRequest::evaluate(
   auto containerDecl = container.getAsDecl();
   forEachPotentialAttachedMacro(containerDecl, MacroRole::Member, nameTracker);
 
+  // If the container is an extension that was created from an extension macro,
+  // look at the nominal declaration to find any extension macros.
+  if (auto ext = dyn_cast<ExtensionDecl>(containerDecl)) {
+    if (auto nominal = nominalForExpandedExtensionDecl(ext)) {
+      forEachPotentialAttachedMacro(
+          nominal, MacroRole::Extension, nameTracker);
+    }
+  }
+
   // Peer and freestanding declaration macros.
   auto dc = container.getAsDeclContext();
   auto idc = container.getAsIterableDeclContext();
@@ -1825,13 +1845,15 @@ populateLookupTableEntryFromMacroExpansions(ASTContext &ctx,
   // names match.
   {
     MacroIntroducedNameTracker nameTracker;
-    if (auto nominal = dyn_cast<NominalTypeDecl>(container.getAsDecl())) {
-      forEachPotentialAttachedMacro(nominal, MacroRole::Extension, nameTracker);
-      if (nameTracker.shouldExpandForName(name)) {
-        (void)evaluateOrDefault(
-            ctx.evaluator,
-            ExpandExtensionMacros{nominal},
-            false);
+    if (auto ext = dyn_cast<ExtensionDecl>(container.getAsDecl())) {
+      if (auto nominal = nominalForExpandedExtensionDecl(ext)) {
+        forEachPotentialAttachedMacro(nominal, MacroRole::Extension, nameTracker);
+        if (nameTracker.shouldExpandForName(name)) {
+          (void)evaluateOrDefault(
+              ctx.evaluator,
+              ExpandExtensionMacros{nominal},
+              false);
+        }
       }
     }
   }

lib/AST/ProtocolConformance.cpp

@@ -1295,8 +1295,8 @@ IterableDeclContext::getLocalConformances(ConformanceLookupKind lookupKind)
            switch (conformance->getSourceKind()) {
            case ConformanceEntryKind::Explicit:
            case ConformanceEntryKind::Synthesized:
+               return true;
            case ConformanceEntryKind::PreMacroExpansion:
-             return true;
            case ConformanceEntryKind::Implied:
            case ConformanceEntryKind::Inherited:
              return false;
@@ -1307,34 +1307,22 @@ IterableDeclContext::getLocalConformances(ConformanceLookupKind lookupKind)
            case ConformanceEntryKind::Explicit:
            case ConformanceEntryKind::Synthesized:
            case ConformanceEntryKind::Implied:
-           case ConformanceEntryKind::PreMacroExpansion:
              return true;
            case ConformanceEntryKind::Inherited:
+           case ConformanceEntryKind::PreMacroExpansion:
              return false;
            }
 
          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::ExcludeUnexpandedMacros: {
+    case ConformanceLookupKind::NonInherited: {
       // Look for a Sendable conformance globally. If it is synthesized
       // and matches this declaration context, use it.
       auto dc = getAsGenericContext();

lib/SIL/IR/SILSymbolVisitor.cpp

@@ -238,9 +238,6 @@ class SILSymbolVisitorImpl : public ASTVisitor<SILSymbolVisitorImpl> {
   void addConformances(const IterableDeclContext *IDC) {
     for (auto conformance :
          IDC->getLocalConformances(ConformanceLookupKind::NonInherited)) {
-      if (conformance->getSourceKind() == ConformanceEntryKind::PreMacroExpansion)
-        continue;
-
       auto protocol = conformance->getProtocol();
       if (Ctx.getOpts().PublicSymbolsOnly &&
           getDeclLinkage(protocol) != FormalLinkage::PublicUnique)

lib/SILGen/SILGenType.cpp

@@ -1132,9 +1132,6 @@ class SILGenType : public TypeMemberVisitor<SILGenType> {
     // are existential and do not have witness tables.
     for (auto *conformance : theType->getLocalConformances(
                                ConformanceLookupKind::NonInherited)) {
-      if (conformance->getSourceKind() == ConformanceEntryKind::PreMacroExpansion)
-        continue;
-
       assert(conformance->isComplete());
       if (auto *normal = dyn_cast<NormalProtocolConformance>(conformance))
         SGM.getWitnessTable(normal);

lib/Sema/TypeCheckMacros.cpp

@@ -1592,15 +1592,7 @@ swift::expandExtensions(CustomAttr *attr, MacroDecl *macro,
   for (auto protocol : potentialConformances) {
     SmallVector<ProtocolConformance *, 2> existingConformances;
     nominal->lookupConformance(protocol, existingConformances);
-
-    bool hasExistingConformance = llvm::any_of(
-        existingConformances,
-        [&](ProtocolConformance *conformance) {
-          return conformance->getSourceKind() !=
-              ConformanceEntryKind::PreMacroExpansion;
-        });
-
-    if (!hasExistingConformance) {
+    if (existingConformances.empty()) {
       introducedConformances.push_back(protocol);
     }
   }

lib/Sema/TypeCheckProtocol.cpp

@@ -6417,8 +6417,7 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
   const auto defaultAccess = nominal->getFormalAccess();
 
   // Check each of the conformances associated with this context.
-  auto conformances = idc->getLocalConformances(
-      ConformanceLookupKind::ExcludeUnexpandedMacros);
+  auto conformances = idc->getLocalConformances();
 
   // The conformance checker bundle that checks all conformances in the context.
   auto &Context = dc->getASTContext();

test/IDE/complete_optionset.swift

@@ -28,7 +28,6 @@ public macro OptionSet<RawType>() =
 // MEMBER_STATIC: Decl[StaticVar]/CurrNominal:        secondDay[#ShippingOptions#]; name=secondDay
 // MEMBER_STATIC: Decl[StaticVar]/CurrNominal:        priority[#ShippingOptions#]; name=priority
 // MEMBER_STATIC: Decl[StaticVar]/CurrNominal:        standard[#ShippingOptions#]; name=standard
-// MEMBER_STATIC: Decl[TypeAlias]/CurrNominal:        ArrayLiteralElement[#ShippingOptions#]; name=ArrayLiteralElement
 // MEMBER_STATIC: Decl[TypeAlias]/CurrNominal:        Element[#ShippingOptions#]; name=Element
 // MEMBER_STATIC: Decl[Constructor]/Super/IsSystem:   init()[#ShippingOptions#]; name=init()
 // MEMBER_STATIC: Decl[Constructor]/Super/IsSystem:   init({#(sequence): Sequence#})[#ShippingOptions#]; name=init(:)

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -1290,6 +1290,39 @@ public struct EquatableMacro: ExtensionMacro {
   }
 }
 
+public struct EquatableViaMembersMacro: 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] {
+    let comparisons: [String] = decl.storedProperties().map { property in
+      guard let binding = property.bindings.first,
+            let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier else {
+        return "true"
+      }
+
+      return "lhs.\(identifier) == rhs.\(identifier)"
+    }
+
+    let condition = comparisons.joined(separator: " && ")
+    let equalOperator: DeclSyntax = """
+      static func ==(lhs: \(type.trimmed), rhs: \(type.trimmed)) -> Bool {
+        return \(raw: condition)
+      }
+      """
+
+    let ext: DeclSyntax = """
+      extension \(type.trimmed): Equatable {
+        \(equalOperator)
+      }
+      """
+    return [ext.cast(ExtensionDeclSyntax.self)]
+  }
+}
+
 public struct ConformanceViaExtensionMacro: ExtensionMacro {
   public static func expansion(
     of node: AttributeSyntax,

test/Macros/macro_expand_extensions.swift

@@ -179,3 +179,22 @@ struct MultipleConformances {}
 // CHECK-DUMP: }
 // CHECK-DUMP: extension MultipleConformances: P2 {
 // CHECK-DUMP: }
+
+@attached(extension, conformances: Equatable, names: named(==))
+macro Equatable() = #externalMacro(module: "MacroDefinition", type: "EquatableViaMembersMacro")
+
+@propertyWrapper
+struct NotEquatable<T> {
+  var wrappedValue: T
+}
+
+@Equatable
+struct HasPropertyWrappers {
+  @NotEquatable
+  var value: Int = 0
+}
+
+func requiresEquatable<T: Equatable>(_: T) { }
+func testHasPropertyWrappers(hpw: HasPropertyWrappers) {
+  requiresEquatable(hpw)
+}