AST: Move expensive generic signature checks to GenericSignature.cpp

slavapestov · slavapestov · commit 0eb66222e23a · 2021-10-30T00:35:59.000-04:00
This removes the final dependency on GenericSignatureBuilder.h.
diff --git a/include/swift/AST/GenericSignature.h b/include/swift/AST/GenericSignature.h
@@ -496,6 +496,16 @@ int compareAssociatedTypes(AssociatedTypeDecl *assocType1,
 
 int compareDependentTypes(Type type1, Type type2);
 
+/// Verify the correctness of the given generic signature.
+///
+/// This routine will test that the given generic signature is both minimal
+/// and canonical, emitting errors if it is not.
+void validateGenericSignature(ASTContext &context,
+                              GenericSignature sig);
+
+/// Verify all of the generic signatures in the given module.
+void validateGenericSignaturesInModule(ModuleDecl *module);
+
 /// Build a generic signature from the given requirements, which are not
 /// required to be minimal or canonical, and may contain unresolved
 /// DependentMemberTypes.
diff --git a/include/swift/AST/GenericSignatureBuilder.h b/include/swift/AST/GenericSignatureBuilder.h
@@ -802,16 +802,6 @@ class GenericSignatureBuilder {
                                                  ProtocolDecl *protocol,
                                                  GenericSignature sig);
 
-  /// Verify the correctness of the given generic signature.
-  ///
-  /// This routine will test that the given generic signature is both minimal
-  /// and canonical, emitting errors if it is not.
-  static void verifyGenericSignature(ASTContext &context,
-                                     GenericSignature sig);
-
-  /// Verify all of the generic sigantures in the given module.
-  static void verifyGenericSignaturesInModule(ModuleDecl *module);
-
   /// Dump all of the requirements, both specified and inferred. It cannot be
   /// statically proven that this doesn't modify the GSB.
   SWIFT_DEBUG_HELPER(void dump());
diff --git a/lib/AST/GenericSignature.cpp b/lib/AST/GenericSignature.cpp
@@ -1561,6 +1561,8 @@ int swift::compareDependentTypes(Type type1, Type type2) {
   return 0;
 }
 
+#pragma mark Generic signature verification
+
 void GenericSignature::verify() const {
   auto canSig = getCanonicalSignature();
 
@@ -1738,6 +1740,116 @@ void GenericSignature::verify() const {
   }
 }
 
+void swift::validateGenericSignature(ASTContext &context,
+                                     GenericSignature sig) {
+  llvm::errs() << "Validating generic signature: ";
+  sig->print(llvm::errs());
+  llvm::errs() << "\n";
+
+  // Try building a new signature having the same requirements.
+  SmallVector<GenericTypeParamType *, 2> genericParams;
+  for (auto *genericParam :  sig.getGenericParams())
+    genericParams.push_back(genericParam);
+
+  SmallVector<Requirement, 2> requirements;
+  for (auto requirement : sig.getRequirements())
+    requirements.push_back(requirement);
+
+  {
+    PrettyStackTraceGenericSignature debugStack("verifying", sig);
+
+    auto newSigWithError = evaluateOrDefault(
+        context.evaluator,
+        AbstractGenericSignatureRequest{
+            nullptr,
+            genericParams,
+            requirements},
+        GenericSignatureWithError());
+
+    // If there were any errors, the signature was invalid.
+    if (newSigWithError.getInt()) {
+      context.Diags.diagnose(SourceLoc(), diag::generic_signature_not_valid,
+                             sig->getAsString());
+    }
+
+    auto newSig = newSigWithError.getPointer();
+
+    // The new signature should be equal.
+    if (!newSig->isEqual(sig)) {
+      context.Diags.diagnose(SourceLoc(), diag::generic_signature_not_equal,
+                             sig->getAsString(), newSig->getAsString());
+    }
+  }
+
+  // Try removing each requirement in turn.
+  for (unsigned victimIndex : indices(requirements)) {
+    PrettyStackTraceGenericSignature debugStack("verifying", sig, victimIndex);
+
+    // Add the requirements *except* the victim.
+    SmallVector<Requirement, 2> newRequirements;
+    for (unsigned i : indices(requirements)) {
+      if (i != victimIndex)
+        newRequirements.push_back(requirements[i]);
+    }
+
+    auto newSigWithError = evaluateOrDefault(
+        context.evaluator,
+        AbstractGenericSignatureRequest{
+          nullptr,
+          genericParams,
+          newRequirements},
+        GenericSignatureWithError());
+
+    // If there were any errors, we formed an invalid signature, so
+    // just continue.
+    if (newSigWithError.getInt())
+      continue;
+
+    auto newSig = newSigWithError.getPointer();
+
+    // If the new signature once again contains the removed requirement, it's
+    // not redundant.
+    if (newSig->isEqual(sig))
+      continue;
+
+    // If the removed requirement is satisfied by the new generic signature,
+    // it is redundant. Complain.
+    if (newSig->isRequirementSatisfied(requirements[victimIndex])) {
+      SmallString<32> reqString;
+      {
+        llvm::raw_svector_ostream out(reqString);
+        requirements[victimIndex].print(out, PrintOptions());
+      }
+      context.Diags.diagnose(SourceLoc(), diag::generic_signature_not_minimal,
+                             reqString, sig->getAsString());
+    }
+  }
+}
+
+void swift::validateGenericSignaturesInModule(ModuleDecl *module) {
+  LoadedFile *loadedFile = nullptr;
+  for (auto fileUnit : module->getFiles()) {
+    loadedFile = dyn_cast<LoadedFile>(fileUnit);
+    if (loadedFile) break;
+  }
+
+  if (!loadedFile) return;
+
+  // Check all of the (canonical) generic signatures.
+  SmallVector<GenericSignature, 8> allGenericSignatures;
+  SmallPtrSet<CanGenericSignature, 4> knownGenericSignatures;
+  (void)loadedFile->getAllGenericSignatures(allGenericSignatures);
+  ASTContext &context = module->getASTContext();
+  for (auto genericSig : allGenericSignatures) {
+    // Check whether this is the first time we've checked this (canonical)
+    // signature.
+    auto canGenericSig = genericSig.getCanonicalSignature();
+    if (!knownGenericSignatures.insert(canGenericSig).second) continue;
+
+    validateGenericSignature(context, canGenericSig);
+  }
+}
+
 GenericSignature
 swift::buildGenericSignature(ASTContext &ctx,
                              GenericSignature baseSignature,
diff --git a/lib/AST/GenericSignatureBuilder.cpp b/lib/AST/GenericSignatureBuilder.cpp
@@ -8444,119 +8444,6 @@ GenericSignature GenericSignatureBuilder::computeGenericSignature(
   return sig;
 }
 
-#pragma mark Generic signature verification
-
-void GenericSignatureBuilder::verifyGenericSignature(ASTContext &context,
-                                                     GenericSignature sig) {
-  llvm::errs() << "Validating generic signature: ";
-  sig->print(llvm::errs());
-  llvm::errs() << "\n";
-
-  // Try building a new signature having the same requirements.
-  SmallVector<GenericTypeParamType *, 2> genericParams;
-  for (auto *genericParam :  sig.getGenericParams())
-    genericParams.push_back(genericParam);
-
-  SmallVector<Requirement, 2> requirements;
-  for (auto requirement : sig.getRequirements())
-    requirements.push_back(requirement);
-
-  {
-    PrettyStackTraceGenericSignature debugStack("verifying", sig);
-
-    auto newSigWithError = evaluateOrDefault(
-        context.evaluator,
-        AbstractGenericSignatureRequest{
-            nullptr,
-            genericParams,
-            requirements},
-        GenericSignatureWithError());
-
-    // If there were any errors, the signature was invalid.
-    if (newSigWithError.getInt()) {
-      context.Diags.diagnose(SourceLoc(), diag::generic_signature_not_valid,
-                             sig->getAsString());
-    }
-
-    auto newSig = newSigWithError.getPointer();
-
-    // The new signature should be equal.
-    if (!newSig->isEqual(sig)) {
-      context.Diags.diagnose(SourceLoc(), diag::generic_signature_not_equal,
-                             sig->getAsString(), newSig->getAsString());
-    }
-  }
-
-  // Try removing each requirement in turn.
-  for (unsigned victimIndex : indices(requirements)) {
-    PrettyStackTraceGenericSignature debugStack("verifying", sig, victimIndex);
-
-    // Add the requirements *except* the victim.
-    SmallVector<Requirement, 2> newRequirements;
-    for (unsigned i : indices(requirements)) {
-      if (i != victimIndex)
-        newRequirements.push_back(requirements[i]);
-    }
-
-    auto newSigWithError = evaluateOrDefault(
-        context.evaluator,
-        AbstractGenericSignatureRequest{
-          nullptr,
-          genericParams,
-          newRequirements},
-        GenericSignatureWithError());
-
-    // If there were any errors, we formed an invalid signature, so
-    // just continue.
-    if (newSigWithError.getInt())
-      continue;
-
-    auto newSig = newSigWithError.getPointer();
-
-    // If the new signature once again contains the removed requirement, it's
-    // not redundant.
-    if (newSig->isEqual(sig))
-      continue;
-
-    // If the removed requirement is satisfied by the new generic signature,
-    // it is redundant. Complain.
-    if (newSig->isRequirementSatisfied(requirements[victimIndex])) {
-      SmallString<32> reqString;
-      {
-        llvm::raw_svector_ostream out(reqString);
-        requirements[victimIndex].print(out, PrintOptions());
-      }
-      context.Diags.diagnose(SourceLoc(), diag::generic_signature_not_minimal,
-                             reqString, sig->getAsString());
-    }
-  }
-}
-
-void GenericSignatureBuilder::verifyGenericSignaturesInModule(
-                                                        ModuleDecl *module) {
-  LoadedFile *loadedFile = nullptr;
-  for (auto fileUnit : module->getFiles()) {
-    loadedFile = dyn_cast<LoadedFile>(fileUnit);
-    if (loadedFile) break;
-  }
-
-  if (!loadedFile) return;
-
-  // Check all of the (canonical) generic signatures.
-  SmallVector<GenericSignature, 8> allGenericSignatures;
-  SmallPtrSet<CanGenericSignature, 4> knownGenericSignatures;
-  (void)loadedFile->getAllGenericSignatures(allGenericSignatures);
-  ASTContext &context = module->getASTContext();
-  for (auto genericSig : allGenericSignatures) {
-    // Check whether this is the first time we've checked this (canonical)
-    // signature.
-    auto canGenericSig = genericSig.getCanonicalSignature();
-    if (!knownGenericSignatures.insert(canGenericSig).second) continue;
-
-    verifyGenericSignature(context, canGenericSig);
-  }
-}
-      
 /// Check whether the inputs to the \c AbstractGenericSignatureRequest are
 /// all canonical.
 static bool isCanonicalRequest(GenericSignature baseSignature,
diff --git a/lib/FrontendTool/FrontendTool.cpp b/lib/FrontendTool/FrontendTool.cpp
@@ -30,7 +30,7 @@
 #include "swift/AST/FileSystem.h"
 #include "swift/AST/FineGrainedDependencies.h"
 #include "swift/AST/FineGrainedDependencyFormat.h"
-#include "swift/AST/GenericSignatureBuilder.h"
+#include "swift/AST/GenericSignature.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/IRGenRequests.h"
 #include "swift/AST/NameLookup.h"
@@ -469,7 +469,7 @@ static void verifyGenericSignaturesIfNeeded(const FrontendOptions &opts,
   if (verifyGenericSignaturesInModule.empty())
     return;
   if (auto module = Context.getModuleByName(verifyGenericSignaturesInModule))
-    GenericSignatureBuilder::verifyGenericSignaturesInModule(module);
+    swift::validateGenericSignaturesInModule(module);
 }
 
 static bool dumpAndPrintScopeMap(const CompilerInstance &Instance,
