Merge pull request #60630 from beccadax/at-implementation

Add @_objcImplementation

Author: beccadax

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -676,7 +676,80 @@ be added to a given type, while `@_nonSendable` indicates that an unavailable
 `(_assumed)` after it, in which case `@Sendable` "beats" it.
 `@_nonSendable(_assumed)` is intended to be used when mass-marking whole regions
 of a header as non-`Sendable` so that you can make spot exceptions with
-`@Sendable`.   
+`@Sendable`.
+
+## `@_objcImplementation(CategoryName)`
+
+Declares an extension that defines an implementation for the Objective-C
+category `CategoryName` on the class in question, or for the main `@interface`
+if the argument list is omitted.
+
+This attribute is used to write fully Objective-C-compatible implementations in
+Swift. Normal Objective-C interop allows Objective-C clients to use instances of
+the subclass, but not to subclass them, and uses a generated header that is not
+meant to be read by humans. `@_objcImplementation`, on the other hand, creates
+classes that are virtually indistinguishable from classes implemented in native 
+Objective-C: they do not have a Swift vtable or any other Swift-specific
+metadata, Swift does not use any special knowledge of the class's "Swiftiness" 
+when using the class so ObjC runtime calls work correctly and they can even be 
+subclassed by Objective-C code, and you write a header for the class by hand 
+that looks exactly like an equivalent ObjC class. Clients should not notice if 
+you replace a native Objective-C `@implementation Foo (Bar)` with a Swift 
+`@_objcImplementation(Bar) extension Foo`.
+
+You create a class with this feature very differently from normal ObjC interop:
+
+1. Hand-write headers that declare the class's Objective-C interface, just as
+   you would for a native Objective-C class. Since you're handwriting these
+   headers, you can write them just as you would for an Objective-C class:
+   splitting them across multiple files, grouping related declarations together,
+   adding comments, declaring Swift behavior using C attributes or API notes,
+   etc.
+   
+2. Import your headers into Swift using a bridging header or umbrella header so
+   Swift can see them.
+
+3. Implement your class using a mixture of `@implementation` declarations in
+   `.m` files and `@_objcImplementation extension`s in `.swift` files. Each
+   `@interface` should have exactly one corresponding implementation; don't try
+   to implement some members of a single `@interface` in ObjC and others in
+   Swift.
+
+   * To implement the main `@interface` of a class in Swift, use
+     `@_objcImplementation extension ClassName`.
+     
+   * To implement a category in Swift, use
+     `@_objcImplementation(CategoryName) extension ClassName`.
+     
+The members of an `@_objcImplementation` extension should fall into one of
+three categories:
+   
+* **Swift-only members** include any member marked `final`. These are not
+  `@objc` or `dynamic` and are only callable from Swift. Use these for
+  Swift-only APIs, random helper methods, etc. 
+    
+* **ObjC helper members** include any non-`final` member marked `fileprivate`
+  or `private`. These are implicitly `@objc dynamic`. Use these for action
+  methods, selector-based callbacks, and other situations where you need a
+  helper method to be accessible from an Objective-C message.
+  
+* **Member implementations** include any other non-`final` member. These are
+  implicitly `@objc dynamic` and must match a member declared in the
+  Objective-C header. Use these to implement the APIs declared in your
+  headers. Swift will emit an error if these don't match your headers.
+
+Notes:
+
+* We don't currently plan to support ObjC generics.
+
+* Eventually, we want the main `@_objcImplementation` extension to be able to
+  declare stored properties that aren't in the interface. We also want
+  `final` stored properties to be allowed to be resilent Swift types, but
+  it's not clear how to achieve that without boxing them in `__SwiftValue`
+  (which we might do as a stopgap).
+     
+* We should think about ObjC "direct" members, but that would probably
+  require a way to spell this in Swift. 
 
 ## `@_objc_non_lazy_realization`
 

include/swift/AST/Attr.h

@@ -172,6 +172,10 @@ class DeclAttribute : public AttributeBase {
       kind : NumKnownProtocolKindBits,
       isUnchecked : 1
     );
+
+    SWIFT_INLINE_BITFIELD(ObjCImplementationAttr, DeclAttribute, 1,
+      isCategoryNameInvalid : 1
+    );
   } Bits;
 
   DeclAttribute *Next = nullptr;
@@ -2275,6 +2279,31 @@ class DocumentationAttr: public DeclAttribute {
   }
 };
 
