RequirementMachine: Allow 'any C & P' to satisfy a superclass requirement 'C' if 'P' is an @objc protocol

The GenericSignatureBuilder did not actually allow this, but it's conflict
detection was imperfect so it did not flag the example in the radar;
variations on this code were rejected by the GenericSignatureBuilder.

Since the Requirement Machine finds all conflicts correctly, relax the
logic here to make this example work.

Fixes rdar://problem/91637621.

Author: slavapestov

lib/AST/RequirementMachine/PropertyUnification.cpp

@@ -658,6 +658,17 @@ void PropertyMap::addProperty(
 ///
 /// - concrete vs superclass
 /// - concrete vs layout
+///
+/// Note that we allow a subclass existential 'any C & P' to satisfy a
+/// superclass requirement 'C' as long as 'P' is an @objc protocol.
+///
+/// This is not fully sound because 'any C & P' is not substitutable for
+/// 'C' if the code calls static method or required initializers on 'C',
+/// but existing code out there relies on this working.
+///
+/// A more refined check would ensure that 'C' had no required initializers
+/// and that 'P' was self-conforming; or we could ban this entirely in a
+/// future -swift-version mode.
 void PropertyMap::checkConcreteTypeRequirements() {
   bool debug = Debug.contains(DebugFlags::ConcreteUnification);
 
@@ -669,6 +680,8 @@ void PropertyMap::checkConcreteTypeRequirements() {
       // If the concrete type is not a class and we have a superclass
       // requirement, we have a conflict.
       if (!concreteType.getConcreteType()->getClassOrBoundGenericClass() &&
+          !(concreteType.getConcreteType()->isObjCExistentialType() &&
+            concreteType.getConcreteType()->getSuperclass()) &&
           props->hasSuperclassBound()) {
         const auto &req = props->getSuperclassRequirement();
         for (auto pair : req.SuperclassRules) {
@@ -677,26 +690,35 @@ void PropertyMap::checkConcreteTypeRequirements() {
         }
       }
 
-      if (checkRuleOnce(concreteTypeRule)) {
-        if (concreteType.getConcreteType()->getClassOrBoundGenericClass()) {
-          // A rule (T.[concrete: C] => T) where C is a class type induces a rule
-          // (T.[superclass: C] => T).
-          auto superclassSymbol = Symbol::forSuperclass(
-              concreteType.getConcreteType(),
-              concreteType.getSubstitutions(),
-              Context);
-
-          recordRelation(props->getKey(), concreteTypeRule,
-                         superclassSymbol, System, debug);
-        }
+      // If the concrete type does not satisfy a class layout constraint and
+      // we have such a layout requirement, we have a conflict.
+      if (!concreteType.getConcreteType()->satisfiesClassConstraint() &&
+          props->LayoutRule &&
+          props->Layout->isClass()) {
+        if (checkRulePairOnce(concreteTypeRule, *props->LayoutRule))
+          System.recordConflict(concreteTypeRule, *props->LayoutRule);
+      }
 
-        // 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 (checkRuleOnce(concreteTypeRule)) {
         if (concreteType.getConcreteType()->satisfiesClassConstraint()) {
           Type superclassType = concreteType.getConcreteType();
           if (!superclassType->getClassOrBoundGenericClass())
             superclassType = superclassType->getSuperclass();
 
+          if (superclassType) {
+            // A rule (T.[concrete: C] => T) where C is a class type induces a rule
+            // (T.[superclass: C] => T).
+            auto superclassSymbol = Symbol::forSuperclass(
+                superclassType->getCanonicalType(),
+                concreteType.getSubstitutions(),
+                Context);
+
+            recordRelation(props->getKey(), concreteTypeRule,
+                           superclassSymbol, System, debug);
+          }
+
+          // 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.
           auto layoutConstraint = LayoutConstraintKind::Class;
           if (superclassType)
             if (auto *classDecl = superclassType->getClassOrBoundGenericClass())
@@ -711,15 +733,6 @@ void PropertyMap::checkConcreteTypeRequirements() {
                          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.
-      if (!concreteType.getConcreteType()->satisfiesClassConstraint() &&
-          props->LayoutRule &&
-          props->Layout->isClass()) {
-        if (checkRulePairOnce(concreteTypeRule, *props->LayoutRule))
-          System.recordConflict(concreteTypeRule, *props->LayoutRule);
-      }
     }
   }
 }

test/Generics/superclass_requirement_and_objc_existential.swift

@@ -0,0 +1,46 @@
+// RUN: %target-typecheck-verify-swift -disable-objc-attr-requires-foundation-module
+// RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -disable-objc-attr-requires-foundation-module 2>&1 | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+class C {}
+@objc protocol P1 {}
+protocol P2 {}
+protocol P3 : AnyObject {}
+
+protocol Q {
+  associatedtype A
+}
+
+/// This is allowed, even though it's not fully sound.
+
+// CHECK-LABEL: .f1@
+// CHECK-NEXT: Generic signature: <T where T : Q, T.[Q]A == C & P1>
+func f1<T : Q>(_: T) where T.A : C, T.A == any (C & P1) {}
+// expected-warning@-1 {{redundant superclass constraint 'T.A' : 'C'}}
+
+/// These are not allowed.
+
+// CHECK-LABEL: .f2@
+// CHECK-NEXT: Generic signature: <T where T : Q>
+func f2<T : Q>(_: T) where T.A : C, T.A == any P1 {}
+// expected-error@-1 {{no type for 'T.A' can satisfy both 'T.A : C' and 'T.A == any P1'}}
+
+// CHECK-LABEL: .f3@
+// CHECK-NEXT: Generic signature: <T where T : Q>
+func f3<T : Q>(_: T) where T.A : C, T.A == any (C & P2) {}
+// expected-error@-1 {{no type for 'T.A' can satisfy both 'T.A : C' and 'T.A == any C & P2'}}
+// expected-error@-2 {{no type for 'T.A' can satisfy both 'T.A : _NativeClass' and 'T.A == any C & P2'}}
+
+// CHECK-LABEL: .f4@
+// CHECK-NEXT: Generic signature: <T where T : Q>
+func f4<T : Q>(_: T) where T.A : C, T.A == any (C & P2) {}
+// expected-error@-1 {{no type for 'T.A' can satisfy both 'T.A : C' and 'T.A == any C & P2'}}
+// expected-error@-2 {{no type for 'T.A' can satisfy both 'T.A : _NativeClass' and 'T.A == any C & P2'}}
+
+// CHECK-LABEL: .f5@
+// CHECK-NEXT: Generic signature: <T where T : Q>
+func f5<T : Q>(_: T) where T.A : C, T.A == any (C & P3) {}
+// expected-error@-1 {{no type for 'T.A' can satisfy both 'T.A : C' and 'T.A == any C & P3'}}
+// expected-error@-2 {{no type for 'T.A' can satisfy both 'T.A : _NativeClass' and 'T.A == any C & P3'}}
+