RequirementMachine: Better simulation of GSB's 'connected components' malarkey

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -40,14 +40,71 @@ STATISTIC(NumLazyRequirementSignaturesLoaded,
 
 #undef DEBUG_TYPE
 
+namespace {
+
+/// Represents a set of types related by same-type requirements, and an
+/// optional concrete type requirement.
+struct ConnectedComponent {
+  llvm::SmallVector<Type, 2> Members;
+  Type ConcreteType;
+
+  void buildRequirements(Type subjectType, std::vector<Requirement> &reqs);
+};
+
+/// Case 1: A set of rewrite rules of the form:
+///
+///   B => A
+///   C => A
+///   D => A
+///
+/// Become a series of same-type requirements
+///
+///   A == B, B == C, C == D
+///
+/// Case 2: A set of rewrite rules of the form:
+///
+///   A.[concrete: X] => A
+///   B => A
+///   C => A
+///   D => A
+///
+/// Become a series of same-type requirements
+///
+///   A == X, B == X, C == X, D == X
+void ConnectedComponent::buildRequirements(Type subjectType,
+                                           std::vector<Requirement> &reqs) {
+  std::sort(Members.begin(), Members.end(),
+            [](Type first, Type second) -> bool {
+              return compareDependentTypes(first, second) < 0;
+            });
+
+  if (!ConcreteType) {
+    for (auto constraintType : Members) {
+      reqs.emplace_back(RequirementKind::SameType,
+                        subjectType, constraintType);
+      subjectType = constraintType;
+    }
+  } else {
+    reqs.emplace_back(RequirementKind::SameType,
+                      subjectType, ConcreteType);
+
+    for (auto constraintType : Members) {
+      reqs.emplace_back(RequirementKind::SameType,
+                        constraintType, ConcreteType);
+    }
+  }
+}
+
+}  // end namespace
+
 /// Convert a list of non-permanent, non-redundant rewrite rules into a minimal
 /// protocol requirement signature for \p proto. The requirements are sorted in
 /// canonical order, and same-type requirements are canonicalized.
 std::vector<Requirement>
 RequirementMachine::buildRequirementSignature(ArrayRef<unsigned> rules,
                                               const ProtocolDecl *proto) const {
   std::vector<Requirement> reqs;
-  llvm::SmallDenseMap<TypeBase *, llvm::SmallVector<Type, 2>> sameTypeReqs;
+  llvm::SmallDenseMap<TypeBase *, ConnectedComponent> sameTypeReqs;
 
   auto genericParams = proto->getGenericSignature().getGenericParams();
   const auto &protos = System.getProtocols();
@@ -81,15 +138,18 @@ RequirementMachine::buildRequirementSignature(ArrayRef<unsigned> rules,
                               protos));
         return;
 
-      case Symbol::Kind::ConcreteType:
-        reqs.emplace_back(RequirementKind::SameType,
-                          subjectType,
-                          Context.getTypeFromSubstitutionSchema(
-                              prop->getConcreteType(),
-                              prop->getSubstitutions(),
-                              genericParams, MutableTerm(),
-                              protos));
+      case Symbol::Kind::ConcreteType: {
+        auto concreteType = Context.getTypeFromSubstitutionSchema(
+                                prop->getConcreteType(),
+                                prop->getSubstitutions(),
+                                genericParams, MutableTerm(),
+                                protos);
+
+        auto &component = sameTypeReqs[subjectType.getPointer()];
+        assert(!component.ConcreteType);
+        component.ConcreteType = concreteType;
         return;
+      }
 
       case Symbol::Kind::Name:
       case Symbol::Kind::AssociatedType:
@@ -104,41 +164,41 @@ RequirementMachine::buildRequirementSignature(ArrayRef<unsigned> rules,
       auto subjectType = Context.getTypeForTerm(rule.getRHS(), genericParams,
                                                 protos);
 
-      sameTypeReqs[subjectType.getPointer()].push_back(constraintType);
+      sameTypeReqs[subjectType.getPointer()].Members.push_back(constraintType);
     }
   };
 
