RequirementMachine: New way of modeling layout requirement implied by superclass requirement

A superclass requirement implies a layout requirement. We don't
want the layout requirement to be present in the minimal
signature, so instead of adding a pair of requirements:

    T.[superclass: C<X, Y>] => T
    T.[layout: _NativeClass] => T

Add this pair of requirements:

    T.[superclass: C<X, Y>] => T
    [superclass: C<X, Y>].[layout: _NativeClass] => [superclass: C<X, Y>] [permanent]

Completion then derives the rule as a consequence:

    T.[layout: _NativeClass] => T

Since this rule is a consequence of the other two rules, homotopy
reduction will mark it redundant.

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachine.cpp

@@ -197,29 +197,51 @@ void RewriteSystemBuilder::addRequirement(const Requirement &req,
     //
     // Together with a rewrite rule
     //
-    //   T.[layout: L] => T
+    //   [superclass: C<X, Y>].[layout: L] => [superclass: C<X, Y>]
     //
     // Where 'L' is either AnyObject or _NativeObject, depending on the
     // ancestry of C.
+    //
+    // The second rule is marked permanent. Completion will derive a new
+    // rule as a consequence of these two rules:
+    //
+    //   T.[layout: L] => T
+    //
+    // The new rule will be marked redundant by homotopy reduction since
+    // it is a consequence of the other two rules.
     auto otherType = CanType(req.getSecondType());
 
+    // Build the symbol [superclass: C<X, Y>].
     SmallVector<Term, 1> substitutions;
     otherType = getConcreteSubstitutionSchema(otherType, proto,
                                               substitutions);
+    auto superclassSymbol = Symbol::forSuperclass(otherType, substitutions,
+                                                  Context);
+
+    {
+      // Build the symbol [layout: L].
+      auto layout =
+        LayoutConstraint::getLayoutConstraint(
+          otherType->getClassOrBoundGenericClass()->usesObjCObjectModel()
+            ? LayoutConstraintKind::Class
+            : LayoutConstraintKind::NativeClass,
+          Context.getASTContext());
+      auto layoutSymbol = Symbol::forLayout(layout, Context);
+
+      MutableTerm layoutSubjectTerm;
+      layoutSubjectTerm.add(superclassSymbol);
+
+      MutableTerm layoutConstraintTerm = layoutSubjectTerm;
+      layoutConstraintTerm.add(layoutSymbol);
+
+      // Add the rule [superclass: C<X, Y>].[layout: L] => [superclass: C<X, Y>].
+      PermanentRules.emplace_back(layoutConstraintTerm,
+                                  layoutSubjectTerm);
+    }
 
+    // Build the term T.[superclass: C<X, Y>].
     constraintTerm = subjectTerm;
-    constraintTerm.add(Symbol::forSuperclass(otherType, substitutions,
-                                             Context));
-    RequirementRules.emplace_back(subjectTerm, constraintTerm);
-
-    constraintTerm = subjectTerm;
-    auto layout =
-      LayoutConstraint::getLayoutConstraint(
-        otherType->getClassOrBoundGenericClass()->usesObjCObjectModel()
-          ? LayoutConstraintKind::Class
-          : LayoutConstraintKind::NativeClass,
-        Context.getASTContext());
-    constraintTerm.add(Symbol::forLayout(layout, Context));
+    constraintTerm.add(superclassSymbol);
     break;
   }
 

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -521,7 +521,7 @@ void RewriteSystem::verifyRewriteRules(ValidityPolicy policy) const {
   }
 
   for (const auto &rule : Rules) {
-    if (rule.isSimplified())
+    if (rule.isSimplified() || rule.isPermanent())
       continue;
 
     const auto &lhs = rule.getLHS();

test/Generics/generic_objc_superclass.swift

@@ -13,6 +13,7 @@ func foo<T : Generic<U>, U>(_: T, _: U) {
 
 // CHECK-LABEL: Requirement machine for <τ_0_0, τ_0_1 where τ_0_0 : Generic<τ_0_1>>
 // CHECK-NEXT: Rewrite system: {
+// CHECK-NEXT: - [superclass: Generic<τ_0_0> with <τ_0_1>].[layout: AnyObject] => [superclass: Generic<τ_0_0> with <τ_0_1>] [permanent]
 // CHECK-NEXT: - τ_0_0.[superclass: Generic<τ_0_0> with <τ_0_1>] => τ_0_0
 // CHECK-NEXT: - τ_0_0.[layout: AnyObject] => τ_0_0
 // CHECK-NEXT: }

test/Generics/superclass_and_layout_requirement.swift

@@ -0,0 +1,9 @@
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-protocol-signatures=on 2>&1 | %FileCheck %s
+
+class C {}
+
+// CHECK: superclass_and_layout_requirement.(file).P@
+// CHECK: Requirement signature: <Self where Self.T : C>
+protocol P {
+  associatedtype T : C
+}

test/Generics/unify_superclass_types_1.swift

@@ -16,11 +16,13 @@ extension P where Self : Derived {
 // CHECK-LABEL: Requirement machine for <τ_0_0 where τ_0_0 : Derived, τ_0_0 : P>
 // CHECK-NEXT: Rewrite system: {
 // CHECK-NEXT: - [P].[P] => [P] [permanent]
+// CHECK-NEXT: - [superclass: Base].[layout: _NativeClass] => [superclass: Base] [permanent]
+// CHECK-NEXT: - [superclass: Derived].[layout: _NativeClass] => [superclass: Derived] [permanent]
 // CHECK-NEXT: - [P].[superclass: Base] => [P]
-// CHECK-NEXT: - [P].[layout: _NativeClass] => [P]
 // CHECK-NEXT: - τ_0_0.[superclass: Derived] => τ_0_0
-// CHECK-NEXT: - τ_0_0.[layout: _NativeClass] => τ_0_0
 // CHECK-NEXT: - τ_0_0.[P] => τ_0_0
+// CHECK-NEXT: - [P].[layout: _NativeClass] => [P]
+// CHECK-NEXT: - τ_0_0.[layout: _NativeClass] => τ_0_0
 // CHECK-NEXT: - τ_0_0.[superclass: Base] => τ_0_0
 // CHECK-NEXT: }
 // CHECK-NEXT: Rewrite loops: {