Add basic Sema support for @_objcImplementation

Does not validate members yet; nor does it emit different metadata.

Author: beccadax

docs/ReferenceGuides/UnderscoredAttributes.md

@@ -676,7 +676,73 @@ 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 classes' 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`.
+     
+   * We should think about Objective-C generics.
+
+4. Every member of an `@_objcImplementation` extension should be either `@objc`
+   or `final`. The `final` members can be made `public` if you want to expose
+   them to Swift clients. The `@objc` members are implicitly `dynamic`.
+   
+   * Eventually, we'd like to allow members which are not explicitly marked
+     `@objc`. The compiler will check that they match something declared in the
+     header, and if they do, it will automatically apply appropriate attributes.
+     If not, it will reject them. Members with an explicit `@objc` will not be
+     checked, so you can define helpers that are callable by selector but not in
+     any header.
+  
+   * 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.
+      
+   * Access control design for ObjC methods TBD.
 
 ## `@_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;
@@ -2289,6 +2293,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

@@ -1496,6 +1496,18 @@ 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 \c clang::ObjCCategoryDecl or \c clang::ObjCInterfaceDecl
+  /// implemented by this extension.
+  ///
+  /// This can return \c nullptr if the category doesn't exist. Do not call it
+  /// unless \c isObjCImplementation() returns \c true.
+  const clang::ObjCContainerDecl *getInterfaceForObjCImplementation() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Extension;
@@ -4359,6 +4371,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.
+  Decl *getImportedObjCCategory(Identifier name) const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Class;

include/swift/AST/DiagnosticsSema.def

@@ -1492,6 +1492,26 @@ 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(cdecl_not_at_top_level,none,
       "@_cdecl can only be applied to global functions", ())
 ERROR(cdecl_empty_name,none,

include/swift/ClangImporter/ClangImporterRequests.h

@@ -178,6 +178,58 @@ class ClangRecordMemberLookup
   evaluate(Evaluator &evaluator, ClangRecordMemberLookupDescriptor desc) const;
 };
 
