// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all %s -inline -sil-combine | %FileCheck %s

sil_stage canonical

import Builtin
import Swift

/////////////////////
// Inlining Tests //
/////////////////////

// *NOTE* These tests currently validate whether or not we
// visit nodes in the correct order since we do not explore inlined
// code for more apply inst to inline. After that point, we will
// probably need to do one of the following:
//
// 1. Introduce a flag to turn off the exploration behavior.
// 2. Introduce some sort of debug output that displays the callgraph
//    traversal order.

// Node -> Node

sil @test1_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

// CHECK-LABEL: sil @test1
// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64)
// CHECK: integer_literal $Builtin.Int1, 0
// CHECK: [[MUL_TUPLE_RESULT:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[INPUT]] : {{.*}}, [[INPUT]]
// CHECK: [[MUL_RESULT:%[0-9]+]] = tuple_extract [[MUL_TUPLE_RESULT]]
// CHECK: return [[MUL_RESULT]]
sil @test1 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test1_multiply_leaf : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  return %2 : $Builtin.Int64
}

//      Node
//     /    \
//    v      v
//  Node -> Node

// CHECK-LABEL: sil @test2_add_leaf

sil @test2_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "uadd_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test2_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test2_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test2_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %3 = function_ref @test2_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  return %4 : $Builtin.Int64
}

// CHECK-LABEL: sil @test2 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
// bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
// CHECK: [[UADD_RESULT_TUPLE:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[INPUT]] : {{.*}}, [[INPUT]]
// CHECK: [[UADD_RESULT:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE]] : $(Builtin.Int64, Builtin.Int1), 0
// CHECK: [[UADD_RESULT_TUPLE2:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[UADD_RESULT]] : {{.*}}, [[UADD_RESULT]]
// CHECK: [[UADD_RESULT2:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE2]]
// CHECK: [[UMUL_RESULT_TUPLE:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT2]] : {{.*}}, [[UADD_RESULT2]]
// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE]]
// CHECK: return [[UMUL_RESULT]] : $Builtin.Int64
sil @test2 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test2_add_leaf: $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %3 = function_ref @test2_add_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %4 = apply %3 (%2) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  return %4 : $Builtin.Int64
}

//      Node
//     /    \
//    v      v
//  Node    Node
//    \      /
//     v    v
//      Node

// CHECK-LABEL: sil @test3_add_leaf

sil @test3_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "uadd_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test3_sub_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = integer_literal $Builtin.Int64, 1
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "usub_with_overflow_Int64"(%0 : $Builtin.Int64, %1 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test3_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test3_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test3_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %3 = function_ref @test3_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  return %4 : $Builtin.Int64
}

sil @test3_sub_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test3_sub_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %3 = function_ref @test3_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  return %4 : $Builtin.Int64
}

// CHECK-LABEL: sil @test3 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
// CHECK: [[LITERAL1:%[0-9]+]] = integer_literal {{.*}}, 1
// CHECK: [[USUB_RESULT_TUPLE:%[0-9]+]] = builtin "usub_with_overflow_Int64"([[INPUT]] : {{.*}}, [[LITERAL1]] : {{.*}}
// CHECK: [[USUB_RESULT:%[0-9]+]] = tuple_extract [[USUB_RESULT_TUPLE]]
// CHECK: [[UMUL_RESULT_TUPLE:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[USUB_RESULT]] : {{.*}}, [[USUB_RESULT]]
// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE]]
// CHECK: [[UADD_RESULT_TUPLE:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[UMUL_RESULT]] : {{.*}}, [[UMUL_RESULT]]
// CHECK: [[UADD_RESULT:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE]]
// CHECK: [[UMUL_RESULT_TUPLE2:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT]] : {{.*}}, [[UADD_RESULT]]
// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE2]]
// CHECK: return [[UMUL_RESULT]]
sil @test3 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test3_sub_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %3 = function_ref @test3_add_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %4 = apply %3 (%2) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  return %4 : $Builtin.Int64
}

//      Node
//     /    \
//    v      v
//  Node -> Node
//    \      /
//     v    v
//       Node

// CHECK-LABEL: sil @test4_add_leaf

sil @test4_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "uadd_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test4_sub_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "usub_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test4_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %2 = integer_literal $Builtin.Int1, 0
  %3 = builtin "umul_with_overflow_Int64"(%0 : $Builtin.Int64, %0 : $Builtin.Int64, %2 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %4 = tuple_extract %3 : $(Builtin.Int64, Builtin.Int1), 0
  return %4: $Builtin.Int64
}

sil @test4_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test4_add_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %3 = function_ref @test4_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  return %4 : $Builtin.Int64
}

sil @test4_add_then_multiply_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test4_add_then_multiply : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %3 = function_ref @test4_multiply_leaf : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %4 = apply %3(%2) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  return %4 : $Builtin.Int64
}

