Merge pull request #72146 from slavapestov/ncgenerics-fixes-9

Non-copyable generics fixes, part 9

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -1302,15 +1302,17 @@ class ASTContext final {
   /// specialized conformance from the generic conformance.
   ProtocolConformance *
   getSpecializedConformance(Type type,
-                            RootProtocolConformance *generic,
+                            NormalProtocolConformance *generic,
                             SubstitutionMap substitutions);
 
-  /// Produce an inherited conformance, for subclasses of a type
-  /// that already conforms to a protocol.
+  /// Produce an inherited conformance, which forwards all operations to a
+  /// base conformance, except for getType(), which must return some subclass
+  /// of the base conformance's conforming type. This models the case where a
+  /// subclass conforms to a protocol because its superclass already conforms.
   ///
   /// \param type The type for which we are retrieving the conformance.
   ///
-  /// \param inherited The inherited conformance.
+  /// \param inherited A normal or specialized conformance.
   ProtocolConformance *
   getInheritedConformance(Type type, ProtocolConformance *inherited);
 

include/swift/AST/Decl.h

@@ -3919,10 +3919,6 @@ class AssociatedTypeDecl : public TypeDecl {
         TypeDecl::getOverriddenDecl());
   }
 
-  /// Determine whether this type has ~<target>` stated as
-  /// one of its inherited types.
-  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
-
   /// Retrieve the set of associated types overridden by this associated
   /// type.
   llvm::TinyPtrVector<AssociatedTypeDecl *> getOverriddenDecls() const;
@@ -4223,7 +4219,7 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   ///
   /// This is used by deserialization of module files to report
   /// conformances.
