Split exact-subclass and bindable-to-subclass queries.

In many places, we're interested in whether a type with archetypes *might be* a superclass of another type with the right bindings, particularly in the optimizer. Provide a separate Type::isBindableToSuperclassOf method that performs this check. Use it in the devirtualizer to fix rdar://problem/24993618. Using it might unblock other places where the optimizer is conservative, but we can fix those separately.

Author: jckarter

include/swift/AST/Types.h

@@ -623,14 +623,34 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   ///          superclass.
   Type getSuperclass(LazyResolver *resolver);
 
-  /// \brief True if this type is a superclass of another type.
+  /// \brief True if this type is the exact superclass of another type.
   ///
   /// \param ty       The potential subclass.
   /// \param resolver The resolver for lazy type checking, or null if the
   ///                 AST is already type-checked.
   ///
   /// \returns True if this type is \c ty or a superclass of \c ty.
-  bool isSuperclassOf(Type ty, LazyResolver *resolver);
+  ///
+  /// If this type is a bound generic class \c Foo<T>, the method only
+  /// returns true if the generic parameters of \c ty exactly match the
+  /// superclass of \c ty. For instance, if \c ty is a
+  /// class DerivedClass: Base<Int>, then \c Base<T> (where T is an archetype)
+  /// will return false. `isBindableToSuperclassOf` should be used
+  /// for queries that care whether a generic class type can be substituted into
+  /// a type's subclass.
+  bool isExactSuperclassOf(Type ty, LazyResolver *resolver);
+
+  /// \brief True if this type is the superclass of another type, or a generic
+  /// type that could be bound to the superclass.
+  ///
+  /// \param ty       The potential subclass.
+  /// \param resolver The resolver for lazy type checking, or null if the
+  ///                 AST is already type-checked.
+  ///
+  /// \returns True if this type is \c ty, a superclass of \c ty, or an
+  ///          archetype-parameterized type that can be bound to a superclass
+  ///          of \c ty.
+  bool isBindableToSuperclassOf(Type ty, LazyResolver *resolver);
 
   /// \brief Determines whether this type is permitted as a method override
   /// of the \p other.

include/swift/SIL/SILType.h

@@ -418,10 +418,19 @@ class SILType {
     return SILType::getPrimitiveObjectType(superclass->getCanonicalType());
   }
 
