RequirementMachine: Implement InferredGenericSignatureRequest

Author: slavapestov

include/swift/AST/TypeCheckRequests.h

@@ -1553,7 +1553,50 @@ class InferredGenericSignatureRequest :
   SourceLoc getNearestLoc() const {
     return SourceLoc();
   }
-                           
+
+  // Cycle handling.
+  void noteCycleStep(DiagnosticEngine &diags) const;
+};
+
+/// Build a generic signature using the RequirementMachine. This is temporary;
+/// once the GenericSignatureBuilder goes away this will be folded into
+/// InferredGenericSignatureRequest.
+class InferredGenericSignatureRequestRQM :
+    public SimpleRequest<InferredGenericSignatureRequestRQM,
+                         GenericSignatureWithError (ModuleDecl *,
+                                                    const GenericSignatureImpl *,
+                                                    GenericParamList *,
+                                                    WhereClauseOwner,
+                                                    SmallVector<Requirement, 2>,
+                                                    SmallVector<TypeLoc, 2>,
+                                                    bool),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  GenericSignatureWithError
+  evaluate(Evaluator &evaluator,
+           ModuleDecl *parentModule,
+           const GenericSignatureImpl *baseSignature,
+           GenericParamList *genericParams,
+           WhereClauseOwner whereClause,
+           SmallVector<Requirement, 2> addedRequirements,
+           SmallVector<TypeLoc, 2> inferenceSources,
+           bool allowConcreteGenericParams) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+
+  /// Inferred generic signature requests don't have source-location info.
+  SourceLoc getNearestLoc() const {
+    return SourceLoc();
+  }
+
   // Cycle handling.
   void noteCycleStep(DiagnosticEngine &diags) const;
 };

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -143,6 +143,14 @@ SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
                                          SmallVector<Requirement, 2>,
                                          SmallVector<TypeLoc, 2>, bool),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequestRQM,