// CHECK-LABEL: sil @test4 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
// CHECK: [[UADD_RESULT_TUPLE:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[INPUT]] : {{.*}}, [[INPUT]]
// CHECK: [[UADD_RESULT:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE]]
// CHECK: [[UMUL_RESULT_TUPLE:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT]] : {{.*}}, [[UADD_RESULT]]
// CHECK: [[UMUL_RESULT:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE]]

// CHECK: [[UADD_RESULT_TUPLE2:%[0-9]+]] = builtin "uadd_with_overflow_Int64"([[UMUL_RESULT]] : {{.*}}, [[UMUL_RESULT]]
// CHECK: [[UADD_RESULT2:%[0-9]+]] = tuple_extract [[UADD_RESULT_TUPLE2]]
// CHECK: [[UMUL_RESULT_TUPLE2:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UADD_RESULT2]] : {{.*}}, [[UADD_RESULT2]]
// CHECK: [[UMUL_RESULT2:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE2]]

// CHECK: [[UMUL_RESULT_TUPLE3:%[0-9]+]] = builtin "umul_with_overflow_Int64"([[UMUL_RESULT2]] : {{.*}}, [[UMUL_RESULT2]]
// CHECK: [[UMUL_RESULT3:%[0-9]+]] = tuple_extract [[UMUL_RESULT_TUPLE3]]
// CHECK: return [[UMUL_RESULT3]] : $Builtin.Int64
sil @test4 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test4_add_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %2 = apply %1 (%0) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %3 = function_ref @test4_add_then_multiply_then_multiply : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  %4 = apply %3 (%2) : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64)
  return %4 : $Builtin.Int64
}

// Circular Inline.

// CHECK-LABEL: sil @test5
// CHECK: bb0([[INPUT:%[0-9]+]] : $Builtin.Int64):
// CHECK: [[FUN:%[0-9]+]] = function_ref @test5 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
// CHECK: [[FUN_RESULT:%[0-9]+]] = apply [[FUN]]([[INPUT]]) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
// CHECK: return [[FUN_RESULT]] : $Builtin.Int64
sil @test5 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $Builtin.Int64):
  %1 = function_ref @test5 : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  %2 = apply %1(%0) : $@convention(thin) (Builtin.Int64) -> Builtin.Int64
  return %2 : $Builtin.Int64
}

//////////////////////
// Apply Type Tests //
//////////////////////

// CHECK-LABEL: sil @generic_function
sil @generic_function : $@convention(thin) <T> (@in T, @in T) -> Builtin.Int8 {
bb0(%0 : $*T, %1 : $*T):
  %2 = integer_literal $Builtin.Int8, 2
  return %2 : $Builtin.Int8
}

// IGNORE-THIS-CHECK-LABEL: sil @ignore_applies_with_substitutions

// We can't deserialize apply_inst with subst lists. When radar://14443304
// is fixed then we should uncomment this test.

// sil @ignore_applies_with_substitutions : $@convention(thin) (Builtin.Int64) -> Builtin.Int8 {
// bb0(%0 : $Builtin.Int64):
//   %1 = function_ref @generic_function : $@convention(thin) <T> (@in T, @in T) -> Builtin.Int8
//   %2 = apply %1<T = Builtin.Int64>(%0, %0) : $@convention(thin) <T> (@in T, @in T) -> Builtin.Int8
//   return %2 : $Builtin.Int8
// }

// CHECK-LABEL: sil @trivial_fun

sil @trivial_fun : $@convention(thin) () -> (Builtin.Int64) {
  %0 = integer_literal $Builtin.Int64, 32
  return %0 : $Builtin.Int64
}

// We can inline function_refs with witness_method calling convention.
sil @trivial_witness_method : $@convention(witness_method) (@inout Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $*Builtin.Int64):
  %1 = load %0 : $*Builtin.Int64
  return %1 : $Builtin.Int64
}

// CHECK-LABEL: sil @trivial_witness_method_caller : $@convention(thin) () -> ()
// CHECK-NOT: apply
// CHECK: return
sil @trivial_witness_method_caller : $@convention(thin) () -> () {
  %0 = alloc_stack $Builtin.Int64
  %1 = integer_literal $Builtin.Int64, 0
  store %1 to %0 : $*Builtin.Int64
  %2 = function_ref @trivial_witness_method : $@convention(witness_method) (@inout Builtin.Int64) -> Builtin.Int64
  apply %2 (%0) : $@convention(witness_method) (@inout Builtin.Int64) -> Builtin.Int64
  dealloc_stack %0 : $*Builtin.Int64
  %3 = tuple()
  return %3 : $()
}

// We can inline function_refs with c calling convention.
sil @trivial_c : $@convention(c) (@inout Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $*Builtin.Int64):
  %1 = load %0 : $*Builtin.Int64
  return %1 : $Builtin.Int64
}

