Merge pull request #24704 from slavapestov/always-emit-class-stubs

Always emit class stubs

Author: slavapestov

lib/IRGen/GenClass.cpp

@@ -1211,7 +1211,6 @@ namespace {
       // hierarchy crosses resilience domains, we use a
       // slightly different query here.
       if (theClass->checkAncestry(AncestryFlags::ResilientOther)) {
-        assert(IGM.Context.LangOpts.EnableObjCResilientClassStubs);
         return IGM.getAddrOfObjCResilientClassStub(theClass, NotForDefinition,
                                              TypeMetadataAddress::AddressPoint);
       }
@@ -2072,9 +2071,7 @@ static llvm::Function *emitObjCMetadataUpdateFunction(IRGenModule &IGM,
 /// does not have statically-emitted metadata.
 bool irgen::hasObjCResilientClassStub(IRGenModule &IGM, ClassDecl *D) {
   assert(IGM.getClassMetadataStrategy(D) == ClassMetadataStrategy::Resilient);
-  return (!D->isGenericContext() &&
-          IGM.ObjCInterop &&
-          IGM.Context.LangOpts.EnableObjCResilientClassStubs);
+  return IGM.ObjCInterop && !D->isGenericContext();
 }
 
 void irgen::emitObjCResilientClassStub(IRGenModule &IGM, ClassDecl *D) {

lib/TBDGen/TBDGen.cpp

@@ -379,13 +379,16 @@ void TBDGenVisitor::visitClassDecl(ClassDecl *CD) {
 
   visitNominalTypeDecl(CD);
 
+  bool resilientAncestry = CD->checkAncestry(AncestryFlags::ResilientOther);
+
   // Types with resilient superclasses have some extra symbols.
-  if (CD->checkAncestry(AncestryFlags::ResilientOther) ||
-      CD->hasResilientMetadata()) {
+  if (resilientAncestry || CD->hasResilientMetadata()) {
     addSymbol(LinkEntity::forClassMetadataBaseOffset(CD));
+  }
 
-    auto &Ctx = CD->getASTContext();
-    if (Ctx.LangOpts.EnableObjCResilientClassStubs) {
+  auto &Ctx = CD->getASTContext();
+  if (Ctx.LangOpts.EnableObjCInterop) {
+    if (resilientAncestry) {
       addSymbol(LinkEntity::forObjCResilientClassStub(
           CD, TypeMetadataAddress::AddressPoint));
     }

stdlib/public/runtime/Metadata.cpp

@@ -2711,16 +2711,23 @@ _swift_initClassMetadataImpl(ClassMetadata *self,
     // globals. Note that the field offset vector is *not* updated;
     // however we should not be using it for anything in a non-generic
     // class.
-    if (auto *stub = description->getObjCResilientClassStub()) {
-      if (_objc_realizeClassFromSwift == nullptr ||
-          objc_loadClassref == nullptr) {
-        fatalError(0, "class %s requires missing Objective-C runtime feature; "
-                  "the deployment target was newer than this OS\n",
-                  self->getDescription()->Name.get());
-      }
+    auto *stub = description->getObjCResilientClassStub();
+
+    // On a new enough runtime, register the class as a replacement for
+    // its stub if we have one, which attaches any categories referencing
+    // the stub.
+    //
+    // On older runtimes, just register the class via the usual mechanism.
+    // The compiler enforces that @objc methods in extensions of classes
+    // with resilient ancestry have the correct availability, so it should
+    // be safe to ignore the stub in this case.
+    if (stub != nullptr &&
+        objc_loadClassref != nullptr &&
+        _objc_realizeClassFromSwift != nullptr) {
       _objc_realizeClassFromSwift((Class) self, const_cast<void *>(stub));
-    } else
+    } else {
       swift_instantiateObjCClass(self);
+    }
   }
 #else
   assert(!description->hasObjCResilientClassStub());

test/Interpreter/objc_class_resilience_stubs.swift

@@ -3,7 +3,7 @@
 // RUN: %target-build-swift-dylib(%t/%target-library-name(resilient_struct)) -enable-library-evolution %S/../Inputs/resilient_struct.swift -emit-module -emit-module-path %t/resilient_struct.swiftmodule
 // RUN: %target-codesign %t/%target-library-name(resilient_struct)
 
-// RUN: %target-build-swift-dylib(%t/%target-library-name(resilient_objc_class)) -I %t -L %t -lresilient_struct -enable-library-evolution %S/../Inputs/resilient_objc_class.swift -emit-module -emit-module-path %t/resilient_objc_class.swiftmodule -Xfrontend -enable-resilient-objc-class-stubs
+// RUN: %target-build-swift-dylib(%t/%target-library-name(resilient_objc_class)) -I %t -L %t -lresilient_struct -enable-library-evolution %S/../Inputs/resilient_objc_class.swift -emit-module -emit-module-path %t/resilient_objc_class.swiftmodule
 // RUN: %target-codesign %t/%target-library-name(resilient_objc_class)
 
 // RUN: %target-build-swift %s -L %t -I %t -lresilient_struct -lresilient_objc_class -o %t/main %target-rpath(%t) -Xfrontend -enable-resilient-objc-class-stubs
@@ -28,6 +28,18 @@ var ResilientClassTestSuite = TestSuite("ResilientClass")
 
 class ResilientNSObjectSubclass : ResilientNSObjectOutsideParent {}
 
+@_optimize(none) func blackHole<T>(_: T) {}
+
+@_optimize(none) func forceMetadata() {
+  blackHole(ResilientNSObjectSubclass())
+}
+
+// This should not crash on older runtimes because we check before
+// attempting to register the class stub.
+ResilientClassTestSuite.test("RealizeResilientClass") {
+  forceMetadata()
+}
+
 @objc protocol MyProtocol {
   func myMethod() -> Int
 }
@@ -61,20 +73,4 @@ ResilientClassTestSuite.test("category on other class")
   expectEqual(69, (o as AnotherProtocol).anotherMethod())
 }
 
-@_optimize(none) func blackHole<T>(_: T) {}
-
-@_optimize(none) func forceMetadata() {
-  blackHole(ResilientNSObjectSubclass())
-}
-
-if loadClassrefMissing {
-  ResilientClassTestSuite.test("RealizeResilientClass")
-    .crashOutputMatches("class ResilientNSObjectSubclass requires missing Objective-C runtime feature")
-    .code {
-      expectCrashLater()
-      print("About to crash...")
-      forceMetadata()
-    }
-}
-
 runAllTests()