Sema: Introduce ResolveTypeWitnessesRequest

Author: slavapestov

include/swift/AST/TypeCheckRequests.h

@@ -2870,6 +2870,24 @@ class ReferencedAssociatedTypesRequest
   bool isCached() const { return true; }
 };
 
+class ResolveTypeWitnessesRequest
+    : public SimpleRequest<ResolveTypeWitnessesRequest,
+                           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 ValueWitnessRequest
     : public SimpleRequest<ValueWitnessRequest,
                            Witness(NormalProtocolConformance *, ValueDecl *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -432,6 +432,9 @@ SWIFT_REQUEST(TypeChecker, AssociatedConformanceRequest,
 SWIFT_REQUEST(TypeChecker, ReferencedAssociatedTypesRequest,
               TinyPtrVector<AssociatedTypeDecl *>(ValueDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ResolveTypeWitnessesRequest,
+              evaluator::SideEffect(NormalProtocolConformance *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ValueWitnessRequest,
               Witness(NormalProtocolConformance *, ValueDecl *),
               SeparatelyCached, NoLocationInfo)

lib/Sema/AssociatedTypeInference.cpp

@@ -3947,64 +3947,62 @@ TypeWitnessSystem::compareResolvedTypes(Type ty1, Type ty2) {
   return ResolvedTypeComparisonResult::EquivalentOrWorse;
 }
 
-void ConformanceChecker::resolveTypeWitnesses() {
-  PrettyStackTraceConformance trace("performing associated type inference on",
-                                    Conformance);
-
+evaluator::SideEffect
+ResolveTypeWitnessesRequest::evaluate(Evaluator &evaluator,
+                                      NormalProtocolConformance *conformance) const {
   // Attempt to infer associated type witnesses.
-  AssociatedTypeInference inference(getASTContext(), Conformance);
+  auto &ctx = conformance->getDeclContext()->getASTContext();
+
+  AssociatedTypeInference inference(ctx, conformance);
   if (auto inferred = inference.solve()) {
     for (const auto &inferredWitness : *inferred) {
-      recordTypeWitness(Conformance,
+      recordTypeWitness(conformance,
                         inferredWitness.first,
                         inferredWitness.second,
                         /*typeDecl=*/nullptr);
     }
 
-    return;
+    return evaluator::SideEffect();
   }
 
   // Conformance failed. Record errors for each of the witnesses.
-  Conformance->setInvalid();
+  conformance->setInvalid();
 
   // We're going to produce an error below. Mark each unresolved
   // associated type witness as erroneous.
-  for (auto assocType : Proto->getAssociatedTypeMembers()) {
+  for (auto assocType : conformance->getProtocol()->getAssociatedTypeMembers()) {
     // If we already have a type witness, do nothing.
-    if (Conformance->hasTypeWitness(assocType))
+    if (conformance->hasTypeWitness(assocType))
       continue;
 
-    recordTypeWitness(Conformance, assocType,
-                      ErrorType::get(getASTContext()), nullptr);
+    recordTypeWitness(conformance, assocType, ErrorType::get(ctx), nullptr);
   }
+
+  return evaluator::SideEffect();
 }
 
-void ConformanceChecker::resolveSingleTypeWitness(
-       AssociatedTypeDecl *assocType) {
-  switch (resolveTypeWitnessViaLookup(Conformance, assocType)) {
+TypeWitnessAndDecl
+TypeWitnessRequest::evaluate(Evaluator &eval,
+                             NormalProtocolConformance *conformance,
+                             AssociatedTypeDecl *requirement) const {
+  switch (resolveTypeWitnessViaLookup(conformance, requirement)) {
   case ResolveWitnessResult::Success:
   case ResolveWitnessResult::ExplicitFailed:
     // We resolved this type witness one way or another.
-    return;
+    break;
 
-  case ResolveWitnessResult::Missing:
+  case ResolveWitnessResult::Missing: {
     // The type witness is still missing. Resolve all of the type witnesses.
-    resolveTypeWitnesses();
-    return;
+    auto &ctx = requirement->getASTContext();
+    evaluateOrDefault(ctx.evaluator,
+                      ResolveTypeWitnessesRequest{conformance},
+                      evaluator::SideEffect());
+    break;
+  }
   }
-}
-
-TypeWitnessAndDecl
-TypeWitnessRequest::evaluate(Evaluator &eval,
-                             NormalProtocolConformance *conformance,
-                             AssociatedTypeDecl *requirement) const {
-  auto &ctx = requirement->getASTContext();
-  ConformanceChecker checker(ctx, conformance);
-  checker.resolveSingleTypeWitness(requirement);
 
-  // FIXME: ConformanceChecker and the other associated WitnessCheckers have
-  // an extremely convoluted caching scheme that doesn't fit nicely into the
-  // evaluator's model. All of this should be refactored away.
+  // FIXME: resolveTypeWitnessViaLookup() and ResolveTypeWitnessesRequest
+  // pre-populate the type witnesses in this manner. This should be cleaned up.
   const auto known = conformance->TypeWitnesses.find(requirement);
   assert(known != conformance->TypeWitnesses.end() &&
          "Didn't resolve witness?");

lib/Sema/CSDiagnostics.cpp

@@ -3459,9 +3459,11 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
           nominal->getSelfInterfaceType(), protocol, SourceLoc(), nominal,
           ProtocolConformanceState::Incomplete, /*isUnchecked=*/false,
           /*isPreconcurrency=*/false);
-      ConformanceChecker checker(getASTContext(), conformance);
       // Type witnesses must be resolved first.
-      checker.resolveTypeWitnesses();
+      evaluateOrDefault(getASTContext().evaluator,
+                        ResolveTypeWitnessesRequest{conformance},
+                        evaluator::SideEffect());
+      ConformanceChecker checker(getASTContext(), conformance);
       checker.resolveValueWitnesses();
       fakeConformances.push_back(conformance);
     }

lib/Sema/TypeCheckProtocol.cpp

@@ -4014,7 +4014,9 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
   auto *nominal = DC->getSelfNominalTypeDecl();
 
   // Resolve all associated types before trying to resolve this witness.
-  resolveTypeWitnesses();
+  evaluateOrDefault(getASTContext().evaluator,
+                    ResolveTypeWitnessesRequest{Conformance},
+                    evaluator::SideEffect());
 
   // If any of the type witnesses was erroneous, don't bother to check
   // this value witness: it will fail.
@@ -4531,7 +4533,9 @@ void ConformanceChecker::resolveSingleWitness(ValueDecl *requirement) {
     return;
 
   // Resolve all associated types before trying to resolve this witness.
-  resolveTypeWitnesses();
+  evaluateOrDefault(getASTContext().evaluator,
+                    ResolveTypeWitnessesRequest{Conformance},
+                    evaluator::SideEffect());
 
   // If any of the type witnesses was erroneous, don't bother to check
   // this value witness: it will fail.
@@ -5048,7 +5052,9 @@ void ConformanceChecker::checkConformance() {
                                   "check-conformance", Conformance);
 
   // Resolve all of the type witnesses.
-  resolveTypeWitnesses();
+  evaluateOrDefault(getASTContext().evaluator,
+                    ResolveTypeWitnessesRequest{Conformance},
+                    evaluator::SideEffect());
 
   // Check the requirements from the requirement signature.
   ensureRequirementsAreSatisfied();

lib/Sema/TypeCheckProtocol.h

@@ -175,9 +175,6 @@ class ConformanceChecker : public WitnessChecker {
 
   ~ConformanceChecker();
 
-  /// Resolve all of the type witnesses.
-  void resolveTypeWitnesses();
-
   /// Resolve all of the non-type witnesses.
   void resolveValueWitnesses();
 
@@ -191,10 +188,6 @@ class ConformanceChecker : public WitnessChecker {
   /// conformance has been completed checked.
   void resolveSingleWitness(ValueDecl *requirement);
 
-  /// Resolve the type witness for the given associated type as
-  /// directly as possible.
-  void resolveSingleTypeWitness(AssociatedTypeDecl *assocType);
-
   /// Check the entire protocol conformance.
   void checkConformance();
 };