Generate IR for @_objcImpls

This commit begins to generate correct metadata for @_objcImplementation extensions:

• Swift-specific metadata and symbols are not generated.
• For main-class @_objcImpls, we visit the class to emit metadata, but visit the extension’s members.
• Includes both IR tests and executable tests, including coverage of same-module @objc subclasses, different-module @objc subclasses, and clang subclasses.

The test cases do not yet cover stored properties.

Author: beccadax

include/swift/AST/TypeMemberVisitor.h

@@ -59,6 +59,16 @@ 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);
+    }
+  }
 };
 
 template<typename ImplClass, typename RetTy = void>
@@ -70,6 +80,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

include/swift/IRGen/Linking.h

@@ -810,6 +810,7 @@ class LinkEntity {
 
   static LinkEntity forTypeMetadata(CanType concreteType,
                                     TypeMetadataAddress addr) {
+    assert(!isObjCImplementation(concreteType));
     LinkEntity entity;
     entity.setForType(Kind::TypeMetadata, concreteType);
     entity.Data |= LINKENTITY_SET_FIELD(MetadataAddress, unsigned(addr));
@@ -872,12 +873,14 @@ class LinkEntity {
   }
 
   static LinkEntity forNominalTypeDescriptor(NominalTypeDecl *decl) {
+    assert(!isObjCImplementation(decl));
     LinkEntity entity;
     entity.setForDecl(Kind::NominalTypeDescriptor, decl);
     return entity;
   }
 
   static LinkEntity forNominalTypeDescriptorRecord(NominalTypeDecl *decl) {
+    assert(!isObjCImplementation(decl));
     LinkEntity entity;
     entity.setForDecl(Kind::NominalTypeDescriptorRecord, decl);
     return entity;
@@ -1553,6 +1556,16 @@ class LinkEntity {
   bool isAlwaysSharedLinkage() const;
 #undef LINKENTITY_GET_FIELD
 #undef LINKENTITY_SET_FIELD
+
+private:
+  static bool isObjCImplementation(NominalTypeDecl *NTD) {
+    if (NTD)
+      return NTD->getObjCImplementationDecl();
+    return false;
+  }
+  static bool isObjCImplementation(CanType ty) {
+    return isObjCImplementation(ty->getClassOrBoundGenericClass());
+  }
 };
 
 struct IRLinkage {

lib/IRGen/ClassLayout.h

@@ -94,7 +94,11 @@ enum class ClassMetadataFlags {
   /// or the field offset vector in the metadata, and the Objective-C runtime
   /// will slide offsets based on the actual superclass size, which is not
   /// known at compile time.
-  ClassHasObjCAncestry = (1 << 6)
+  ClassHasObjCAncestry = (1 << 6),
+
+  /// Is the class implemented by an \c @_objcImplementation extension? If so,
+  /// we should generate pure ObjC-compatible metadata.
+  ClassHasObjCImplementation = (1 << 7)
 };
 
 using ClassMetadataOptions = OptionSet<ClassMetadataFlags>;
@@ -211,6 +215,12 @@ class ClassLayout {
 
     return std::make_pair(AllFieldAccesses[index], AllElements[index]);
   }
+
+  /// Returns true if the class is implemented by an \c @_objcImplementation
+  /// extension, and therefore should not have any Swift-specific metadata.
+  bool hasObjCImplementation() const {
+    return Options.contains(ClassMetadataFlags::ClassHasObjCImplementation);
+  }
 };
 
 } // end namespace irgen

lib/IRGen/GenClass.cpp

@@ -165,6 +165,9 @@ namespace {
       auto theClass = classType.getClassOrBoundGenericClass();
       assert(theClass);
 
+      if (theClass->getObjCImplementationDecl())
+        Options |= ClassMetadataFlags::ClassHasObjCImplementation;
+
       if (theClass->isGenericContext() && !theClass->hasClangNode())
         Options |= ClassMetadataFlags::ClassIsGeneric;
 
@@ -1116,6 +1119,15 @@ namespace {
       return pair.second;
     }
 
+    Optional<StringRef> getObjCImplCategoryName() const {
+      if (!TheExtension || !TheExtension->isObjCImplementation())
+        return None;
+      if (auto ident = TheExtension->getCategoryNameForObjCImplementation()) {
+        assert(!ident->empty());
+        return ident->str();
+      }
+      return None;
+    }
     bool isBuildingClass() const {
       return TheEntity.isa<ClassUnion>() && !TheExtension;
     }
@@ -1210,11 +1222,11 @@ namespace {
         const ClassLayout &fieldLayout)
         : IGM(IGM), TheEntity(theUnion), TheExtension(nullptr),
           FieldLayout(&fieldLayout) {
-      visitConformances(getClass());
+      visitConformances(getClass()->getImplementationContext());
 
       if (getClass()->isRootDefaultActor())
         Ivars.push_back(Field::DefaultActorStorage);
-      visitMembers(getClass());
+      visitImplementationMembers(getClass());
 
       if (Lowering::usesObjCAllocator(getClass())) {
         addIVarInitializer();
@@ -1228,9 +1240,9 @@ namespace {
           FieldLayout(nullptr) {
       buildCategoryName(CategoryName);
 
-      visitConformances(theExtension);
+      visitConformances(theExtension->getImplementationContext());
 
-      for (Decl *member : TheExtension->getMembers())
+      for (Decl *member : TheExtension->getImplementationContext()->getMembers())
         visit(member);
     }
 
@@ -1379,6 +1391,12 @@ namespace {
   private:
     void buildCategoryName(SmallVectorImpl<char> &s) {
       llvm::raw_svector_ostream os(s);
+
+      if (auto implementationCategoryName = getObjCImplCategoryName()) {
+        os << *implementationCategoryName;
+        return;
+      }
+
       // Find the module the extension is declared in.
       ModuleDecl *TheModule = TheExtension->getParentModule();
 
@@ -1392,7 +1410,10 @@ namespace {
     llvm::Constant *getClassMetadataRef() {
       auto *theClass = getClass();
 
-      if (theClass->hasClangNode())
+      // If this is truly an imported ObjC class, with no @_objcImplementation,
+      // someone else will emit the ObjC metadata symbol and we simply want to
+      // use it.
+      if (theClass->hasClangNode() && !theClass->getObjCImplementationDecl())
         return IGM.getAddrOfObjCClass(theClass, NotForDefinition);
 
       // Note that getClassMetadataStrategy() will return

lib/IRGen/GenDecl.cpp

@@ -4731,8 +4731,11 @@ llvm::GlobalValue *IRGenModule::defineTypeMetadata(
     SmallVector<std::pair<Size, SILDeclRef>, 8> vtableEntries) {
   assert(init);
 
-  auto isPrespecialized = concreteType->getAnyGeneric() &&
-                          concreteType->getAnyGeneric()->isGenericContext();
+  auto concreteTypeDecl = concreteType->getAnyGeneric();
+  auto isPrespecialized = concreteTypeDecl &&
+                          concreteTypeDecl->isGenericContext();
+  bool isObjCImpl = concreteTypeDecl &&
+                    concreteTypeDecl->getObjCImplementationDecl();
 
   if (isPattern) {
     assert(isConstant && "Type metadata patterns must be constant");
@@ -4748,8 +4751,11 @@ llvm::GlobalValue *IRGenModule::defineTypeMetadata(
            *this, concreteType))
           ? LinkEntity::forNoncanonicalSpecializedGenericTypeMetadata(
                 concreteType)
-          : LinkEntity::forTypeMetadata(concreteType,
-                                        TypeMetadataAddress::FullMetadata);
+          : (isObjCImpl
+                ? LinkEntity::forObjCClass(
+                      concreteType->getClassOrBoundGenericClass())
+                : LinkEntity::forTypeMetadata(
+                      concreteType, TypeMetadataAddress::FullMetadata));
 
   auto DbgTy = DebugTypeInfo::getMetadata(MetatypeType::get(concreteType),
     entity.getDefaultDeclarationType(*this)->getPointerTo(),
@@ -4777,12 +4783,14 @@ llvm::GlobalValue *IRGenModule::defineTypeMetadata(
   unsigned adjustmentIndex = MetadataAdjustmentIndex::ValueType;
 
   if (auto nominal = concreteType->getAnyNominal()) {
-    // Keep type metadata around for all types.
-    addRuntimeResolvableType(nominal);
-
-    // Don't define the alias for foreign type metadata or prespecialized
-    // generic metadata, since neither is ABI.
-    if (requiresForeignTypeMetadata(nominal) || isPrespecialized)
+    // Keep type metadata around for all types (except @_objcImplementation,
+    // since we're using ObjC metadata for that).
+    if (!isObjCImpl)
+      addRuntimeResolvableType(nominal);
+
+    // Don't define the alias for foreign type metadata, prespecialized
+    // generic metadata, or @_objcImplementation classes, since they're not ABI.
+    if (requiresForeignTypeMetadata(nominal) || isPrespecialized || isObjCImpl)
       return var;
 
     // Native Swift class metadata has a destructor before the address point.
@@ -4842,9 +4850,12 @@ IRGenModule::getAddrOfTypeMetadata(CanType concreteType,
   } else if (nominal) {
     // The symbol for native non-generic nominal type metadata is generated at
     // the aliased address point (see defineTypeMetadata() above).
-    assert(!nominal->hasClangNode());
-
-    defaultVarTy = TypeMetadataStructTy;
+    if (nominal->getObjCImplementationDecl()) {
+      defaultVarTy = ObjCClassStructTy;
+    } else {
+      assert(!nominal->hasClangNode());
+      defaultVarTy = TypeMetadataStructTy;
+    }
     adjustmentIndex = 0;
   } else {
     // FIXME: Non-nominal metadata provided by the C++ runtime is exported
@@ -4874,11 +4885,17 @@ IRGenModule::getAddrOfTypeMetadata(CanType concreteType,
   DebugTypeInfo DbgTy;
 
   switch (canonicality) {
-  case TypeMetadataCanonicality::Canonical:
-    entity = LinkEntity::forTypeMetadata(
-        concreteType, fullMetadata ? TypeMetadataAddress::FullMetadata
-                                   : TypeMetadataAddress::AddressPoint);
+  case TypeMetadataCanonicality::Canonical: {
+    auto classDecl = concreteType->getClassOrBoundGenericClass();
+    if (classDecl && classDecl->getObjCImplementationDecl()) {
+      entity = LinkEntity::forObjCClass(classDecl);
+    } else {
+      entity = LinkEntity::forTypeMetadata(
+          concreteType, fullMetadata ? TypeMetadataAddress::FullMetadata
+                                     : TypeMetadataAddress::AddressPoint);
+    }
     break;
+  }
   case TypeMetadataCanonicality::Noncanonical:
     entity =
         LinkEntity::forNoncanonicalSpecializedGenericTypeMetadata(concreteType);
@@ -5340,6 +5357,11 @@ void IRGenModule::emitNestedTypeDecls(DeclRange members) {
 }
 
 static bool shouldEmitCategory(IRGenModule &IGM, ExtensionDecl *ext) {
+  if (ext->isObjCImplementation()) {
+    assert(ext->getCategoryNameForObjCImplementation() != Identifier());
+    return true;
+  }
+
   for (auto conformance : ext->getLocalConformances()) {
     if (conformance->getProtocol()->isObjC())
       return true;
@@ -5376,7 +5398,12 @@ void IRGenModule::emitExtension(ExtensionDecl *ext) {
   if (!origClass)
     return;
 
-  if (shouldEmitCategory(*this, ext)) {
+  if (ext->isObjCImplementation()
+        && ext->getCategoryNameForObjCImplementation() == Identifier()) {
+    // This is the @_objcImplementation for the class--generate its class
+    // metadata.
+    emitClassDecl(origClass);
+  } else if (shouldEmitCategory(*this, ext)) {
     assert(origClass && !origClass->isForeign() &&
            "foreign types cannot have categories emitted");
     llvm::Constant *category = emitCategoryData(*this, ext);