// RUN: %empty-directory(%t)
// RUN: %target-build-swift-dylib(%t/%target-library-name(PrintShims)) %S/../../Inputs/print-shims.swift -module-name PrintShims -emit-module -emit-module-path %t/PrintShims.swiftmodule
// RUN: %target-codesign %t/%target-library-name(PrintShims)
// RUN: %target-build-swift  -g -parse-sil %s -emit-ir -I %t -L %t -lPrintShim | %FileCheck %s --check-prefix=CHECK-LL
// RUN: %target-build-swift  -g -parse-sil %s -module-name main -o %t/main -I %t -L %t -lPrintShims %target-rpath(%t) 
// RUN: %target-codesign %t/main
// RUN: %target-run %t/main %t/%target-library-name(PrintShims) | %FileCheck %s

// REQUIRES: executable_test
// REQUIRES: swift_test_mode_optimize_none
// REQUIRES: concurrency
// REQUIRES: concurrency_runtime
// UNSUPPORTED: back_deployment_runtime


import Builtin
import Swift
import PrintShims
import _Concurrency

sil public_external @printAny : $@convention(thin) (@in_guaranteed Any) -> ()





class S {
  func classinstanceSInt64ToVoid(_ int: Int64) async
  deinit
  init()
}

// CHECK-LL: @classinstanceSInt64ToVoidTu =
// CHECK-LL: define hidden swift{{(tail)?}}cc void @classinstanceSInt64ToVoid(
sil hidden @classinstanceSInt64ToVoid : $@async @convention(method) (Int64, @guaranteed S) -> () {
bb0(%int : $Int64, %instance : $S):
  %take_s = function_ref @take_S : $@async @convention(thin) (@guaranteed S) -> ()
  %result = apply %take_s(%instance) : $@async @convention(thin) (@guaranteed S) -> ()
  return %result : $()
}

sil hidden @take_S : $@async @convention(thin) (@guaranteed S) -> () {
bb0(%instance : $S):
  %any = alloc_stack $Any
  strong_retain %instance : $S
  %any_addr = init_existential_addr %any : $*Any, $S
  store %instance to %any_addr : $*S
  %print_any = function_ref @printAny : $@convention(thin) (@in_guaranteed Any) -> ()
  %result = apply %print_any(%any) : $@convention(thin) (@in_guaranteed Any) -> ()
  destroy_addr %any_addr : $*S
  dealloc_stack %any : $*Any
  return %result : $()
}

sil hidden [exact_self_class] @S_allocating_init : $@convention(method) (@thick S.Type) -> @owned S {
bb0(%0 : $@thick S.Type):
  %1 = alloc_ref $S
  %2 = function_ref @$S_init : $@convention(method) (@owned S) -> @owned S
  %3 = apply %2(%1) : $@convention(method) (@owned S) -> @owned S
  return %3 : $S
}

sil hidden @$S_init : $@convention(method) (@owned S) -> @owned S {
bb0(%0 : $S):
  return %0 : $S
}

sil hidden @$S_deinit : $@convention(method) (@guaranteed S) -> @owned Builtin.NativeObject {
bb0(%0 : $S):
  %2 = unchecked_ref_cast %0 : $S to $Builtin.NativeObject
  return %2 : $Builtin.NativeObject
}

sil hidden @S_deallocating_deinit : $@convention(method) (@owned S) -> () {
bb0(%0 : $S):
  %2 = function_ref @$S_deinit : $@convention(method) (@guaranteed S) -> @owned Builtin.NativeObject
  %3 = apply %2(%0) : $@convention(method) (@guaranteed S) -> @owned Builtin.NativeObject
  %4 = unchecked_ref_cast %3 : $Builtin.NativeObject to $S
  dealloc_ref %4 : $S
  %6 = tuple ()
  return %6 : $()
}

sil_vtable S {
  #S.classinstanceSInt64ToVoid: (S) -> (Int64) async -> () : @classinstanceSInt64ToVoid
  #S.init!allocator: (S.Type) -> () -> S : @S_allocating_init
  #S.deinit!deallocator: @S_deallocating_deinit
}

sil @test_case : $@convention(thin) @async () -> () {
  %s_type = metatype $@thick S.Type
  %allocating_init = function_ref @S_allocating_init : $@convention(method) (@thick S.Type) -> @owned S
  %instance = apply %allocating_init(%s_type) : $@convention(method) (@thick S.Type) -> @owned S
  %classinstanceSInt64ToVoid = class_method %instance : $S, #S.classinstanceSInt64ToVoid : (S) -> (Int64) async -> (), $@convention(method) @async (Int64, @guaranteed S) -> ()
  strong_retain %instance : $S
  %int_literal = integer_literal $Builtin.Int64, 42
  %int = struct $Int64 (%int_literal : $Builtin.Int64)
  %result = apply %classinstanceSInt64ToVoid(%int, %instance) : $@convention(method) @async (Int64, @guaranteed S) -> () // CHECK: main.S
  strong_release %instance : $S

  %void = tuple()
  return %void : $()
}

// Defined in _Concurrency
sil @$ss13_runAsyncMainyyyyYaKcF : $@convention(thin) (@guaranteed @async @callee_guaranteed () -> @error Error) -> ()

sil @no_throw_to_throw_think : $@convention(thin) @async (@guaranteed @async @callee_guaranteed () -> ()) -> @error Error {
bb0(%0 :$@async @callee_guaranteed () -> ()):
  %void = apply %0() : $@async @callee_guaranteed () -> ()
  return %void : $()
}

// main
sil @main : $@convention(c) () -> Int32 {
  %test_case_nothrow = function_ref @test_case : $@convention(thin) @async () -> ()
  %thick_test_case = thin_to_thick_function %test_case_nothrow : $@convention(thin) @async () -> () to $@callee_guaranteed @async () -> ()
  %thunk = function_ref @no_throw_to_throw_think : $@convention(thin) @async (@guaranteed @async @callee_guaranteed () -> ()) -> @error Error
  %throwing = partial_apply [callee_guaranteed] %thunk(%thick_test_case) : $@convention(thin) @async (@guaranteed @async @callee_guaranteed () -> ()) -> @error Error
  %runAsyncMain = function_ref @$ss13_runAsyncMainyyyyYaKcF : $@convention(thin) (@guaranteed @async @callee_guaranteed () -> @error Error) -> ()
  %result = apply %runAsyncMain(%throwing) : $@convention(thin) (@guaranteed @async @callee_guaranteed () -> @error Error) -> ()
  %out_literal = integer_literal $Builtin.Int32, 0
  %out = struct $Int32 (%out_literal : $Builtin.Int32)
  return %out : $Int32
}