[NFC] combine collectExistentialConformances

kavon · kavon · commit 4eccbe136edd · 2024-01-10T19:39:07.000-08:00
There are a bunch of static `collectExistentialConformances` copied
around Sema and SILGen that are almost the same, save for whether they
want to permit missing conformances and/or check conditional
conformances.

This commit requestifies and combines all but one of these functions
into a `ModuleDecl::collectExistentialConformances`. The motivation for
this clean-up is another place that will need this procedure.
diff --git a/include/swift/AST/Module.h b/include/swift/AST/Module.h
@@ -853,6 +853,13 @@ class ModuleDecl
   ProtocolConformanceRef conformsToProtocol(Type sourceTy,
                                             ProtocolDecl *targetProtocol);
 
+  /// Collect the conformances of \c fromType each of the protocols of an
+  /// existential type's layout.
+  ArrayRef<ProtocolConformanceRef>
+  collectExistentialConformances(CanType fromType, CanType existential,
+                                 bool skipConditionalRequirements = true,
+                                 bool allowMissing = false);
+
   /// Find a member named \p name in \p container that was declared in this
   /// module.
   ///
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -323,6 +323,34 @@ class ExistentialConformsToSelfRequest :
   void cacheResult(bool value) const;
 };
 
+class CollectExistentialConformancesRequest
+    : public SimpleRequest<CollectExistentialConformancesRequest,
+                           ArrayRef<ProtocolConformanceRef>(ModuleDecl*,
+                                                            CanType,
+                                                            CanType,
+                                                            bool,
+                                                            bool),
+                           RequestFlags::Uncached> { // TODO: maybe cache this?
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ArrayRef<ProtocolConformanceRef>
+      evaluate(Evaluator &evaluator,
+               ModuleDecl *module,
+               CanType fromType,
+               CanType existential,
+               bool skipConditionalRequirements,
+               bool allowMissing) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 /// Determine whether an existential type conforming to this protocol
 /// requires the \c any syntax.
 class HasSelfOrAssociatedTypeRequirementsRequest :
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -100,6 +100,13 @@ SWIFT_REQUEST(TypeChecker, EnumRawTypeRequest,
               Type(EnumDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ExistentialConformsToSelfRequest,
               bool(ProtocolDecl *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CollectExistentialConformancesRequest,
+            ArrayRef<ProtocolConformanceRef>(ModuleDecl*,
+                                             CanType,
+                                             CanType,
+                                             bool,
+                                             bool),
+            Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasSelfOrAssociatedTypeRequirementsRequest,
               bool(ProtocolDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ExtendedTypeRequest, Type(ExtensionDecl *), Cached,
diff --git a/lib/AST/Module.cpp b/lib/AST/Module.cpp
@@ -1568,6 +1568,19 @@ void ModuleDecl::getDisplayDecls(SmallVectorImpl<Decl*> &Results, bool Recursive
 #endif
 }
 
+ArrayRef<ProtocolConformanceRef>
+ModuleDecl::collectExistentialConformances(CanType fromType,
+                                           CanType existential,
+                                           bool skipConditionalRequirements,
+                                           bool allowMissing) {
+  CollectExistentialConformancesRequest request{this,
+                                                fromType,
+                                                existential,
+                                                skipConditionalRequirements,
+                                                allowMissing};
+  return evaluateOrDefault(getASTContext().evaluator, request, /*default=*/{});
+}
+
 ProtocolConformanceRef
 ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   ASTContext &ctx = getASTContext();
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -240,25 +240,6 @@ namespace {
   };
 } // end anonymous namespace
 
-
-static ArrayRef<ProtocolConformanceRef>
-collectExistentialConformances(ModuleDecl *M, CanType fromType, CanType toType) {
-  assert(!fromType.isAnyExistentialType());
-
-  auto layout = toType.getExistentialLayout();
-  auto protocols = layout.getProtocols();
-  
-  SmallVector<ProtocolConformanceRef, 4> conformances;
-  for (auto proto : protocols) {
-    auto conformance =
-      M->lookupConformance(fromType, proto, /*allowMissing=*/true);
-    assert(conformance);
-    conformances.push_back(conformance);
-  }
-  
-  return M->getASTContext().AllocateCopy(conformances);
-}
-
 static ManagedValue emitTransformExistential(SILGenFunction &SGF,
                                              SILLocation loc,
                                              ManagedValue input,
@@ -292,10 +273,13 @@ static ManagedValue emitTransformExistential(SILGenFunction &SGF,
       ->getExistentialInstanceType()->getCanonicalType();
   }
 
+  assert(!fromInstanceType.isAnyExistentialType());
   ArrayRef<ProtocolConformanceRef> conformances =
-      collectExistentialConformances(SGF.SGM.M.getSwiftModule(),
+      SGF.SGM.M.getSwiftModule()->collectExistentialConformances(
                                      fromInstanceType,
-                                     toInstanceType);
+                                     toInstanceType,
+                                     /*skipConditionalRequirements=*/true,
+                                     /*allowMissing=*/true);
 
   // Build result existential
   AbstractionPattern opaque = AbstractionPattern::getOpaque();
diff --git a/lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp b/lib/SILOptimizer/FunctionSignatureTransforms/ExistentialTransform.cpp
@@ -111,25 +111,6 @@ void ExistentialSpecializerCloner::cloneAndPopulateFunction() {
   }
 }
 
-// Gather the conformances needed for an existential value based on an opened
-// archetype. This adds any conformances inherited from superclass constraints.
-static ArrayRef<ProtocolConformanceRef>
-collectExistentialConformances(ModuleDecl *M, CanType openedType,
-                               CanType existentialType) {
-  assert(!openedType.isAnyExistentialType());
-
-  auto layout = existentialType.getExistentialLayout();
-  auto protocols = layout.getProtocols();
-
-  SmallVector<ProtocolConformanceRef, 4> conformances;
-  for (auto proto : protocols) {
-    auto conformance = M->lookupConformance(openedType, proto);
-    assert(conformance);
-    conformances.push_back(conformance);
-  }
-  return M->getASTContext().AllocateCopy(conformances);
-}
-
 // Create the entry basic block with the function arguments.
 void ExistentialSpecializerCloner::cloneArguments(
     SmallVectorImpl<SILValue> &entryArgs) {
@@ -180,11 +161,17 @@ void ExistentialSpecializerCloner::cloneArguments(
         ValueOwnershipKind(NewF, GenericSILType,
                            ArgDesc.Arg->getArgumentConvention()));
     NewArg->copyFlags(ArgDesc.Arg);
-    // Determine the Conformances.
+
+    // Gather the conformances needed for an existential value based on an
+    // opened archetype. This adds any conformances inherited from superclass
+    // constraints.
     SILType ExistentialType = ArgDesc.Arg->getType().getObjectType();
     CanType OpenedType = NewArg->getType().getASTType();
-    auto Conformances = collectExistentialConformances(
-        M.getSwiftModule(), OpenedType, ExistentialType.getASTType());
+    assert(!OpenedType.isAnyExistentialType());
+    auto Conformances = M.getSwiftModule()->collectExistentialConformances(
+        OpenedType,
+        ExistentialType.getASTType());
+
     auto ExistentialRepr =
         ArgDesc.Arg->getType().getPreferredExistentialRepresentation();
     auto &EAD = ExistentialArgDescriptor[ArgDesc.Index];
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -5721,25 +5721,6 @@ Expr *ExprRewriter::coerceSuperclass(Expr *expr, Type toType) {
     new (ctx) DerivedToBaseExpr(expr, toType));
 }
 
-/// Collect the conformances for all the protocols of an existential type.
-/// If the source type is also existential, we don't want to check conformance
-/// because most protocols do not conform to themselves -- however we still
-/// allow the conversion here, except the ErasureExpr ends up with trivial
-/// conformances.
-static ArrayRef<ProtocolConformanceRef>
-collectExistentialConformances(Type fromType, Type toType,
-                               ModuleDecl *module) {
-  auto layout = toType->getExistentialLayout();
-
-  SmallVector<ProtocolConformanceRef, 4> conformances;
-  for (auto proto : layout.getProtocols()) {
-    conformances.push_back(TypeChecker::containsProtocol(
-        fromType, proto, module, false, /*allowMissing=*/true));
-  }
-
-  return toType->getASTContext().AllocateCopy(conformances);
-}
-
 /// Given that the given expression is an implicit conversion added
 /// to the target by coerceToType, find out how many OptionalEvaluationExprs
 /// it includes and the target.
@@ -6729,9 +6710,17 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
 
   ASTContext &ctx = cs.getASTContext();
 
+  /// Collect the conformances for all the protocols of an existential type.
+  /// If the source type is also existential, we don't want to check conformance
+  /// because most protocols do not conform to themselves -- however we still
+  /// allow the conversion here, except the ErasureExpr ends up with trivial
+  /// conformances.
   auto conformances =
-    collectExistentialConformances(fromInstanceType, toInstanceType,
-                                   dc->getParentModule());
+      dc->getParentModule()
+        ->collectExistentialConformances(fromInstanceType->getCanonicalType(),
+                                         toInstanceType->getCanonicalType(),
+                                         /*skipConditionalRequirements=*/false,
+                                         /*allowMissing=*/true);
 
   // Use the requirements of any parameterized protocols to build out fake
   // argument conversions that can be used to infer opaque types.
diff --git a/lib/Sema/TypeCheckRequestFunctions.cpp b/lib/Sema/TypeCheckRequestFunctions.cpp
@@ -414,6 +414,31 @@ Type ResultBuilderTypeRequest::evaluate(Evaluator &evaluator,
   return type->mapTypeOutOfContext();
 }
 
+ArrayRef<ProtocolConformanceRef>
+CollectExistentialConformancesRequest::evaluate(Evaluator &evaluator,
+                                      ModuleDecl *module,
+                                      CanType fromType,
+                                      CanType existential,
+                                      bool skipConditionalRequirements,
+                                      bool allowMissing) const {
+  assert(existential.isAnyExistentialType());
+
+  auto layout = existential.getExistentialLayout();
+  auto protocols = layout.getProtocols();
+
+  SmallVector<ProtocolConformanceRef, 4> conformances;
+  for (auto *proto : protocols) {
+    auto conformance =
+        TypeChecker::containsProtocol(
+            fromType, proto, module,
+            skipConditionalRequirements, allowMissing);
+    assert(conformance);
+    conformances.push_back(conformance);
+  }
+
+  return module->getASTContext().AllocateCopy(conformances);
+}
+
 // Define request evaluation functions for each of the type checker requests.
 static AbstractRequestFunction *typeCheckerRequestFunctions[] = {
 #define SWIFT_REQUEST(Zone, Name, Sig, Caching, LocOptions)                    \
