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();
 };

lib/Sema/TypeChecker.cpp

@@ -295,7 +295,7 @@ TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF) const {
       for (auto *decl : synthesizedSF->getTopLevelDecls()) {
         auto extension = cast<ExtensionDecl>(decl);
 
-        // Limit typechecking of synthesized _impicit_ extensions to conformance
+        // Limit typechecking of synthesized _implicit_ extensions to conformance
         // checking. This is done because a conditional conformance to Copyable
         // is synthesized as an extension, based on the markings of `~Copyable`
         // in a value type. This call to `checkConformancesInContext` will

test/decl/circularity.swift

@@ -69,7 +69,7 @@ class C1 {
 }
 
 class C2: C1, P {
-    // expected-note@-1 {{through reference here}}
+    // expected-note@-1 2{{through reference here}}
     override func run(a: A) {}
     // expected-error@-1 {{circular reference}}
     // expected-note@-2 {{while resolving type 'A'}}
@@ -84,7 +84,7 @@ open class G1<A> {
 class C3: G1<A>, P {
     // expected-error@-1 {{type 'C3' does not conform to protocol 'P'}}
     // expected-error@-2 {{cannot find type 'A' in scope}}
-    // expected-note@-3 {{through reference here}}
+    // expected-note@-3 2{{through reference here}}
     override func run(a: A) {}
     // expected-error@-1 {{method does not override any method from its superclass}}
     // expected-error@-2 {{circular reference}}
@@ -102,7 +102,7 @@ class C4 {
   required init(x: Int) {}
 }
 
-class D4 : C4, P1 { // expected-note 3 {{through reference here}}
+class D4 : C4, P1 { // expected-note 4 {{through reference here}}
   required init(x: X) { // expected-error {{circular reference}}
     // expected-note@-1 {{while resolving type 'X'}}
     // expected-note@-2 2{{through reference here}}

validation-test/compiler_crashers_2_fixed/0163-issue-50566.swift

@@ -10,5 +10,5 @@ protocol P1 {
 extension Foo: P1 where A : P1 {}
 // expected-error@-1 {{extension of generic struct 'Foo' has self-referential generic requirements}}
 // expected-note@-2 {{while resolving type 'A'}}
-// expected-note@-3 {{through reference here}}
+// expected-note@-3 2{{through reference here}}
 // expected-error@-4 {{type 'Foo<T>' does not conform to protocol 'P1'}}