SIL: Start cleaning up getMethodDispatch() / requiresObjCDispatch()

slavapestov · slavapestov · commit 832a637c0402 · 2015-12-11T08:58:52.000-08:00
Move these to SILDeclRef, maybe not the best place but a good home for now. Factor out a new requiresForeignToNativeThunk() function, which cleans up some code duplication introduced by the following patch: 478e1c7 This is a small step towards consolidating duplicated logic for figuring out method dispatch semantics and emitting curry thunks.
diff --git a/include/swift/SIL/SILDeclRef.h b/include/swift/SIL/SILDeclRef.h
@@ -45,6 +45,23 @@ namespace swift {
   class SILLocation;
   class AnyFunctionRef;
 
+/// How a method is dispatched.
+enum class MethodDispatch {
+  // The method implementation can be referenced statically.
+  Static,
+  // The method implementation uses class_method dispatch.
+  Class,
+};
+
+/// Get the method dispatch mechanism for a method.
+MethodDispatch getMethodDispatch(AbstractFunctionDecl *method);
+
+/// True if calling the given method or property should use ObjC dispatch.
+bool requiresObjCDispatch(ValueDecl *vd);
+
+/// True if the entry point is natively foreign.
+bool requiresForeignToNativeThunk(ValueDecl *vd);
+
 enum ForDefinition_t : bool {
   NotForDefinition = false,
   ForDefinition = true
diff --git a/lib/SIL/SILDeclRef.cpp b/lib/SIL/SILDeclRef.cpp
@@ -25,6 +25,85 @@
 #include "clang/AST/DeclObjC.h"
 using namespace swift;
 
+/// Get the method dispatch mechanism for a method.
+MethodDispatch
+swift::getMethodDispatch(AbstractFunctionDecl *method) {
+  // Final methods can be statically referenced.
+  if (method->isFinal())
+    return MethodDispatch::Static;
+  // Some methods are forced to be statically dispatched.
+  if (method->hasForcedStaticDispatch())
+    return MethodDispatch::Static;
+
+  // If this declaration is in a class but not marked final, then it is
+  // always dynamically dispatched.
+  auto dc = method->getDeclContext();
+  if (isa<ClassDecl>(dc))
+    return MethodDispatch::Class;
+
+  // Class extension methods are only dynamically dispatched if they're
+  // dispatched by objc_msgSend, which happens if they're foreign or dynamic.
+  if (dc->isClassOrClassExtensionContext()) {
+    if (method->hasClangNode())
+      return MethodDispatch::Class;
+    if (auto fd = dyn_cast<FuncDecl>(method)) {
+      if (fd->isAccessor() && fd->getAccessorStorageDecl()->hasClangNode())
+        return MethodDispatch::Class;
+    }
+    if (method->getAttrs().hasAttribute<DynamicAttr>())
+      return MethodDispatch::Class;
+  }
+
+  // Otherwise, it can be referenced statically.
+  return MethodDispatch::Static;
+}
+
+bool swift::requiresForeignToNativeThunk(ValueDecl *vd) {
+  // Functions imported from C, Objective-C methods imported from Objective-C,
+  // as well as methods in @objc protocols (even protocols defined in Swift)
+  // require a foreign to native thunk.
+  auto dc = vd->getDeclContext();
+  if (auto proto = dyn_cast<ProtocolDecl>(dc))
+    if (proto->isObjC())
+      return true;
+
+  if (auto fd = dyn_cast<FuncDecl>(vd))
+    return fd->hasClangNode();
+
+  return false;
+}
+
+/// FIXME: merge requiresObjCDispatch() into getMethodDispatch() and add
+/// an ObjectiveC case to the MethodDispatch enum.
+bool swift::requiresObjCDispatch(ValueDecl *vd) {
+  // Final functions never require ObjC dispatch.
+  if (vd->isFinal())
+    return false;
+
+  if (requiresForeignToNativeThunk(vd))
+    return true;
+
+  if (auto *fd = dyn_cast<FuncDecl>(vd)) {
+    // Property accessors should be generated alongside the property.
+    if (fd->isGetterOrSetter())
+      return requiresObjCDispatch(fd->getAccessorStorageDecl());
+
+    return fd->getAttrs().hasAttribute<DynamicAttr>();
+  }
+
+  if (auto *cd = dyn_cast<ConstructorDecl>(vd)) {
+    if (cd->hasClangNode())
+      return true;
+
+    return cd->getAttrs().hasAttribute<DynamicAttr>();
+  }
+
+  if (auto *asd = dyn_cast<AbstractStorageDecl>(vd))
+    return asd->requiresObjCGetterAndSetter();
+
+  return vd->getAttrs().hasAttribute<DynamicAttr>();
+}
+
 static unsigned getFuncNaturalUncurryLevel(AnyFunctionRef AFR) {
   assert(AFR.getBodyParamPatterns().size() >= 1 && "no arguments for func?!");
   unsigned Level = AFR.getBodyParamPatterns().size() - 1;
@@ -338,14 +417,8 @@ bool SILDeclRef::isForeignToNativeThunk() const {
   // have a foreign-to-native thunk.
   if (!hasDecl())
     return false;
-  // Otherwise, match whether we have a clang node with whether we're foreign.
-  if (isa<FuncDecl>(getDecl()) && getDecl()->hasClangNode())
+  if (requiresForeignToNativeThunk(getDecl()))
     return !isForeign;
-  // Objective-C protocol methods also require a foreign to native thunk.
-  auto dc = getDecl()->getDeclContext();
-  if (auto proto = dyn_cast<ProtocolDecl>(dc))
-    if (proto->isObjC())
-      return !isForeign;
   // ObjC initializing constructors and factories are foreign.
   // We emit a special native allocating constructor though.
   if (isa<ConstructorDecl>(getDecl())
diff --git a/lib/SILGen/SILGen.h b/lib/SILGen/SILGen.h
@@ -323,13 +323,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
   /// True if the given constructor requires an entry point for ObjC method
   /// dispatch.
   bool requiresObjCMethodEntryPoint(ConstructorDecl *constructor);
-  
-  /// True if calling the given method or property should use ObjC dispatch.
-  bool requiresObjCDispatch(ValueDecl *vd);
-  
-  /// True if super-calling the given method from a subclass should use ObjC
-  /// dispatch.
-  bool requiresObjCSuperDispatch(ValueDecl *vd);
 
   /// Emit a global initialization.
   void emitGlobalInitialization(PatternBindingDecl *initializer, unsigned elt);
diff --git a/lib/SILGen/SILGenApply.cpp b/lib/SILGen/SILGenApply.cpp
@@ -29,40 +29,6 @@
 using namespace swift;
 using namespace Lowering;
 
-/// Get the method dispatch mechanism for a method.
-MethodDispatch
-SILGenFunction::getMethodDispatch(AbstractFunctionDecl *method) {
-  // Final methods can be statically referenced.
-  if (method->isFinal())
-    return MethodDispatch::Static;
-  // Some methods are forced to be statically dispatched.
-  if (method->hasForcedStaticDispatch())
-    return MethodDispatch::Static;
-
-  // If this declaration is in a class but not marked final, then it is
-  // always dynamically dispatched.
-  auto dc = method->getDeclContext();
-  if (isa<ClassDecl>(dc))
-    return MethodDispatch::Class;
-
-  // Class extension methods are only dynamically dispatched if they're
-  // dispatched by objc_msgSend, which happens if they're foreign or dynamic.
-  if (auto declaredType = dc->getDeclaredTypeInContext())
-    if (declaredType->getClassOrBoundGenericClass()) {
-      if (method->hasClangNode())
-        return MethodDispatch::Class;
-      if (auto fd = dyn_cast<FuncDecl>(method)) {
-        if (fd->isAccessor() && fd->getAccessorStorageDecl()->hasClangNode())
-          return MethodDispatch::Class;
-      }
-      if (method->getAttrs().hasAttribute<DynamicAttr>())
-        return MethodDispatch::Class;
-    }
-
-  // Otherwise, it can be referenced statically.
-  return MethodDispatch::Static;
-}
-
 static SILDeclRef::Loc getLocForFunctionRef(AnyFunctionRef fn) {
   if (auto afd = fn.getAbstractFunctionDecl()) {
     return afd;
@@ -539,7 +505,7 @@ class Callee {
       // make sure we emit the right set of thunks.
       if (constant->isCurried && Constant.hasDecl())
         if (auto func = Constant.getAbstractFunctionDecl())
-          if (gen.getMethodDispatch(func) == MethodDispatch::Class)
+          if (getMethodDispatch(func) == MethodDispatch::Class)
             constant = constant->asDirectReference(true);
       
       constantInfo = gen.getConstantInfo(*constant);
@@ -1102,7 +1068,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       if (e->getAccessSemantics() != AccessSemantics::Ordinary) {
         isDynamicallyDispatched = false;
       } else {
-        switch (SGF.getMethodDispatch(afd)) {
+        switch (getMethodDispatch(afd)) {
         case MethodDispatch::Class:
           isDynamicallyDispatched = true;
           break;
@@ -1121,7 +1087,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
         if (ctor->isRequired() &&
             thisCallSite->getArg()->getType()->is<AnyMetatypeType>() &&
             !thisCallSite->getArg()->isStaticallyDerivedMetatype()) {
-          if (SGF.SGM.requiresObjCDispatch(afd)) {
+          if (requiresObjCDispatch(afd)) {
             // When we're performing Objective-C dispatch, we don't have an
             // allocating constructor to call. So, perform an alloc_ref_dynamic
             // and pass that along to the initializer.
@@ -1171,7 +1137,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
         SILDeclRef constant(afd, kind.getValue(),
                             SILDeclRef::ConstructAtBestResilienceExpansion,
                             SILDeclRef::ConstructAtNaturalUncurryLevel,
-                            SGF.SGM.requiresObjCDispatch(afd));
+                            requiresObjCDispatch(afd));
 
         setCallee(Callee::forClassMethod(SGF, selfValue,
                                          constant, getSubstFnType(), e));
@@ -1203,7 +1169,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
     SILDeclRef constant(e->getDecl(),
                         SILDeclRef::ConstructAtBestResilienceExpansion,
                         SILDeclRef::ConstructAtNaturalUncurryLevel,
-                        SGF.SGM.requiresObjCDispatch(e->getDecl()));
+                        requiresObjCDispatch(e->getDecl()));
 
     // Otherwise, we have a statically-dispatched call.
     CanFunctionType substFnType = getSubstFnType();
@@ -1345,7 +1311,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       constant = SILDeclRef(ctorRef->getDecl(), SILDeclRef::Kind::Initializer,
                          SILDeclRef::ConstructAtBestResilienceExpansion,
                          SILDeclRef::ConstructAtNaturalUncurryLevel,
-                         SGF.SGM.requiresObjCSuperDispatch(ctorRef->getDecl()));
+                         requiresObjCDispatch(ctorRef->getDecl()));
 
       if (ctorRef->getDeclRef().isSpecialized())
         substitutions = ctorRef->getDeclRef().getSubstitutions();
@@ -1354,7 +1320,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
       constant = SILDeclRef(declRef->getDecl(),
                          SILDeclRef::ConstructAtBestResilienceExpansion,
                          SILDeclRef::ConstructAtNaturalUncurryLevel,
-                         SGF.SGM.requiresObjCSuperDispatch(declRef->getDecl()));
+                         requiresObjCDispatch(declRef->getDecl()));
 
       if (declRef->getDeclRef().isSpecialized())
         substitutions = declRef->getDeclRef().getSubstitutions();
@@ -1536,12 +1502,12 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                                : SILDeclRef::Kind::Initializer,
                              SILDeclRef::ConstructAtBestResilienceExpansion,
                              SILDeclRef::ConstructAtNaturalUncurryLevel,
-                             SGF.SGM.requiresObjCDispatch(ctorRef->getDecl()));
+                             requiresObjCDispatch(ctorRef->getDecl()));
       setCallee(Callee::forArchetype(SGF, SILValue(),
                      self.getType().getSwiftRValueType(), constant,
                      cast<AnyFunctionType>(expr->getType()->getCanonicalType()),
                      expr));
-    } else if (SGF.getMethodDispatch(ctorRef->getDecl())
+    } else if (getMethodDispatch(ctorRef->getDecl())
                  == MethodDispatch::Class) {
       // Dynamic dispatch to the initializer.
       setCallee(Callee::forClassMethod(
@@ -1553,7 +1519,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
                                : SILDeclRef::Kind::Initializer,
                              SILDeclRef::ConstructAtBestResilienceExpansion,
                              SILDeclRef::ConstructAtNaturalUncurryLevel,
-                             SGF.SGM.requiresObjCDispatch(ctorRef->getDecl())),
+                             requiresObjCDispatch(ctorRef->getDecl())),
                   getSubstFnType(), fn));
     } else {
       // Directly call the peer constructor.
@@ -3799,7 +3765,7 @@ static Callee getBaseAccessorFunctionRef(SILGenFunction &gen,
 
   bool isClassDispatch = false;
   if (!isDirectUse) {
-    switch (gen.getMethodDispatch(decl)) {
+    switch (getMethodDispatch(decl)) {
     case MethodDispatch::Class:
       isClassDispatch = true;
       break;
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
@@ -147,14 +147,8 @@ SILValue SILGenFunction::emitGlobalFunctionRef(SILLocation loc,
       // If the function is fully uncurried and natively foreign, reference its
       // foreign entry point.
       if (!next.isCurried) {
-        if (vd->hasClangNode())
+        if (requiresForeignToNativeThunk(vd))
           next = next.asForeign();
-
-        // Objective-C protocol methods also require a foreign to native thunk.
-        auto dc = vd->getDeclContext();
-        if (auto proto = dyn_cast<ProtocolDecl>(dc))
-          if (proto->isObjC())
-            next = next.asForeign();
       }
       
       // Preserve whether the curry thunks lead to a direct reference to the
@@ -620,7 +614,7 @@ static SILValue getNextUncurryLevelRef(SILGenFunction &gen,
       thisArg = curriedArgs.back();
 
   if (isa<AbstractFunctionDecl>(next.getDecl()) &&
-      gen.getMethodDispatch(cast<AbstractFunctionDecl>(next.getDecl()))
+      getMethodDispatch(cast<AbstractFunctionDecl>(next.getDecl()))
         == MethodDispatch::Class) {
     SILValue thisArg = curriedArgs.back();
 
diff --git a/lib/SILGen/SILGenFunction.h b/lib/SILGen/SILGenFunction.h
@@ -31,14 +31,6 @@ class LValue;
 class ManagedValue;
 class RValue;
 class TemporaryInitialization;
-
-/// How a method is dispatched.
-enum class MethodDispatch {
-  // The method implementation can be referenced statically.
-  Static,
-  // The method implementation uses class_method dispatch.
-  Class,
-};
   
 /// Internal context information for the SILGenFunction visitor.
 ///
@@ -1540,9 +1532,6 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   /// intrinsic.
   Substitution getPointerSubstitution(Type pointerType,
                                       ArchetypeType *archetype);
-  
-  /// Get the method dispatch mechanism for a method.
-  MethodDispatch getMethodDispatch(AbstractFunctionDecl *method);
 };
 
 
diff --git a/lib/SILGen/SILGenType.cpp b/lib/SILGen/SILGenType.cpp
@@ -136,47 +136,6 @@ bool SILGenModule::requiresObjCMethodEntryPoint(ConstructorDecl *constructor) {
   return constructor->isObjC();
 }
 
-bool SILGenModule::requiresObjCDispatch(ValueDecl *vd) {
-  // Final functions never require ObjC dispatch.
-  if (vd->isFinal())
-    return false;
-
-  // If the decl is an @objc protocol requirement, then the only witness is
-  // objc.
-  if (auto *proto = dyn_cast<ProtocolDecl>(vd->getDeclContext()))
-    if (proto->isObjC())
-      return true;
-
-  if (auto *fd = dyn_cast<FuncDecl>(vd)) {
-    // If a function has an associated Clang node, it's foreign and only has
-    // an ObjC entry point.
-    if (vd->hasClangNode())
-      return true;
-
-    // Property accessors should be generated alongside the property.
-    if (fd->isGetterOrSetter())
-      return requiresObjCDispatch(fd->getAccessorStorageDecl());
-
-    return fd->getAttrs().hasAttribute<DynamicAttr>();
-  }
-  if (auto *cd = dyn_cast<ConstructorDecl>(vd)) {
-    // If a function has an associated Clang node, it's foreign and only has
-    // an ObjC entry point.
-    if (vd->hasClangNode())
-      return true;
-    
-    return cd->getAttrs().hasAttribute<DynamicAttr>();
-  }
-  if (auto *asd = dyn_cast<AbstractStorageDecl>(vd))
-    return asd->requiresObjCGetterAndSetter();
-
-  return vd->getAttrs().hasAttribute<DynamicAttr>();
-}
-
-bool SILGenModule::requiresObjCSuperDispatch(ValueDecl *vd) {
-  return requiresObjCDispatch(vd);
-}
-
 namespace {
 
 /// An ASTVisitor for populating SILVTable entries from ClassDecl members.
