RequirementMachine: Implement AbstractGenericSignatureRequestRQM

Author: slavapestov

include/swift/AST/TypeCheckRequests.h

@@ -1467,6 +1467,38 @@ class AbstractGenericSignatureRequest :
   }
 };
 
+/// Build a generic signature using the RequirementMachine. This is temporary;
+/// once the GenericSignatureBuilder goes away this will be folded into
+/// AbstractGenericSignatureRequest.
+class AbstractGenericSignatureRequestRQM :
+    public SimpleRequest<AbstractGenericSignatureRequestRQM,
+                         GenericSignatureWithError (const GenericSignatureImpl *,
+                                                    SmallVector<GenericTypeParamType *, 2>,
+                                                    SmallVector<Requirement, 2>),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  GenericSignatureWithError
+  evaluate(Evaluator &evaluator,
+           const GenericSignatureImpl *baseSignature,
+           SmallVector<GenericTypeParamType *, 2> addedParameters,
+           SmallVector<Requirement, 2> addedRequirements) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+
+  /// Abstract generic signature requests never have source-location info.
+  SourceLoc getNearestLoc() const {
+    return SourceLoc();
+  }
+};
+
 class InferredGenericSignatureRequest :
     public SimpleRequest<InferredGenericSignatureRequest,
                          GenericSignatureWithError (ModuleDecl *,

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -546,6 +546,45 @@ void RequirementMachine::initWithProtocols(ArrayRef<const ProtocolDecl *> protos
   }
 }
 
+/// Build a requirement machine from a set of generic parameters and
+/// (possibly non-canonical or non-minimal) structural requirements.
+void RequirementMachine::initWithAbstractRequirements(
+    ArrayRef<GenericTypeParamType *> genericParams,
+    ArrayRef<Requirement> requirements) {
+  Params.append(genericParams.begin(), genericParams.end());
+
+  auto &ctx = Context.getASTContext();
+  auto *Stats = ctx.Stats;
+
+  if (Stats)
+    ++Stats->getFrontendCounters().NumRequirementMachines;
+
+  FrontendStatsTracer tracer(Stats, "build-rewrite-system");
+
+  if (Dump) {
+    llvm::dbgs() << "Adding generic parameters:";
+    for (auto *paramTy : genericParams)
+      llvm::dbgs() << " " << Type(paramTy);
+    llvm::dbgs() << "\n";
+  }
+
+  // Collect the top-level requirements, and all transtively-referenced
+  // protocol requirement signatures.
+  RewriteSystemBuilder builder(Context, Dump);
+  builder.addRequirements(requirements);
+
+  // Add the initial set of rewrite rules to the rewrite system.
+  System.initialize(/*recordLoops=*/true,
+                    std::move(builder.PermanentRules),
+                    std::move(builder.RequirementRules));
+
+  computeCompletion(RewriteSystem::AllowInvalidRequirements);
+
+  if (Dump) {
+    llvm::dbgs() << "}\n";
+  }
+}
+
 /// Attempt to obtain a confluent rewrite system using the completion
 /// procedure.
 void RequirementMachine::computeCompletion(RewriteSystem::ValidityPolicy policy) {

lib/AST/RequirementMachine/RequirementMachine.h

@@ -27,6 +27,7 @@ class raw_ostream;
 
 namespace swift {
 
+class AbstractGenericSignatureRequestRQM;
 class ASTContext;
 class AssociatedTypeDecl;
 class CanType;
@@ -45,6 +46,7 @@ class RewriteContext;
 class RequirementMachine final {
   friend class swift::ASTContext;
   friend class swift::rewriting::RewriteContext;
+  friend class swift::AbstractGenericSignatureRequestRQM;
 
   CanGenericSignature Sig;
   SmallVector<Type, 2> Params;
@@ -81,6 +83,9 @@ class RequirementMachine final {
 
   void initWithGenericSignature(CanGenericSignature sig);
   void initWithProtocols(ArrayRef<const ProtocolDecl *> protos);
+  void initWithAbstractRequirements(
+      ArrayRef<GenericTypeParamType *> genericParams,
+      ArrayRef<Requirement> requirements);
 
   bool isComplete() const;
 

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/Requirement.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Statistic.h"
+#include <memory>
 #include <vector>
 
 using namespace swift;
@@ -292,4 +293,58 @@ RequirementMachine::computeMinimalGenericSignatureRequirements() {
 
   auto rules = System.getMinimizedGenericSignatureRules();
   return buildRequirementsFromRules(rules, getGenericParams());
+}
+
+GenericSignatureWithError
+AbstractGenericSignatureRequestRQM::evaluate(
+         Evaluator &evaluator,
+         const GenericSignatureImpl *baseSignatureImpl,
+         SmallVector<GenericTypeParamType *, 2> addedParameters,
+         SmallVector<Requirement, 2> addedRequirements) const {
+  GenericSignature baseSignature = GenericSignature{baseSignatureImpl};
+  // If nothing is added to the base signature, just return the base
+  // signature.
+  if (addedParameters.empty() && addedRequirements.empty())
+    return GenericSignatureWithError(baseSignature, /*hadError=*/false);
+
+  ASTContext &ctx = addedParameters.empty()
+      ? addedRequirements.front().getFirstType()->getASTContext()
+      : addedParameters.front()->getASTContext();
+
+  SmallVector<GenericTypeParamType *, 4> genericParams(
+      baseSignature.getGenericParams().begin(),
+      baseSignature.getGenericParams().end());
+  genericParams.append(
+      addedParameters.begin(),
+      addedParameters.end());
+
+  // If there are no added requirements, we can form the signature directly
+  // with the added parameters.
+  if (addedRequirements.empty()) {
+    auto result = GenericSignature::get(genericParams,
+                                        baseSignature.getRequirements());
+    return GenericSignatureWithError(result, /*hadError=*/false);
+  }
+
+  SmallVector<Requirement, 4> requirements(
+      baseSignature.getRequirements().begin(),
+      baseSignature.getRequirements().end());
+  requirements.append(
+      addedRequirements.begin(),
+      addedRequirements.end());
+
+  // Heap-allocate the requirement machine to save stack space.
+  std::unique_ptr<RequirementMachine> machine(new RequirementMachine(
+      ctx.getRewriteContext()));
+
+  machine->initWithAbstractRequirements(genericParams, requirements);
+
+  auto minimalRequirements =
+    machine->computeMinimalGenericSignatureRequirements();
+
+  // FIXME: Implement this
+  bool hadError = false;
+
+  auto result = GenericSignature::get(genericParams, minimalRequirements);
+  return GenericSignatureWithError(result, hadError);
 }