AST: Simplify collectExistentialConformances()

slavapestov · slavapestov · commit 6027bf46a691 · 2024-02-10T09:36:37.000-05:00
diff --git a/include/swift/AST/Module.h b/include/swift/AST/Module.h
@@ -862,11 +862,8 @@ class ModuleDecl
 
   /// Collect the conformances of \c fromType to each of the protocols of an
   /// existential type's layout.
-  ///
-  /// See `TypeChecker::containsProtocol` for details on the boolean arguments.
   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
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -323,30 +323,6 @@ 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;
-};
-
 /// 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
@@ -101,13 +101,6 @@ 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/ConformanceLookup.cpp b/lib/AST/ConformanceLookup.cpp
@@ -47,14 +47,20 @@ using namespace swift;
 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=*/{});
+  assert(existential.isAnyExistentialType());
+
+  auto layout = existential.getExistentialLayout();
+  auto protocols = layout.getProtocols();
+
+  SmallVector<ProtocolConformanceRef, 4> conformances;
+  for (auto *proto : protocols) {
+    auto conformance = lookupConformance(fromType, proto, allowMissing);
+    assert(conformance);
+    conformances.push_back(conformance);
+  }
+
+  return getASTContext().AllocateCopy(conformances);
 }
 
 ProtocolConformanceRef
diff --git a/lib/SILGen/SILGenPoly.cpp b/lib/SILGen/SILGenPoly.cpp
@@ -279,7 +279,6 @@ static ManagedValue emitTransformExistential(SILGenFunction &SGF,
       SGF.SGM.M.getSwiftModule()->collectExistentialConformances(
                                      fromInstanceType,
                                      toInstanceType,
-                                     /*skipConditionalRequirements=*/true,
                                      /*allowMissing=*/true);
 
   // Build result existential
diff --git a/lib/Sema/CSApply.cpp b/lib/Sema/CSApply.cpp
@@ -6671,12 +6671,6 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
   /// 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 =
-      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.
@@ -6738,6 +6732,16 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
     auto *archetypeVal = cs.cacheType(
         new (ctx) OpaqueValueExpr(expr->getSourceRange(), fromType));
 
+    fromInstanceType = fromType;
+    while (auto *metatypeType = fromInstanceType->getAs<MetatypeType>())
+      fromInstanceType = metatypeType->getInstanceType();
+
+    auto conformances =
+        dc->getParentModule()
+          ->collectExistentialConformances(fromInstanceType->getCanonicalType(),
+                                           toInstanceType->getCanonicalType(),
+                                           /*allowMissing=*/true);
+
     auto *result = cs.cacheType(ErasureExpr::create(ctx, archetypeVal, toType,
                                                     conformances,
                                                     argConversions));
@@ -6753,6 +6757,12 @@ Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
     }
   }
 
+  auto conformances =
+      dc->getParentModule()
+        ->collectExistentialConformances(fromInstanceType->getCanonicalType(),
+                                         toInstanceType->getCanonicalType(),
+                                         /*allowMissing=*/true);
+
   return cs.cacheType(ErasureExpr::create(ctx, expr, toType,
                                           conformances, argConversions));
 }
diff --git a/lib/Sema/CSSimplify.cpp b/lib/Sema/CSSimplify.cpp
@@ -8550,7 +8550,6 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
   case ConstraintKind::SelfObjectOfProtocol: {
     auto conformance = TypeChecker::containsProtocol(
         type, protocol, DC->getParentModule(),
-        /*skipConditionalRequirements=*/true,
         /*allowMissing=*/true);
     if (conformance) {
       return recordConformance(conformance);
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -5280,7 +5280,6 @@ void swift::diagnoseConformanceFailure(Type T,
 
 ProtocolConformanceRef
 TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto, ModuleDecl *M,
-                              bool skipConditionalRequirements,
                               bool allowMissing) {
   // Existential types don't need to conform, i.e., they only need to
   // contain the protocol.
@@ -5305,10 +5304,8 @@ TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto, ModuleDecl *M,
     // would result in a missing conformance if type is `& Sendable`
     // protocol composition. It's handled for type as a whole below.
     if (auto superclass = layout.getSuperclass()) {
-      auto result =
-          (skipConditionalRequirements
-               ? M->lookupConformance(superclass, Proto, /*allowMissing=*/false)
-               : M->checkConformance(superclass, Proto, /*allowMissing=*/false));
+      auto result = M->lookupConformance(superclass, Proto,
+                                         /*allowMissing=*/false);
       if (result) {
         return result;
       }
@@ -5331,9 +5328,7 @@ TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto, ModuleDecl *M,
   }
 
   // For non-existential types, this is equivalent to checking conformance.
-  return (skipConditionalRequirements
-          ? M->lookupConformance(T, Proto, allowMissing)
-          : M->checkConformance(T, Proto, allowMissing));
+  return M->lookupConformance(T, Proto, allowMissing);
 }
 
 bool TypeChecker::conformsToKnownProtocol(
diff --git a/lib/Sema/TypeCheckRequestFunctions.cpp b/lib/Sema/TypeCheckRequestFunctions.cpp
@@ -397,31 +397,6 @@ 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)                    \
diff --git a/lib/Sema/TypeChecker.h b/lib/Sema/TypeChecker.h
@@ -797,7 +797,6 @@ Expr *addImplicitLoadExpr(
 /// an empty optional.
 ProtocolConformanceRef containsProtocol(Type T, ProtocolDecl *Proto,
                                         ModuleDecl *M,
-                                        bool skipConditionalRequirements=false,
                                         bool allowMissing=false);
 
 /// Check whether the type conforms to a given known protocol.
diff --git a/test/ClangImporter/objc_async.swift b/test/ClangImporter/objc_async.swift
@@ -354,8 +354,6 @@ func testSender(
   sender.sendSendableSubclasses(nonSendableObject)
   // expected-warning@-1 {{conformance of 'NonSendableClass' to 'Sendable' is unavailable}}
   sender.sendSendableSubclasses(sendableSubclassOfNonSendableObject)
-  // expected-warning@-1 {{conformance of 'NonSendableClass' to 'Sendable' is unavailable}}
-  // FIXME(rdar://89992569): Should allow for the possibility that NonSendableClass will have a Sendable subclass
 
   sender.sendProto(sendableProtos)
   sender.sendProto(nonSendableProtos)