+  if (getDebugOptions().contains(DebugFlags::Minimization)) {
+    llvm::dbgs() << "Minimized rules:\n";
+  }
+
   // Build the list of requirements, storing same-type requirements off
   // to the side.
   for (unsigned ruleID : rules) {
     const auto &rule = System.getRule(ruleID);
+
+    if (getDebugOptions().contains(DebugFlags::Minimization)) {
+      llvm::dbgs() << "- " << rule << "\n";
+    }
+
     createRequirementFromRule(rule);
   }
 
-  // A set of rewrite rules of the form:
-  //
-  //   B => A
-  //   C => A
-  //   D => A
-  //
-  // Become a series of same-type requirements
-  //
-  //   A == B, B == C, C == D
-  //
+  // Now, convert each connected component into a series of same-type
+  // requirements.
   for (auto &pair : sameTypeReqs) {
-    std::sort(pair.second.begin(), pair.second.end(),
-              [](Type first, Type second) -> bool {
-                return compareDependentTypes(first, second) < 0;
-              });
-
-    Type subjectType(pair.first);
-    for (auto constraintType : pair.second) {
-      reqs.emplace_back(RequirementKind::SameType, subjectType, constraintType);
-      subjectType = constraintType;
+    pair.second.buildRequirements(pair.first, reqs);
+  }
+
+  if (getDebugOptions().contains(DebugFlags::Minimization)) {
+    llvm::dbgs() << "Requirements:\n";
+    for (const auto &req : reqs) {
+      req.dump(llvm::dbgs());
+      llvm::dbgs() << "\n";
     }
   }
 
-  // Sort the requirements in canonical order.
+  // Finally, sort the requirements in canonical order.
   std::sort(reqs.begin(), reqs.end(),
             [](const Requirement &lhs, const Requirement &rhs) -> bool {
               return lhs.compare(rhs) < 0;

test/Generics/connected_components_concrete.swift

@@ -0,0 +1,32 @@
+// RUN: %target-swift-frontend -typecheck -debug-generic-signatures -requirement-machine-protocol-signatures=on %s 2>&1 | %FileCheck %s
+
+protocol P {
+  associatedtype T
+}
+
+protocol Base {
+  associatedtype A
+  associatedtype B
+  associatedtype C
+  associatedtype D : P where B == D.T
+}
+
+// CHECK-LABEL: connected_components_concrete.(file).Derived1@
+// CHECK-LABEL: Requirement signature: <Self where Self : Base, Self.A == Int, Self.B == Int, Self.C == Int>
+protocol Derived1 : Base where A == B, A == C, A == Int {}
+
+// CHECK-LABEL: connected_components_concrete.(file).Derived2@
+// CHECK-LABEL: Requirement signature: <Self where Self : Base, Self.A == Int, Self.B == Int, Self.C == Int>
+protocol Derived2 : Base where A == D.T, A == C, B == Int {}
+
+// CHECK-LABEL: connected_components_concrete.(file).Derived3@
+// CHECK-LABEL: Requirement signature: <Self where Self : Base, Self.A == Int, Self.B == Int, Self.C == Int>
+protocol Derived3 : Base where A == B, B == C, A == Int {}
+
+// CHECK-LABEL: connected_components_concrete.(file).Derived4@
+// CHECK-LABEL: Requirement signature: <Self where Self : Base, Self.A == Int, Self.B == Int, Self.C == Int>
+protocol Derived4 : Base where A == Int, B == Int, C == Int {}
+
+// CHECK-LABEL: connected_components_concrete.(file).Derived5@
+// CHECK-LABEL: Requirement signature: <Self where Self : Base, Self.A == Int, Self.B == Int, Self.C == Int>
+protocol Derived5 : Base where A == Int, D.T == Int, C == Int {}