RequirementMachine: Try to minimize away concrete conformances first

Author: slavapestov

lib/AST/RequirementMachine/GeneratingConformances.cpp

@@ -219,7 +219,7 @@ class GeneratingConformances {
 
   void verifyGeneratingConformanceEquations() const;
 
-  void computeGeneratingConformances();
+  void computeGeneratingConformances(bool firstPass);
 
   void verifyGeneratingConformances() const;
 
@@ -799,10 +799,37 @@ void GeneratingConformances::verifyGeneratingConformanceEquations() const {
 
 /// Find a minimal set of generating conformances by marking all other
 /// conformances redundant.
-void GeneratingConformances::computeGeneratingConformances() {
+///
+/// In the first pass, we only consider conformance requirements that are
+/// made redundant by concrete conformances.
+void GeneratingConformances::computeGeneratingConformances(
+    bool firstPass) {
   for (unsigned ruleID : ConformanceRules) {
     const auto &paths = ConformancePaths[ruleID];
 
+    if (firstPass) {
+      bool derivedViaConcrete = false;
+      for (const auto &path : paths) {
+        if (path.empty())
+          break;
+
+        if (System.getRule(path.back()).getLHS().back().getKind() ==
+            Symbol::Kind::ConcreteConformance) {
+          derivedViaConcrete = true;
+          break;
+        }
+      }
+
+      // If this rule doesn't involve concrete conformances it will be
+      // considered in the second pass.
+      if (!derivedViaConcrete)
+        continue;
+    } else {
+      // Ignore rules already determined to be redundant by the first pass.
+      if (RedundantConformances.count(ruleID) > 0)
+        continue;
+    }
+
     bool isProtocolRefinement = ProtocolRefinements.count(ruleID) > 0;
 
     for (const auto &path : paths) {
@@ -893,7 +920,8 @@ void RewriteSystem::computeGeneratingConformances(
   }
 
   builder.verifyGeneratingConformanceEquations();
-  builder.computeGeneratingConformances();
+  builder.computeGeneratingConformances(/*firstPass=*/true);
+  builder.computeGeneratingConformances(/*firstPass=*/false);
   builder.verifyGeneratingConformances();
 
   if (Debug.contains(DebugFlags::GeneratingConformances)) {

test/Generics/concrete_conformances_in_protocol.swift

@@ -0,0 +1,75 @@
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=verify 2>&1 | %FileCheck %s
+
+protocol P {
+  associatedtype T
+}
+struct S : P {
+  typealias T = S
+}
+
+// CHECK-LABEL: concrete_conformances_in_protocol.(file).R0@
+// CHECK-LABEL: Requirement signature: <Self where Self.A == S>
+
+protocol R0 {
+  associatedtype A where A : P, A == S
+}
+
+////
+
+struct G<T> : P {}
+
+// CHECK-LABEL: concrete_conformances_in_protocol.(file).R1@
+// CHECK-LABEL: Requirement signature: <Self where Self.B == G<Self.A>>
+
+protocol R1 {
+  associatedtype A
+  associatedtype B where B : P, B == G<A>
+}
+
+// CHECK-LABEL: concrete_conformances_in_protocol.(file).R2@
+// CHECK-LABEL: Requirement signature: <Self where Self.A == G<Self.B>>
+
+protocol R2 {
+  associatedtype A where A : P, A == G<B>
+  associatedtype B
+}
+
+////
+
+protocol PP {
+  associatedtype T : P
+}
+
+struct GG<T : P> : PP {}
+
+// CHECK-LABEL: concrete_conformances_in_protocol.(file).RR3@
+// CHECK-LABEL: Requirement signature: <Self where Self.A : P, Self.B == GG<Self.A>>
+
+protocol RR3 {
+  associatedtype A : P
+  associatedtype B where B : PP, B == GG<A>
+}
+
+// CHECK-LABEL: concrete_conformances_in_protocol.(file).RR4@
+// CHECK-LABEL: Requirement signature: <Self where Self.A == GG<Self.B>, Self.B : P>
+
+protocol RR4 {
+  associatedtype A where A : PP, A == GG<B>
+  associatedtype B : P
+}
+
+// CHECK-LABEL: concrete_conformances_in_protocol.(file).RR5@
+// CHECK-LABEL: Requirement signature: <Self where Self.A : PP, Self.B == GG<Self.A.T>>
+
+protocol RR5 {
+  associatedtype A : PP
+  associatedtype B where B : PP, B == GG<A.T>
+}
+
+// CHECK-LABEL: concrete_conformances_in_protocol.(file).RR6@
+// CHECK-LABEL: Requirement signature: <Self where Self.A == GG<Self.B.T>, Self.B : PP>
+
+protocol RR6 {
+  associatedtype A where A : PP, A == GG<B.T>
+  associatedtype B : PP
+}