Omit @objcImpl from module interfaces

Module interfaces should not include the @objcImplementation attribute, member implementations that are redundant with the ObjC header, or anything that would be invalid in an ordinary extension (e.g. overridden initializers, stored Swift-only properties).

lib/AST/ASTPrinter.cpp

@@ -137,6 +137,11 @@ static bool contributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
   return !ND->isResilient() && ASD->hasStorage() && !ASD->isStatic();
 }
 
+static bool isInObjCImpl(const ValueDecl *VD) {
+  auto *ED = dyn_cast<ExtensionDecl>(VD->getDeclContext());
+  return ED && ED->isObjCImplementation();
+}
+
 PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                                    bool preferTypeRepr,
                                                    bool printFullConvention,
@@ -208,9 +213,9 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
       if (!options.PrintSPIs && D->isSPI())
         return false;
 
+      if (auto *VD = dyn_cast<ValueDecl>(D)) {
         // Skip anything that isn't 'public' or '@usableFromInline' or has a
         // _specialize attribute with a targetFunction parameter.
-      if (auto *VD = dyn_cast<ValueDecl>(D)) {
         if (!isPublicOrUsableFromInline(VD) &&
             !isPrespecilizationDeclWithTarget(VD)) {
           // We do want to print private stored properties, without their
@@ -221,6 +226,13 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
 
           return false;
         }
+
+        // Skip member implementations and @objc overrides in @objcImpl
+        // extensions.
+        if (VD->isObjCMemberImplementation()
+            || (isInObjCImpl(VD) && VD->getOverriddenDecl() && VD->isObjC())) {
+          return false;
+        }
       }
 
       // Skip extensions that extend things we wouldn't print.
@@ -312,6 +324,7 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
     DAK_AccessControl,
     DAK_SetterAccess,
     DAK_Lazy,
+    DAK_ObjCImplementation,
     DAK_StaticInitializeObjCMetadata,
     DAK_RestatedObjCConformance,
     DAK_NonSendable,
@@ -1125,8 +1138,10 @@ void PrintAST::printAttributes(const Decl *D) {
 
     if (auto vd = dyn_cast<VarDecl>(D)) {
       // Don't print @_hasInitialValue if we're printing an initializer
-      // expression or if the storage is resilient.
-      if (vd->isInitExposedToClients() || vd->isResilient())
+      // expression, if the storage is resilient, or if it's in an
+      // @objcImplementation extension (where final properties should appear
+      // computed).
+      if (vd->isInitExposedToClients() || vd->isResilient() || isInObjCImpl(vd))
         Options.ExcludeAttrList.push_back(DAK_HasInitialValue);
 
       if (!Options.PrintForSIL) {
@@ -2105,8 +2120,9 @@ void PrintAST::printAccessors(const AbstractStorageDecl *ASD) {
   // Don't print accessors for trivially stored properties...
   if (impl.isSimpleStored()) {
     // ...unless we're printing for SIL, which expects a { get set? } on
-    //    trivial properties
-    if (Options.PrintForSIL) {
+    //    trivial properties, or in an @objcImpl extension, which treats
+    //    final stored properties as computed.
+    if (Options.PrintForSIL || isInObjCImpl(ASD)) {
       Printer << " { get " << (impl.supportsMutation() ? "set }" : "}");
     }
     // ...or you're private/internal(set), at which point we'll print

test/ModuleInterface/Inputs/objc_implementation/module.modulemap

@@ -0,0 +1,4 @@
+module objc_implementation {
+  header "objc_implementation.h"
+  export *
+}

test/ModuleInterface/Inputs/objc_implementation/objc_implementation.h

@@ -0,0 +1,41 @@
+#import <Foundation/Foundation.h>
+
+@interface ImplClass: NSObject
+
+- (nonnull instancetype)init;
+
+@property (assign) int implProperty;
+
+- (void)mainMethod:(int)param;
+
+@end
+
+
+@interface ImplClass (Category1)
+
+- (void)category1Method:(int)param;
+
+@end
+
+
+@interface ImplClass (Category2)
+
+- (void)category2Method:(int)param;
+
+@end
+
+
+@interface NoImplClass
+
+- (void)noImplMethod:(int)param;
+
+@end
+
+@interface NoInitImplClass: NSObject
+
+@property (readonly, strong, nonnull) NSString *s1;
+@property (strong, nonnull) NSString *s2;
+@property (readonly, strong, nonnull) NSString *s3;
+@property (strong, nonnull) NSString *s4;
+
+@end

test/ModuleInterface/objc_implementation.swift

@@ -0,0 +1,84 @@
+// RUN: %target-swift-frontend(mock-sdk: %clang-importer-sdk) -emit-module -I %S/Inputs/objc_implementation -F %clang-importer-sdk-path/frameworks %s -import-underlying-module -swift-version 5 -enable-library-evolution -emit-module-interface-path %t.swiftinterface
+// RUN: %FileCheck --input-file %t.swiftinterface %s
+// RUN: %FileCheck --input-file %t.swiftinterface --check-prefix NEGATIVE %s
+// REQUIRES: objc_interop
+
+// We should never see @_objcImplementation in the header
+// NEGATIVE-NOT: @_objcImplementation
+
+//
+// @_objcImplementation class
+//
+
+// CHECK-LABEL: extension objc_implementation.ImplClass {
+@_objcImplementation extension ImplClass {
+  // CHECK-NOT: init()
+  @objc public override init() {
+    implProperty = 42
+    implProperty2 = NSObject()
+    super.init()
+  }
+
+  // CHECK-NOT: var implProperty:
+  @objc public var implProperty: Int32 {
+    didSet { print(implProperty) }
+  }
+
+  // CHECK-DAG: final public var implProperty2: ObjectiveC.NSObject? { get set }
+  public final var implProperty2: NSObject?
+
+  // CHECK-NOT: func mainMethod
+  @objc public func mainMethod(_: Int32) { print(implProperty) }
+
+  // CHECK-NOT: deinit
+}
+// CHECK: }
+
+//
+// @_objcImplementation category
+//
+
+// Empty category should be omitted, so there's only one `extension ImplClass`.
+// CHECK-NOT: extension objc_implementation.ImplClass {
+@_objcImplementation(Category1) extension ImplClass {
+  // NEGATIVE-NOT: func category1Method
+  @objc public func category1Method(_: Int32) {
+    print("category1Method")
+  }
+}
+
+//
+// Second @_objcImplementation class, inherited initializer
+//
+
+// NEGATIVE-NOT: extension objc_implementation.NoInitImplClass
+@_objcImplementation extension NoInitImplClass {
+  // NEGATIVE-NOT: var s1:
+  @objc public let s1 = "s1v"
+  // NEGATIVE-NOT: var s2:
+  @objc public var s2 = "s2v"
+  // NEGATIVE-NOT: var s3:
+  @objc(s3) public let s3 = "s3v"
+  // NEGATIVE-NOT: var s4:
+  @objc(s4) public var s4 = "s4v"
+}
+
+//
+// @objc subclass of @_objcImplementation class
+//
+
+// CHECK-LABEL: @objc @_inheritsConvenienceInitializers open class SwiftSubclass : objc_implementation.ImplClass {
+open class SwiftSubclass: ImplClass {
+  // CHECK-DAG: @objc override dynamic open func mainMethod
+  override open func mainMethod(_: Int32) {
+    print("subclass mainMethod")
+  }
+
+  // CHECK-DAG: @objc dynamic public init()
+  // CHECK-DAG: @objc deinit
+}
+// CHECK: }
+
+//
+// Epilogue
+//