Set a minimum deployment target for objcImpl

The runtime layout tricks we’re playing only work on ABI-stable OSes, so require that as a minimum deployment target if you’re implementing whole ObjC classes with @implementation.

This allows us to simplify the runtime function by eliminating a pre-stable code path, which is nice because we’ll probably need to either port it to Swift or open-code it in IRGen.

Author: beccadax

include/swift/AST/DiagnosticsSema.def

@@ -1796,6 +1796,10 @@ ERROR(attr_objc_implementation_no_conformance,none,
       "add this conformance %select{with an ordinary extension|"
       "in the Objective-C header}1",
       (Type, bool))
+ERROR(attr_objc_implementation_raise_minimum_deployment_target,none,
+      "'@implementation' of an Objective-C class requires a minimum deployment "
+      "target of at least %0 %1",
+      (StringRef, llvm::VersionTuple))
 
 ERROR(member_of_objc_implementation_not_objc_or_final,none,
       "%kind0 does not match any %kindonly0 declared in the headers for %1; "

lib/Sema/TypeCheckAttr.cpp

@@ -1607,6 +1607,27 @@ visitObjCImplementationAttr(ObjCImplementationAttr *attr) {
 
       return;
     }
+
+    // Stored property support may require ivar layouts to be updated at runtime
+    // using features only available on ABI-stable runtimes. Make sure the
+    // minimum deployment target is high enough if we're implementing a main
+    // class body. (Categories ought to back-deploy arbitrarily far.)
+    //
+    // This check could perhaps be refined further; for instance, we might be
+    // able to allow extensions with appropriate availability even if they're in
+    // a module with a lower minimum deployment target. But in the year 2024,
+    // it's probably reasonable to limit an advanced feature to 2019 runtimes.
+    auto deploymentAvailability = AvailabilityContext::forDeploymentTarget(Ctx);
+    auto metadataUpdateAvailability =
+        Ctx.getObjCMetadataUpdateCallbackAvailability();
+    if (attr->CategoryName.empty() &&
+        !deploymentAvailability.isContainedIn(metadataUpdateAvailability)) {
+      auto currentPlatform = targetPlatform(Ctx.LangOpts);
+      diagnose(attr->getLocation(),
+               diag::attr_objc_implementation_raise_minimum_deployment_target,
+               prettyPlatformString(currentPlatform),
+               metadataUpdateAvailability.getOSVersion().getLowerEndpoint());
+    }
   }
   else if (auto AFD = dyn_cast<AbstractFunctionDecl>(D)) {
     if (!hasObjCImplementationFeature(D, attr, Feature::CImplementation))

stdlib/public/runtime/Metadata.cpp

@@ -3980,36 +3980,10 @@ swift::swift_updatePureObjCClassMetadata(Class cls,
                                          ClassLayoutFlags flags,
                                          size_t numFields,
                                          const TypeLayout * const *fieldTypes) {
-  auto self = (ObjCClass *)cls;
-  bool requiresUpdate = SWIFT_RUNTIME_WEAK_CHECK(_objc_realizeClassFromSwift);
-
-  // Realize the superclass first.
-  (void)swift_getInitializedObjCClass((Class)self->Isa);
-
-  auto rodata = getROData(self);
-
-  // If we're running on a older Objective-C runtime, just realize
-  // the class.
-  if (!requiresUpdate) {
-    // If we don't have a backward deployment layout, we cannot proceed here.
-    if (rodata->InstanceSize == 0) {
-      fatalError(0, "class %s does not have a fragile layout; "
-                 "the deployment target was newer than this OS\n",
-                 rodata->Name);
-    }
-
-    // Realize the class. This causes the runtime to slide the field offsets
-    // stored in the field offset globals.
-    //
-    // Note that the field offset vector is *not* updated; however in
-    // Objective-C interop mode, we don't actually use the field offset vector
-    // of non-generic classes.
-    //
-    // In particular, class mirrors always use the Objective-C ivar descriptors,
-    // which point at field offset globals and not the field offset vector.
-    swift_getInitializedObjCClass((Class)self);
-    return cls;
-  }
+  bool hasRealizeClassFromSwift =
+    SWIFT_RUNTIME_WEAK_CHECK(_objc_realizeClassFromSwift);
+  assert(hasRealizeClassFromSwift);
+  (void)hasRealizeClassFromSwift;
 
   SWIFT_DEFER {
     // Realize the class. This causes the runtime to slide the field offsets
@@ -4019,7 +3993,10 @@ swift::swift_updatePureObjCClassMetadata(Class cls,
 
   // Update the field offset globals using runtime type information; the layout
   // of resilient types might be different than the statically-emitted layout.
+  ObjCClass *self = (ObjCClass *)cls;
+  ClassROData *rodata = getROData(self);
   ClassIvarList *ivars = rodata->IvarList;
+
   if (!ivars) {
     assert(numFields == 0);
     return cls;

test/decl/ext/objc_implementation_deployment_target.swift

@@ -0,0 +1,14 @@
+// Hardcode x86_64 macOS because Apple Silicon was born ABI-stable
+// RUN: %target-typecheck-verify-swift -import-objc-header %S/Inputs/objc_implementation.h -target x86_64-apple-macosx10.14.3
+// REQUIRES: objc_interop
+// REQUIRES: OS=macosx
+
+@_objcImplementation extension ObjCImplSubclass {
+  // expected-error@-1 {{'@implementation' of an Objective-C class requires a minimum deployment target of at least macOS 10.14.4}}
+}
+
+@_objcImplementation(Conformance) extension ObjCClass {
+  // no-error@-1
+  func requiredMethod1() {}
+  func requiredMethod2() {}
+}