Merge pull request #10901 from rjmccall/bridging-function-bugs

Author: swift-ci

lib/SIL/TypeLowering.cpp

@@ -1567,9 +1567,26 @@ CanType TypeConverter::getLoweredRValueType(AbstractionPattern origType,
   //     on the abstract CC
   //   - ownership conventions are deduced
   if (auto substFnType = dyn_cast<AnyFunctionType>(substType)) {
-    auto bridgedFnType = getBridgedFunctionType(origType, substFnType,
-                                                substFnType->getExtInfo());
-    return getNativeSILFunctionType(M, origType, bridgedFnType);
+    // If the formal type uses a C convention, it is not formally
+    // abstractable, and it may be subject to implicit bridging.
+    auto extInfo = substFnType->getExtInfo();
+    if (getSILFunctionLanguage(extInfo.getSILRepresentation())
+          == SILFunctionLanguage::C) {
+      // Bridge the parameters and result of the function type.
+      auto bridgedFnType = getBridgedFunctionType(origType, substFnType,
+                                                  extInfo);
+      substFnType = bridgedFnType;
+
+      // Also rewrite the type of the abstraction pattern.
+      auto signature = getCurGenericContext();
+      if (origType.isTypeParameter()) {
+        origType = AbstractionPattern(signature, bridgedFnType);
+      } else {
+        origType.rewriteType(signature, bridgedFnType);
+      }
+    }
+
+    return getNativeSILFunctionType(M, origType, substFnType);
   }
 
   // Ignore dynamic self types.

lib/SILGen/SILGenBridging.cpp

@@ -359,6 +359,12 @@ static void buildFuncToBlockInvokeBody(SILGenFunction &SGF,
   SILFunctionConventions blockConv(blockTy, SGF.SGM.M);
   SILFunctionConventions funcConv(funcTy, SGF.SGM.M);
 
+  // Make sure we lower the component types of the formal block type.
+  formalBlockType =
+    SGF.SGM.Types.getBridgedFunctionType(AbstractionPattern(formalBlockType),
+                                         formalBlockType,
+                                         formalBlockType->getExtInfo());
+
   // Set up the indirect result.
   SILType blockResultTy = blockTy->getAllResultsType();
   SILValue indirectResult;

test/SILGen/objc_bridging.swift

@@ -637,3 +637,36 @@ func callNonStandardBlock(value: Int) {
   // CHECK: enum $Optional<@convention(block) () -> @owned Optional<AnyObject>>
   takesNonStandardBlock { return value }
 }
+
+func takeTwoAnys(_ lhs: Any, _ rhs: Any) -> Any { return lhs }
+
+// CHECK-LABEL: sil hidden @_T013objc_bridging22defineNonStandardBlockyyp1x_tF
+func defineNonStandardBlock(x: Any) {
+  // CHECK: function_ref @_T013objc_bridging22defineNonStandardBlockyyp1x_tFypypcfU_
+  // CHECK: function_ref @_T0ypypIxir_yXlyXlIyBya_TR : $@convention(c) (@inout_aliasable @block_storage @callee_owned (@in Any) -> @out Any, AnyObject) -> @autoreleased AnyObject
+
+  let fn : @convention(block) (Any) -> Any = { y in takeTwoAnys(x, y) }
+}
+
+// CHECK-LABEL: sil shared [transparent] [serializable] [reabstraction_thunk] @_T0ypypIxir_yXlyXlIyBya_TR : $@convention(c) (@inout_aliasable @block_storage @callee_owned (@in Any) -> @out Any, AnyObject) -> @autoreleased AnyObject
+// CHECK: bb0(%0 : $*@block_storage @callee_owned (@in Any) -> @out Any, %1 : $AnyObject):
+// CHECK:   [[T0:%.*]] = copy_value %1 : $AnyObject
+// CHECK:   [[T1:%.*]] = open_existential_ref [[T0]] : $AnyObject
+// CHECK:   [[ARG:%.*]] = alloc_stack $Any
+// CHECK:   [[T2:%.*]] = init_existential_addr [[ARG]]
+// CHECK:   store [[T1]] to [init] [[T2]]
+// CHECK:   [[RESULT:%.*]] = alloc_stack $Any
+// CHECK:   apply {{.*}}([[RESULT]], [[ARG]])
+
+// CHECK-LABEL: sil hidden @_T013objc_bridging15castToCFunctionySV3ptr_tF : $@convention(thin) (UnsafeRawPointer) -> () {
+func castToCFunction(ptr: UnsafeRawPointer) {
+  // CHECK: [[CASTFN:%.*]] = function_ref @_T0s13unsafeBitCastq_x_q_m2totr0_lF
+  // CHECK: [[OUT:%.*]] = alloc_stack $@convention(c) (Optional<AnyObject>) -> ()
+  // CHECK: [[IN:%.]] = alloc_stack $UnsafeRawPointer
+  // CHECK: store %0 to [trivial] [[IN]] : $*UnsafeRawPointer
+  // CHECK: [[META:%.*]] = metatype $@thick (@convention(c) (Optional<AnyObject>) -> ()).Type
+  // CHECK: apply [[CASTFN]]<UnsafeRawPointer, @convention(c) (AnyObject?) -> ()>([[OUT]], [[IN]], [[META]]) : $@convention(thin) <τ_0_0, τ_0_1> (@in τ_0_0, @thick τ_0_1.Type) -> @out τ_0_1
+  // CHECK: [[RESULT:%.*]] = load [trivial] %3 : $*@convention(c) (Optional<AnyObject>) -> ()
+  typealias Fn = @convention(c) (AnyObject?) -> Void
+  unsafeBitCast(ptr, to: Fn.self)(nil)
+}