// CHECK-LABEL: sil @trivial_c_caller : $@convention(thin) () -> ()
// CHECK-NOT: apply
// CHECK: return
sil @trivial_c_caller : $@convention(thin) () -> () {
  %0 = alloc_stack $Builtin.Int64
  %1 = integer_literal $Builtin.Int64, 0
  store %1 to %0 : $*Builtin.Int64
  %2 = function_ref @trivial_c : $@convention(c) (@inout Builtin.Int64) -> Builtin.Int64
  apply %2 (%0) : $@convention(c) (@inout Builtin.Int64) -> Builtin.Int64
  dealloc_stack %0 : $*Builtin.Int64
  %3 = tuple()
  return %3 : $()
}

// We can inline function_refs with objc_method calling convention.
//
// ObjC calls are unable to be devirtualized since at runtime the call
// could change. But there is no reason in principal why we could not
// (if there existed something like sealed classes in objc perhaps?),
// inline a function_ref to such a call.
sil @trivial_objc : $@convention(objc_method) (@inout Builtin.Int64) -> Builtin.Int64 {
bb0(%0 : $*Builtin.Int64):
  %1 = load %0 : $*Builtin.Int64
  return %1 : $Builtin.Int64
}

// CHECK-LABEL: sil @trivial_objc_caller : $@convention(thin) () -> ()
// CHECK-NOT: apply
// CHECK: return
sil @trivial_objc_caller : $@convention(thin) () -> () {
  %0 = alloc_stack $Builtin.Int64
  %1 = integer_literal $Builtin.Int64, 0
  store %1 to %0 : $*Builtin.Int64
  %2 = function_ref @trivial_objc : $@convention(objc_method) (@inout Builtin.Int64) -> Builtin.Int64
  apply %2 (%0) : $@convention(objc_method) (@inout Builtin.Int64) -> Builtin.Int64
  dealloc_stack %0 : $*Builtin.Int64
  %3 = tuple()
  return %3 : $()
}

//////////
// Misc //
//////////

// Make sure SILCloner does not get into an infinite loop here.
sil @_TFsoi1xFT3lhsVs5UWord3rhsS__S_ : $@convention(thin) (UInt32, UInt32) -> UInt32 {
bb0(%0 : $UInt32, %1 : $UInt32):
  %3 = struct_extract %0 : $UInt32, #UInt32._value   // user: %5
  %4 = struct_extract %1 : $UInt32, #UInt32._value   // user: %5
  %5 = builtin "xor_Int32"(%3 : $Builtin.Int32, %4 : $Builtin.Int32) : $Builtin.Int32 // user: %6
  %6 = struct $UInt32 (%5 : $Builtin.Int32)         // user: %7
  return %6 : $UInt32                               // id: %7
}

sil @_TFsop1tFT1aVs5UWord_S_ : $@convention(thin) (UInt32) -> UInt32 {
bb0(%0 : $UInt32):
  // function_ref Swift.^ [infix] (lhs : Swift.UInt32, rhs : Swift.UInt32) -> Swift.UInt32
  %1 = function_ref @_TFsoi1xFT3lhsVs5UWord3rhsS__S_ : $@convention(thin) (UInt32, UInt32) -> UInt32 // user: %6
  // function_ref Swift.~ [prefix] (a : Swift.UInt32) -> Swift.UInt32
  %2 = function_ref @_TFsop1tFT1aVs5UWord_S_ : $@convention(thin) (UInt32) -> UInt32 // user: %5
  %3 = integer_literal $Builtin.Int32, 0            // user: %4
  %4 = struct $UInt32 (%3 : $Builtin.Int32)         // user: %5
  %5 = apply %2(%4) : $@convention(thin) (UInt32) -> UInt32     // user: %6
  %6 = apply %1(%0, %5) : $@convention(thin) (UInt32, UInt32) -> UInt32 // user: %7
  return %6 : $UInt32                               // id: %7
}

// Transparent function may inline private functions.
//
sil private @private_ret_undef : $@convention(thin) () -> () {
entry:
  return undef : $()
}

sil @uses_private : $@convention(thin) () -> () {
entry:
  %f = function_ref @private_ret_undef : $@convention(thin) () -> ()
  %z = apply %f() : $@convention(thin) () -> ()
  return %z : $()
}

// CHECK-LABEL: sil [transparent] @transparent_uses_uses_private : $@convention(thin) () -> () {
// CHECK-NOT: function_ref @uses_private
// CHECK: return
sil [transparent] @transparent_uses_uses_private : $@convention(thin) () -> () {
entry:
  %f = function_ref @uses_private : $@convention(thin) () -> ()
  %z = apply %f() : $@convention(thin) () -> ()
  return %z : $()
}

// Test fragile-resilient inlining rules:
// Everything is allowed except inlining of a resilient function into a fragile function.

sil @resilient_function : $@convention(thin) () -> () {
entry:
  return undef : $()
}

sil [serialized] @fragile_function : $@convention(thin) () -> () {
entry:
  return undef : $()
}

// CHECK-LABEL: sil [serialized] @fragile_calls_resilient : $@convention(thin) () -> () {
// CHECK: function_ref @resilient_function
// CHECK: return
sil [serialized] @fragile_calls_resilient : $@convention(thin) () -> () {
entry:
  %f = function_ref @resilient_function : $@convention(thin) () -> ()
  %z = apply %f() : $@convention(thin) () -> ()
  return %z : $()
}

