Sema: Introduce ResolveValueWitnessesRequest

slavapestov · slavapestov · commit 821c3a39c2ed · 2024-01-31T21:56:45.000-05:00
diff --git a/include/swift/AST/TypeCheckRequests.h b/include/swift/AST/TypeCheckRequests.h
@@ -2910,6 +2910,24 @@ class ValueWitnessRequest
   void cacheResult(Witness value) const;
 };
 
+class ResolveValueWitnessesRequest
+    : public SimpleRequest<ResolveValueWitnessesRequest,
+                           evaluator::SideEffect(NormalProtocolConformance *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  evaluator::SideEffect
+  evaluate(Evaluator &evaluator, NormalProtocolConformance *conformance) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class AssociatedConformanceRequest
     : public SimpleRequest<AssociatedConformanceRequest,
                            ProtocolConformanceRef(NormalProtocolConformance *,
diff --git a/include/swift/AST/TypeCheckerTypeIDZone.def b/include/swift/AST/TypeCheckerTypeIDZone.def
@@ -438,6 +438,9 @@ SWIFT_REQUEST(TypeChecker, ResolveTypeWitnessesRequest,
 SWIFT_REQUEST(TypeChecker, ValueWitnessRequest,
               Witness(NormalProtocolConformance *, ValueDecl *),
               SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ResolveValueWitnessesRequest,
+              evaluator::SideEffect(NormalProtocolConformance *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PatternTypeRequest,
               Type(ContextualPattern),
               Cached, HasNearestLocation)
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -3454,19 +3454,24 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
     llvm::raw_svector_ostream SS(Text);
     llvm::SmallVector<NormalProtocolConformance *, 2> fakeConformances;
     for (auto protocol : missingProtocols) {
+      // Create a fake conformance for this type to the given protocol.
       auto conformance = getASTContext().getNormalConformance(
           nominal->getSelfInterfaceType(), protocol, SourceLoc(), nominal,
           ProtocolConformanceState::Incomplete, /*isUnchecked=*/false,
           /*isPreconcurrency=*/false);
-      // Type witnesses must be resolved first.
+
+      // Resolve the conformance to generate fixits.
       evaluateOrDefault(getASTContext().evaluator,
                         ResolveTypeWitnessesRequest{conformance},
                         evaluator::SideEffect());
-      ConformanceChecker checker(getASTContext(), conformance);
-      checker.resolveValueWitnesses();
+      evaluateOrDefault(getASTContext().evaluator,
+                        ResolveValueWitnessesRequest{conformance},
+                        evaluator::SideEffect());
+
       fakeConformances.push_back(conformance);
     }
 
+    // Collect all of the fixits generated above.
     for (auto conformance : fakeConformances) {
       auto missingWitnesses = getASTContext().takeDelayedMissingWitnesses(conformance);
       for (auto decl : missingWitnesses) {
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -2168,6 +2168,9 @@ static bool hasAdditionalSemanticChecks(ProtocolDecl *proto) {
   return proto->isSpecificProtocol(KnownProtocolKind::Sendable);
 }
 
+static void ensureRequirementsAreSatisfied(ASTContext &ctx,
+                                           NormalProtocolConformance *conformance);
+
 /// Determine whether the type \c T conforms to the protocol \c Proto,
 /// recording the complete witness table if it does.
 void MultiConformanceChecker::
@@ -2191,7 +2194,6 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
   auto Proto = conformance->getProtocol();
   auto ProtoType = Proto->getDeclaredInterfaceType();
   SourceLoc ComplainLoc = conformance->getLoc();
-  auto &C = ProtoType->getASTContext();
 
   // Note that we are checking this conformance now.
   conformance->setState(ProtocolConformanceState::Checking);
@@ -2205,27 +2207,27 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
 
   // If the protocol requires a class, non-classes are a non-starter.
   if (Proto->requiresClass() && !DC->getSelfClassDecl()) {
-    C.Diags.diagnose(ComplainLoc,
-                     diag::non_class_cannot_conform_to_class_protocol, T,
-                     ProtoType);
+    Context.Diags.diagnose(ComplainLoc,
+                           diag::non_class_cannot_conform_to_class_protocol, T,
+                           ProtoType);
     conformance->setInvalid();
     return;
   }
 
   if (T->isActorType()) {
     if (auto globalActor = Proto->getGlobalActorAttr()) {
-      C.Diags.diagnose(ComplainLoc,
-                       diag::actor_cannot_conform_to_global_actor_protocol, T,
-                       ProtoType);
+      Context.Diags.diagnose(ComplainLoc,
+                             diag::actor_cannot_conform_to_global_actor_protocol, T,
+                             ProtoType);
 
       CustomAttr *attr;
       NominalTypeDecl *actor;
 
       std::tie(attr, actor) = *globalActor;
 
-      C.Diags.diagnose(attr->getLocation(),
-                       diag::protocol_isolated_to_global_actor_here, ProtoType,
-                       actor->getDeclaredInterfaceType());
+      Context.Diags.diagnose(attr->getLocation(),
+                             diag::protocol_isolated_to_global_actor_here, ProtoType,
+                             actor->getDeclaredInterfaceType());
 
       conformance->setInvalid();
       return;
@@ -2248,7 +2250,7 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
           break;
       }
       if (diagKind) {
-        C.Diags.diagnose(ComplainLoc, diagKind.value(), T, ProtoType);
+        Context.Diags.diagnose(ComplainLoc, diagKind.value(), T, ProtoType);
         conformance->setInvalid();
         return;
       }
@@ -2260,9 +2262,9 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
     // with the Obj-C runtime when they're satisfied, but we'd still have solve
     // the problem with extensions that we check for below.
     if (!conformance->getConditionalRequirements().empty()) {
-      C.Diags.diagnose(ComplainLoc,
-                       diag::objc_protocol_cannot_have_conditional_conformance,
-                       T, ProtoType);
+      Context.Diags.diagnose(ComplainLoc,
+                             diag::objc_protocol_cannot_have_conditional_conformance,
+                             T, ProtoType);
       conformance->setInvalid();
       return;
     }
@@ -2274,9 +2276,9 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
       if (auto classDecl = ext->getSelfClassDecl()) {
         if (classDecl->isGenericContext()) {
           if (!classDecl->isTypeErasedGenericClass()) {
-            C.Diags.diagnose(ComplainLoc,
-                             diag::objc_protocol_in_generic_extension,
-                             classDecl->isGeneric(), T, ProtoType);
+            Context.Diags.diagnose(ComplainLoc,
+                                   diag::objc_protocol_in_generic_extension,
+                                   classDecl->isGeneric(), T, ProtoType);
             conformance->setInvalid();
             return;
           }
@@ -2288,22 +2290,24 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
   // Not every protocol/type is compatible with conditional conformances.
   auto conditionalReqs = conformance->getConditionalRequirements();
   if (!conditionalReqs.empty()) {
-    auto nestedType = DC->getSelfNominalTypeDecl()->getDeclaredInterfaceType();
-    // Obj-C generics cannot be looked up at runtime, so we don't support
-    // conditional conformances involving them. Check the full stack of nested
-    // types for any obj-c ones.
-    while (nestedType) {
-      if (auto clazz = nestedType->getClassOrBoundGenericClass()) {
-        if (clazz->isTypeErasedGenericClass()) {
-          C.Diags.diagnose(ComplainLoc,
-                           diag::objc_generics_cannot_conditionally_conform, T,
-                           ProtoType);
-          conformance->setInvalid();
-          return;
+    auto nestedType = DC->getSelfInterfaceType();
+    if (nestedType->getAnyNominal()) {
+      // Obj-C generics cannot be looked up at runtime, so we don't support
+      // conditional conformances involving them. Check the full stack of nested
+      // types for any obj-c ones.
+      while (nestedType) {
+        if (auto clazz = nestedType->getClassOrBoundGenericClass()) {
+          if (clazz->isTypeErasedGenericClass()) {
+            Context.Diags.diagnose(ComplainLoc,
+                                   diag::objc_generics_cannot_conditionally_conform,
+                                   T, ProtoType);
+            conformance->setInvalid();
+            return;
+          }
         }
-      }
 
-      nestedType = nestedType->getNominalParent();
+        nestedType = nestedType->getNominalParent();
+      }
     }
 
     // If the protocol to which we are conditionally conforming is not a marker
@@ -2313,7 +2317,7 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
       for (const auto &req : conditionalReqs) {
         if (req.getKind() == RequirementKind::Conformance &&
             req.getProtocolDecl()->isMarkerProtocol()) {
-          C.Diags.diagnose(
+          Context.Diags.diagnose(
             ComplainLoc, diag::marker_protocol_conditional_conformance,
             Proto->getName(), req.getFirstType(),
             req.getProtocolDecl()->getName());
@@ -2332,16 +2336,16 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
       const auto effectiveVers =
           getASTContext().LangOpts.EffectiveLanguageVersion;
       if (serialized->getLanguageVersionBuiltWith() != effectiveVers) {
-        C.Diags.diagnose(ComplainLoc,
-                         diag::protocol_has_missing_requirements_versioned, T,
-                         ProtoType, serialized->getLanguageVersionBuiltWith(),
-                         effectiveVers);
+        Context.Diags.diagnose(ComplainLoc,
+                               diag::protocol_has_missing_requirements_versioned,
+                               T, ProtoType, serialized->getLanguageVersionBuiltWith(),
+                               effectiveVers);
         hasDiagnosed = true;
       }
     }
     if (!hasDiagnosed) {
-      C.Diags.diagnose(ComplainLoc, diag::protocol_has_missing_requirements, T,
-                       ProtoType);
+      Context.Diags.diagnose(ComplainLoc, diag::protocol_has_missing_requirements,
+                             T, ProtoType);
     }
     conformance->setInvalid();
     return;
@@ -2350,7 +2354,7 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
   // Complain about the use of @unchecked for protocols that don't have
   // additional semantic checks.
   if (conformance->isUnchecked() && !hasAdditionalSemanticChecks(Proto)) {
-    C.Diags.diagnose(
+    Context.Diags.diagnose(
       ComplainLoc, diag::unchecked_conformance_not_special, ProtoType);
   }
 
@@ -2379,12 +2383,35 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
       // should go into the new extension we (might) suggest here.
 
       diagnoseConformanceImpliedByConditionalConformance(
-          C.Diags, conformance, implyingConf);
+          Context.Diags, conformance, implyingConf);
 
       conformance->setInvalid();
     }
   }
 
+  // Except in specific hardcoded cases for Foundation/Swift
+  // standard library compatibility, an _ObjectiveCBridgeable
+  // conformance must appear in the same module as the definition of
+  // the conforming type.
+  //
+  // Note that we check the module name to smooth over the difference
+  // between an imported Objective-C module and its overlay.
+  if (Proto->isSpecificProtocol(KnownProtocolKind::ObjectiveCBridgeable)) {
+    auto nominal = DC->getSelfNominalTypeDecl();
+    if (!Context.isTypeBridgedInExternalModule(nominal)) {
+      auto clangLoader = Context.getClangModuleLoader();
+      if (nominal->getParentModule() != DC->getParentModule() &&
+          !(clangLoader &&
+            clangLoader->isInOverlayModuleForImportedModule(DC, nominal))) {
+        auto nominalModule = nominal->getParentModule();
+        Context.Diags.diagnose(conformance->getLoc(),
+                               diag::nonlocal_bridged_to_objc,
+                               nominal->getName(), Proto->getName(),
+                               nominalModule->getName());
+      }
+    }
+  }
+
   // Check that T conforms to all inherited protocols.
   for (auto InheritedProto : Proto->getInheritedProtocols()) {
     auto InheritedConformance =
@@ -2396,8 +2423,8 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
       // Recursive call already diagnosed this problem, but tack on a note
       // to establish the relationship.
       if (ComplainLoc.isValid()) {
-        C.Diags.diagnose(Proto, diag::inherited_protocol_does_not_conform, T,
-                         InheritedProto->getDeclaredInterfaceType());
+        Context.Diags.diagnose(Proto, diag::inherited_protocol_does_not_conform,
+                               T, InheritedProto->getDeclaredInterfaceType());
       }
 
       conformance->setInvalid();
@@ -2408,8 +2435,18 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
   if (conformance->isComplete())
     return;
 
-  ConformanceChecker checker(getASTContext(), conformance);
-  checker.checkConformance();
+  // Resolve all of the type witnesses.
+  evaluateOrDefault(Context.evaluator,
+                    ResolveTypeWitnessesRequest{conformance},
+                    evaluator::SideEffect());
+
+  // Check the requirements from the requirement signature.
+  ensureRequirementsAreSatisfied(Context, conformance);
+
+  // Check non-type requirements.
+  evaluateOrDefault(Context.evaluator,
+                    ResolveValueWitnessesRequest{conformance},
+                    evaluator::SideEffect());
 }
 
 /// Add the next associated type deduction to the string representation
@@ -5034,45 +5071,13 @@ void ConformanceChecker::resolveValueWitnesses() {
   }
 }
 
-void ConformanceChecker::checkConformance() {
-  assert(!Conformance->isComplete() && "Conformance is already complete");
-
-  FrontendStatsTracer statsTracer(getASTContext().Stats,
-                                  "check-conformance", Conformance);
-
-  // Resolve all of the type witnesses.
-  evaluateOrDefault(getASTContext().evaluator,
-                    ResolveTypeWitnessesRequest{Conformance},
-                    evaluator::SideEffect());
-
-  // Check the requirements from the requirement signature.
-  ensureRequirementsAreSatisfied(getASTContext(), Conformance);
-
-  // Check non-type requirements.
-  resolveValueWitnesses();
-
-  // Except in specific hardcoded cases for Foundation/Swift
-  // standard library compatibility, an _ObjectiveCBridgeable
-  // conformance must appear in the same module as the definition of
-  // the conforming type.
-  //
-  // Note that we check the module name to smooth over the difference
-  // between an imported Objective-C module and its overlay.
-  if (Proto->isSpecificProtocol(KnownProtocolKind::ObjectiveCBridgeable)) {
-    auto nominal = DC->getSelfNominalTypeDecl();
-    if (!getASTContext().isTypeBridgedInExternalModule(nominal)) {
-      auto clangLoader = getASTContext().getClangModuleLoader();
-      if (nominal->getParentModule() != DC->getParentModule() &&
-          !(clangLoader &&
-            clangLoader->isInOverlayModuleForImportedModule(DC, nominal))) {
-        auto nominalModule = nominal->getParentModule();
-        auto &C = nominal->getASTContext();
-        C.Diags.diagnose(Loc, diag::nonlocal_bridged_to_objc,
-                         nominal->getName(), Proto->getName(),
-                         nominalModule->getName());
-      }
-    }
-  }
+evaluator::SideEffect
+ResolveValueWitnessesRequest::evaluate(Evaluator &evaluator,
+                                NormalProtocolConformance *conformance) const {
+  auto &ctx = conformance->getDeclContext()->getASTContext();
+  ConformanceChecker checker(ctx, conformance);
+  checker.resolveValueWitnesses();
+  return evaluator::SideEffect();
 }
 
 void swift::diagnoseConformanceFailure(Type T,
@@ -5133,16 +5138,23 @@ void swift::diagnoseConformanceFailure(Type T,
       return;
     }
 
-    // If it is missing the ActorSystem type, suggest adding it:
-    auto systemTy = getDistributedActorSystemType(/*actor=*/nominal);
-    if (!systemTy || systemTy->hasError()) {
-      diags.diagnose(ComplainLoc,
-                     diag::distributed_actor_conformance_missing_system_type,
-                     nominal->getName());
-      diags.diagnose(nominal->getStartLoc(),
-                     diag::note_distributed_actor_system_can_be_defined_using_defaultdistributedactorsystem);
-      return;
+    if (nominal->isDistributedActor()) {
+      // If it is missing the ActorSystem type, suggest adding it:
+      auto systemTy = getDistributedActorSystemType(/*actor=*/nominal);
+      if (!systemTy || systemTy->hasError()) {
+        diags.diagnose(ComplainLoc,
+                       diag::distributed_actor_conformance_missing_system_type,
+                       nominal->getName());
+        diags.diagnose(nominal->getStartLoc(),
+                       diag::note_distributed_actor_system_can_be_defined_using_defaultdistributedactorsystem);
+      }
     }
+
+    // For a non-class nominal type, we already diagnose the failure in
+    // ensureRequirementsAreSatisfied() when the 'Self: AnyObject' requirement
+    // fails.
+    if (!isa<ClassDecl>(nominal))
+      return;
   }
 
   // Special case: for enums with a raw type, explain that the failing
diff --git a/lib/Sema/TypeCheckProtocol.h b/lib/Sema/TypeCheckProtocol.h
