Merge pull request #34766 from slavapestov/emit-stub-for-concrete-subclass-of-generic

Emit Objective-C resilient class stubs for concrete subclasses of generic subclasses of NSObject

Author: slavapestov

lib/IRGen/GenClass.cpp

@@ -2144,13 +2144,17 @@ static llvm::Function *emitObjCMetadataUpdateFunction(IRGenModule &IGM,
 /// ancestry. This lets us attach categories to the class even though it
 /// does not have statically-emitted metadata.
 bool IRGenModule::hasObjCResilientClassStub(ClassDecl *D) {
-  assert(getClassMetadataStrategy(D) == ClassMetadataStrategy::Resilient);
+#ifndef NDEBUG
+  auto strategy = getClassMetadataStrategy(D);
+  assert(strategy == ClassMetadataStrategy::Resilient ||
+         strategy == ClassMetadataStrategy::Singleton);
+#endif
+
   return ObjCInterop && !D->isGenericContext();
 }
 
-void IRGenModule::emitObjCResilientClassStub(ClassDecl *D) {
-  assert(hasObjCResilientClassStub(D));
-
+llvm::Constant *IRGenModule::emitObjCResilientClassStub(
+    ClassDecl *D, bool isPublic) {
   ConstantInitBuilder builder(*this);
   auto fields = builder.beginStruct(ObjCFullResilientClassStubTy);
   fields.addInt(SizeTy, 0); // reserved
@@ -2178,9 +2182,13 @@ void IRGenModule::emitObjCResilientClassStub(ClassDecl *D) {
   objcStub = llvm::ConstantExpr::getPointerCast(objcStub,
       ObjCResilientClassStubTy->getPointerTo());
 
-  entity = LinkEntity::forObjCResilientClassStub(
-      D, TypeMetadataAddress::AddressPoint);
-  defineAlias(entity, objcStub);
+  if (isPublic) {
+    entity = LinkEntity::forObjCResilientClassStub(
+        D, TypeMetadataAddress::AddressPoint);
+    defineAlias(entity, objcStub);
+  }
+
+  return objcStub;
 }
 
 static llvm::Constant *doEmitClassPrivateData(

lib/IRGen/GenMeta.cpp

@@ -3794,23 +3794,44 @@ void irgen::emitClassMetadata(IRGenModule &IGM, ClassDecl *classDecl,
   if (IGM.ObjCInterop) {
     switch (strategy) {
     case ClassMetadataStrategy::Resilient:
-      // Even non-@objc classes can have Objective-C categories attached, so
-      // we always emit a resilient class stub as long as -enable-objc-interop
-      // is set.
+      // We always emit a resilient class stub as long as -enable-objc-interop
+      // is set. You can define @objc members in an extension of a resilient
+      // class across a module boundary, and this category is attached to the
+      // class stub.
       if (IGM.hasObjCResilientClassStub(classDecl)) {
-        IGM.emitObjCResilientClassStub(classDecl);
+        auto *stub = IGM.emitObjCResilientClassStub(
+            classDecl, /*isPublic=*/true);
 
-        if (classDecl->isObjC()) {
-          auto *stub = IGM.getAddrOfObjCResilientClassStub(
-              classDecl, NotForDefinition,
-              TypeMetadataAddress::AddressPoint);
+        // If the class has Objective-C ancestry but does *not* have generic
+        // ancestry, it appears in the generated header. We emit an Objective-C
+        // class symbol aliased to the class stub for Clang to reference.
+        if (classDecl->isObjC())
           emitObjCClassSymbol(IGM, classDecl, stub);
 
+        // Note that if the class has generic ancestry, isObjC() is false.
+        // This is because such classes cannot appear in the generated header,
+        // because their generic superclasses cannot appear in the generated
+        // header either. However, we still want to emit the class stub in
+        // the __objc_stublist section of the binary, so that they are visited
+        // by objc_copyClassList().
+        if (classDecl->checkAncestry(AncestryFlags::ObjC))
           IGM.addObjCClassStub(stub);
-        }
       }
       break;
+
     case ClassMetadataStrategy::Singleton:
+      // If the class has Objective-C ancestry, we emit the class stub and
+      // add it to the __obj_stublist. Note that the stub is not public in
+      // this case, since there is no reason to reference directly; it only
+      // exists so that objc_copyClassList() can find it.
+      if (IGM.hasObjCResilientClassStub(classDecl)) {
+        if (classDecl->checkAncestry(AncestryFlags::ObjC)) {
+          auto *stub = IGM.emitObjCResilientClassStub(
+              classDecl, /*isPublic=*/false);
+          IGM.addObjCClassStub(stub);
+        }
+      }
+
       break;
 
     case ClassMetadataStrategy::Update:
@@ -3820,7 +3841,7 @@ void irgen::emitClassMetadata(IRGenModule &IGM, ClassDecl *classDecl,
         emitObjCClassSymbol(IGM, classDecl, var);
 
       IGM.addObjCClass(var,
-                classDecl->getAttrs().hasAttribute<ObjCNonLazyRealizationAttr>());
+          classDecl->getAttrs().hasAttribute<ObjCNonLazyRealizationAttr>());
       break;
     }
   }

lib/IRGen/GenObjC.cpp

@@ -1085,8 +1085,6 @@ static llvm::Constant *getObjCEncodingForTypes(IRGenModule &IGM,
 
   std::string encodingString;
 
-  auto fnClangTy = fnType->getClangTypeInfo().getType();
-
   // Return type.
   {
     auto clangType = IGM.getClangType(resultType.getASTType());

lib/IRGen/IRGenModule.h

@@ -1636,7 +1636,7 @@ private:                            \
   bool hasObjCResilientClassStub(ClassDecl *D);
 
   /// Emit a resilient class stub.
-  void emitObjCResilientClassStub(ClassDecl *D);
+  llvm::Constant *emitObjCResilientClassStub(ClassDecl *D, bool isPublic);
 
 private:
   llvm::Constant *

test/IRGen/class_update_callback_with_stub.swift

@@ -105,7 +105,7 @@ import resilient_objc_class
 // -- ... but they do appear in the stub list
 
 // CHECK-LABEL: @objc_class_stubs = internal global
-// CHECK-SAME: @"$s31class_update_callback_with_stub25ResilientNSObjectSubclassCMs"
+// CHECK-SAME: @"$s31class_update_callback_with_stub25ResilientNSObjectSubclassCMt"
 // CHECK-SAME: , section "__DATA,__objc_stublist,regular,no_dead_strip"
 
 // -- The category list
@@ -128,7 +128,7 @@ import resilient_objc_class
 
 
 // -- Class symbol for NSObject-derived class points at the class stub
-// CHECK: @"OBJC_CLASS_$__TtC31class_update_callback_with_stub25ResilientNSObjectSubclass" = alias %objc_class_stub, %objc_class_stub* @"$s31class_update_callback_with_stub25ResilientNSObjectSubclassCMs"
+// CHECK: @"OBJC_CLASS_$__TtC31class_update_callback_with_stub25ResilientNSObjectSubclass" = alias %objc_class_stub, {{.*}} @"$s31class_update_callback_with_stub25ResilientNSObjectSubclassCMt"
 
 
 // -- Metadata update callbacks referenced from class stubs

test/IRGen/objc_generic_class_stub.swift

@@ -0,0 +1,19 @@
+
+// RUN: %empty-directory(%t)
+// RUN: %build-irgen-test-overlays
+// RUN: %target-swift-frontend(mock-sdk: -sdk %S/Inputs -I %t) -primary-file %s -emit-ir | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import Foundation
+
+public class GenericNSObjectSubclass<T> : NSObject {}
+
+public class ConcreteNSObjectSubclass : GenericNSObjectSubclass<Int> {}
+
+// Note the stub here is internal; it's only purpose is to appear in the stub list
+// so that it can be realized by objc_copyClassList():
+
+// CHECK-LABEL: @"$s23objc_generic_class_stub24ConcreteNSObjectSubclassCMt" = internal global %objc_full_class_stub { i64 0, i64 1, %objc_class* (%objc_class*, i8*)* @"$s23objc_generic_class_stub24ConcreteNSObjectSubclassCMU" }
+
+// CHECK-LABEL: @objc_class_stubs = internal global {{.*}} @"$s23objc_generic_class_stub24ConcreteNSObjectSubclassCMt" {{.*}}, section "__DATA,__objc_stublist,regular,no_dead_strip"