// CHECK-LABEL: sil [serialized] @fragile_calls_fragile : $@convention(thin) () -> () {
// CHECK-NOT: function_ref @resilient_function
// CHECK: return
sil [serialized] @fragile_calls_fragile : $@convention(thin) () -> () {
entry:
  %f = function_ref @fragile_function : $@convention(thin) () -> ()
  %z = apply %f() : $@convention(thin) () -> ()
  return %z : $()
}

// CHECK-LABEL: sil @resilient_calls_fragile : $@convention(thin) () -> () {
// CHECK-NOT: function_ref @resilient_function
// CHECK: return
sil @resilient_calls_fragile : $@convention(thin) () -> () {
entry:
  %f = function_ref @fragile_function : $@convention(thin) () -> ()
  %z = apply %f() : $@convention(thin) () -> ()
  return %z : $()
}

// CHECK-LABEL: sil @resilient_calls_resilient : $@convention(thin) () -> () {
// CHECK-NOT: function_ref @resilient_function
// CHECK: return
sil @resilient_calls_resilient : $@convention(thin) () -> () {
entry:
  %f = function_ref @resilient_function : $@convention(thin) () -> ()
  %z = apply %f() : $@convention(thin) () -> ()
  return %z : $()
}

// CHECK-LABEL: sil @calls_self
// CHECK-NEXT: bb0:
// CHECK: function_ref @calls_self
// CHECK-NEXT: apply
// CHECK-NEXT: return
sil @calls_self : $@convention(thin) () -> () {
entry:
  %f = function_ref @calls_self : $@convention(thin) () -> ()
  %z = apply %f() : $@convention(thin) () -> ()
  return %z : $()
}

// Visibility Tests
// These tests stem from a time where visibility had an influence
// on the inlining. This is no longer the case so we just check
// if everything can be inlined, regardless of visibility.

sil_global private @private_global : $Builtin.Word
sil private @private_function : $@convention(thin) () -> () {
  %0 = integer_literal $Builtin.Int32, 0
  %1 = tuple()
  return %1 : $()
}
sil @references_private_global : $@convention(thin) () -> () {
  %0 = global_addr @private_global : $*Builtin.Word
  %1 = tuple()
  return %1 : $()
}
sil @references_private_function : $@convention(thin) () -> () {
  %0 = function_ref @private_function : $@convention(thin) () -> ()
  %1 = tuple()
  return %1 : $()
}

sil_global shared @shared_global : $Builtin.Word
sil shared @shared_function : $@convention(thin) () -> () {
  %0 = integer_literal $Builtin.Int32, 1
  %1 = tuple()
  return %1 : $()
}
sil @references_shared_global : $@convention(thin) () -> () {
  %0 = global_addr @shared_global : $*Builtin.Word
  %1 = tuple()
  return %1 : $()
}
sil @references_shared_function : $@convention(thin) () -> () {
  %0 = function_ref @shared_function : $@convention(thin) () -> ()
  %1 = tuple()
  return %1 : $()
}

sil_global hidden @hidden_global : $Builtin.Word
sil hidden @hidden_function : $@convention(thin) () -> () {
  %0 = integer_literal $Builtin.Int32, 2
  %1 = tuple()
  return %1 : $()
}
sil @references_hidden_global : $@convention(thin) () -> () {
  %0 = global_addr @hidden_global : $*Builtin.Word
  %1 = tuple()
  return %1 : $()
}
sil @references_hidden_function : $@convention(thin) () -> () {
  %0 = function_ref @hidden_function : $@convention(thin) () -> ()
  %1 = tuple()
  return %1 : $()
}

sil_global @public_global : $Builtin.Word
sil @public_function : $@convention(thin) () -> () {
  %0 = integer_literal $Builtin.Int32, 4
  %1 = tuple()
  return %1 : $()
}

