RequirementMachine: Fix getCanonicalTypeInContext() to handle member types of superclass bounds

If you have

    protocol P {
      associatedtype T
    }

    class C<T> : P {}

Then substituting the type parameter T.T from the generic signature
<T where T : P> into the generic signature <T, U where T : C<U>>
is the identity operation, and also returns T.T, because subst()
isn't smart enough to replace T.T with U.

So getCanonicalTypeInContext() has to do the concrete conformance
lookup here, just like it does for the analogous situation where
you have a concrete type requirement.

This could be solved in a more principled way by better book-keeping
elsewhere, but the GSB supported the old behavior, so we can
simulate it easily enough in the RequirementMachine also.

Author: slavapestov

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -346,14 +346,31 @@ Type RequirementMachine::getCanonicalTypeInContext(
       verify(prefix);
 
       auto *props = Map.lookUpProperties(prefix);
-      if (props && props->isConcreteType()) {
-        auto concreteType = props->getConcreteType(genericParams,
-                                                   protos, Context);
-        if (!concreteType->hasTypeParameter())
-          return concreteType;
-
-        // FIXME: Recursion guard is needed here
-        return getCanonicalTypeInContext(concreteType, genericParams);
+      if (props) {
+        if (props->isConcreteType()) {
+          auto concreteType = props->getConcreteType(genericParams,
+                                                     protos, Context);
+          if (!concreteType->hasTypeParameter())
+            return concreteType;
+
+          // FIXME: Recursion guard is needed here
+          return getCanonicalTypeInContext(concreteType, genericParams);
+        }
+
+        // Skip this part if the entire input term is valid, because in that
+        // case we don't want to replace the term with its superclass bound;
+        // unlike a fixed concrete type, the superclass bound only comes into
+        // play when looking up a member type.
+        if (props->hasSuperclassBound() &&
+            prefix.size() != term.size()) {
+          auto superclass = props->getSuperclassBound(genericParams,
+                                                      protos, Context);
+          if (!superclass->hasTypeParameter())
+            return superclass;
+
+          // FIXME: Recursion guard is needed here
+          return getCanonicalTypeInContext(superclass, genericParams);
+        }
       }
 
       return Context.getTypeForTerm(prefix, genericParams, protos);

test/Generics/member_type_of_superclass_bound.swift

@@ -0,0 +1,24 @@
+// RUN: %target-swift-emit-silgen %s -requirement-machine=verify
+
+// The substituted type of SS.x.x is computed by taking the type of S.x,
+// which is T.T in the generic signature <T where T : P>, and then
+// canonicalizing it in the generic signature <T : C<U>, U>.
+//
+// The latter generic signature does not have a conformance requirement T : P,
+// but the superclass bound C<U> of T conforms to P concretely; make sure that
+// the requirement machine's getCanonicalTypeInContext() can handle this.
+public protocol P {
+  associatedtype T
+}
+
+public class C<T> : P {}
+
+public struct S<T : P> {
+  public var x: T.T
+}
+
+public struct SS<T : C<U>, U> {
+  public var x: S<T>
+}
+
+