RequirementMachine: New way of introducing concrete conformance rules

Define the relation as

    [concrete: C].[P] =>> [concrete: C].[concrete: C : P]

instead of

    [concrete: C].[P] =>> [concrete: C : P]

This changes the rewrite loop recorded for a rule T.[concrete: C : P]
to have (T.[concrete: C] => T) appearing twice in context instead of
just once.

We don't ever want a concrete conformance rule to be able to imply a
concrete type rule. This became possible with loop normalization
because the single occurrence of (T.[concrete: C] => T).[P] could
cancel with a subsequent step (T => T.[concrete: C]).[P] in another
rewrite loop after substitution.

Author: slavapestov

lib/AST/RequirementMachine/ConcreteTypeWitness.cpp

@@ -483,14 +483,29 @@ void PropertyMap::recordConcreteConformanceRule(
 
   auto protocolSymbol = *conformanceRule.isPropertyRule();
 
-  // Now, transform T''.[concrete: C].[P] into T''.[concrete: C : P].
+  // Now, transform T''.[concrete: C].[P] into T''.[concrete: C].[concrete: C : P].
   unsigned relationID = System.recordConcreteConformanceRelation(
       concreteSymbol, protocolSymbol, concreteConformanceSymbol);
 
   path.add(RewriteStep::forRelation(
       /*startOffset=*/rhs.size(), relationID,
       /*inverse=*/false));
 
+  // If T' is a suffix of T, prepend the prefix to the concrete type's
+  // substitutions.
+  if (prefixLength > 0 &&
+      !concreteConformanceSymbol.getSubstitutions().empty()) {
+    path.add(RewriteStep::forPrefixSubstitutions(prefixLength, /*endOffset=*/1,
+                                                 /*inverse=*/true));
+  }
+
+  // Finally, apply the concrete type rule to obtain T''.[concrete: C : P].
+  path.add(RewriteStep::forRewriteRule(
+      /*startOffset=*/rhs.size() - concreteRule.getRHS().size(),
+      /*endOffset=*/1,
+      /*ruleID=*/concreteRuleID,
+      /*inverse=*/false));
+
   MutableTerm lhs(rhs);
   lhs.add(concreteConformanceSymbol);
 

lib/AST/RequirementMachine/PropertyRelations.cpp

@@ -65,9 +65,9 @@ unsigned RewriteSystem::recordRelation(Symbol lhsProperty,
       Term::get(rhsTerm, Context));
 }
 
-/// Record a relation ([concrete: C].[P] => [concrete: C : P])
-/// or ([superclass: C].[P] => [concrete: C : P]) which combines a
-/// concrete type symbol (or a superclass symbol) with a protocol
+/// Record a relation ([concrete: C].[P] => [concrete: C].[concrete: C : P])
+/// or ([superclass: C].[P] => [superclass: C].[concrete: C : P]) which combines
+/// a concrete type symbol (or a superclass symbol) with a protocol
 /// symbol to form a single a concrete conformance symbol.
 unsigned RewriteSystem::recordConcreteConformanceRelation(
     Symbol concreteSymbol, Symbol protocolSymbol,
@@ -83,6 +83,7 @@ unsigned RewriteSystem::recordConcreteConformanceRelation(
   lhsTerm.add(protocolSymbol);
 
   MutableTerm rhsTerm;
+  rhsTerm.add(concreteSymbol);
   rhsTerm.add(concreteConformanceSymbol);
 
   return recordRelation(

test/Generics/concrete_conformance_minimization.swift

@@ -1,5 +1,6 @@
 // RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
 // RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on -disable-requirement-machine-concrete-contraction 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -requirement-machine-inferred-signatures=on -disable-requirement-machine-concrete-contraction -enable-requirement-machine-loop-normalization 2>&1 | %FileCheck %s
 
 struct MyOptionSet : OptionSet {
   let rawValue: UInt

test/Generics/concrete_conformance_rule_simplified.swift

@@ -1,5 +1,6 @@
 // RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
 // RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on -disable-requirement-machine-concrete-contraction 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on -disable-requirement-machine-concrete-contraction -enable-requirement-machine-loop-normalization 2>&1 | %FileCheck %s
 
 protocol P1 {}
 

test/Generics/loop_normalization_1.swift

@@ -0,0 +1,40 @@
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on -enable-requirement-machine-loop-normalization 2>&1 | %FileCheck %s
+
+protocol P {
+  associatedtype T
+}
+
+struct C {}
+
+// CHECK-LABEL: .f1@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f1<T: P, U: P>(_: T, _: U) where T.T == C, T.T == U.T { }
+
+// CHECK-LABEL: .f2@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f2<T: P, U: P>(_: T, _: U) where U.T == C, T.T == U.T { }
+
+// CHECK-LABEL: .f3@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f3<T: P, U: P>(_: T, _: U) where T.T == C, U.T == C, T.T == U.T { }
+
+// CHECK-LABEL: .f4@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f4<T: P, U: P>(_: T, _: U) where T.T == C, T.T == U.T, U.T == C { }
+
+// CHECK-LABEL: .f5@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f5<T: P, U: P>(_: T, _: U) where T.T == U.T, T.T == C, U.T == C { }
+
+// CHECK-LABEL: .f6@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f6<T: P, U: P>(_: T, _: U) where U.T == C, T.T == C, T.T == U.T { }
+
+// CHECK-LABEL: .f7@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f7<T: P, U: P>(_: T, _: U) where T.T == C, U.T == C, T.T == U.T { }
+
+// CHECK-LABEL: .f8@
+// CHECK-NEXT: Generic signature: <T, U where T : P, U : P, T.[P]T == C, U.[P]T == C>
+func f8<T: P, U: P>(_: T, _: U) where T.T == U.T, U.T == C, T.T == C { }

test/Generics/loop_normalization_2.swift

@@ -0,0 +1,29 @@
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -enable-requirement-machine-loop-normalization 2>&1 | %FileCheck %s
+
+protocol P1 {
+  associatedtype A
+}
+
+protocol P2 : P1 where A == S0 {
+  associatedtype B : P2 = S2
+    where B.A == A, B.B == B
+}
+
+struct S0 {}
+
+struct S1 : P2 {}
+
+struct S2 : P2 {}
+
+// CHECK-LABEL: .Q1@
+// CHECK-NEXT: Requirement signature: <Self where Self.[Q1]T == S1>
+protocol Q1 {
+  associatedtype T where T : P2, T == S1
+}
+
+// CHECK-LABEL: .Q2@
+// CHECK-NEXT: Requirement signature: <Self where Self.[Q2]T == S2>
+protocol Q2 {
+  associatedtype T where T : P2, T == S2
+}

test/Generics/redundant_parent_path_in_protocol.swift

@@ -1,4 +1,5 @@
 // RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on -enable-requirement-machine-loop-normalization 2>&1 | %FileCheck %s
 
 // CHECK-LABEL: redundant_parent_path_in_protocol.(file).P1@
 // CHECK-NEXT: Requirement signature: <Self>