-  void registerProtocolConformance(ProtocolConformance *conformance,
+  void registerProtocolConformance(NormalProtocolConformance *conformance,
                                    bool synthesized = false);
 
   void setConformanceLoader(LazyMemberLoader *resolver, uint64_t contextData);
@@ -5258,10 +5254,6 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// Determine whether this protocol inherits from the given ("super")
   /// protocol.
   bool inheritsFrom(const ProtocolDecl *Super) const;
-
-  /// Determine whether this protocol has ~<target>` stated on
-  /// itself, one of its inherited types or `Self` requirements.
-  InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
 
   SourceLoc getStartLoc() const { return ProtocolLoc; }
   SourceRange getSourceRange() const {

include/swift/AST/ProtocolConformance.h

@@ -880,7 +880,7 @@ class SelfProtocolConformance : public RootProtocolConformance {
 class SpecializedProtocolConformance : public ProtocolConformance,
                                        public llvm::FoldingSetNode {
   /// The generic conformance from which this conformance was derived.
-  RootProtocolConformance *GenericConformance;
+  NormalProtocolConformance *GenericConformance;
 
   /// The substitutions applied to the generic conformance to produce this
   /// conformance.
@@ -899,15 +899,15 @@ class SpecializedProtocolConformance : public ProtocolConformance,
   friend class ASTContext;
 
   SpecializedProtocolConformance(Type conformingType,
-                                 RootProtocolConformance *genericConformance,
+                                 NormalProtocolConformance *genericConformance,
                                  SubstitutionMap substitutions);
 
   void computeConditionalRequirements() const;
 
 public:
   /// Get the generic conformance from which this conformance was derived,
   /// if there is one.
-  RootProtocolConformance *getGenericConformance() const {
+  NormalProtocolConformance *getGenericConformance() const {
     return GenericConformance;
   }
 
@@ -993,7 +993,7 @@ class SpecializedProtocolConformance : public ProtocolConformance,
   }
 
   static void Profile(llvm::FoldingSetNodeID &ID, Type type,
-                      RootProtocolConformance *genericConformance,
+                      NormalProtocolConformance *genericConformance,
                       SubstitutionMap subs) {
     ID.AddPointer(type.getPointer());
     ID.AddPointer(genericConformance);

lib/AST/ASTContext.cpp

@@ -2600,7 +2600,7 @@ ASTContext::getBuiltinConformance(Type type, ProtocolDecl *protocol,
 }
 
 static bool collapseSpecializedConformance(Type type,
-                                           RootProtocolConformance *conformance,
+                                           NormalProtocolConformance *conformance,
                                            SubstitutionMap substitutions) {
   if (!conformance->getType()->isEqual(type))
     return false;
@@ -2615,7 +2615,7 @@ static bool collapseSpecializedConformance(Type type,
 
 ProtocolConformance *
 ASTContext::getSpecializedConformance(Type type,
-                                      RootProtocolConformance *generic,
+                                      NormalProtocolConformance *generic,
                                       SubstitutionMap substitutions) {
   // If the specialization is a no-op, use the root conformance instead.
   if (collapseSpecializedConformance(type, generic, substitutions)) {

lib/AST/ConformanceLookup.cpp

@@ -29,7 +29,6 @@
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/GenericEnvironment.h"
-#include "swift/AST/InverseMarking.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/PackConformance.h"
@@ -403,39 +402,6 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
   return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
-static ProtocolConformanceRef
-getBuiltinInvertibleProtocolConformance(NominalTypeDecl *nominal,
-                                        Type type,
-                                        ProtocolDecl *protocol) {
-  assert(isa<ClassDecl>(nominal));
-  ASTContext &ctx = protocol->getASTContext();
-
-  auto ip = protocol->getInvertibleProtocolKind();
-  switch (*ip) {
-  case InvertibleProtocolKind::Copyable:
-    // If move-only classes is enabled, we'll check the markings.
-    if (ctx.LangOpts.hasFeature(Feature::MoveOnlyClasses)) {
-      switch (nominal->hasInverseMarking(*ip).getKind()) {
-      case InverseMarking::Kind::LegacyExplicit:
-      case InverseMarking::Kind::Explicit:
-        // An inverse ~Copyable prevents conformance.
-        return ProtocolConformanceRef::forInvalid();
-
-      case InverseMarking::Kind::None:
-        break;
-      }
-    }
-    break;
-  case InvertibleProtocolKind::Escapable:
-    // Always conforms.
-    break;
-  }
-
-  return ProtocolConformanceRef(
-      ctx.getBuiltinConformance(type, protocol,
-                                BuiltinConformanceKind::Synthesized));
-}
-
 /// Synthesize a builtin type conformance to the given protocol, if
 /// appropriate.
 static ProtocolConformanceRef
@@ -625,13 +591,6 @@ LookupConformanceInModuleRequest::evaluate(
   if (!nominal || isa<ProtocolDecl>(nominal))
     return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
-  // We specially avoid recording conformances to invertible protocols in a
-  // class's conformance table. This prevents an evaluator cycle.
-  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)
-      && isa<ClassDecl>(nominal)
-      && protocol->getInvertibleProtocolKind())
-        return getBuiltinInvertibleProtocolConformance(nominal, type, protocol);
-
   // Expand conformances added by extension macros.
   //
   // FIXME: This expansion should only be done if the
@@ -643,8 +602,12 @@ LookupConformanceInModuleRequest::evaluate(
       ExpandExtensionMacros{nominal},
       { });
 
-  // Find the (unspecialized) conformance.
+  // Find the root conformance in the nominal type declaration's
+  // conformance lookup table.
   SmallVector<ProtocolConformance *, 2> conformances;
+
+  // If the conformance lookup table produced nothing, we try to derive the
+  // conformance for a few special protocol kinds.
   if (!nominal->lookupConformance(protocol, conformances)) {
     if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
       // Try to infer Sendable conformance.
@@ -677,31 +640,17 @@ LookupConformanceInModuleRequest::evaluate(
       } else {
         return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
-    } else if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)
-               || protocol->isSpecificProtocol(KnownProtocolKind::Escapable)) {
-      const auto kp = protocol->getKnownProtocolKind().value();
-
-      if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)
-          && kp == KnownProtocolKind::Copyable) {
+    } else if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
+      if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
         // Return an abstract conformance to maintain legacy compatability.
         // We only need to do this until we are properly dealing with or
         // omitting Copyable conformances in modules/interfaces.
 
         if (nominal->canBeCopyable())
           return ProtocolConformanceRef(protocol);
-        else
-          return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
 
-      // Try to infer the conformance.
-      ImplicitKnownProtocolConformanceRequest cvRequest{nominal, kp};
-      if (auto conformance = evaluateOrDefault(
-          ctx.evaluator, cvRequest, nullptr)) {
-        conformances.clear();
-        conformances.push_back(conformance);
-      } else {
-        return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
-      }
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
     } else if (protocol->isSpecificProtocol(
                    KnownProtocolKind::BitwiseCopyable)) {
       // Try to infer BitwiseCopyable conformance.
@@ -720,6 +669,8 @@ LookupConformanceInModuleRequest::evaluate(
     }
   }
 
+  // We should have at least one conformance by now, or we would have returned
+  // above.
   assert(!conformances.empty());
 
   // If we have multiple conformances, first try to filter out any that are
@@ -768,27 +719,32 @@ LookupConformanceInModuleRequest::evaluate(
     return ProtocolConformanceRef(conformance);
   }
 
-  // If the type is specialized, find the conformance for the generic type.
+  // We now have a root conformance for the nominal's declared interface type.
+  // If our type is specialized, apply a substitution map to the root
+  // conformance.
   if (type->isSpecialized()) {
-    // Figure out the type that's explicitly conforming to this protocol.
-    Type explicitConformanceType = conformance->getType();
-    DeclContext *explicitConformanceDC = conformance->getDeclContext();
-
-    // If the explicit conformance is associated with a type that is different
-    // from the type we're checking, retrieve generic conformance.
-    if (!explicitConformanceType->isEqual(type)) {
-      // Gather the substitutions we need to map the generic conformance to
-      // the specialized conformance.
-      auto subMap = type->getContextSubstitutionMap(mod, explicitConformanceDC);
-
-      // Create the specialized conformance entry.
-      auto result = ctx.getSpecializedConformance(type,
-        cast<RootProtocolConformance>(conformance), subMap);
-      return ProtocolConformanceRef(result);
+    if (!conformance->getType()->isEqual(type)) {
+      // We use a builtin conformance for unconditional Copyable and Escapable
+      // conformances. Avoid building a substitution map and just return the
+      // correct builtin conformance for the specialized type.
+      if (auto *builtinConf = dyn_cast<BuiltinProtocolConformance>(conformance)) {
+        return ProtocolConformanceRef(
+            ctx.getBuiltinConformance(type, protocol,
+                                      builtinConf->getBuiltinConformanceKind()));
+      }
+
+      // Otherwise, we have a normal conformance, so we're going to build a
+      // specialized conformance from the context substitution map of the
+      // specialized type.
+      auto *normalConf = cast<NormalProtocolConformance>(conformance);
+      auto *conformanceDC = normalConf->getDeclContext();
+      auto subMap = type->getContextSubstitutionMap(mod, conformanceDC);
+      return ProtocolConformanceRef(
+          ctx.getSpecializedConformance(type, normalConf, subMap));
     }
   }
 
-  // Record and return the simple conformance.
+  // Return the root conformance.
   return ProtocolConformanceRef(conformance);
 }
 

lib/AST/ConformanceLookupTable.cpp

@@ -174,7 +174,7 @@ void ConformanceLookupTable::forEachInStage(ConformanceStage stage,
     if (loader.first) {
       SmallVector<ProtocolConformance *, 2> conformances;
       loader.first->loadAllConformances(nominal, loader.second, conformances);
-      loadAllConformances(nominal, conformances);
+      registerProtocolConformances(nominal, conformances);
     }
 
     nominalFunc(nominal);
@@ -202,7 +202,7 @@ void ConformanceLookupTable::forEachInStage(ConformanceStage stage,
     if (loader.first) {
       SmallVector<ProtocolConformance *, 2> conformances;
       loader.first->loadAllConformances(next, loader.second, conformances);
-      loadAllConformances(next, conformances);
+      registerProtocolConformances(next, conformances);
       for (auto conf : conformances) {
         protocols.push_back(
             {conf->getProtocol(), SourceLoc(), SourceLoc(), SourceLoc()});
@@ -295,8 +295,19 @@ void ConformanceLookupTable::updateLookupTable(NominalTypeDecl *nominal,
     forEachInStage(
         stage, nominal,
         [&](NominalTypeDecl *nominal) {
-          addInheritedProtocols(nominal,
-                                ConformanceSource::forExplicit(nominal));
+          auto source = ConformanceSource::forExplicit(nominal);
+
+          // Get all of the protocols in the inheritance clause.
+          InvertibleProtocolSet inverses;
+          bool anyObject = false;
+          for (const auto &found :
+                  getDirectlyInheritedNominalTypeDecls(nominal, inverses, anyObject)) {
+            if (auto proto = dyn_cast<ProtocolDecl>(found.Item)) {
+              addProtocol(proto, found.Loc,
+                          source.withUncheckedLoc(found.uncheckedLoc)
+                                .withPreconcurrencyLoc(found.preconcurrencyLoc));
+            }
+          }
 
           addMacroGeneratedProtocols(
               nominal, ConformanceSource::forUnexpandedMacro(nominal));
@@ -422,19 +433,17 @@ void ConformanceLookupTable::updateLookupTable(NominalTypeDecl *nominal,
   }
 }
 
-void ConformanceLookupTable::loadAllConformances(
+void ConformanceLookupTable::registerProtocolConformances(
        DeclContext *dc,
        ArrayRef<ProtocolConformance*> conformances) {
   // If this declaration context came from source, there's nothing to
   // do here.
-  if (dc->getParentSourceFile() ||
-      dc->getParentModule()->isBuiltinModule()) {
-    return;
-  }
+  assert(!dc->getParentSourceFile() &&
+         !dc->getParentModule()->isBuiltinModule());
 
   // Add entries for each loaded conformance.
   for (auto conformance : conformances) {
-    registerProtocolConformance(conformance);
+    registerProtocolConformance(dc, conformance);
   }
 }
 
@@ -494,22 +503,6 @@ bool ConformanceLookupTable::addProtocol(ProtocolDecl *protocol, SourceLoc loc,
   return true;
 }
 
-void ConformanceLookupTable::addInheritedProtocols(
-    llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
-    ConformanceSource source) {
-  // Find all of the protocols in the inheritance list.
-  InvertibleProtocolSet inverses;
-  bool anyObject = false;
-  for (const auto &found :
-          getDirectlyInheritedNominalTypeDecls(decl, inverses, anyObject)) {
-    if (auto proto = dyn_cast<ProtocolDecl>(found.Item)) {
-      addProtocol(proto, found.Loc,
-                  source.withUncheckedLoc(found.uncheckedLoc)
-                        .withPreconcurrencyLoc(found.preconcurrencyLoc));
-    }
-  }
-}
-
 void ConformanceLookupTable::addMacroGeneratedProtocols(
     NominalTypeDecl *nominal, ConformanceSource source) {
   nominal->forEachAttachedMacro(
@@ -928,7 +921,22 @@ ConformanceLookupTable::getConformance(NominalTypeDecl *nominal,
   // Form the conformance.
   Type type = entry->getDeclContext()->getDeclaredInterfaceType();
   ASTContext &ctx = nominal->getASTContext();
-  if (entry->getKind() == ConformanceEntryKind::Inherited) {
+
+  if (protocol->getInvertibleProtocolKind() &&
+      entry->getDeclContext() == nominal &&
+      (entry->getKind() == ConformanceEntryKind::Synthesized ||
+       entry->getKind() == ConformanceEntryKind::Inherited)) {
+    // Unconditional conformances to Copyable and Escapable are represented as
+    // builtin conformances, which do not need to store a substitution map.
+    //
+    // This avoids an exponential blowup when constructing the context
+    // substitution map for a type like G<G<G<G<...>>>>.
+    Type conformingType = nominal->getSelfInterfaceType();
+
+    entry->Conformance = ctx.getBuiltinConformance(
+        conformingType, protocol, BuiltinConformanceKind::Synthesized);
+
+  } else if (entry->getKind() == ConformanceEntryKind::Inherited) {
     // For an inherited conformance, the conforming nominal type will
     // be different from the nominal type.
     assert(conformingNominal != nominal && "Broken inherited conformance");
@@ -1024,10 +1032,9 @@ void ConformanceLookupTable::addSynthesizedConformance(
 }
 
 void ConformanceLookupTable::registerProtocolConformance(
-       ProtocolConformance *conformance,
+       DeclContext *dc, ProtocolConformance *conformance,
        bool synthesized) {
   auto protocol = conformance->getProtocol();
-  auto dc = conformance->getDeclContext();
   auto nominal = dc->getSelfNominalTypeDecl();
 
   // If there is an entry to update, do so.