swift-mirror/test/IRGen/async/run-partialapply-capture-generic_conformer-and-generic-to-void.sil

// 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 _Concurrency

sil public_external @printGeneric : $@convention(thin) <T> (@in_guaranteed T) -> ()
sil public_external @printInt64 : $@convention(thin) (Int64) -> ()

public protocol Observable {
  associatedtype Result
  func subscribe<T: Observer>(o: T) async -> ()
}
class ObservableImpl : Observable {
  typealias Result = Void
  func subscribe<T: Observer>(o: T) async -> ()
}
sil_vtable ObservableImpl {
}
// CHECK-LL: define hidden swift{{(tail)?}}cc void @subscribe_ObservableImpl_Observable(
sil hidden @subscribe_ObservableImpl_Observable : $@convention(witness_method: Observable) @async <τ_0_0 where τ_0_0 : Observer> (@in_guaranteed τ_0_0, @in_guaranteed ObservableImpl) -> () {
bb0(%observer : $*τ_0_0, %self : $*ObservableImpl):
  %printGeneric = function_ref @printGeneric : $@convention(thin) <T> (@in_guaranteed T) -> ()
  %printGeneric_result1 = apply %printGeneric<τ_0_0>(%observer) : $@convention(thin) <T> (@in_guaranteed T) -> () // CHECK: main.ObserverImpl
  %printGeneric_result2 = apply %printGeneric<ObservableImpl>(%self) : $@convention(thin) <T> (@in_guaranteed T) -> () // CHECK: main.ObservableImpl
  %result = tuple ()
  return %result : $()
}
sil_witness_table ObservableImpl : Observable module main {
  associated_type Result : ()
  method #Observable.subscribe: <Self where Self : Observable><T where T : Observer> (Self) -> (T) async -> () : @subscribe_ObservableImpl_Observable
}

public protocol Observer {
  associatedtype Result
}

class ObserverImpl : Observer {
  typealias Result = Void
}
sil_vtable ObserverImpl {}
sil_witness_table ObserverImpl : Observer module main {
    associated_type Result : ()
}

sil hidden @witness_method : $@async @convention(thin) <S where S : Observable><O where O : Observer, S.Result == O.Result> (@in S) -> @owned @async @callee_guaranteed (@in O) -> () {
bb0(%0 : $*S):
  %1 = witness_method $S, #Observable.subscribe : $@async @convention(witness_method: Observable) <τ_0_0 where τ_0_0 : Observable><τ_1_0 where τ_1_0 : Observer, τ_0_0.Result == τ_1_0.Result> (@in τ_1_0, @in_guaranteed τ_0_0) -> ()
  %2 = partial_apply [callee_guaranteed] %1<S, O>(%0) : $@async @convention(witness_method: Observable) <τ_0_0 where τ_0_0 : Observable><τ_1_0 where τ_1_0 : Observer, τ_0_0.Result == τ_1_0.Result> (@in τ_1_0, @in_guaranteed τ_0_0) -> ()
  return %2 : $@async @callee_guaranteed (@in O) -> ()
}


sil @test_case : $@convention(thin) @async () -> () {
  %observableImpl = alloc_ref $ObservableImpl
  strong_retain %observableImpl : $ObservableImpl
  %observableImpl_addr = alloc_stack $ObservableImpl
  store %observableImpl to %observableImpl_addr : $*ObservableImpl
  %witness_method = function_ref @witness_method : $@async @convention(thin) <S where S : Observable><O where O : Observer, S.Result == O.Result> (@in S) -> @owned @async @callee_guaranteed (@in O) -> ()
  %partiallyApplied = apply %witness_method<ObservableImpl, ObserverImpl>(%observableImpl_addr) : $@async @convention(thin) <S where S : Observable><O where O : Observer, S.Result == O.Result> (@in S) -> @owned @async @callee_guaranteed (@in O) -> ()
  %observerImpl = alloc_ref $ObserverImpl
  %observerImpl_addr = alloc_stack $ObserverImpl
  store %observerImpl to %observerImpl_addr : $*ObserverImpl

  %result = apply %partiallyApplied(%observerImpl_addr) : $@async @callee_guaranteed (@in ObserverImpl) -> ()

  dealloc_stack %observerImpl_addr : $*ObserverImpl
  dealloc_stack %observableImpl_addr : $*ObservableImpl

  %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
}