RequirementMachine: Use ProtocolDecl::getProtocolDependencies()

When using the requirement machine to build protocol signatures,
we can't get the protocol's dependencies by looking at the
conformance requirements in it's requirement signature, because
we haven't computed the requirement signature yet.

Instead, get the dependencies via the recently-added
getStructuralRequirements() request.

Author: slavapestov

lib/AST/RequirementMachine/ProtocolGraph.cpp

@@ -23,7 +23,7 @@ using namespace rewriting;
 void ProtocolGraph::visitRequirements(ArrayRef<Requirement> reqs) {
   for (auto req : reqs) {
     if (req.getKind() == RequirementKind::Conformance) {
-      addProtocol(req.getProtocolDecl());
+      addProtocol(req.getProtocolDecl(), /*initialComponent=*/false);
     }
   }
 }
@@ -32,7 +32,7 @@ void ProtocolGraph::visitRequirements(ArrayRef<Requirement> reqs) {
 /// \p protos.
 void ProtocolGraph::visitProtocols(ArrayRef<const ProtocolDecl *> protos) {
   for (auto proto : protos) {
-    addProtocol(proto);
+    addProtocol(proto, /*initialComponent=*/true);
   }
 }
 
@@ -50,13 +50,15 @@ const ProtocolInfo &ProtocolGraph::getProtocolInfo(
 }
 
 /// Record information about a protocol if we have no seen it yet.
-void ProtocolGraph::addProtocol(const ProtocolDecl *proto) {
+void ProtocolGraph::addProtocol(const ProtocolDecl *proto,
+                                bool initialComponent) {
   if (Info.count(proto) > 0)
     return;
 
   Info[proto] = {proto->getInheritedProtocols(),
                  proto->getAssociatedTypeMembers(),
-                 proto->getRequirementSignature()};
+                 proto->getProtocolDependencies(),
+                 initialComponent};
   Protocols.push_back(proto);
 }
 
@@ -66,7 +68,9 @@ void ProtocolGraph::computeTransitiveClosure() {
   unsigned i = 0;
   while (i < Protocols.size()) {
     auto *proto = Protocols[i++];
-    visitRequirements(getProtocolInfo(proto).Requirements);
+    for (auto *proto : getProtocolInfo(proto).Dependencies) {
+      addProtocol(proto, /*initialComponent=*/false);
+    }
   }
 }
 

lib/AST/RequirementMachine/ProtocolGraph.h

@@ -42,8 +42,8 @@ struct ProtocolInfo {
   /// ProtocolGraph::computeInheritedAssociatedTypes().
   llvm::TinyPtrVector<AssociatedTypeDecl *> InheritedAssociatedTypes;
 
-  /// The protocol's requirement signature.
-  ArrayRef<Requirement> Requirements;
+  /// The protocol's dependencies.
+  ArrayRef<ProtocolDecl *> Dependencies;
 
   /// Used by ProtocolGraph::computeProtocolDepth() to detect circularity.
   unsigned Mark : 1;
@@ -55,27 +55,34 @@ struct ProtocolInfo {
 
   /// Index of the protocol in the linear order. Computed by
   /// ProtocolGraph::computeLinearOrder().
-  unsigned Index : 32;
+  unsigned Index : 31;
+
+  /// When building a protocol requirement signature, the initial set of
+  /// protocols are marked with this bit.
+  unsigned InitialComponent : 1;
 
   ProtocolInfo() {
     Mark = 0;
     Depth = 0;
     Index = 0;
+    InitialComponent = 0;
   }
 
   ProtocolInfo(ArrayRef<ProtocolDecl *> inherited,
                ArrayRef<AssociatedTypeDecl *> &&types,
-               ArrayRef<Requirement> reqs)
+               ArrayRef<ProtocolDecl *> deps,
+               bool initialComponent)
     : Inherited(inherited),
       AssociatedTypes(types),
-      Requirements(reqs) {
+      Dependencies(deps) {
     Mark = 0;
     Depth = 0;
     Index = 0;
+    InitialComponent = initialComponent;
   }
 };
 
-/// Stores cached information about all protocols transtively
+/// Stores cached information about all protocols transitively
 /// referenced from a set of generic requirements.
 ///
 /// Out-of-line methods are documented in ProtocolGraph.cpp.
@@ -101,7 +108,8 @@ class ProtocolGraph {
       const ProtocolDecl *proto) const;
 
 private:
-  void addProtocol(const ProtocolDecl *proto);
+  void addProtocol(const ProtocolDecl *proto,
+                   bool initialComponent);
   void computeTransitiveClosure();
   void computeLinearOrder();
   void computeInheritedAssociatedTypes();

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -243,8 +243,20 @@ void RewriteSystemBuilder::processProtocolDependencies() {
     for (auto *assocType : info.InheritedAssociatedTypes)
       addAssociatedType(assocType, proto);
 
-    for (auto req : info.Requirements)
-      addRequirement(req.getCanonical(), proto);
+    // If this protocol is part of the initial connected component, we're
+    // building requirement signatures for all protocols in this component,
+    // and so we must start with the structural requirements.
+    //
+    // Otherwise, we should either already have a requirement signature, or
+    // we can trigger the computation of the requirement signatures of the
+    // next component recursively.
+    if (info.InitialComponent) {
+      for (auto req : proto->getStructuralRequirements())
+        addRequirement(req.req.getCanonical(), proto);
+    } else {
+      for (auto req : proto->getRequirementSignature())
+        addRequirement(req.getCanonical(), proto);
+    }
 
     if (Dump) {
       llvm::dbgs() << "}\n";

lib/Sema/TypeCheckDecl.cpp

@@ -1093,7 +1093,12 @@ ProtocolDependenciesRequest::evaluate(Evaluator &evaluator,
 
   // If we have a serialized requirement signature, deserialize it and
   // look at conformance requirements.
-  if (proto->hasLazyRequirementSignature()) {
+  //
+  // FIXME: For now we just fall back to the GSB for all protocols
+  // unless -requirement-machine-protocol-signatures=on is passed.
+  if (proto->hasLazyRequirementSignature() ||
+      (ctx.LangOpts.RequirementMachineProtocolSignatures
+        == RequirementMachineMode::Disabled)) {
     for (auto req : proto->getRequirementSignature()) {
       if (req.getKind() == RequirementKind::Conformance) {
         result.push_back(req.getProtocolDecl());