IRGen: Don't crash when emitting a capture descriptor containing an opened existential

Author: slavapestov

lib/IRGen/GenReflection.cpp

@@ -601,6 +601,7 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
   CanSILFunctionType SubstCalleeType;
   SubstitutionList Subs;
   const HeapLayout &Layout;
+
 public:
   CaptureDescriptorBuilder(IRGenModule &IGM,
                            SILFunction &Caller,
@@ -630,6 +631,35 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
     }
   }
 
+  /// Give up if we captured an opened existential type. Eventually we
+  /// should figure out how to represent this.
+  static bool hasOpenedExistential(CanSILFunctionType OrigCalleeType,
+                                   const HeapLayout &Layout) {
+    if (!OrigCalleeType->isPolymorphic() ||
+        OrigCalleeType->isPseudogeneric())
+      return false;
+
+    auto &Bindings = Layout.getBindings();
+    for (unsigned i = 0; i < Bindings.size(); ++i) {
+      // Skip protocol requirements (FIXME: for now?)
+      if (Bindings[i].Protocol != nullptr)
+        continue;
+
+      if (Bindings[i].TypeParameter->hasOpenedExistential())
+        return true;
+    }
+
+    auto ElementTypes = Layout.getElementTypes().slice(
+        Layout.hasBindings() ? 1 : 0);
+    for (auto ElementType : ElementTypes) {
+      auto SwiftType = ElementType.getSwiftRValueType();
+      if (SwiftType->hasOpenedExistential())
+        return true;
+    }
+
+    return false;
+  }
+
   /// Slice off the NecessaryBindings struct at the beginning, if it's there.
   /// We'll keep track of how many things are in the bindings struct with its
   /// own count in the capture descriptor.
@@ -660,8 +690,9 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
         continue;
 
       auto Source = SourceBuilder.createClosureBinding(i);
-      auto BindingType = Caller.mapTypeOutOfContext(Bindings[i].TypeParameter);
-      SourceMap.push_back({BindingType->getCanonicalType(), Source});
+      auto BindingType = Bindings[i].TypeParameter;
+      auto InterfaceType = Caller.mapTypeOutOfContext(BindingType);
+      SourceMap.push_back({InterfaceType->getCanonicalType(), Source});
     }
 
     // Check if any requirements were fulfilled by metadata stored inside a
@@ -701,10 +732,9 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
       // parameters.
       auto Src = Path.getMetadataSource(SourceBuilder, Root);
 
-      auto SubstType =
-        Caller.mapTypeOutOfContext(
-            GenericParam.subst(SubstMap, None));
-      SourceMap.push_back({SubstType->getCanonicalType(), Src});
+      auto SubstType = GenericParam.subst(SubstMap);
+      auto InterfaceType = Caller.mapTypeOutOfContext(SubstType);
+      SourceMap.push_back({InterfaceType->getCanonicalType(), Src});
     });
 
     return SourceMap;
@@ -872,11 +902,13 @@ IRGenModule::getAddrOfCaptureDescriptor(SILFunction &Caller,
   if (!IRGen.Opts.EnableReflectionMetadata)
     return llvm::Constant::getNullValue(CaptureDescriptorPtrTy);
 
+  if (CaptureDescriptorBuilder::hasOpenedExistential(OrigCalleeType, Layout))
+    return llvm::Constant::getNullValue(CaptureDescriptorPtrTy);
+
   CaptureDescriptorBuilder builder(*this, Caller,
                                    OrigCalleeType, SubstCalleeType, Subs,
                                    Layout);
   auto var = builder.emit();
-
   return llvm::ConstantExpr::getBitCast(var, CaptureDescriptorPtrTy);
 }
 

test/Reflection/capture_descriptors.sil

@@ -241,3 +241,27 @@ bb0(%thin: $@convention(thin) () -> (), %c: $@convention(c) () -> (), %block: $@
 // CHECK-NEXT: (function convention=thin
 // CHECK-NEXT:   (tuple))
 // CHECK-NEXT: - Metadata sources:
+
+// Capturing opened existentials
+//
+// Not supported yet -- make sure we bail out instead of crashing.
+//
+// FIXME: Eventually, we should emit a useful capture descriptor
+// for this case.
+
+sil @existential_callee : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> @out P {
+bb0(%0 : $*P):
+  unreachable
+}
+
+
+sil @existential_caller : $@convention(thin) (@in P) -> () {
+bb0(%0 : $*P):
+  %payload = open_existential_addr immutable_access %0 : $*P to $*@opened("2D7A8F84-2973-11E7-838D-34363BD08DA0") P
+  %f = function_ref @existential_callee : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> @out P
+  %result = partial_apply %f<@opened("2D7A8F84-2973-11E7-838D-34363BD08DA0") P>() : $@convention(thin) <τ_0_0 where τ_0_0 : P> () -> @out P
+  destroy_value %result : $@callee_owned () -> @out P
+  destroy_addr %0 : $*P
+  %tuple = tuple ()
+  return %tuple : $()
+}

test/SILGen/function_conversion.swift

@@ -1,4 +1,5 @@
-// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -primary-file %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -primary-file %s
 
 // Check SILGen against various FunctionConversionExprs emitted by Sema.
 

test/SILGen/partial_apply_protocol.swift

@@ -1,4 +1,5 @@
-// RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-silgen -primary-file %s | %FileCheck %s
+// RUN: %target-swift-frontend -emit-ir -primary-file %s
 
 protocol Clonable {
   func clone() -> Self