GSB: The combination of a superclass and conformance requirement might force a type to be concrete

A protocol can constrain an associated type to Self:

    protocol P {
      associatedtype A : Q where A.B == Self
    }

    protocol Q {
      associatedtype B
    }

And a class might conform to this protocol:

    class C : P {
      typealias A = D
    }

    class D : Q {
      typealias B = C
    }

The generic signature <Self where Self : P, Self : C> is built during
conformance checking. Since Self : C, we must have that Self.A == D;
since D.B == C, the requierement 'A.B == Self' in protocol P implies
that 'Self == C'. So the correct minimized signature here is
<Self where Self == C>.

This wasn't handled properly before, because of assumptions in
removeSelfDerived() and a couple of other places.

Fixes rdar://71677712, rdar://76155506, https://bugs.swift.org/browse/SR-10033,
https://bugs.swift.org/browse/SR-13884.

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -5790,6 +5790,11 @@ class RedundantRequirementGraph {
       RequirementKind kind,
       const SmallVectorImpl<Constraint<T>> &impliedByConcrete,
       const Optional<ExplicitRequirement> &concreteTypeRequirement) {
+    // This can occur if the combination of a superclass requirement and
+    // protocol conformance requirement force a type to become concrete.
+    if (!concreteTypeRequirement)
+      return;
+
     for (auto constraint : impliedByConcrete) {
       if (constraint.source->isDerivedNonRootRequirement())
         continue;
@@ -8102,6 +8107,11 @@ void GenericSignatureBuilder::checkConcreteTypeConstraints(
                     /*dropDerivedViaConcrete=*/true,
                     /*allCanBeSelfDerived=*/true);
 
+  // This can occur if the combination of a superclass requirement and
+  // protocol conformance requirement force a type to become concrete.
+  if (equivClass->concreteTypeConstraints.empty())
+    return;
+
   checkConstraintList<Type>(
     genericParams, equivClass->concreteTypeConstraints, RequirementKind::SameType,
     [&](const ConcreteConstraint &constraint) {
@@ -8527,12 +8537,26 @@ GenericSignature GenericSignatureBuilder::rebuildSignatureWithoutRedundantRequir
 
     auto subjectType = req.getSource()->getStoredType();
     subjectType = stripBoundDependentMemberTypes(subjectType);
-    subjectType =
+    auto resolvedSubjectType =
         resolveDependentMemberTypes(*this, subjectType,
                                     ArchetypeResolutionKind::WellFormed);
 
-    if (auto optReq = createRequirement(req.getKind(), subjectType, req.getRHS(),
-                                        getGenericParams())) {
+    // This can occur if the combination of a superclass requirement and
+    // protocol conformance requirement force a type to become concrete.
+    //
+    // FIXME: Is there a more principled formulation of this?
+    if (req.getKind() == RequirementKind::Superclass &&
+        !resolvedSubjectType->isTypeParameter()) {
+      newBuilder.addRequirement(Requirement(RequirementKind::SameType,
+                                            subjectType, resolvedSubjectType),
+                                newSource, nullptr);
+      continue;
+    }
+
+    assert(resolvedSubjectType->isTypeParameter());
+
+    if (auto optReq = createRequirement(req.getKind(), resolvedSubjectType,
+                                        req.getRHS(), getGenericParams())) {
       auto newReq = stripBoundDependentMemberTypes(*optReq);
       newBuilder.addRequirement(newReq, newSource, nullptr);
     }

test/Generics/sr13884.swift

@@ -0,0 +1,34 @@
+// RUN: %target-typecheck-verify-swift
+// RUN: %target-swift-frontend -emit-ir -debug-generic-signatures %s 2>&1 | %FileCheck %s
+
+public protocol P {
+  associatedtype A : Q where A.B == Self
+}
+
+public protocol Q {
+  associatedtype B
+}
+
+public class C : P {
+  public typealias A = D
+}
+
+public class D : Q {
+  public typealias B = C
+}
+
+// Both <T : P & C> and <T : C & P> minimize to <T where T == C>:
+// - T : P and T : C imply that T.A == C.A == D;
+// - T : P also implies that T.A.B == T, via A.B == Self in P;
+// - Since T.A == D, T.A.B == D.B, therefore Self == D.B.
+// - D.B is a typealias for C, so really Self == C.
+
+// CHECK-LABEL: Generic signature: <T where T == D.B>
+public func takesBoth1<T : P & C>(_: T) {}
+// expected-warning@-1 {{redundant conformance constraint 'T' : 'P'}}
+// expected-note@-2 {{conformance constraint 'T' : 'P' implied here}}
+
+// CHECK-LABEL: Generic signature: <U where U == D.B>
+public func takesBoth2<U : C & P>(_: U) {}
+// expected-warning@-1 {{redundant conformance constraint 'U' : 'P'}}
+// expected-note@-2 {{conformance constraint 'U' : 'P' implied here}}

test/SILGen/class_conforms_with_default_concrete_self.swift

@@ -0,0 +1,28 @@
+// RUN: %target-swift-emit-silgen %s | %FileCheck %s
+
+public protocol P {
+  associatedtype A : Q where A.B == Self
+
+  func hasDefaultImplementation1()
+  func hasDefaultImplementation2<U>(_: U) where U : Q, U.B == Self
+}
+
+public extension P {
+  func hasDefaultImplementation1() {}
+  func hasDefaultImplementation2<U>(_: U) where U : Q, U.B == Self {}
+}
+
+public protocol Q {
+  associatedtype B
+}
+
+public class C : P {
+  public typealias A = D
+}
+
+public class D : Q {
+  public typealias B = C
+}
+
+// CHECK-LABEL: sil shared [transparent] [serialized] [thunk] [ossa] @$s41class_conforms_with_default_concrete_self1CCAA1PA2aDP25hasDefaultImplementation1yyFTW : $@convention(witness_method: P) (@in_guaranteed C) -> () {
+// CHECK-LABEL: sil shared [transparent] [serialized] [thunk] [ossa] @$s41class_conforms_with_default_concrete_self1CCAA1PA2aDP25hasDefaultImplementation2yyqd__1BQyd__RszAA1QRd__lFTW : $@convention(witness_method: P) <τ_0_0 where τ_0_0 == C><τ_1_0 where τ_1_0 : Q, τ_1_0.B == C> (@in_guaranteed τ_1_0, @in_guaranteed C) -> () {

validation-test/compiler_crashers_2/0189-sr10033.swift renamed to validation-test/compiler_crashers_2_fixed/0189-sr10033.swift

@@ -1,6 +1,4 @@
-// RUN: not --crash %target-swift-frontend -typecheck %s
-
-// REQUIRES: asserts
+// RUN: %target-swift-frontend -emit-ir -verify %s
 
 protocol P1 {
   associatedtype A2 : P2 where A2.A1 == Self