+/// The input type for a clang category lookup request.
+struct ClangCategoryLookupDescriptor final {
+  const ClassDecl *classDecl;
+  Identifier categoryName;
+
+  ClangCategoryLookupDescriptor(const ClassDecl *classDecl,
+                                Identifier categoryName)
+      : classDecl(classDecl), categoryName(categoryName) {}
+
+  friend llvm::hash_code hash_value(const ClangCategoryLookupDescriptor &desc) {
+    return llvm::hash_combine(desc.classDecl, desc.categoryName);
+  }
+
+  friend bool operator==(const ClangCategoryLookupDescriptor &lhs,
+                         const ClangCategoryLookupDescriptor &rhs) {
+    return lhs.classDecl == rhs.classDecl
+               && lhs.categoryName == rhs.categoryName;
+  }
+
+  friend bool operator!=(const ClangCategoryLookupDescriptor &lhs,
+                         const ClangCategoryLookupDescriptor &rhs) {
+    return !(lhs == rhs);
+  }
+};
+
+void simple_display(llvm::raw_ostream &out,
+                    const ClangCategoryLookupDescriptor &desc);
+SourceLoc extractNearestSourceLoc(const ClangCategoryLookupDescriptor &desc);
+
+/// Given a Swift class, find the imported Swift decl representing the
+/// \c \@interface with the given category name. That is, this will return an
+/// \c swift::ExtensionDecl backed by a \c clang::ObjCCategoryDecl, or a
+/// \c swift::ClassDecl backed by a \c clang::ObjCInterfaceDecl, or \c nullptr
+/// if the class is not imported from Clang or it does not have a category by
+/// that name.
+///
+/// An empty/invalid \c categoryName requests the main interface for the class.
+class ClangCategoryLookupRequest
+    : public SimpleRequest<ClangCategoryLookupRequest,
+                           Decl *(ClangCategoryLookupDescriptor),
+                           RequestFlags::Uncached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  Decl *evaluate(Evaluator &evaluator,
+                 ClangCategoryLookupDescriptor desc) const;
+};
+
 enum class CxxRecordSemanticsKind {
   Trivial,
   Owned,

include/swift/ClangImporter/ClangImporterTypeIDZone.def

@@ -24,6 +24,9 @@ SWIFT_REQUEST(ClangImporter, CXXNamespaceMemberLookup,
 SWIFT_REQUEST(ClangImporter, ClangRecordMemberLookup,
               Decl *(ClangRecordMemberLookupDescriptor), Uncached,
               NoLocationInfo)
+SWIFT_REQUEST(ClangImporter, ClangCategoryLookupRequest,
+              Decl *(ClangCategoryLookupDescriptor), Uncached,
+              NoLocationInfo)
 SWIFT_REQUEST(ClangImporter, CxxRecordSemantics,
               CxxRecordSemanticsKind(const clang::CXXRecordDecl *), Cached,
               NoLocationInfo)

lib/AST/Attr.cpp

@@ -1356,6 +1356,8 @@ StringRef DeclAttribute::getAttrName() const {
   case DAK_ObjC:
   case DAK_ObjCRuntimeName:
     return "objc";
+  case DAK_ObjCImplementation:
+    return "_objcImplementation";
   case DAK_MainType:
     return "main";
   case DAK_DynamicReplacement:

lib/AST/Decl.cpp

@@ -1465,6 +1465,31 @@ Type ExtensionDecl::getExtendedType() const {
   return ErrorType::get(ctx);
 }
 
+bool ExtensionDecl::isObjCImplementation() const {
+  return getAttrs().hasAttribute<ObjCImplementationAttr>();
+}
+
+const clang::ObjCContainerDecl *
+ExtensionDecl::getInterfaceForObjCImplementation() const {
+  assert(isObjCImplementation());
+
+  auto attr = getAttrs().getAttribute<ObjCImplementationAttr>();
+  if (attr->isCategoryNameInvalid())
+    return nullptr;
+
+  auto CD = dyn_cast_or_null<ClassDecl>(getExtendedNominal());
+  if (!CD)
+    return nullptr;
+
+  auto importedDecl = CD->getImportedObjCCategory(attr->CategoryName);
+  if (!importedDecl)
+    return nullptr;
+
+  assert(importedDecl->hasClangNode() &&
+         "@interface imported as clang-node-less decl?");
+  return cast<clang::ObjCContainerDecl>(importedDecl->getClangDecl());
+}
+
 PatternBindingDecl::PatternBindingDecl(SourceLoc StaticLoc,
                                        StaticSpellingKind StaticSpelling,
                                        SourceLoc VarLoc,

lib/ClangImporter/ClangImporter.cpp

@@ -5024,6 +5024,56 @@ TinyPtrVector<ValueDecl *> ClangRecordMemberLookup::evaluate(
   return result;
 }
 
+Decl *ClangCategoryLookupRequest::
+evaluate(Evaluator &evaluator, ClangCategoryLookupDescriptor desc) const {
+  const ClassDecl *CD = desc.classDecl;
+  Identifier categoryName = desc.categoryName;
+
+  auto clangClass =
+      dyn_cast_or_null<clang::ObjCInterfaceDecl>(CD->getClangDecl());
+  if (!clangClass)
+    return nullptr;
+
+  if (categoryName.empty())
+    // No category name, so we want the decl for the `@interface` in
+    // `clangClass`.
+    return const_cast<ClassDecl *>(CD);
+
+  auto ident = &clangClass->getASTContext().Idents.get(categoryName.str());
+  auto clangCategory = clangClass->FindCategoryDeclaration(ident);
+  if (!clangCategory)
+    return nullptr;
+
+  ASTContext &ctx = CD->getASTContext();
+  return ctx.getClangModuleLoader()->importDeclDirectly(clangCategory);
+}
+
+Decl *ClassDecl::getImportedObjCCategory(Identifier name) const {
+  ClangCategoryLookupDescriptor desc{this, name};
+  return evaluateOrDefault(getASTContext().evaluator,
+                           ClangCategoryLookupRequest(desc),
+                           nullptr);
+}
+
+void swift::simple_display(llvm::raw_ostream &out,
+                           const ClangCategoryLookupDescriptor &desc) {
+  out << "Looking up @interface for ";
+  if (!desc.categoryName.empty()) {
+    out << "category ";
+    simple_display(out, desc.categoryName);
+  }
+  else {
+    out << "main body";
+  }
+  out << " of ";
+  simple_display(out, desc.classDecl);
+}
+
+SourceLoc
+swift::extractNearestSourceLoc(const ClangCategoryLookupDescriptor &desc) {
+  return extractNearestSourceLoc(desc.classDecl);
+}
+
 TinyPtrVector<ValueDecl *>
 ClangImporter::Implementation::loadNamedMembers(
     const IterableDeclContext *IDC, DeclBaseName N, uint64_t contextData) {

lib/Parse/ParseDecl.cpp

@@ -2858,6 +2858,16 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
     Attributes.add(attr);
     break;
   }
+  case DAK_ObjCImplementation: {
+    SourceRange range;
+    auto name = parseSingleAttrOptionIdentifier(*this, Loc, range, AttrName, DK,
+                                                /*allowOmitted=*/true);
+    if (!name)
+      return false;
+
+    Attributes.add(new (Context) ObjCImplementationAttr(*name, AtLoc, range));
+    break;
+  }
   case DAK_ObjCRuntimeName: {
     SourceRange range;
     auto name =