-  /// Return true if Ty is a subtype of this SILType, or null otherwise.
-  bool isSuperclassOf(SILType Ty) const {
-    return getSwiftRValueType()->isSuperclassOf(Ty.getSwiftRValueType(),
-                                                nullptr);
+  /// Return true if Ty is a subtype of this exact SILType, or false otherwise.
+  bool isExactSuperclassOf(SILType Ty) const {
+    return getSwiftRValueType()->isExactSuperclassOf(Ty.getSwiftRValueType(),
+                                                     nullptr);
+  }
+
+  /// Return true if Ty is a subtype of this SILType, or if this SILType
+  /// contains archetypes that can be found to form a supertype of Ty, or false
+  /// otherwise.
+  bool isBindableToSuperclassOf(SILType Ty) const {
+    return getSwiftRValueType()->isBindableToSuperclassOf(
+                                                        Ty.getSwiftRValueType(),
+                                                        nullptr);
   }
 
   /// Transform the function type SILType by replacing all of its interface

include/swift/SIL/TypeSubstCloner.h

@@ -208,7 +208,7 @@ class TypeSubstCloner : public SILClonerWithScopes<ImplClass> {
       CanType Ty = Conformance.getConcrete()->getType()->getCanonicalType();
 
       if (Ty != newLookupType) {
-        assert(Ty->isSuperclassOf(newLookupType, nullptr) &&
+        assert(Ty->isExactSuperclassOf(newLookupType, nullptr) &&
                "Should only create upcasts for sub class.");
 
         // We use the super class as the new look up type.

lib/AST/ASTVerifier.cpp

@@ -2467,7 +2467,7 @@ struct ASTNodeBase {};
 
       // If the destination is a class, walk the supertypes of the source.
       if (destTy->getClassOrBoundGenericClass()) {
-        if (!destTy->isSuperclassOf(srcTy, nullptr)) {
+        if (!destTy->isBindableToSuperclassOf(srcTy, nullptr)) {
           srcTy.print(Out);
           Out << " is not a superclass of ";
           destTy.print(Out);

lib/AST/ArchetypeBuilder.cpp

@@ -979,12 +979,33 @@ bool ArchetypeBuilder::addSuperclassRequirement(PotentialArchetype *T,
 
   // If T already has a superclass, make sure it's related.
   if (T->Superclass) {
-    if (T->Superclass->isSuperclassOf(Superclass, nullptr)) {
+    // TODO: In principle, this could be isBindableToSuperclassOf instead of
+    // isExactSubclassOf. If you had:
+    //
+    //   class Foo<T>
+    //   class Bar: Foo<Int>
+    //
+    //   func foo<T, U where U: Foo<T>, U: Bar>(...) { ... }
+    //
+    // then the second constraint should be allowed, constraining U to Bar
+    // and secondarily imposing a T == Int constraint.
+    if (T->Superclass->isExactSuperclassOf(Superclass, nullptr)) {
       T->Superclass = Superclass;
 
       // We've strengthened the bound, so update superclass conformances.
       updateSuperclassConformances();
-    } else if (!Superclass->isSuperclassOf(T->Superclass, nullptr)) {
+    // TODO: Similar to the above, a more general isBindableToSuperclassOf
+    // base class constraint could potentially introduce secondary constraints.
+    // If you had:
+    //
+    //   class Foo<T>
+    //   class Bar: Foo<Int>
+    //
+    //   func foo<T, U where U: Bar, U: Foo<T>>(...) { ... }
+    //
+    // then the second `U: Foo<T>` constraint introduces a `T == Int`
+    // constraint.
+    } else if (!Superclass->isExactSuperclassOf(T->Superclass, nullptr)) {
       Diags.diagnose(Source.getLoc(),
                      diag::requires_superclass_conflict, T->getName(),
                      T->Superclass, Superclass)

lib/AST/ProtocolConformance.cpp

@@ -521,7 +521,7 @@ ProtocolConformance::getInheritedConformance(ProtocolDecl *protocol) const {
                                  subMap, conformanceMap);
   }
   assert((getType()->isEqual(foundInherited->getType()) ||
-          foundInherited->getType()->isSuperclassOf(getType(), nullptr))
+          foundInherited->getType()->isExactSuperclassOf(getType(), nullptr))
          && "inherited conformance does not match type");
   return foundInherited;
 }

lib/AST/Type.cpp

@@ -1652,7 +1652,7 @@ Type TypeBase::getSuperclass(LazyResolver *resolver) {
   return superclassTy.subst(module, substitutions, None);
 }
 
-bool TypeBase::isSuperclassOf(Type ty, LazyResolver *resolver) {
+bool TypeBase::isExactSuperclassOf(Type ty, LazyResolver *resolver) {
   // For there to be a superclass relationship, we must be a superclass, and
   // the potential subtype must be a class or superclass-bounded archetype.
   if (!getClassOrBoundGenericClass() || !ty->mayHaveSuperclass())
@@ -1667,6 +1667,189 @@ bool TypeBase::isSuperclassOf(Type ty, LazyResolver *resolver) {
   return false;
 }
 
+/// Returns true if type `a` has archetypes that can be bound to form `b`.
+static bool isBindableTo(Type a, Type b, LazyResolver *resolver) {
+  class IsBindableVisitor : public TypeVisitor<IsBindableVisitor, bool, CanType>
+  {
+    llvm::DenseMap<ArchetypeType *, CanType> Bindings;
+    LazyResolver *Resolver;
+  public:
+    IsBindableVisitor(LazyResolver *Resolver)
+      : Resolver(Resolver) {}
+  
+    bool visitArchetypeType(ArchetypeType *orig, CanType subst) {
+      // If we already bound this archetype, make sure the new binding candidate
+      // is the same type.
+      auto bound = Bindings.find(orig);
+      if (bound != Bindings.end()) {
+        return bound->second->isEqual(subst);
+      }
+      // Check that the archetype isn't constrained in a way that makes the
+      // binding impossible.
+      // For instance, if the archetype is class-constrained, and the binding
+      // is not a class, it can never be bound.
+      if (orig->requiresClass() && !subst->mayHaveSuperclass())
+        return false;
+      
+      // TODO: If the archetype has a superclass constraint, check that the
+      // substitution is a subclass.
+      
+      // TODO: For private types or protocols, we might be able to definitively
+      // deny bindings.
+      
+      // Otherwise, there may be an external retroactive conformance that
+      // allows the binding.
+      
+      // Remember the binding, and succeed.
+      Bindings.insert({orig, subst});
+      return true;
+    }
+    
+    bool visitType(TypeBase *orig, CanType subst) {
+      llvm_unreachable("not a valid canonical type substitution");
+    }
+    
+    bool visitNominalType(NominalType *nom, CanType subst) {
+      if (auto substNom = dyn_cast<NominalType>(subst)) {
+        if (nom->getDecl() != substNom->getDecl())
+          return false;
+        
+        if (nom->getDecl()->isInvalid())
+          return false;
+        
+        // Same decl should always either have or not have a parent.
+        assert((bool)nom->getParent() == (bool)substNom->getParent());
+        
+        if (nom->getParent())
+          return visit(nom->getParent()->getCanonicalType(),
+                       substNom->getParent()->getCanonicalType());
+        return true;
+      }
+      return false;
+    }
+    
+    bool visitAnyMetatypeType(AnyMetatypeType *meta, CanType subst) {
+      if (auto substMeta = dyn_cast<AnyMetatypeType>(subst)) {
+        if (substMeta->getKind() != meta->getKind())
+          return false;
+        return visit(meta->getInstanceType()->getCanonicalType(),
+                     substMeta->getInstanceType()->getCanonicalType());
+      }
+      return false;
+    }
+    
+    bool visitTupleType(TupleType *tuple, CanType subst) {
+      if (auto substTuple = dyn_cast<TupleType>(subst)) {
+        // Tuple elements must match.
+        if (tuple->getNumElements() != substTuple->getNumElements())
+          return false;
+        // TODO: Label reordering?
+        for (unsigned i : indices(tuple->getElements())) {
+          auto elt = tuple->getElements()[i],
+               substElt = substTuple->getElements()[i];
+          if (elt.getName() != substElt.getName())
+            return false;
+          if (!visit(elt.getType(), substElt.getType()->getCanonicalType()))
+            return false;
+        }
+        return true;
+      }
+      return false;
+    }
+    
+    bool visitDependentMemberType(DependentMemberType *dt, CanType subst) {
+      llvm_unreachable("can't visit dependent types");
+    }
+    bool visitGenericTypeParamType(GenericTypeParamType *dt, CanType subst) {
+      llvm_unreachable("can't visit dependent types");
+    }
+    
+    bool visitFunctionType(FunctionType *func, CanType subst) {
+      if (auto substFunc = dyn_cast<FunctionType>(subst)) {
+        if (func->getExtInfo() != substFunc->getExtInfo())
+          return false;
+        
+        if (!visit(func->getInput()->getCanonicalType(),
+                   substFunc->getInput()->getCanonicalType()))
+          return false;
+        
+        return visit(func->getResult()->getCanonicalType(),
+                     substFunc->getResult()->getCanonicalType());
+      }
+      return false;
+    }
+    
+    bool visitBoundGenericType(BoundGenericType *bgt, CanType subst) {
+      if (auto substBGT = dyn_cast<BoundGenericType>(subst)) {
+        if (bgt->getDecl() != substBGT->getDecl())
+          return false;
+        
+        if (bgt->getDecl()->isInvalid())
+          return false;
+        
+        auto origSubs = bgt->getSubstitutions(bgt->getDecl()->getParentModule(),
+                                              Resolver);
+        auto substSubs = substBGT->getSubstitutions(
+                                              bgt->getDecl()->getParentModule(),
+                                              Resolver);
+        assert(origSubs.size() == substSubs.size());
+        for (unsigned subi : indices(origSubs)) {
+          if (!visit(origSubs[subi].getReplacement()->getCanonicalType(),
+                     substSubs[subi].getReplacement()->getCanonicalType()))
+            return false;
+          assert(origSubs[subi].getConformances().size()
+                 == substSubs[subi].getConformances().size());
+          for (unsigned conformancei :
+                 indices(origSubs[subi].getConformances())) {
+            if (origSubs[subi].getConformances()[conformancei]
+                  != substSubs[subi].getConformances()[conformancei])
+              return false;
+          }
+        }
+        
+        // Same decl should always either have or not have a parent.
+        assert((bool)bgt->getParent() == (bool)substBGT->getParent());
+        if (bgt->getParent())
+          return visit(bgt->getParent()->getCanonicalType(),
+                       substBGT->getParent()->getCanonicalType());
+        return true;
+      }
+      return false;
+    }
+  };
+  
+  return IsBindableVisitor(resolver).visit(a->getCanonicalType(),
+                                           b->getCanonicalType());
+}
+
+bool TypeBase::isBindableToSuperclassOf(Type ty, LazyResolver *resolver) {
+  // Do an exact match if no archetypes are involved.
+  if (!hasArchetype())
+    return isExactSuperclassOf(ty, resolver);
+  
+  // For there to be a superclass relationship,
+  // the potential subtype must be a class or superclass-bounded archetype.
+  if (!ty->mayHaveSuperclass())
+    return false;
+
+  // If the type is itself an archetype, we could always potentially bind it
+  // to the superclass (via external retroactive conformance, even if the
+  // type isn't statically known to conform).
+  //
+  // We could theoretically reject cases where the set of conformances is known
+  // (say the protocol or classes are private or internal).
+  if (is<ArchetypeType>())
+    return true;
+  
+  do {
+    if (isBindableTo(this, ty, resolver))
+      return true;
+    if (ty->getAnyNominal() && ty->getAnyNominal()->isInvalid())
+      return false;
+  } while ((ty = ty->getSuperclass(resolver)));
+  return false;
+}
+
 static bool isBridgeableObjectType(CanType type) {
   // Metatypes aren't always trivially bridgeable unless they've been
   // SIL-lowered to have an @objc representation.
@@ -1829,7 +2012,7 @@ static bool canOverride(CanType t1, CanType t2,
   }
 
   // Class-to-class.
-  return t2->isSuperclassOf(t1, resolver);
+  return t2->isExactSuperclassOf(t1, resolver);
 }
 
 bool TypeBase::canOverride(Type other, bool allowUnsafeParameterOverride,

lib/ClangImporter/ImportType.cpp

@@ -2413,7 +2413,7 @@ bool ClangImporter::Implementation::matchesNSObjectBound(Type type) {
     return false;
 
   // Class type or existential that inherits from NSObject.
-  if (NSObjectType->isSuperclassOf(type, getTypeResolver()))
+  if (NSObjectType->isExactSuperclassOf(type, getTypeResolver()))
     return true;
 
   // Struct or enum type must have been bridged.

lib/SIL/DynamicCasts.cpp

@@ -369,9 +369,11 @@ swift::classifyDynamicCast(Module *M,
   auto targetClass = target.getClassOrBoundGenericClass();
   if (sourceClass) {
     if (targetClass) {
-      if (target->isSuperclassOf(source, nullptr))
+      if (target->isExactSuperclassOf(source, nullptr))
         return DynamicCastFeasibility::WillSucceed;
-      if (source->isSuperclassOf(target, nullptr))
+      if (target->isBindableToSuperclassOf(source, nullptr))
+        return DynamicCastFeasibility::MaySucceed;
+      if (source->isBindableToSuperclassOf(target, nullptr))
         return DynamicCastFeasibility::MaySucceed;
 
       // FIXME: bridged types, e.g. CF <-> NS (but not for metatypes).
@@ -896,7 +898,7 @@ bool swift::canUseScalarCheckedCastInstructions(SILModule &M,
     // If we statically know the target is an NSError subclass, then the cast
     // can go through the scalar path (and it's trivially true so can be
     // killed).
-    return targetType->isSuperclassOf(objectType, nullptr);
+    return targetType->isExactSuperclassOf(objectType, nullptr);
   }
 
   // Three supported cases:

lib/SIL/SILVerifier.cpp

@@ -2077,7 +2077,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       require(toCanTy.getClassOrBoundGenericClass(),
               "downcast must convert to a class type");
       require(SILType::getPrimitiveObjectType(fromCanTy).
-              isSuperclassOf(SILType::getPrimitiveObjectType(toCanTy)),
+              isBindableToSuperclassOf(SILType::getPrimitiveObjectType(toCanTy)),
               "downcast must convert to a subclass");
     }
   }
@@ -2231,7 +2231,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                          ->getInstanceType());
       require(instTy->getClassOrBoundGenericClass(),
               "upcast must convert a class metatype to a class metatype");
-      require(instTy->isSuperclassOf(opInstTy, nullptr),
+      require(instTy->isExactSuperclassOf(opInstTy, nullptr),
               "upcast must cast to a superclass or an existential metatype");
       return;
     }
@@ -2257,7 +2257,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     require(ToTy.getClassOrBoundGenericClass(),
             "upcast must convert a class instance to a class type");
-    require(ToTy.isSuperclassOf(FromTy),
+    require(ToTy.isExactSuperclassOf(FromTy),
             "upcast must cast to a superclass");
   }