RequirementMachine: Eliminate layout requirement implied by concrete type requirement

A type parameter subject to an AnyObject requirement might also be subject
to a concrete type requirement. There are two cases to handle here:

- If the concrete type is a class, the layout requirement is redundant.
- If the concrete type is not a class, we have a conflict.

There is an existing test that's good enough; I just changed it to
run with -requirement-machine-inferred-signatures=verify.

Author: slavapestov

lib/AST/RequirementMachine/PropertyUnification.cpp

@@ -67,7 +67,9 @@ static void recordRelation(Term key,
          (lhsProperty.getKind() == Symbol::Kind::Superclass &&
           rhsProperty.getKind() == Symbol::Kind::Layout) ||
          (lhsProperty.getKind() == Symbol::Kind::ConcreteType &&
-          rhsProperty.getKind() == Symbol::Kind::Superclass));
+          rhsProperty.getKind() == Symbol::Kind::Superclass) ||
+         (lhsProperty.getKind() == Symbol::Kind::ConcreteType &&
+          rhsProperty.getKind() == Symbol::Kind::Layout));
 
   if (debug) {
     llvm::dbgs() << "%% Recording relation: ";
@@ -484,7 +486,7 @@ void PropertyMap::checkConcreteTypeRequirements() {
   bool debug = Debug.contains(DebugFlags::ConcreteUnification);
 
   for (auto *props : Entries) {
-    if (props->ConcreteTypeRule && props->SuperclassRule) {
+    if (props->ConcreteTypeRule) {
       auto concreteType = props->ConcreteType->getConcreteType();
 
       // A rule (T.[concrete: C] => T) where C is a class type induces a rule
@@ -497,12 +499,42 @@ void PropertyMap::checkConcreteTypeRequirements() {
         recordRelation(props->getKey(), *props->ConcreteTypeRule,
                        superclassSymbol, System, debug);
 
-      // Otherwise, we have a concrete vs superclass conflict.
-      } else {
+      // If the concrete type is not a class and we have a superclass
+      // requirement, we have a conflict.
+      } else if (props->SuperclassRule) {
         recordConflict(props->getKey(),
                        *props->ConcreteTypeRule,
                        *props->SuperclassRule, System);
       }
+
+      // A rule (T.[concrete: C] => T) where C is a class type induces a rule
+      // (T.[layout: L] => T), where L is either AnyObject or _NativeObject.
+      if (concreteType->satisfiesClassConstraint()) {
+        Type superclassType = concreteType;
+        if (!concreteType->getClassOrBoundGenericClass())
+          superclassType = concreteType->getSuperclass();
+
+        auto layoutConstraint = LayoutConstraintKind::Class;
+        if (superclassType)
+          if (auto *classDecl = superclassType->getClassOrBoundGenericClass())
+            layoutConstraint = classDecl->getLayoutConstraintKind();
+
+        auto layout =
+            LayoutConstraint::getLayoutConstraint(
+              layoutConstraint, Context.getASTContext());
+        auto layoutSymbol = Symbol::forLayout(layout, Context);
+
+        recordRelation(props->getKey(), *props->ConcreteTypeRule,
+                       layoutSymbol, System, debug);
+
+      // If the concrete type does not satisfy a class layout constraint and
+      // we have such a layout requirement, we have a conflict.
+      } else if (props->LayoutRule &&
+                 props->Layout->isClass()) {
+        recordConflict(props->getKey(),
+                       *props->ConcreteTypeRule,
+                       *props->LayoutRule, System);
+      }
     }
   }
 }

test/Generics/concrete_same_type_versus_anyobject.swift

@@ -1,5 +1,5 @@
 // RUN: %target-typecheck-verify-swift
-// RUN: not %target-swift-frontend -typecheck -debug-generic-signatures %s 2>&1 | %FileCheck %s
+// RUN: not %target-swift-frontend -typecheck -debug-generic-signatures -requirement-machine-inferred-signatures=verify %s 2>&1 | %FileCheck %s
 struct S {}
 class C {}