SILGen: Properly lower types of ObjC generic methods dispatched off AnyObject.

jckarter · jckarter · commit dec5f541279f · 2016-05-23T17:17:48.000-07:00
When an ObjC generic method is found by AnyObject dispatch, we don't have any type information to bind generic parameter dependencies. Sema expands these generic parameters to their upper bounds in an AnyObject dispatch. However, SILGen was still lowering the type of a dynamic method invocation from the method's formal type, expecting its generic parameters to be bound by substitutions provided from a call. Lower dynamic method calls using the substituted type from the AST instead to avoid this. Fixes rdar://problem/26380562.
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -656,6 +656,10 @@ class alignas(1 << TypeAlignInBits) TypeBase {
   ///          of \c ty.
   bool isBindableToSuperclassOf(Type ty, LazyResolver *resolver);
 
+  /// True if this type contains archetypes that could be substituted with
+  /// concrete types to form the argument type.
+  bool isBindableTo(Type ty, LazyResolver *resolver);
+
   /// \brief Determines whether this type is permitted as a method override
   /// of the \p other.
   bool canOverride(Type other, OverrideMatchMode matchMode,
diff --git a/include/swift/SIL/TypeLowering.h b/include/swift/SIL/TypeLowering.h
@@ -810,6 +810,13 @@ class TypeConverter {
   ABIDifference checkFunctionForABIDifferences(SILFunctionType *fnTy1,
                                                SILFunctionType *fnTy2);
 
+
+  /// Lower the function type as a possible substitution for the type of
+  /// \p constant. The result is not cached as part of the constant's normal
+  /// ConstantInfo.
+  CanSILFunctionType
+  getUncachedSILFunctionTypeForConstant(SILDeclRef constant,
+                                  CanAnyFunctionType origInterfaceType);
 private:
   Type getLoweredCBridgedType(AbstractionPattern pattern, Type t,
                               bool canBridgeBool,
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -1639,7 +1639,7 @@ bool TypeBase::isExactSuperclassOf(Type ty, LazyResolver *resolver) {
 }
 
 /// Returns true if type `a` has archetypes that can be bound to form `b`.
-static bool isBindableTo(Type a, Type b, LazyResolver *resolver) {
+bool TypeBase::isBindableTo(Type b, LazyResolver *resolver) {
   class IsBindableVisitor : public TypeVisitor<IsBindableVisitor, bool, CanType>
   {
     llvm::DenseMap<ArchetypeType *, CanType> Bindings;
@@ -1655,11 +1655,24 @@ static bool isBindableTo(Type a, Type b, LazyResolver *resolver) {
       if (bound != Bindings.end()) {
         return bound->second->isEqual(subst);
       }
+      
+      auto canBindClassConstrainedArchetype = [](CanType t) -> bool {
+        // Classes and class-constrained archetypes.
+        if (t->mayHaveSuperclass())
+          return true;
+        
+        // Pure @objc existentials.
+        if (t->isObjCExistentialType())
+          return true;
+        
+        return false;
+      };
+      
       // 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())
+      if (orig->requiresClass() && !canBindClassConstrainedArchetype(subst))
         return false;
       
       // TODO: If the archetype has a superclass constraint, check that the
@@ -1750,6 +1763,46 @@ static bool isBindableTo(Type a, Type b, LazyResolver *resolver) {
       return false;
     }
     
+    bool visitSILFunctionType(SILFunctionType *func,
+                              CanType subst) {
+      if (auto substFunc = dyn_cast<SILFunctionType>(subst)) {
+        if (func->getExtInfo() != substFunc->getExtInfo())
+          return false;
+        
+        // TODO: Generic signatures
+        if (func->getGenericSignature() || substFunc->getGenericSignature())
+          return false;
+        
+        if (func->getParameters().size() != substFunc->getParameters().size())
+          return false;
+        if (func->getAllResults().size() != substFunc->getAllResults().size())
+          return false;
+        
+        for (unsigned i : indices(func->getParameters())) {
+          if (func->getParameters()[i].getConvention()
+                != substFunc->getParameters()[i].getConvention())
+            return false;
+          if (!visit(func->getParameters()[i].getType(),
+                     substFunc->getParameters()[i].getType()))
+            return false;
+        }
+        
+        for (unsigned i : indices(func->getAllResults())) {
+          if (func->getAllResults()[i].getConvention()
+                != substFunc->getAllResults()[i].getConvention())
+            return false;
+          
+          if (!visit(func->getAllResults()[i].getType(),
+                     substFunc->getAllResults()[i].getType()))
+            return false;
+        }
+        
+        return true;
+      }
+      
+      return false;
+    }
+    
     bool visitBoundGenericType(BoundGenericType *bgt, CanType subst) {
       if (auto substBGT = dyn_cast<BoundGenericType>(subst)) {
         if (bgt->getDecl() != substBGT->getDecl())
@@ -1798,7 +1851,7 @@ static bool isBindableTo(Type a, Type b, LazyResolver *resolver) {
     }
   };
   
-  return IsBindableVisitor(resolver).visit(a->getCanonicalType(),
+  return IsBindableVisitor(resolver).visit(getCanonicalType(),
                                            b->getCanonicalType());
 }
 
@@ -1822,7 +1875,7 @@ bool TypeBase::isBindableToSuperclassOf(Type ty, LazyResolver *resolver) {
     return true;
   
   do {
-    if (isBindableTo(this, ty, resolver))
+    if (isBindableTo(ty, resolver))
       return true;
     if (ty->getAnyNominal() && ty->getAnyNominal()->isInvalid())
       return false;
diff --git a/lib/SIL/SILFunctionType.cpp b/lib/SIL/SILFunctionType.cpp
@@ -1495,7 +1495,8 @@ getSILFunctionTypeForSelectorFamily(SILModule &M, SelectorFamily family,
 }
 
 static CanSILFunctionType
-getUncachedSILFunctionTypeForConstant(SILModule &M, SILDeclRef constant,
+getUncachedSILFunctionTypeForConstant(SILModule &M,
+                                  SILDeclRef constant,
                                   CanAnyFunctionType origLoweredInterfaceType) {
   assert(origLoweredInterfaceType->getExtInfo().getSILRepresentation()
            != SILFunctionTypeRepresentation::Thick
@@ -1505,7 +1506,7 @@ getUncachedSILFunctionTypeForConstant(SILModule &M, SILDeclRef constant,
   auto extInfo = origLoweredInterfaceType->getExtInfo();
 
   if (!constant.isForeign) {
-    return getNativeSILFunctionType(M,
+    return ::getNativeSILFunctionType(M,
                   AbstractionPattern(origLoweredInterfaceType),
                   origLoweredInterfaceType,
                   extInfo,
@@ -1538,6 +1539,16 @@ getUncachedSILFunctionTypeForConstant(SILModule &M, SILDeclRef constant,
                                              extInfo, foreignError);
 }
 
+CanSILFunctionType TypeConverter::
+getUncachedSILFunctionTypeForConstant(SILDeclRef constant,
+                                      CanAnyFunctionType origInterfaceType) {
+  auto origLoweredInterfaceType = getLoweredASTFunctionType(origInterfaceType,
+                                                            constant.uncurryLevel,
+                                                            constant);
+  return ::getUncachedSILFunctionTypeForConstant(M, constant,
+                                                 origLoweredInterfaceType);
+}
+
 static bool isClassOrProtocolMethod(ValueDecl *vd) {
   if (!vd->getDeclContext())
     return false;
@@ -1620,8 +1631,8 @@ SILConstantInfo TypeConverter::getConstantInfo(SILDeclRef constant) {
 
   // The SIL type encodes conventions according to the original type.
   CanSILFunctionType silFnType =
-    getUncachedSILFunctionTypeForConstant(M, constant,
-                                          loweredInterfaceType);
+    ::getUncachedSILFunctionTypeForConstant(M, constant,
+                                            loweredInterfaceType);
 
   DEBUG(llvm::dbgs() << "lowering type for constant ";
         constant.print(llvm::dbgs());
diff --git a/lib/SIL/SILVerifier.cpp b/lib/SIL/SILVerifier.cpp
@@ -18,6 +18,7 @@
 #include "swift/SIL/SILVTable.h"
 #include "swift/SIL/Dominance.h"
 #include "swift/SIL/DynamicCasts.h"
+#include "swift/AST/AnyFunctionRef.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Module.h"
@@ -1708,7 +1709,10 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
                                      dynResults,
                                      methodTy->getOptionalErrorResult(),
                                      F.getASTContext());
-    return SILType::getPrimitiveObjectType(fnTy);
+    auto boundFnTy = ArchetypeBuilder::mapTypeIntoContext(
+        method.getDecl()->getDeclContext(), fnTy)
+      ->getCanonicalType();
+    return SILType::getPrimitiveObjectType(boundFnTy);
   }
   
   void checkDynamicMethodInst(DynamicMethodInst *EMI) {
@@ -1721,12 +1725,13 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
               "operand must have metatype type");
       require(operandType.getSwiftType()->castTo<MetatypeType>()
                 ->getInstanceType()->mayHaveSuperclass(),
-              "operand must have metatype of class or class-bound type");
+              "operand must have metatype of class or class-bounded type");
     }
     
-    requireSameType(EMI->getType(),
-                    getDynamicMethodType(operandType, EMI->getMember()),
-                    "result must be of the method's type");
+    require(getDynamicMethodType(operandType, EMI->getMember())
+              .getSwiftRValueType()
+              ->isBindableTo(EMI->getType().getSwiftRValueType(), nullptr),
+            "result must be of the method's type");
   }
 
   void checkClassMethodInst(ClassMethodInst *CMI) {
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -281,17 +281,17 @@ class Callee {
 
   /// Add the 'self' type to the substituted function type of this
   /// dynamic callee.
-  void addDynamicCalleeSelfToFormalType(SILGenModule &SGM) {
+  void addDynamicCalleeSelfToFormalType(SILGenModule &SGM,
+                                        CanAnyFunctionType substFormalType) {
     assert(kind == Kind::DynamicMethod);
 
-    // Drop the original self clause.
-    CanType methodType = OrigFormalInterfaceType.getResult();
-
-    // Replace it with the dynamic self type.
+    // Add the dynamic self type to the substituted type. Even if the dynamic
+    // callee came from a generic ObjC class, when we find it on AnyObject the
+    // parameters should be substituted with their upper bound types.
     OrigFormalInterfaceType
       = getDynamicMethodFormalType(SGM, SelfValue,
                                    Constant.getDecl(),
-                                   Constant, methodType);
+                                   Constant, substFormalType);
     assert(!OrigFormalInterfaceType->hasTypeParameter());
 
     // Add a self clause to the substituted type.
@@ -354,7 +354,7 @@ class Callee {
                            SILLocation l) {
     Callee callee(Kind::DynamicMethod, gen, proto, name,
                   substFormalType, l);
-    callee.addDynamicCalleeSelfToFormalType(gen.SGM);
+    callee.addDynamicCalleeSelfToFormalType(gen.SGM, substFormalType);
     return callee;
   }
   Callee(Callee &&) = default;
@@ -425,7 +425,6 @@ class Callee {
   getAtUncurryLevel(SILGenFunction &gen, unsigned level) const {
     ManagedValue mv;
     ApplyOptions options = ApplyOptions::None;
-    SILConstantInfo constantInfo;
     Optional<SILDeclRef> constant = None;
 
     switch (kind) {
@@ -447,7 +446,7 @@ class Callee {
           if (getMethodDispatch(func) == MethodDispatch::Class)
             constant = constant->asDirectReference(true);
       
-      constantInfo = gen.getConstantInfo(*constant);
+      auto constantInfo = gen.getConstantInfo(*constant);
       SILValue ref = gen.emitGlobalFunctionRef(Loc, *constant, constantInfo);
       mv = ManagedValue::forUnmanaged(ref);
       break;
@@ -456,7 +455,7 @@ class Callee {
       assert(level <= Constant.uncurryLevel
              && "uncurrying past natural uncurry level of enum constructor");
       constant = Constant.atUncurryLevel(level);
-      constantInfo = gen.getConstantInfo(*constant);
+      auto constantInfo = gen.getConstantInfo(*constant);
 
       // We should not end up here if the enum constructor call is fully
       // applied.
@@ -470,7 +469,7 @@ class Callee {
       assert(level <= Constant.uncurryLevel
              && "uncurrying past natural uncurry level of method");
       constant = Constant.atUncurryLevel(level);
-      constantInfo = gen.getConstantInfo(*constant);
+      auto constantInfo = gen.getConstantInfo(*constant);
 
       // If the call is curried, emit a direct call to the curry thunk.
       if (level < Constant.uncurryLevel) {
@@ -496,7 +495,7 @@ class Callee {
              "Currying the self parameter of super method calls should've been emitted");
 
       constant = Constant.atUncurryLevel(level);
-      constantInfo = gen.getConstantInfo(*constant);
+      auto constantInfo = gen.getConstantInfo(*constant);
 
       if (SILDeclRef baseConstant = Constant.getBaseOverriddenVTableEntry())
         constantInfo = gen.SGM.Types.getConstantOverrideInfo(Constant,
@@ -514,7 +513,7 @@ class Callee {
       assert(level <= Constant.uncurryLevel
              && "uncurrying past natural uncurry level of method");
       constant = Constant.atUncurryLevel(level);
-      constantInfo = gen.getConstantInfo(*constant);
+      auto constantInfo = gen.getConstantInfo(*constant);
 
       // If the call is curried, emit a direct call to the curry thunk.
       if (level < Constant.uncurryLevel) {
@@ -550,11 +549,16 @@ class Callee {
              && "uncurrying past natural uncurry level of method");
 
       auto constant = Constant.atUncurryLevel(level);
-      constantInfo = gen.getConstantInfo(constant);
+      // Lower the substituted type from the AST, which should have any generic
+      // parameters in the original signature erased to their upper bounds.
+      auto objcFormalType = CanAnyFunctionType(SubstFormalType->withExtInfo(
+         SubstFormalType->getExtInfo()
+           .withSILRepresentation(SILFunctionTypeRepresentation::ObjCMethod)));
+      auto fnType = gen.SGM.M.Types
+        .getUncachedSILFunctionTypeForConstant(constant, objcFormalType);
 
       auto closureType =
-        replaceSelfTypeForDynamicLookup(gen.getASTContext(),
-                                constantInfo.SILFnType,
+        replaceSelfTypeForDynamicLookup(gen.getASTContext(), fnType,
                                 SelfValue->getType().getSwiftRValueType(),
                                 Constant);
 
diff --git a/test/SILGen/objc_imported_generic.swift b/test/SILGen/objc_imported_generic.swift
@@ -9,3 +9,10 @@ func callInitializer() {
 
 // CHECK-LABEL: sil shared @_TFCSo12GenericClassCfT5thingGSQx__GSQGS_x__
 // CHECK:         thick_to_objc_metatype {{%.*}} : $@thick GenericClass<T>.Type to $@objc_metatype GenericClass<T>.Type
+
+public func genericMethodOnAnyObject(o: AnyObject, b: Bool) -> AnyObject {
+  return o.thing!()!
+}
+
+// CHECK-LABEL: sil @_TF21objc_imported_generic24genericMethodOnAnyObject
+// CHECK:         dynamic_method [volatile] {{%.*}} : $@opened([[TAG:.*]]) AnyObject, #GenericClass.thing!1.foreign : <T where T : AnyObject> GenericClass<T> -> () -> T?, $@convention(objc_method) (@opened([[TAG]]) AnyObject) -> @autoreleased Optional<AnyObject>
