AST: Factor out AbstractGenericSignatureRequest into a new buildGenericSignature() function

This is slightly cleaner.

Author: slavapestov

include/swift/AST/GenericSignature.h

@@ -114,7 +114,9 @@ class GenericSignature {
 
 public:
   /// Create a new generic signature with the given type parameters and
-  /// requirements.
+  /// requirements. The requirements must already be minimal and canonical;
+  /// to build a signature from an arbitrary set of requirements, use
+  /// swift::buildGenericSignature() instead.
   static GenericSignature get(ArrayRef<GenericTypeParamType *> params,
                               ArrayRef<Requirement> requirements,
                               bool isKnownCanonical = false);
@@ -494,6 +496,21 @@ int compareAssociatedTypes(AssociatedTypeDecl *assocType1,
 
 int compareDependentTypes(Type type1, Type type2);
 
+/// Build a generic signature from the given requirements, which are not
+/// required to be minimal or canonical, and may contain unresolved
+/// DependentMemberTypes.
+///
+/// If \p baseSignature is non-null, the new parameters and requirements
+/// are added on; existing requirements of the base signature might become
+/// redundant.
+///
+/// If \p baseSignature is null, build a new signature from scratch.
+GenericSignature buildGenericSignature(
+    ASTContext &ctx,
+    GenericSignature baseSignature,
+    SmallVector<GenericTypeParamType *, 2> addedParameters,
+    SmallVector<Requirement, 2> addedRequirements);
+
 } // end namespace swift
 
 namespace llvm {

lib/AST/ASTContext.cpp

@@ -4253,13 +4253,11 @@ OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl, unsigned ordinal,
   }
 # endif
 #endif
-  auto signature = evaluateOrDefault(
-      ctx.evaluator,
-      AbstractGenericSignatureRequest{
-        Decl->getOpaqueInterfaceGenericSignature().getPointer(),
+  auto signature = buildGenericSignature(
+        ctx,
+        Decl->getOpaqueInterfaceGenericSignature(),
         /*genericParams=*/{ },
-        std::move(newRequirements)},
-      nullptr);
+        std::move(newRequirements));
 
   auto reqs = signature->getLocalRequirements(opaqueParamType);
   auto superclass = reqs.superclass;
@@ -5024,10 +5022,10 @@ CanGenericSignature ASTContext::getOpenedArchetypeSignature(Type type) {
   auto genericParam = GenericTypeParamType::get(0, 0, *this);
   Requirement requirement(RequirementKind::Conformance, genericParam,
                           existential);
-  auto genericSig = evaluateOrDefault(
-      evaluator,
-      AbstractGenericSignatureRequest{nullptr, {genericParam}, {requirement}},
-      GenericSignature());
+  auto genericSig = buildGenericSignature(*this,
+                                          GenericSignature(),
+                                          {genericParam},
+                                          {requirement});
 
   CanGenericSignature canGenericSig(genericSig);
 
@@ -5125,13 +5123,9 @@ ASTContext::getOverrideGenericSignature(const ValueDecl *base,
     }
   }
 
-  auto genericSig = evaluateOrDefault(
-      evaluator,
-      AbstractGenericSignatureRequest{
-        derivedClassSig.getPointer(),
-        std::move(addedGenericParams),
-        std::move(addedRequirements)},
-      GenericSignature());
+  auto genericSig = buildGenericSignature(*this, derivedClassSig,
+                                          std::move(addedGenericParams),
+                                          std::move(addedRequirements));
   getImpl().overrideSigCache.insert(std::make_pair(key, genericSig));
   return genericSig;
 }

lib/AST/ASTDemangler.cpp

@@ -897,12 +897,8 @@ CanGenericSignature ASTBuilder::demangleGenericSignature(
 
   decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
                     ASTBuilder>(node, requirements, *this);
-  return evaluateOrDefault(Ctx.evaluator,
-                           AbstractGenericSignatureRequest{
-                               nominalDecl->getGenericSignature().getPointer(),
-                               {},
-                               std::move(requirements)},
-                           GenericSignature())
+  return buildGenericSignature(Ctx, nominalDecl->getGenericSignature(),
+                               {}, std::move(requirements))
       .getCanonicalSignature();
 }
 

lib/AST/AutoDiff.cpp

@@ -273,12 +273,9 @@ GenericSignature autodiff::getConstrainedDerivativeGenericSignature(
       requirements.push_back(req);
     }
   }
-  return evaluateOrDefault(
-      ctx.evaluator,
-      AbstractGenericSignatureRequest{derivativeGenSig.getPointer(),
-                                      /*addedGenericParams*/ {},
-                                      std::move(requirements)},
-      nullptr);
+  return buildGenericSignature(ctx, derivativeGenSig,
+                               /*addedGenericParams*/ {},
+                               std::move(requirements));
 }
 
 // Given the rest of a `Builtin.applyDerivative_{jvp|vjp}` or

lib/AST/Builtins.cpp

@@ -305,12 +305,10 @@ synthesizeGenericSignature(SynthesisContext &SC,
   CollectGenericParams collector(SC);
   list.Params.visit(collector);
 
-  return evaluateOrDefault(
-    SC.Context.evaluator,
-    AbstractGenericSignatureRequest{
-      nullptr, std::move(collector.GenericParamTypes),
-               std::move(collector.AddedRequirements)},
-    nullptr);
+  return buildGenericSignature(SC.Context,
+                               GenericSignature(),
+                               std::move(collector.GenericParamTypes),
+                               std::move(collector.AddedRequirements));
 }
 
 /// Build a builtin function declaration.
