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

@@ -1778,6 +1778,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

@@ -1573,6 +1573,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 (!attr->CategoryName.empty()) {

stdlib/public/runtime/Metadata.cpp

@@ -25,6 +25,7 @@
 #include "MetadataCache.h"
 #include "BytecodeLayouts.h"
 #include "swift/ABI/TypeIdentity.h"
+#include "swift/Basic/Defer.h"
 #include "swift/Basic/MathUtils.h"
 #include "swift/Basic/Lazy.h"
 #include "swift/Basic/Range.h"
@@ -3980,7 +3981,6 @@ swift::swift_updatePureObjCClassMetadata(Class cls,
                                          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);
@@ -3990,38 +3990,21 @@ swift::swift_updatePureObjCClassMetadata(Class cls,
   auto rodata = getROData(self);
   self->RODataAndFlags = (uintptr_t)rodata;
 
-  // 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);
-    }
+  bool requiresRealizeClassFromSwift =
+    SWIFT_RUNTIME_WEAK_CHECK(_objc_realizeClassFromSwift);
+  assert(requiresRealizeClassFromSwift);
 
+  SWIFT_DEFER {
     // 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;
-  }
+    SWIFT_RUNTIME_WEAK_USE(_objc_realizeClassFromSwift(cls, cls));
+  };
 
   // Update the field offset globals using runtime type information; the layout
   // of resilient types might be different than the statically-emitted layout.
   ClassIvarList *ivars = rodata->IvarList;
   if (!ivars) {
     assert(numFields == 0);
-
-    // See remark above about how this slides field offset globals.
-    SWIFT_RUNTIME_WEAK_USE(_objc_realizeClassFromSwift(cls, cls));
-
     return cls;
   }
 
@@ -4030,16 +4013,12 @@ swift::swift_updatePureObjCClassMetadata(Class cls,
 
   bool copiedIvarList = false;
 
-  // Update the field offset globals using runtime type information; the layout
-  // of resilient types might be different than the statically-emitted layout.
-  size_t size, alignMask;
-
   // Start layout from our static notion of where the superclass starts.
   // Objective-C expects us to have generated a correct ivar layout, which it
   // will simply slide if it needs to.
   assert(self->Superclass && "Swift cannot implement a root class");
-  size = rodata->InstanceStart;
-  alignMask = 0xF; // malloc alignment guarantee
+  size_t size = rodata->InstanceStart;
+  size_t alignMask = 0xF; // malloc alignment guarantee
 
   // Okay, now do layout.
   for (unsigned i = 0; i != numFields; ++i) {
@@ -4092,9 +4071,6 @@ swift::swift_updatePureObjCClassMetadata(Class cls,
   if (rodata->InstanceSize != size)
     rodata->InstanceSize = size;
 
-  // See remark above about how this slides field offset globals.
-  SWIFT_RUNTIME_WEAK_USE(_objc_realizeClassFromSwift(cls, cls));
-
   return cls;
 }
 #endif

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() {}
+}