sil @references_public_global : $@convention(thin) () -> () {
  %0 = global_addr @public_global : $*Builtin.Word
  %1 = tuple()
  return %1 : $()
}
sil @references_public_function : $@convention(thin) () -> () {
  %0 = function_ref @public_function : $@convention(thin) () -> ()
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil private @private_function_test : $@convention(thin) () -> () {
// CHECK-NOT: function_ref
// CHECK: return
sil private @private_function_test : $@convention(thin) () -> () {
  %0 = function_ref @references_public_function : $@convention(thin) () -> ()
  %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
  %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
  %3 = function_ref @references_private_function : $@convention(thin) () -> ()
  %4 = function_ref @references_public_global : $@convention(thin) () -> ()
  %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
  %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
  %7 = function_ref @references_private_global : $@convention(thin) () -> ()
  apply %0() : $@convention(thin) () -> ()
  apply %1() : $@convention(thin) () -> ()
  apply %2() : $@convention(thin) () -> ()
  apply %3() : $@convention(thin) () -> ()
  apply %4() : $@convention(thin) () -> ()
  apply %5() : $@convention(thin) () -> ()
  apply %6() : $@convention(thin) () -> ()
  apply %7() : $@convention(thin) () -> ()
  %8 = tuple()
  return %8 : $()
}

// CHECK-LABEL: sil shared @shared_function_test : $@convention(thin) () -> () {
// CHECK-NOT: function_ref
// CHECK: return
sil shared @shared_function_test : $@convention(thin) () -> () {
  %0 = function_ref @references_public_function : $@convention(thin) () -> ()
  %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
  %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
  %3 = function_ref @references_private_function : $@convention(thin) () -> ()
  %4 = function_ref @references_public_global : $@convention(thin) () -> ()
  %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
  %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
  %7 = function_ref @references_private_global : $@convention(thin) () -> ()
  apply %0() : $@convention(thin) () -> ()
  apply %1() : $@convention(thin) () -> ()
  apply %2() : $@convention(thin) () -> ()
  apply %3() : $@convention(thin) () -> ()
  apply %4() : $@convention(thin) () -> ()
  apply %5() : $@convention(thin) () -> ()
  apply %6() : $@convention(thin) () -> ()
  apply %7() : $@convention(thin) () -> ()
  %8 = tuple()
  return %8 : $()
}

// CHECK-LABEL: sil hidden @hidden_function_test : $@convention(thin) () -> () {
// CHECK-NOT: function_ref
// CHECK: return
sil hidden @hidden_function_test : $@convention(thin) () -> () {
  %0 = function_ref @references_public_function : $@convention(thin) () -> ()
  %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
  %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
  %3 = function_ref @references_private_function : $@convention(thin) () -> ()
  %4 = function_ref @references_public_global : $@convention(thin) () -> ()
  %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
  %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
  %7 = function_ref @references_private_global : $@convention(thin) () -> ()
  apply %0() : $@convention(thin) () -> ()
  apply %1() : $@convention(thin) () -> ()
  apply %2() : $@convention(thin) () -> ()
  apply %3() : $@convention(thin) () -> ()
  apply %4() : $@convention(thin) () -> ()
  apply %5() : $@convention(thin) () -> ()
  apply %6() : $@convention(thin) () -> ()
  apply %7() : $@convention(thin) () -> ()
  %8 = tuple()
  return %8 : $()
}

// CHECK-LABEL: sil @public_function_test : $@convention(thin) () -> () {
// CHECK-NOT: function_ref
// CHECK: return
sil @public_function_test : $@convention(thin) () -> () {
  %0 = function_ref @references_public_function : $@convention(thin) () -> ()
  %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
  %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
  %3 = function_ref @references_private_function : $@convention(thin) () -> ()
  %4 = function_ref @references_public_global : $@convention(thin) () -> ()
  %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
  %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
  %7 = function_ref @references_private_global : $@convention(thin) () -> ()
  apply %0() : $@convention(thin) () -> ()
  apply %1() : $@convention(thin) () -> ()
  apply %2() : $@convention(thin) () -> ()
  apply %3() : $@convention(thin) () -> ()
  apply %4() : $@convention(thin) () -> ()
  apply %5() : $@convention(thin) () -> ()
  apply %6() : $@convention(thin) () -> ()
  apply %7() : $@convention(thin) () -> ()
  %8 = tuple()
  return %8 : $()
}

// CHECK-LABEL: sil hidden_external @hidden_external_function_test : $@convention(thin) () -> () {
// CHECK-NOT: function_ref
// CHECK: return
sil hidden_external @hidden_external_function_test : $@convention(thin) () -> () {
  %0 = function_ref @references_public_function : $@convention(thin) () -> ()
  %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
  %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
  %3 = function_ref @references_private_function : $@convention(thin) () -> ()
  %4 = function_ref @references_public_global : $@convention(thin) () -> ()
  %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
  %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
  %7 = function_ref @references_private_global : $@convention(thin) () -> ()
  apply %0() : $@convention(thin) () -> ()
  apply %1() : $@convention(thin) () -> ()
  apply %2() : $@convention(thin) () -> ()
  apply %3() : $@convention(thin) () -> ()
  apply %4() : $@convention(thin) () -> ()
  apply %5() : $@convention(thin) () -> ()
  apply %6() : $@convention(thin) () -> ()
  apply %7() : $@convention(thin) () -> ()
  %8 = tuple()
  return %8 : $()
}

// CHECK-LABEL: sil public_external @public_external_function_test : $@convention(thin) () -> () {
// CHECK-NOT: function_ref
// CHECK: return
sil public_external @public_external_function_test : $@convention(thin) () -> () {
  %0 = function_ref @references_public_function : $@convention(thin) () -> ()
  %1 = function_ref @references_shared_function : $@convention(thin) () -> ()
  %2 = function_ref @references_hidden_function : $@convention(thin) () -> ()
  %3 = function_ref @references_private_function : $@convention(thin) () -> ()
  %4 = function_ref @references_public_global : $@convention(thin) () -> ()
  %5 = function_ref @references_shared_global : $@convention(thin) () -> ()
  %6 = function_ref @references_hidden_global : $@convention(thin) () -> ()
  %7 = function_ref @references_private_global : $@convention(thin) () -> ()
  apply %0() : $@convention(thin) () -> ()
  apply %1() : $@convention(thin) () -> ()
  apply %2() : $@convention(thin) () -> ()
  apply %3() : $@convention(thin) () -> ()
  apply %4() : $@convention(thin) () -> ()
  apply %5() : $@convention(thin) () -> ()
  apply %6() : $@convention(thin) () -> ()
  apply %7() : $@convention(thin) () -> ()
  %8 = tuple()
  return %8 : $()
}

// CHECK-LABEL: @caller_of_noinline
sil @caller_of_noinline : $@convention(thin) () -> () {
bb0:
  // CHECK: function_ref @noinline_callee
  // CHECK: apply
  %0 = function_ref @noinline_callee : $@convention(thin) () -> Int
  %1 = apply %0() : $@convention(thin) () -> Int
  %2 = tuple ()
  return %2 : $()
}
// CHECK-LABEL: [noinline] @noinline_callee
sil [noinline] @noinline_callee : $@convention(thin) () -> Int {
bb0:
  %0 = function_ref @_TFSi33_convertFromBuiltinIntegerLiteralfMSiFBi2048_Si : $@convention(thin) (Builtin.Int2048, @thin Int.Type) -> Int
  %1 = metatype $@thin Int.Type
  %2 = integer_literal $Builtin.Int2048, 0
  %3 = apply %0(%2, %1) : $@convention(thin) (Builtin.Int2048, @thin Int.Type) -> Int
  return %3 : $Int
}
sil [transparent] @_TFSi33_convertFromBuiltinIntegerLiteralfMSiFBi2048_Si : $@convention(thin) (Builtin.Int2048, @thin Int.Type) -> Int

sil @unknown_function : $@convention(thin) () -> ()

sil @coldcall : $@convention(thin) () -> () {
bb0:
  // make it a non-trivial function
  %f = function_ref @unknown_function : $@convention(thin) () -> ()
  %a1 = apply %f() : $@convention(thin) () -> ()
  %a2 = apply %f() : $@convention(thin) () -> ()
  %a3 = apply %f() : $@convention(thin) () -> ()
  %a4 = apply %f() : $@convention(thin) () -> ()
  %a5 = apply %f() : $@convention(thin) () -> ()
  %a6 = apply %f() : $@convention(thin) () -> ()
  %a7 = apply %f() : $@convention(thin) () -> ()
  %a8 = apply %f() : $@convention(thin) () -> ()
  %a9 = apply %f() : $@convention(thin) () -> ()
  %a10 = apply %f() : $@convention(thin) () -> ()
  %a11 = apply %f() : $@convention(thin) () -> ()
  %a12 = apply %f() : $@convention(thin) () -> ()
  %a13 = apply %f() : $@convention(thin) () -> ()
  %a14 = apply %f() : $@convention(thin) () -> ()
  %a15 = apply %f() : $@convention(thin) () -> ()
  %a16 = apply %f() : $@convention(thin) () -> ()
  %a17 = apply %f() : $@convention(thin) () -> ()
  %a18 = apply %f() : $@convention(thin) () -> ()
  %a19 = apply %f() : $@convention(thin) () -> ()
  %a20 = apply %f() : $@convention(thin) () -> ()
  %a21 = apply %f() : $@convention(thin) () -> ()
  %a22 = apply %f() : $@convention(thin) () -> ()
  %0 = tuple ()                                   // user: %1
  return %0 : $()                                 // id: %1
}

// Generic call to "branchHint" for use in specialized @slowPath
sil public_external [transparent] [_semantics "branchhint"] @_TFs11_branchHintUs7Boolean__FTQ_Sb_Sb : $@convention(thin)(Bool, Bool) -> Bool {
bb0(%0 : $Bool, %1 : $Bool):
  return %0 : $Bool
}

// Specialized call to "slowPath" for use in @coldcall_caller
sil shared [noinline] [transparent] [_semantics "slowpath"] @_TTSgSbSbs7Boolean___TFs9_slowPathUs7Boolean__FQ_Sb : $@convention(thin) (Bool) -> Bool {
bb0(%0 : $Bool):
  %3 = integer_literal $Builtin.Int1, 0
  %4 = struct $Bool (%3 : $Builtin.Int1)
  %5 = function_ref @_TFs11_branchHintUs7Boolean__FTQ_Sb_Sb : $@convention(thin) (Bool, Bool) -> Bool
  %6 = apply %5(%0, %4) : $@convention(thin) (Bool, Bool) -> Bool
  return %6 : $Bool
}

// CHECK-LABEL:  @coldcall_caller
// CHECK: slowPath
// CHECK-LABEL: bb1:
// CHECK: function_ref @coldcall
// CHECK: apply
// CHECK-LABEL: bb2:
sil @coldcall_caller : $@convention(thin) (Int32) -> () {
bb0(%0 : $Int32):
  %1 = alloc_stack $Bool                          // users: %7, %9, %11
  %2 = integer_literal $Builtin.Int32, 0          // user: %5
  %4 = struct_extract %0 : $Int32, #Int32._value   // user: %5
  %5 = builtin "cmp_eq_Word"(%4 : $Builtin.Int32, %2 : $Builtin.Int32) : $Builtin.Int1 // user: %6
  %6 = struct $Bool (%5 : $Builtin.Int1)          // user: %7
  store %6 to %1 : $*Bool                       // id: %7
  %8 = function_ref @_TTSgSbSbs7Boolean___TFs9_slowPathUs7Boolean__FQ_Sb : $@convention(thin) (Bool) -> Bool // user: %9
  %9 = apply %8(%6) : $@convention(thin) (Bool) -> Bool // user: %10
  %10 = struct_extract %9 : $Bool, #Bool._value    // user: %12
  dealloc_stack %1 : $*Bool      // id: %11
  cond_br %10, bb1, bb2                           // id: %12

bb1:                                              // Preds: bb0
  %13 = function_ref @coldcall : $@convention(thin) () -> () // user: %14
  %14 = apply %13() : $@convention(thin) () -> ()
  br bb2                                          // id: %15

bb2:                                              // Preds: bb0 bb1
  %16 = tuple ()                                  // user: %17
  return %16 : $()                                // id: %17
}

sil [transparent] @slowHelper : $@convention(thin) () -> () {
bb0:
  // make it a non-trivial function
  %f = function_ref @unknown_function : $@convention(thin) () -> ()
  %a1 = apply %f() : $@convention(thin) () -> ()
  %a2 = apply %f() : $@convention(thin) () -> ()
  %a3 = apply %f() : $@convention(thin) () -> ()
  %a4 = apply %f() : $@convention(thin) () -> ()
  %a5 = apply %f() : $@convention(thin) () -> ()
  %a6 = apply %f() : $@convention(thin) () -> ()
  %a7 = apply %f() : $@convention(thin) () -> ()
  %a8 = apply %f() : $@convention(thin) () -> ()
  %a9 = apply %f() : $@convention(thin) () -> ()
  %a10 = apply %f() : $@convention(thin) () -> ()
  %a11 = apply %f() : $@convention(thin) () -> ()
  %a12 = apply %f() : $@convention(thin) () -> ()
  %a13 = apply %f() : $@convention(thin) () -> ()
  %a14 = apply %f() : $@convention(thin) () -> ()
  %a15 = apply %f() : $@convention(thin) () -> ()
  %a16 = apply %f() : $@convention(thin) () -> ()
  %a17 = apply %f() : $@convention(thin) () -> ()
  %a18 = apply %f() : $@convention(thin) () -> ()
  %a19 = apply %f() : $@convention(thin) () -> ()
  %a20 = apply %f() : $@convention(thin) () -> ()
  %a21 = apply %f() : $@convention(thin) () -> ()
  %a22 = apply %f() : $@convention(thin) () -> ()
  %t = tuple ()
  return %t : $()
}

sil [transparent] [_semantics "fastpath"] @fastPathHelper : $@convention(thin) (Bool) -> Bool

// fastpath.closedTest0 () -> ()
// From <rdar://problem/17611447> _fastPath kills optimizer
// First test that the inliner is not inlining the slow call.
// Then test that same calls is not inlined when transparent.
// CHECK-LABEL:  @testNoInlineSlow
// CHECK-LABEL: bb0:
// CHECK: function_ref @fastPathHelper
// CHECK-LABEL: bb1:
// CHECK: function_ref @slowHelper
// CHECK-LABEL: bb2:
sil @testNoInlineSlow : $@convention(thin) () -> () {
bb0:
  %f1 = function_ref @fastPathHelper : $@convention(thin) (Bool) -> Bool
  %v9 = alloc_stack $Bool
  %v12 = integer_literal $Builtin.Int1, 0
  %v16 = struct $Bool (%v12 : $Builtin.Int1)
  store %v16 to %v9 : $*Bool                      // id: %17
  %v18 = apply %f1(%v16) : $@convention(thin) (Bool) -> Bool
  %v19 = struct_extract %v18 : $Bool, #Bool._value
  dealloc_stack %v9 : $*Bool      // id: %20
  cond_br %v19, bb2, bb1                           // id: %21

bb1:
  %f2 = function_ref @slowHelper : $@convention(thin) () -> ()
  %r2 = apply %f2() : $@convention(thin) () -> ()
  br bb2

bb2:
  %t3 = tuple ()
  return %t3 : $()
}

// CHECK-LABEL:  @testInlineSlowTransparent
// CHECK-LABEL: bb0:
// CHECK: function_ref @fastPathHelper
// CHECK-LABEL: bb1:
// CHECK: function_ref @slowHelper
// CHECK-LABEL: bb2:
sil @testInlineSlowTransparent : $@convention(thin) () -> () {
bb0:
  %f1 = function_ref @fastPathHelper : $@convention(thin) (Bool) -> Bool
  %v9 = alloc_stack $Bool
  %v12 = integer_literal $Builtin.Int1, 0
  %v16 = struct $Bool (%v12 : $Builtin.Int1)
  store %v16 to %v9 : $*Bool                      // id: %17
  %v18 = apply %f1(%v16) : $@convention(thin) (Bool) -> Bool
  %v19 = struct_extract %v18 : $Bool, #Bool._value
  dealloc_stack %v9 : $*Bool      // id: %20
  cond_br %v19, bb2, bb1                           // id: %21

bb1:
  %f2 = function_ref @slowHelper : $@convention(thin) () -> ()
  %r2 = apply %f2() : $@convention(thin) () -> ()
  br bb2

bb2:
  %t3 = tuple ()
  return %t3 : $()
}

// Attempt to ensure that calling the devirtualizer on a try_apply
// from the performance inliner doesn't result in an assert/crash.

class C {
  @inline(never) func callThrowing<T>(other: T, closure: () throws -> T) -> T
}

// CHECK-LABEL: sil [noinline] @callThrowing
sil [noinline] @callThrowing : $@convention(method) <T> (@in T, @owned @callee_owned () -> (@out T, @error Error), @guaranteed C) -> @out T {
bb0(%0 : $*T, %1 : $*T, %2 : $@callee_owned () -> (@out T, @error Error), %3 : $C):
  strong_retain %2 : $@callee_owned () -> (@out T, @error Error)
  try_apply %2(%0) : $@callee_owned () -> (@out T, @error Error), normal bb1, error bb4

bb1(%6 : $()):
  br bb2

bb2:
  strong_release %2 : $@callee_owned () -> (@out T, @error Error)
  destroy_addr %1 : $*T
  %10 = tuple ()
  return %10 : $()

bb3:
  copy_addr %1 to [initialization] %0 : $*T
  strong_release %15 : $Error
  br bb2

bb4(%15 : $Error):
  br bb3
}


// CHECK-LABEL: sil @callNonThrowing
sil @callNonThrowing : $@convention(thin) (@owned C) -> Int32 {
bb0(%0 : $C):
  %1 = integer_literal $Builtin.Int32, 1
  %2 = struct $Int32 (%1 : $Builtin.Int32)
  %3 = alloc_stack $Int32
  store %2 to %3 : $*Int32
  %5 = function_ref @theClosure : $@convention(thin) () -> (Int32, @error Error)
  %6 = thin_to_thick_function %5 : $@convention(thin) () -> (Int32, @error Error) to $@callee_owned () -> (Int32, @error Error)
  %7 = function_ref @reabstractionThunk : $@convention(thin) (@owned @callee_owned () -> (Int32, @error Error)) -> (@out Int32, @error Error)
  %8 = partial_apply %7(%6) : $@convention(thin) (@owned @callee_owned () -> (Int32, @error Error)) -> (@out Int32, @error Error)
  %9 = alloc_stack $Int32
  %10 = function_ref @callThrowing : $@convention(method) <τ_0_0> (@in τ_0_0, @owned @callee_owned () -> (@out τ_0_0, @error Error), @guaranteed C) -> @out τ_0_0
  %11 = apply %10<Int32>(%9, %3, %8, %0) : $@convention(method) <τ_0_0> (@in τ_0_0, @owned @callee_owned () -> (@out τ_0_0, @error Error), @guaranteed C) -> @out τ_0_0
  %12 = load %9 : $*Int32
  dealloc_stack %9 : $*Int32
  dealloc_stack %3 : $*Int32
  strong_release %0 : $C
// CHECK: return
  return %12 : $Int32
}


// CHECK-LABEL: sil @theClosure
sil @theClosure : $@convention(thin) () -> (Int32, @error Error) {
bb0:
  %0 = integer_literal $Builtin.Int32, 0
  %1 = struct $Int32 (%0 : $Builtin.Int32)
  return %1 : $Int32
}

// CHECK-LABEL: sil [transparent] [reabstraction_thunk] @reabstractionThunk
sil [transparent] [reabstraction_thunk] @reabstractionThunk : $@convention(thin) (@owned @callee_owned () -> (Int32, @error Error)) -> (@out Int32, @error Error) {
bb0(%0 : $*Int32, %1 : $@callee_owned () -> (Int32, @error Error)):
  try_apply %1() : $@callee_owned () -> (Int32, @error Error), normal bb1, error bb2

bb1(%3 : $Int32):
  store %3 to %0 : $*Int32
  %5 = tuple ()
  return %5 : $()

bb2(%7 : $Error):
  %8 = builtin "willThrow"(%7 : $Error) : $()
  throw %7 : $Error
}

sil_vtable C {
  #C.callThrowing!1: callThrowing
}