+class ObjCImplementationAttr final : public DeclAttribute {
+public:
+  Identifier CategoryName;
+
+  ObjCImplementationAttr(Identifier CategoryName, SourceLoc AtLoc,
+                         SourceRange Range, bool Implicit = false,
+                         bool isCategoryNameInvalid = false)
+    : DeclAttribute(DAK_ObjCImplementation, AtLoc, Range, Implicit),
+      CategoryName(CategoryName) {
+    Bits.ObjCImplementationAttr.isCategoryNameInvalid = isCategoryNameInvalid;
+  }
+
+  bool isCategoryNameInvalid() const {
+    return Bits.ObjCImplementationAttr.isCategoryNameInvalid;
+  }
+
+  void setCategoryNameInvalid(bool newValue = true) {
+    Bits.ObjCImplementationAttr.isCategoryNameInvalid = newValue;
+  }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_ObjCImplementation;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/Decl.h

@@ -723,6 +723,13 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 private:
   llvm::PointerUnion<DeclContext *, ASTContext *> Context;
 
+  /// The imported Clang declaration representing the \c @_objcInterface for
+  /// this declaration (or vice versa), or \c nullptr if there is none.
+  ///
+  /// If \c this (an otherwise nonsensical value), the value has not yet been
+  /// computed.
+  Decl *CachedObjCImplementationDecl;
+
   Decl(const Decl&) = delete;
   void operator=(const Decl&) = delete;
   SourceLoc getLocFromSource() const;
@@ -740,7 +747,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
 protected:
 
   Decl(DeclKind kind, llvm::PointerUnion<DeclContext *, ASTContext *> context)
-    : Context(context) {
+    : Context(context), CachedObjCImplementationDecl(this) {
     Bits.OpaqueBits = 0;
     Bits.Decl.Kind = unsigned(kind);
     Bits.Decl.Invalid = false;
@@ -975,6 +982,32 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     return getClangNodeImpl().getAsMacro();
   }
 
+  /// If this is the Swift implementation of a declaration imported from ObjC,
+  /// returns the imported declaration. Otherwise return \c nullptr.
+  ///
+  /// \seeAlso ExtensionDecl::isObjCInterface()
+  Decl *getImplementedObjCDecl() const;
+
+  /// If this is the ObjC interface of a declaration implemented in Swift,
+  /// returns the implementating declaration. Otherwise return \c nullptr.
+  ///
+  /// \seeAlso ExtensionDecl::isObjCInterface()
+  Decl *getObjCImplementationDecl() const;
+
+  Optional<Decl *> getCachedObjCImplementationDecl() const {
+    if (CachedObjCImplementationDecl == this)
+      return None;
+    return CachedObjCImplementationDecl;
+  }
+
+  void setCachedObjCImplementationDecl(Decl *decl) {
+    assert((CachedObjCImplementationDecl == this
+              || CachedObjCImplementationDecl == decl)
+               && "can't change CachedObjCInterfaceDecl once it's computed");
+    assert(decl != this && "can't form circular reference");
+    CachedObjCImplementationDecl = decl;
+  }
+
   /// Return the GenericContext if the Decl has one.
   LLVM_READONLY
   const GenericContext *getAsGenericContext() const;
@@ -1496,6 +1529,16 @@ class ExtensionDecl final : public GenericContext, public Decl,
   /// resiliently moved into the original protocol itself.
   bool isEquivalentToExtendedContext() const;
 
+  /// True if this extension provides an implementation for an imported
+  /// Objective-C \c \@interface. This implies various restrictions and special
+  /// behaviors for its members.
+  bool isObjCImplementation() const;
+
+  /// Returns the name of the category specified by the \c \@_objcImplementation
+  /// attribute, or \c None if the name is invalid. Do not call unless
+  /// \c isObjCImplementation() returns \c true.
+  Optional<Identifier> getCategoryNameForObjCImplementation() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Extension;
@@ -4460,6 +4503,12 @@ class ClassDecl final : public NominalTypeDecl {
   /// the Objective-C runtime.
   StringRef getObjCRuntimeName(llvm::SmallVectorImpl<char> &buffer) const;
 
+  /// Return the imported declaration for the category with the given name; this
+  /// will always be an Objective-C-backed \c ExtensionDecl or, if \p name is
+  /// empty, \c ClassDecl. Returns \c nullptr if the class was not imported from
+  /// Objective-C or does not have an imported category by that name.
+  IterableDeclContext *getImportedObjCCategory(Identifier name) const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Class;

include/swift/AST/DeclContext.h

@@ -507,6 +507,11 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
   LLVM_READONLY
   DeclContext *getModuleScopeContext() const;
 
+  /// If this DeclContext is an \c \@_objcImplementation extension, returns the
+  /// \c DeclContext for the Objective-C declaration it implements. Otherwise
+  /// returns \c this.
+  DeclContext *getImplementedObjCContext() const;
+
   /// Returns the source file that contains this context, or null if this
   /// is not within a source file.
   LLVM_READONLY
@@ -824,6 +829,11 @@ class IterableDeclContext {
   /// abstractions on top of member loading, such as a name lookup table.
   DeclRange getCurrentMembersWithoutLoading() const;
 
+  /// Return the context that contains the actual implemented members. This
+  /// is \em usually just \c this, but if \c this is an imported class or
+  /// category, it may be a Swift extension instead.
+  IterableDeclContext *getImplementationContext();
+
   /// Add a member to this context.
   ///
   /// If the hint decl is specified, the new decl is inserted immediately

include/swift/AST/DiagnosticsClangImporter.def

@@ -133,6 +133,13 @@ WARNING(api_pattern_attr_ignored, none,
         "'%0' swift attribute ignored on type '%1': type is not copyable or destructible",
         (StringRef, StringRef))
 
+ERROR(objc_implementation_two_impls, none,
+      "duplicate implementation of Objective-C %select{|category %0 on }0"
+      "class %1",
+      (Identifier, ValueDecl *))
+NOTE(previous_objc_implementation, none,
+     "previously implemented by extension here", ())
+
 NOTE(macro_not_imported_unsupported_operator, none, "operator not supported in macro arithmetic", ())
 NOTE(macro_not_imported_unsupported_named_operator, none, "operator '%0' not supported in macro arithmetic", (StringRef))
 NOTE(macro_not_imported_invalid_string_literal, none, "invalid string literal", ())

include/swift/AST/DiagnosticsSema.def

@@ -1492,6 +1492,42 @@ ERROR(swift_native_objc_runtime_base_not_on_root_class,none,
       "@_swift_native_objc_runtime_base_not_on_root_class can only be applied "
       "to root classes", ())
 
+ERROR(attr_objc_implementation_must_be_unconditional,none,
+      "only unconditional extensions can implement an Objective-C '@interface'",
+      ())
+ERROR(attr_objc_implementation_must_extend_class,none,
+      "cannot mark extension of %0 %1 with '@_objcImplementation'; it is not "
+      "an imported Objective-C class",
+      (DescriptiveDeclKind, ValueDecl *))
+ERROR(attr_objc_implementation_must_be_imported,none,
+      "'@_objcImplementation' cannot be used to extend %0 %1 because it was "
+      "defined by a Swift 'class' declaration, not an imported Objective-C "
+      "'@interface' declaration",
+      (DescriptiveDeclKind, ValueDecl *))
+ERROR(attr_objc_implementation_category_not_found,none,
+      "could not find category %0 on Objective-C class %1; make sure your "
+      "umbrella or bridging header imports the header that declares it",
+      (Identifier, ValueDecl*))
+NOTE(attr_objc_implementation_fixit_remove_category_name,none,
+     "remove arguments to implement the main '@interface' for this class",
+     ())
+ERROR(attr_objc_implementation_no_objc_final,none,
+      "%0 %1 cannot be 'final' because Objective-C subclasses of %2 can "
+      "override it",
+      (DescriptiveDeclKind, ValueDecl *, ValueDecl *))
+
+ERROR(member_of_objc_implementation_not_objc_or_final,none,
+      "%0 %1 does not match any %0 declared in the headers for %2; did you use "
+      "the %0's Swift name?",
+      (DescriptiveDeclKind, ValueDecl *, ValueDecl *))
+NOTE(fixit_add_objc_for_objc_implementation,none,
+     "add '@objc' to define an Objective-C-compatible %0 not declared in "
+     "the header",
+     (DescriptiveDeclKind))
+NOTE(fixit_add_final_for_objc_implementation,none,
+     "add 'final' to define a Swift %0 that cannot be overridden",
+     (DescriptiveDeclKind))
+
 ERROR(cdecl_not_at_top_level,none,
       "@_cdecl can only be applied to global functions", ())
 ERROR(cdecl_empty_name,none,

include/swift/AST/Identifier.h

@@ -94,7 +94,9 @@ class Identifier {
 
   bool empty() const { return Pointer == nullptr; }
 
-  bool is(StringRef string) const { return str().equals(string); }
+  LLVM_ATTRIBUTE_USED bool is(StringRef string) const {
+    return str().equals(string);
+  }
 
   /// isOperator - Return true if this identifier is an operator, false if it is
   /// a normal identifier.

include/swift/AST/TypeMemberVisitor.h

@@ -59,6 +59,24 @@ class TypeMemberVisitor : public DeclVisitor<ImplClass, RetTy> {
       asImpl().visit(member);
     }
   }
+
+  /// A convenience method to visit all the members in the implementation
+  /// context.
+  ///
+  /// \seealso IterableDeclContext::getImplementationContext()
+  void visitImplementationMembers(NominalTypeDecl *D) {
+    for (Decl *member : D->getImplementationContext()->getMembers()) {
+      asImpl().visit(member);
+    }
+    
+    // If this is a main-interface @_objcImplementation extension and the class
+    // has a synthesized destructor, visit it now.
+    if (auto cd = dyn_cast_or_null<ClassDecl>(D)) {
+      auto dd = cd->getDestructor();
+      if (dd->getDeclContext() == cd && cd->getImplementationContext() != cd)
+        asImpl().visit(dd);
+    }
+  }
 };
 
 template<typename ImplClass, typename RetTy = void>
@@ -70,6 +88,10 @@ class ClassMemberVisitor : public TypeMemberVisitor<ImplClass, RetTy> {
   void visitMembers(ClassDecl *D) {
     TypeMemberVisitor<ImplClass, RetTy>::visitMembers(D);
   }
+
+  void visitImplementationMembers(ClassDecl *D) {
+    TypeMemberVisitor<ImplClass, RetTy>::visitImplementationMembers(D);
+  }
 };
 
 #undef BAD_MEMBER