+              GenericSignatureWithError (ModuleDecl *,
+                                         const GenericSignatureImpl *,
+                                         GenericParamList *,
+                                         WhereClauseOwner,
+                                         SmallVector<Requirement, 2>,
+                                         SmallVector<TypeLoc, 2>, bool),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, DistributedModuleIsAvailableRequest,
               bool(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InheritedTypeRequest,

lib/AST/RequirementMachine/RequirementMachine.h

@@ -32,6 +32,7 @@ class ASTContext;
 class AssociatedTypeDecl;
 class CanType;
 class GenericTypeParamType;
+class InferredGenericSignatureRequestRQM;
 class LayoutConstraint;
 class ProtocolDecl;
 class Requirement;
@@ -47,6 +48,7 @@ class RequirementMachine final {
   friend class swift::ASTContext;
   friend class swift::rewriting::RewriteContext;
   friend class swift::AbstractGenericSignatureRequestRQM;
+  friend class swift::InferredGenericSignatureRequestRQM;
 
   CanGenericSignature Sig;
   SmallVector<Type, 2> Params;

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Requirement.h"
 #include "swift/AST/TypeCheckRequests.h"
+#include "swift/AST/TypeRepr.h"
 #include "swift/Basic/Statistic.h"
 #include "RequirementLowering.h"
 #include <memory>
@@ -357,5 +358,110 @@ AbstractGenericSignatureRequestRQM::evaluate(
   bool hadError = false;
 
   auto result = GenericSignature::get(genericParams, minimalRequirements);
+  return GenericSignatureWithError(result, hadError);
+}
+
+GenericSignatureWithError
+InferredGenericSignatureRequestRQM::evaluate(
+        Evaluator &evaluator,
+        ModuleDecl *parentModule,
+        const GenericSignatureImpl *parentSigImpl,
+        GenericParamList *genericParamList,
+        WhereClauseOwner whereClause,
+        SmallVector<Requirement, 2> addedRequirements,
+        SmallVector<TypeLoc, 2> inferenceSources,
+        bool allowConcreteGenericParams) const {
+  GenericSignature parentSig(parentSigImpl);
+
+  SmallVector<GenericTypeParamType *, 4> genericParams(
+      parentSig.getGenericParams().begin(),
+      parentSig.getGenericParams().end());
+
+  SmallVector<StructuralRequirement, 4> requirements;
+  for (const auto &req : parentSig.getRequirements())
+    requirements.push_back({req, SourceLoc(), /*wasInferred=*/false});
+
+  const auto visitRequirement = [&](const Requirement &req,
+                                    RequirementRepr *reqRepr) {
+    realizeRequirement(req, reqRepr, /*infer=*/true, requirements);
+    return false;
+  };
+
+  if (genericParamList) {
+    // Extensions never have a parent signature.
+    assert(genericParamList->getOuterParameters() == nullptr || !parentSig);
+
+    // Collect all outer generic parameter lists.
+    SmallVector<GenericParamList *, 2> gpLists;
+    for (auto *outerParamList = genericParamList;
+         outerParamList != nullptr;
+         outerParamList = outerParamList->getOuterParameters()) {
+      gpLists.push_back(outerParamList);
+    }
+
+    // The generic parameter lists must appear from innermost to outermost.
+    // We walk them backwards to order outer parameters before inner
+    // parameters.
+    for (auto *gpList : llvm::reverse(gpLists)) {
+      assert(gpList->size() > 0 &&
+             "Parsed an empty generic parameter list?");
+
+      for (auto *gpDecl : *gpList) {
+        auto *gpType = gpDecl->getDeclaredInterfaceType()
+                             ->castTo<GenericTypeParamType>();
+        genericParams.push_back(gpType);
+
+        realizeInheritedRequirements(gpDecl, gpType, /*infer=*/true,
+                                     requirements);
+      }
+
+      // Add the generic parameter list's 'where' clause to the builder.
+      //
+      // The only time generic parameter lists have a 'where' clause is
+      // in SIL mode; all other generic declarations have a free-standing
+      // 'where' clause, which will be visited below.
+      WhereClauseOwner(parentModule, gpList)
+        .visitRequirements(TypeResolutionStage::Structural,
+                           visitRequirement);
+    }
+  }
+
+  if (whereClause) {
+    std::move(whereClause).visitRequirements(
+        TypeResolutionStage::Structural,
+        visitRequirement);
+  }
+
+  // Perform requirement inference from function parameter and result
+  // types and such.
+  for (auto sourcePair : inferenceSources) {
+    auto *typeRepr = sourcePair.getTypeRepr();
+    auto loc = typeRepr ? typeRepr->getStartLoc() : SourceLoc();
+
+    inferRequirements(sourcePair.getType(), loc, requirements);
+  }
+
+  // Finish by adding any remaining requirements. This is used to introduce
+  // inferred same-type requirements when building the generic signature of
+  // an extension whose extended type is a generic typealias.
+  for (const auto &req : addedRequirements)
+    requirements.push_back({req, SourceLoc(), /*wasInferred=*/true});
+
+  // Heap-allocate the requirement machine to save stack space.
+  std::unique_ptr<RequirementMachine> machine(new RequirementMachine(
+      parentModule->getASTContext().getRewriteContext()));
+
+  machine->initWithWrittenRequirements(genericParams, requirements);
+
+  auto minimalRequirements =
+    machine->computeMinimalGenericSignatureRequirements();
+
+  // FIXME: Implement this
+  bool hadError = false;
+
+  auto result = GenericSignature::get(genericParams, minimalRequirements);
+
+  // FIXME: Handle allowConcreteGenericParams
+
   return GenericSignatureWithError(result, hadError);
 }

lib/AST/TypeCheckRequests.cpp

@@ -766,6 +766,14 @@ void InferredGenericSignatureRequest::noteCycleStep(DiagnosticEngine &d) const {
   // into this request.  See rdar://55263708
 }
 
+void InferredGenericSignatureRequestRQM::noteCycleStep(DiagnosticEngine &d) const {
+  // For now, the GSB does a better job of describing the exact structure of
+  // the cycle.
+  //
+  // FIXME: We should consider merging the circularity handling the GSB does
+  // into this request.  See rdar://55263708
+}
+
 //----------------------------------------------------------------------------//
 // UnderlyingTypeRequest computation.
 //----------------------------------------------------------------------------//