@@ -671,8 +669,8 @@ namespace {
     bool Async = false;
     BuiltinThrowsKind Throws = BuiltinThrowsKind::None;
 
-    // Accumulate params and requirements here, so that we can make the
-    // appropriate `AbstractGenericSignatureRequest` when `build()` is called.
+    // Accumulate params and requirements here, so that we can call
+    // `buildGenericSignature()` when `build()` is called.
     SmallVector<GenericTypeParamType *, 2> genericParamTypes;
     SmallVector<Requirement, 2> addedRequirements;
 
@@ -727,11 +725,10 @@ namespace {
     }
 
     FuncDecl *build(Identifier name) {
-      auto GenericSig = evaluateOrDefault(
-        Context.evaluator,
-        AbstractGenericSignatureRequest{
-          nullptr, std::move(genericParamTypes), std::move(addedRequirements)},
-        nullptr);
+      auto GenericSig = buildGenericSignature(
+          Context, GenericSignature(),
+          std::move(genericParamTypes),
+          std::move(addedRequirements));
       return getBuiltinGenericFunction(name, InterfaceParams,
                                        InterfaceResult,
                                        TheGenericParamList, GenericSig,

lib/AST/GenericSignature.cpp

@@ -22,6 +22,7 @@
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/PrettyStackTrace.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/STLExtras.h"
@@ -1735,4 +1736,18 @@ void GenericSignature::verify() const {
       abort();
     }
   }
+}
+
+GenericSignature
+swift::buildGenericSignature(ASTContext &ctx,
+                             GenericSignature baseSignature,
+                             SmallVector<GenericTypeParamType *, 2> addedParameters,
+                             SmallVector<Requirement, 2> addedRequirements) {
+  return evaluateOrDefault(
+      ctx.evaluator,
+      AbstractGenericSignatureRequest{
+        baseSignature.getPointer(),
+        addedParameters,
+        addedRequirements},
+      GenericSignature());
 }

lib/AST/RequirementEnvironment.cpp

@@ -207,12 +207,8 @@ RequirementEnvironment::RequirementEnvironment(
   }
 
   // Produce the generic signature and environment.
-  // FIXME: Pass in a source location for the conformance, perhaps? It seems
-  // like this could fail.
-  syntheticSignature = evaluateOrDefault(
-      ctx.evaluator,
-      AbstractGenericSignatureRequest{
-        nullptr, std::move(genericParamTypes), std::move(requirements)},
-      GenericSignature());
+  syntheticSignature = buildGenericSignature(ctx, GenericSignature(),
+                                             std::move(genericParamTypes),
+                                             std::move(requirements));
   syntheticEnvironment = syntheticSignature.getGenericEnvironment();
 }

lib/AST/Type.cpp

@@ -1890,13 +1890,11 @@ class IsBindableVisitor
 
       // Build the generic signature with the additional collected requirements.
       if (!addedRequirements.empty()) {
-        upperBoundGenericSig = evaluateOrDefault(
-                                           decl->getASTContext().evaluator,
-                                           AbstractGenericSignatureRequest{
-                                             upperBoundGenericSig.getPointer(),
-                                             /*genericParams=*/{ },
-                                             std::move(addedRequirements)},
-                                           nullptr);
+        upperBoundGenericSig = buildGenericSignature(decl->getASTContext(),
+                                                     upperBoundGenericSig,
+                                                     /*genericParams=*/{ },
+                                                     std::move(addedRequirements));
+
         upperBoundSubstMap = SubstitutionMap::get(upperBoundGenericSig,
           [&](SubstitutableType *t) -> Type {
             // Type substitutions remain the same as the original substitution
@@ -3988,10 +3986,8 @@ static Type substGenericFunctionType(GenericFunctionType *genericFnType,
     // If there were semantic changes, we need to build a new generic
     // signature.
     ASTContext &ctx = genericFnType->getASTContext();
-    genericSig = evaluateOrDefault(
-        ctx.evaluator,
-        AbstractGenericSignatureRequest{nullptr, genericParams, requirements},
-        GenericSignature());
+    genericSig = buildGenericSignature(ctx, GenericSignature(),
+                                       genericParams, requirements);
   } else {
     // Use the mapped generic signature.
     genericSig = GenericSignature::get(genericParams, requirements);

lib/ClangImporter/ImportDecl.cpp

@@ -9199,11 +9199,10 @@ GenericSignature ClangImporter::Implementation::buildGenericSignature(
     }
   }
 
-  return evaluateOrDefault(
-      SwiftContext.evaluator,
-      AbstractGenericSignatureRequest{
-        nullptr, std::move(genericParamTypes), std::move(requirements)},
-      GenericSignature());
+  return swift::buildGenericSignature(
+      SwiftContext, GenericSignature(),
+      std::move(genericParamTypes),
+      std::move(requirements));
 }
 
 Decl *

lib/SIL/IR/SILFunctionType.cpp

@@ -405,10 +405,7 @@ static CanGenericSignature buildDifferentiableGenericSignature(CanGenericSignatu
     });
   }
 
-  return evaluateOrDefault(
-      ctx.evaluator,
-      AbstractGenericSignatureRequest{sig.getPointer(), {}, reqs},
-      GenericSignature()).getCanonicalSignature();
+  return buildGenericSignature(ctx, sig, {}, reqs).getCanonicalSignature();
 }
 
 /// Given an original type, computes its tangent type for the purpose of