Reflection fixes for closures and imported types (3.0) (#2736)

* Reflection: Emit metadata for fixed-layout SIL boxes

We were recovering metadata from generic boxes by reading
the instantiated payload metadata from the box's metadata,
but this approach doesn't work for fixed-size boxes, whose
metadata does not store the payload metadata at all.

Instead, emit a capture descriptor with no metadata sources
and a single capture, using the lowered AST type appearing
in the alloc_box instruction that emitted the box.

Since box metadata is shared by all POD types of the same
size, and all single-retainable pointer payloads, the
AST type might not accurately reflect what is actually in
the box.

However, this type is *layout compatible* with the box
payload, at least enough to know where the retainable
pointers are, because after all IRGen uses this type to
synthesize the destructor.

Fixes <rdar://problem/26314060>.

* Reflection: Don't emit associated type records for conformances without associated types

This saves a bit of space. We don't care about conformances per se
in remote reflection, only what the associated types are.

* Reflection: Record builtin and imported types referenced from captures

* Reflection: Don't emit builtin descriptors for imported classes

Previously we would emit both a builtin descriptor and field
descriptor for imported classes, but we only need the latter.

Untangle some code and fix a crash with imported Objective-C
generics in the process.

Fixes <rdar://problem/26498484>.

* Reflection: Emit field metadata for @objc classes

While we can skip emitting metadata for imported classes (clients
should ask the Objective-C runtime instead) it was not correct to
do so for Swift-defined classes that used Objective-C reference
counting.

* Reflection: Emit descriptors for referenced imported protocols

When we encounter a protocol typeref, we have to know if its @objc,
class-bound, or opaque, so make sure we provide the necessary
information when imported protocols are referenced.

* Reflection: Simplify associated type metadata emission

Instead of hooking into nominal type and extension emission
and walking all conformances of those declarations, let's
just directly hook into the logic for emitting conformances.

This fixes an issue where we would apparently emit duplicate
conformances, as well as unnecessary conformances that are
defined elsewhere.

* Reflection: Fix tests for iPhoneOS

* Reflection: More robust typeref_decoding_objc test

Go through some pains to ensure that we emit an override for
the default initializer, since otherwise we emit a fatalError()
call which ends up creating some closures.

The exact order of the closures changed between master and
swift-3.0-preview-1-branch. It is better not to test this
part at all.

Author: slavapestov

include/swift/Reflection/Records.h

@@ -104,14 +104,25 @@ struct FieldRecordIterator {
 };
 
 enum class FieldDescriptorKind : uint16_t {
+  // Swift nominal types.
   Struct,
   Class,
   Enum,
+
+  // A Swift opaque protocol. There are no fields, just a record for the
+  // type itself.
   Protocol,
+
+  // A Swift class-bound protocol.
   ClassProtocol,
+
+  // An Objective-C protocol, which may be imported or defined in Swift.
   ObjCProtocol,
-  ObjCClass,
-  Imported
+
+  // An Objective-C class, which may be imported or defined in Swift.
+  // In the former case, field type metadata is not emitted, and
+  // must be obtained from the Objective-C runtime.
+  ObjCClass
 };
 
 // Field descriptors contain a collection of field records for a single

lib/IRGen/GenClass.cpp

@@ -773,7 +773,7 @@ void IRGenModule::emitClassDecl(ClassDecl *D) {
                     classTI.getLayout(*this, selfType),
                     classTI.getClassLayout(*this, selfType));
   emitNestedTypeDecls(D->getMembers());
-  emitReflectionMetadata(D);
+  emitFieldMetadataRecord(D);
 }
 
 namespace {

lib/IRGen/GenDecl.cpp

@@ -2053,6 +2053,8 @@ llvm::Constant *IRGenModule::emitProtocolConformances() {
 
   SmallVector<llvm::Constant*, 8> elts;
   for (auto *conformance : ProtocolConformances) {
+    emitAssociatedTypeMetadataRecord(conformance);
+
     auto descriptorRef = getAddrOfLLVMVariableOrGOTEquivalent(
                   LinkEntity::forProtocolDescriptor(conformance->getProtocol()),
                   getPointerAlignment(), ProtocolDescriptorStructTy);
@@ -2755,7 +2757,6 @@ static bool shouldEmitCategory(IRGenModule &IGM, ExtensionDecl *ext) {
 }
 
 void IRGenModule::emitExtension(ExtensionDecl *ext) {
-  emitAssociatedTypeMetadataRecord(ext);
   emitNestedTypeDecls(ext->getMembers());
 
   // Generate a category if the extension either introduces a

lib/IRGen/GenEnum.cpp

@@ -5562,7 +5562,7 @@ const TypeInfo *TypeConverter::convertEnumType(TypeBase *key, CanType type,
 void IRGenModule::emitEnumDecl(EnumDecl *theEnum) {
   emitEnumMetadata(*this, theEnum);
   emitNestedTypeDecls(theEnum->getMembers());
-  emitReflectionMetadata(theEnum);
+  emitFieldMetadataRecord(theEnum);
 }
 
 void irgen::emitSwitchAddressOnlyEnumDispatch(IRGenFunction &IGF,

lib/IRGen/GenHeap.cpp

@@ -1386,7 +1386,7 @@ class BoxTypeInfo : public HeapTypeInfo<BoxTypeInfo> {
 
   /// Allocate a box of the given type.
   virtual OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType,
+  allocate(IRGenFunction &IGF, SILType boxedType, SILType boxedInterfaceType,
            const llvm::Twine &name) const = 0;
 
   /// Deallocate an uninitialized box.
@@ -1404,7 +1404,7 @@ class EmptyBoxTypeInfo final : public BoxTypeInfo {
   EmptyBoxTypeInfo(IRGenModule &IGM) : BoxTypeInfo(IGM) {}
 
   OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType,
+  allocate(IRGenFunction &IGF, SILType boxedType, SILType boxedInterfaceType,
            const llvm::Twine &name) const override {
     return OwnedAddress(IGF.getTypeInfo(boxedType).getUndefAddress(),
                         IGF.IGM.RefCountedNull);
@@ -1429,7 +1429,7 @@ class NonFixedBoxTypeInfo final : public BoxTypeInfo {
   NonFixedBoxTypeInfo(IRGenModule &IGM) : BoxTypeInfo(IGM) {}
 
   OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType,
+  allocate(IRGenFunction &IGF, SILType boxedType, SILType boxedInterfaceType,
            const llvm::Twine &name) const override {
     auto &ti = IGF.getTypeInfo(boxedType);
     // Use the runtime to allocate a box of the appropriate size.
@@ -1470,14 +1470,15 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {
   {}
 
   OwnedAddress
-  allocate(IRGenFunction &IGF, SILType boxedType, const llvm::Twine &name)
+  allocate(IRGenFunction &IGF, SILType boxedType, SILType boxedInterfaceType,
+           const llvm::Twine &name)
   const override {
     // Allocate a new object using the layout.
 
-    auto nullCaptureDescriptor
-      = llvm::ConstantPointerNull::get(IGF.IGM.CaptureDescriptorPtrTy);
+    auto boxDescriptor = IGF.IGM.getAddrOfBoxDescriptor(
+        boxedInterfaceType.getSwiftRValueType());
     llvm::Value *allocation = IGF.emitUnmanagedAlloc(layout, name,
-                                                     nullCaptureDescriptor);
+                                                     boxDescriptor);
     Address rawAddr = project(IGF, allocation, boxedType);
     return {rawAddr, allocation};
   }
@@ -1586,9 +1587,13 @@ const TypeInfo *TypeConverter::convertBoxType(SILBoxType *T) {
 
 OwnedAddress
 irgen::emitAllocateBox(IRGenFunction &IGF, CanSILBoxType boxType,
+                       CanSILBoxType boxInterfaceType,
                        const llvm::Twine &name) {
   auto &boxTI = IGF.getTypeInfoForLowered(boxType).as<BoxTypeInfo>();
-  return boxTI.allocate(IGF, boxType->getBoxedAddressType(), name);
+  return boxTI.allocate(IGF,
+                        boxType->getBoxedAddressType(),
+                        boxInterfaceType->getBoxedAddressType(),
+                        name);
 }
 
 void irgen::emitDeallocateBox(IRGenFunction &IGF,

lib/IRGen/GenHeap.h

@@ -116,8 +116,12 @@ void emitDeallocatePartialClassInstance(IRGenFunction &IGF,
                                         llvm::Value *alignMask);
 
 /// Allocate a boxed value.
+///
+/// The interface type is required for emitting reflection metadata.
 OwnedAddress
-emitAllocateBox(IRGenFunction &IGF, CanSILBoxType boxType,
+emitAllocateBox(IRGenFunction &IGF,
+                CanSILBoxType boxType,
+                CanSILBoxType boxInterfaceType,
                 const llvm::Twine &name);
 
 /// Deallocate a box whose value is uninitialized.

lib/IRGen/GenMeta.cpp

@@ -5690,7 +5690,7 @@ void IRGenModule::emitProtocolDecl(ProtocolDecl *protocol) {
   var->setConstant(true);
   var->setInitializer(init);
 
-  emitReflectionMetadata(protocol);
+  emitFieldMetadataRecord(protocol);
 }
 
 /// \brief Load a reference to the protocol descriptor for the given protocol.