RequirementMachine: Fixes some bugs with superclass requirements

include/swift/AST/TypeMatcher.h

@@ -195,13 +195,25 @@ class TypeMatcher {
     TRIVIAL_CASE(ModuleType)
     TRIVIAL_CASE(DynamicSelfType)
     TRIVIAL_CASE(ArchetypeType)
-    TRIVIAL_CASE(DependentMemberType)
+
+    bool visitDependentMemberType(CanDependentMemberType firstType,
+                                   Type secondType,
+                                   Type sugaredFirstType) {
+      /* If the types match, continue. */
+      if (!Matcher.asDerived().alwaysMismatchTypeParameters() &&
+          firstType->isEqual(secondType))
+        return true;
+
+      /* Otherwise, let the derived class deal with the mismatch. */
+      return mismatch(firstType.getPointer(), secondType,
+                      sugaredFirstType);
+    }
 
     bool visitGenericTypeParamType(CanGenericTypeParamType firstType,
                                    Type secondType,
                                    Type sugaredFirstType) {
       /* If the types match, continue. */
-      if (!Matcher.asDerived().alwaysMismatchGenericParams() &&
+      if (!Matcher.asDerived().alwaysMismatchTypeParameters() &&
           firstType->isEqual(secondType))
         return true;
 
@@ -312,7 +324,7 @@ class TypeMatcher {
 #undef TRIVIAL_CASE
   };
 
-  bool alwaysMismatchGenericParams() const { return false; }
+  bool alwaysMismatchTypeParameters() const { return false; }
 
   ImplClass &asDerived() { return static_cast<ImplClass &>(*this); }
 

lib/AST/GenericSignatureBuilder.cpp

@@ -4494,7 +4494,7 @@ bool GenericSignatureBuilder::updateSuperclass(
 
     auto layout =
       LayoutConstraint::getLayoutConstraint(
-        superclass->getClassOrBoundGenericClass()->isObjC()
+        superclass->getClassOrBoundGenericClass()->usesObjCObjectModel()
           ? LayoutConstraintKind::Class
           : LayoutConstraintKind::NativeClass,
         getASTContext());

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -47,12 +47,12 @@ RequirementMachine::getLocalRequirements(
     return result;
 
   if (props->isConcreteType()) {
-    result.concreteType = props->getConcreteType({}, protos, Context);
+    result.concreteType = props->getConcreteType({}, term, protos, Context);
     return result;
   }
 
   if (props->hasSuperclassBound()) {
-    result.superclass = props->getSuperclassBound({}, protos, Context);
+    result.superclass = props->getSuperclassBound({}, term, protos, Context);
   }
 
   for (const auto *proto : props->getConformsToExcludingSuperclassConformances())
@@ -153,7 +153,7 @@ Type RequirementMachine::getSuperclassBound(Type depType) const {
     return Type();
 
   auto &protos = System.getProtocols();
-  return props->getSuperclassBound({ }, protos, Context);
+  return props->getSuperclassBound({ }, term, protos, Context);
 }
 
 bool RequirementMachine::isConcreteType(Type depType) const {
@@ -183,7 +183,7 @@ Type RequirementMachine::getConcreteType(Type depType) const {
     return Type();
 
   auto &protos = System.getProtocols();
-  return props->getConcreteType({ }, protos, Context);
+  return props->getConcreteType({ }, term, protos, Context);
 }
 
 bool RequirementMachine::areSameTypeParameterInContext(Type depType1,
@@ -346,14 +346,33 @@ 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,
+                                                     prefix, 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,
+                                                      prefix, protos,
+                                                      Context);
+          if (!superclass->hasTypeParameter())
+            return superclass;
+
+          // FIXME: Recursion guard is needed here
+          return getCanonicalTypeInContext(superclass, genericParams);
+        }
       }
 
       return Context.getTypeForTerm(prefix, genericParams, protos);