Sema: Stop recording missing witnesses in the ConformanceChecker

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -499,7 +499,7 @@ ResolveWitnessResult ConformanceChecker::resolveTypeWitnessViaLookup(
     return ResolveWitnessResult::ExplicitFailed;
   }
   // Save the missing type witness for later diagnosis.
-  GlobalMissingWitnesses.insert({assocType, {}});
+  getASTContext().addDelayedMissingWitness(Conformance, {assocType, {}});
 
   // None of the candidates were viable.
   getASTContext().addDelayedConformanceDiag(Conformance, true,
@@ -3653,7 +3653,7 @@ auto AssociatedTypeInference::solve(ConformanceChecker &checker)
 
   // Save the missing type witnesses for later diagnosis.
   for (auto assocType : unresolvedAssocTypes) {
-    checker.GlobalMissingWitnesses.insert({assocType, {}});
+    ctx.addDelayedMissingWitness(conformance, {assocType, {}});
   }
 
   return llvm::None;
@@ -3996,12 +3996,8 @@ TypeWitnessRequest::evaluate(Evaluator &eval,
                              NormalProtocolConformance *conformance,
                              AssociatedTypeDecl *requirement) const {
   auto &ctx = requirement->getASTContext();
-  llvm::SetVector<ASTContext::MissingWitness> MissingWitnesses;
-  ConformanceChecker checker(ctx, conformance, MissingWitnesses);
+  ConformanceChecker checker(ctx, conformance);
   checker.resolveSingleTypeWitness(requirement);
-  for (auto missing : MissingWitnesses) {
-    ctx.addDelayedMissingWitness(conformance, missing);
-  }
 
   // FIXME: ConformanceChecker and the other associated WitnessCheckers have
   // an extremely convoluted caching scheme that doesn't fit nicely into the

lib/Sema/CSDiagnostics.cpp

@@ -3453,22 +3453,25 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
   {
     llvm::SmallString<128> Text;
     llvm::raw_svector_ostream SS(Text);
-    llvm::SetVector<ASTContext::MissingWitness> missingWitnesses;
+    llvm::SmallVector<NormalProtocolConformance *, 2> fakeConformances;
     for (auto protocol : missingProtocols) {
-      auto conformance = NormalProtocolConformance(
-          nominal->getDeclaredType(), protocol, SourceLoc(), nominal,
+      auto conformance = getASTContext().getNormalConformance(
+          nominal->getSelfInterfaceType(), protocol, SourceLoc(), nominal,
           ProtocolConformanceState::Incomplete, /*isUnchecked=*/false,
           /*isPreconcurrency=*/false);
-      ConformanceChecker checker(getASTContext(), &conformance,
-                                 missingWitnesses);
+      ConformanceChecker checker(getASTContext(), conformance);
       // Type witnesses must be resolved first.
       checker.resolveTypeWitnesses();
       checker.resolveValueWitnesses();
+      fakeConformances.push_back(conformance);
     }
 
-    for (auto decl : missingWitnesses) {
-      swift::printRequirementStub(decl.requirement, nominal, nominal->getDeclaredType(),
-                                  nominal->getStartLoc(), SS);
+    for (auto conformance : fakeConformances) {
+      auto missingWitnesses = getASTContext().takeDelayedMissingWitnesses(conformance);
+      for (auto decl : missingWitnesses) {
+        swift::printRequirementStub(decl.requirement, nominal, nominal->getDeclaredType(),
+                                    nominal->getStartLoc(), SS);
+      }
     }
 
     if (!Text.empty()) {

lib/Sema/TypeCheckProtocol.cpp

@@ -1884,7 +1884,6 @@ class MultiConformanceChecker {
   llvm::SmallVector<ValueDecl*, 16> UnsatisfiedReqs;
   llvm::SmallVector<ConformanceChecker, 4> AllUsedCheckers;
   llvm::SmallVector<NormalProtocolConformance*, 4> AllConformances;
-  llvm::SetVector<ASTContext::MissingWitness> MissingWitnesses;
   llvm::SmallPtrSet<ValueDecl *, 8> CoveredMembers;
 
   /// Check one conformance.
@@ -1976,6 +1975,8 @@ static void diagnoseProtocolStubFixit(
     ArrayRef<ASTContext::MissingWitness> missingWitnesses);
 
 void MultiConformanceChecker::checkAllConformances() {
+  llvm::SetVector<ASTContext::MissingWitness> MissingWitnesses;
+
   bool anyInvalid = false;
   for (auto *conformance : AllConformances) {
     checkIndividualConformance(conformance);
@@ -1995,16 +1996,12 @@ void MultiConformanceChecker::checkAllConformances() {
       }
     }
 
-    if (AllUsedCheckers.empty() ||
-        AllUsedCheckers.back().Conformance != conformance) {
-      continue;
-    }
-
-    auto &checker = AllUsedCheckers.back();
-    auto LocalMissing = checker.getLocalMissingWitness();
+    auto LocalMissing = Context.takeDelayedMissingWitnesses(conformance);
     if (LocalMissing.empty())
       continue;
 
+    MissingWitnesses.insert(LocalMissing.begin(), LocalMissing.end());
+
     // Diagnose the missing witnesses.
     for (auto &Missing : LocalMissing) {
       auto requirement = Missing.requirement;
@@ -2031,10 +2028,9 @@ void MultiConformanceChecker::checkAllConformances() {
 
   // Otherwise, backtrack to the last checker that has missing witnesses
   // and diagnose missing witnesses from there.
-  for (auto &checker : llvm::reverse(AllUsedCheckers)) {
-    if (!checker.getLocalMissingWitness().empty()) {
-      diagnoseProtocolStubFixit(Context,
-                                checker.Conformance,
+  for (auto *conformance : llvm::reverse(AllConformances)) {
+    if (Context.hasDelayedConformanceErrors(conformance)) {
+      diagnoseProtocolStubFixit(Context, conformance,
                                 MissingWitnesses.getArrayRef());
       break;
     }
@@ -2408,15 +2404,8 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
   if (conformance->isComplete())
     return;
 
-  // Revive registered missing witnesses to handle it below.
-  auto revivedMissingWitnesses =
-      getASTContext().takeDelayedMissingWitnesses(conformance);
-
   // The conformance checker we're using.
-  AllUsedCheckers.emplace_back(getASTContext(), conformance, MissingWitnesses);
-  MissingWitnesses.insert(revivedMissingWitnesses.begin(),
-                          revivedMissingWitnesses.end());
-
+  AllUsedCheckers.emplace_back(getASTContext(), conformance);
   AllUsedCheckers.back().checkConformance();
 }
 
@@ -2959,13 +2948,10 @@ diagnoseMatch(ModuleDecl *module, NormalProtocolConformance *conformance,
 }
 
 ConformanceChecker::ConformanceChecker(
-    ASTContext &ctx, NormalProtocolConformance *conformance,
-    llvm::SetVector<ASTContext::MissingWitness> &GlobalMissingWitnesses)
+    ASTContext &ctx, NormalProtocolConformance *conformance)
     : WitnessChecker(ctx, conformance->getProtocol(), conformance->getType(),
                      conformance->getDeclContext()),
-      Conformance(conformance), Loc(conformance->getLoc()),
-      GlobalMissingWitnesses(GlobalMissingWitnesses),
-      LocalMissingWitnessesStartIndex(GlobalMissingWitnesses.size()) {}
+      Conformance(conformance), Loc(conformance->getLoc()) {}
 
 ConformanceChecker::~ConformanceChecker() {}
 
@@ -4340,7 +4326,7 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
   if (!numViable) {
     // Save the missing requirement for later diagnosis.
     if (shouldRecordMissingWitness(Proto, Conformance, requirement))
-      GlobalMissingWitnesses.insert({requirement, matches});
+      getASTContext().addDelayedMissingWitness(Conformance, {requirement, matches});
     return ResolveWitnessResult::Missing;
   }
 
@@ -6458,12 +6444,8 @@ ValueWitnessRequest::evaluate(Evaluator &eval,
                               NormalProtocolConformance *conformance,
                               ValueDecl *requirement) const {
   auto &ctx = requirement->getASTContext();
-  llvm::SetVector<ASTContext::MissingWitness> MissingWitnesses;
-  ConformanceChecker checker(ctx, conformance, MissingWitnesses);
+  ConformanceChecker checker(ctx, conformance);
   checker.resolveSingleWitness(requirement);
-  for (auto missing : MissingWitnesses) {
-    ctx.addDelayedMissingWitness(conformance, missing);
-  }
 
   // FIXME: ConformanceChecker and the other associated WitnessCheckers have
   // an extremely convoluted caching scheme that doesn't fit nicely into the

lib/Sema/TypeCheckProtocol.h

@@ -126,15 +126,6 @@ class ConformanceChecker : public WitnessChecker {
   NormalProtocolConformance *Conformance;
   SourceLoc Loc;
 
-  /// Keep track of missing witnesses, either type or value, for later
-  /// diagnosis emits. This may contain witnesses that are external to the
-  /// protocol under checking.
-  llvm::SetVector<ASTContext::MissingWitness> &GlobalMissingWitnesses;
-
-  /// Keep track of the slice in GlobalMissingWitnesses that is local to
-  /// this protocol under checking.
-  unsigned LocalMissingWitnessesStartIndex;
-
   /// Record a (non-type) witness for the given requirement.
   void recordWitness(ValueDecl *requirement, const RequirementMatch &match);
 
@@ -184,14 +175,7 @@ class ConformanceChecker : public WitnessChecker {
   /// the chosen type witnesses.
   void ensureRequirementsAreSatisfied();
 
-  ArrayRef<ASTContext::MissingWitness> getLocalMissingWitness() {
-    return GlobalMissingWitnesses.getArrayRef().
-      slice(LocalMissingWitnessesStartIndex,
-            GlobalMissingWitnesses.size() - LocalMissingWitnessesStartIndex);
-  }
-
-  ConformanceChecker(ASTContext &ctx, NormalProtocolConformance *conformance,
-                     llvm::SetVector<ASTContext::MissingWitness> &GlobalMissingWitnesses);
+  ConformanceChecker(ASTContext &ctx, NormalProtocolConformance *conformance);
 
   ~ConformanceChecker();