mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
0cad62521e
Use underscores rather than hyphens so that text editors understand the name as a single word.
822 lines
35 KiB
Plaintext
822 lines
35 KiB
Plaintext
// RUN: %target-sil-opt -module-name infer --test-runner %s 2>&1 | %FileCheck %s
|
|
|
|
// REQUIRES: concurrency
|
|
// REQUIRES: asserts
|
|
|
|
// PLEASE READ THIS!
|
|
//
|
|
// This test is specifically meant to test how we infer isolation for specific
|
|
// values.
|
|
|
|
sil_stage raw
|
|
|
|
import Swift
|
|
import Builtin
|
|
import _Concurrency
|
|
|
|
////////////////////////
|
|
// MARK: Declarations //
|
|
////////////////////////
|
|
|
|
class NonSendableKlass {
|
|
}
|
|
|
|
actor MyActor {
|
|
var ns: NonSendableKlass
|
|
|
|
func doSomething() async -> NonSendableKlass
|
|
}
|
|
|
|
sil @transferNonSendableKlass : $@convention(thin) @async (@guaranteed NonSendableKlass) -> ()
|
|
sil @useNonSendableKlass : $@convention(thin) (@guaranteed NonSendableKlass) -> ()
|
|
sil @constructNonSendableKlass : $@convention(thin) () -> @owned NonSendableKlass
|
|
sil @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
sil @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
sil @useUnmanagedNonSendableKlass : $@convention(thin) (@guaranteed @sil_unmanaged NonSendableKlass) -> ()
|
|
|
|
sil @useActor : $@convention(thin) (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
sil @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
|
|
///////////////////////
|
|
// MARK: Basic Tests //
|
|
///////////////////////
|
|
|
|
// For now we always infer an actor as having unknown isolation since we only
|
|
// talk about isolation of an actor (or other Sendable types).
|
|
//
|
|
// CHECK: begin running test 1 of 1 on actor_self_isolation_unknown: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = argument of bb0 : $MyActor
|
|
// CHECK-NEXT: Isolation: unknown
|
|
// CHECK-NEXT: end running test 1 of 1 on actor_self_isolation_unknown: sil_isolation_info_inference with: @trace[0]
|
|
sil [ossa] @actor_self_isolation_unknown : $@convention(thin) (@guaranteed MyActor) -> () {
|
|
bb0(%0 : @guaranteed $MyActor):
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
debug_value [trace] %0 : $MyActor
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on actor_field_isolation: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %2 = ref_element_addr %0 : $MyActor
|
|
// CHECK-NEXT: Isolation: 'argument'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on actor_field_isolation: sil_isolation_info_inference with: @trace[0]
|
|
sil [ossa] @actor_field_isolation : $@convention(thin) (@guaranteed MyActor) -> () {
|
|
bb0(%0 : @guaranteed $MyActor):
|
|
debug_value %0 : $MyActor, let, name "argument"
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
%1 = ref_element_addr %0 : $MyActor, #MyActor.ns
|
|
debug_value [trace] %1 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
/////////////////////////////////
|
|
// MARK: Temporary Alloc Stack //
|
|
/////////////////////////////////
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_infer_from_indirect_arg_same_block: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_infer_from_indirect_arg_same_block: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_infer_from_indirect_arg_same_block : $@convention(thin) () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
%0 = alloc_stack $NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_infer_from_indirect_arg_with_isolation_same_block: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: global actor '<null>'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_infer_from_indirect_arg_with_isolation_same_block: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_infer_from_indirect_arg_with_isolation_same_block : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
%0 = alloc_stack $NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_infer_failure_write_before_in_same_block: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_infer_failure_write_before_in_same_block: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_infer_failure_write_before_in_same_block : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
|
|
// First call without transferring (performing a write).
|
|
%f = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
// Then do it indirect. The write before should have inhibited the inference.
|
|
%f2 = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f2(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_infer_failure_ignore_later_same_block_init: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: global actor '<null>'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_infer_failure_ignore_later_same_block_init: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_infer_failure_ignore_later_same_block_init : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_infer_failure_ignore_later_same_block_init_2: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: actor-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_infer_failure_ignore_later_same_block_init_2: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_infer_failure_ignore_later_same_block_init_2 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_simple: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: actor-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_simple: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_simple : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_disrupting_write: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_disrupting_write: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_disrupting_write : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
// First call without transferring (performing a write).
|
|
%f2 = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f2(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_disrupting_write_2: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_disrupting_write_2: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_disrupting_write_2 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
// First call without transferring (performing a write).
|
|
%f2 = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f2(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb3:
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_disrupting_write_3: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_disrupting_write_3: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_disrupting_write_3 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
|
|
// First call without transferring (performing a write).
|
|
%f2 = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f2(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_matching_inits: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_matching_inits: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_matching_inits : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb2:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb3:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_matching_inits_2: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_matching_inits_2: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_matching_inits_2 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb2:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb3:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// If we see multiple initializations, just leave it as disconnected. This is
|
|
// more conservative.
|
|
//
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_conflicting_inits: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_conflicting_inits: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_conflicting_inits : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb2:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb3:
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// If we see multiple initializations along any path... we need to be disconnected.
|
|
//
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_conflicting_inits_2: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_conflicting_inits_2: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_conflicting_inits_2 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=actor_instance] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// More complex CFG work with a loop.
|
|
//
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: global actor '<null>'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_larger_cfg : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
br bb4
|
|
|
|
bb4:
|
|
br bb5
|
|
|
|
bb5:
|
|
cond_br undef, bb4, bb6
|
|
|
|
bb6:
|
|
br bb7
|
|
|
|
bb7:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_2: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: global actor '<null>'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_2: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_larger_cfg_2 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
br bb4
|
|
|
|
bb4:
|
|
br bb5
|
|
|
|
bb5:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
cond_br undef, bb4, bb6
|
|
|
|
bb6:
|
|
br bb7
|
|
|
|
bb7:
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_3: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: global actor '<null>'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_3: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_larger_cfg_3 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
br bb4
|
|
|
|
bb4:
|
|
br bb5
|
|
|
|
bb5:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
cond_br undef, bb4, bb6
|
|
|
|
bb6:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb7
|
|
|
|
bb7:
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_4: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_4: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_larger_cfg_4 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
%f2 = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f2(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb3
|
|
|
|
bb3:
|
|
br bb4
|
|
|
|
bb4:
|
|
br bb5
|
|
|
|
bb5:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
cond_br undef, bb4, bb6
|
|
|
|
bb6:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb7
|
|
|
|
bb7:
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_5: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: global actor '<null>'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_5: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_larger_cfg_5 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
br bb4
|
|
|
|
bb4:
|
|
br bb5
|
|
|
|
bb5:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
cond_br undef, bb5a, bb6
|
|
|
|
bb5a:
|
|
%f2 = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f2(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb4
|
|
|
|
bb6:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb7
|
|
|
|
bb7:
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK: begin running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_6: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %0 = alloc_stack $NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on temp_alloc_stack_different_block_larger_cfg_6: sil_isolation_info_inference with: @trace[0]
|
|
sil @temp_alloc_stack_different_block_larger_cfg_6 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
|
|
%0 = alloc_stack $NonSendableKlass
|
|
debug_value [trace] %0 : $*NonSendableKlass
|
|
%f = function_ref @constructNonSendableKlassIndirectAsync : $@convention(thin) @async () -> @out NonSendableKlass
|
|
|
|
cond_br undef, bb1, bb2
|
|
|
|
bb1:
|
|
br bb3
|
|
|
|
bb2:
|
|
br bb3
|
|
|
|
bb3:
|
|
br bb4
|
|
|
|
bb4:
|
|
br bb5
|
|
|
|
bb5:
|
|
cond_br undef, bb5a, bb6
|
|
|
|
bb5a:
|
|
%f2 = function_ref @constructNonSendableKlassIndirect : $@convention(thin) () -> @out NonSendableKlass
|
|
apply %f2(%0) : $@convention(thin) () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb4
|
|
|
|
bb6:
|
|
apply [caller_isolation=nonisolated] [callee_isolation=global_actor] %f(%0) : $@convention(thin) @async () -> @out NonSendableKlass
|
|
destroy_addr %0 : $*NonSendableKlass
|
|
br bb7
|
|
|
|
bb7:
|
|
dealloc_stack %0 : $*NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: begin running test 1 of 1 on lookthrough_test: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %7 = apply %6(%5) : $@convention(thin) (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: Isolation: 'argument'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on lookthrough_test: sil_isolation_info_inference with: @trace[0]
|
|
sil [ossa] @lookthrough_test : $@convention(thin) (@owned MyActor) -> @owned NonSendableKlass {
|
|
bb0(%0 : @owned $MyActor):
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
debug_value %0 : $MyActor, let, name "argument"
|
|
%1 = end_init_let_ref %0 : $MyActor
|
|
%1a = copy_value %1 : $MyActor
|
|
%1b = move_value %1a : $MyActor
|
|
%1c = begin_borrow %1b : $MyActor
|
|
%2 = function_ref @useActor : $@convention(thin) (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
%3 = apply %2(%1c) : $@convention(thin) (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
debug_value [trace] %3 : $NonSendableKlass
|
|
end_borrow %1c : $MyActor
|
|
destroy_value %1 : $MyActor
|
|
destroy_value %1b : $MyActor
|
|
return %3 : $NonSendableKlass
|
|
}
|
|
|
|
// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_1: sil_isolation_info_inference with: @trace[0]
|
|
// CHECK-NEXT: Input Value: %2 = apply %1(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: Isolation: disconnected
|
|
// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_1: sil_isolation_info_inference with: @trace[0]
|
|
sil [ossa] @isolated_variable_test_1 : $@convention(thin) @async () -> () {
|
|
bb0:
|
|
specify_test "sil_isolation_info_inference @trace[0]"
|
|
%0 = enum $Optional<MyActor>, #Optional.none
|
|
%1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
%2 = apply %1(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
//debug_value [trace] %1 : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
debug_value [trace] %2 : $NonSendableKlass
|
|
destroy_value %2 : $NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
sil @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
|
|
// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_2:
|
|
// CHECK-NEXT: First Value: %3 = apply %2(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: First Isolation: 'self'-isolated
|
|
// CHECK-NEXT: Second Value: %6 = apply %4(%5) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: Second Isolation: 'self'-isolated
|
|
// CHECK-NEXT: Merged Isolation: 'self'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_2: sil-isolation-info-merged-inference with: @trace[0], @trace[1]
|
|
sil [ossa] @isolated_variable_test_2 : $@convention(thin) @async (@guaranteed Optional<MyActor>) -> () {
|
|
bb0(%0 : @guaranteed $Optional<MyActor>):
|
|
debug_value %0 : $Optional<MyActor>, let, name "self"
|
|
specify_test "sil-isolation-info-merged-inference @trace[0] @trace[1]"
|
|
%1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
%2 = apply %1(%0) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
%3 = function_ref @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
%0a = unchecked_enum_data %0 : $Optional<MyActor>, #Optional.some!enumelt
|
|
%4 = apply %3(%0a) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
debug_value [trace] %2 : $NonSendableKlass
|
|
debug_value [trace] %4 : $NonSendableKlass
|
|
destroy_value %2 : $NonSendableKlass
|
|
destroy_value %4 : $NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_3:
|
|
// CHECK-NEXT: First Value: %4 = apply %2(%3) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: First Isolation: 'self'-isolated
|
|
// CHECK-NEXT: Second Value: %6 = apply %5(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: Second Isolation: 'self'-isolated
|
|
// CHECK-NEXT: Merged Isolation: 'self'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_3: sil-isolation-info-merged-inference with: @trace[0], @trace[1]
|
|
sil [ossa] @isolated_variable_test_3 : $@convention(thin) @async (@guaranteed MyActor) -> () {
|
|
bb0(%0 : @guaranteed $MyActor):
|
|
debug_value %0 : $MyActor, let, name "self"
|
|
specify_test "sil-isolation-info-merged-inference @trace[0] @trace[1]"
|
|
%1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
%0a = enum $Optional<MyActor>, #Optional.some!enumelt, %0 : $MyActor
|
|
%2 = apply %1(%0a) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
%3 = function_ref @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
%4 = apply %3(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
debug_value [trace] %2 : $NonSendableKlass
|
|
debug_value [trace] %4 : $NonSendableKlass
|
|
destroy_value %2 : $NonSendableKlass
|
|
destroy_value %4 : $NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|
|
|
|
// CHECK-LABEL: begin running test 1 of 1 on isolated_variable_test_4:
|
|
// CHECK-NEXT: First Value: %8 = apply %2(%7) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: First Isolation: 'self'-isolated
|
|
// CHECK-NEXT: Second Value: %10 = apply %9(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
// CHECK-NEXT: Second Isolation: 'self'-isolated
|
|
// CHECK-NEXT: Merged Isolation: 'self'-isolated
|
|
// CHECK-NEXT: end running test 1 of 1 on isolated_variable_test_4: sil-isolation-info-merged-inference with: @trace[0], @trace[1]
|
|
sil [ossa] @isolated_variable_test_4 : $@convention(thin) @async (@guaranteed MyActor) -> () {
|
|
bb0(%0 : @guaranteed $MyActor):
|
|
debug_value %0 : $MyActor, let, name "self"
|
|
specify_test "sil-isolation-info-merged-inference @trace[0] @trace[1]"
|
|
%1 = function_ref @useOptionalActor : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
%0a = init_existential_ref %0 : $MyActor : $MyActor, $AnyObject
|
|
%0b = unconditional_checked_cast %0a : $AnyObject to MyActor
|
|
%0c = unchecked_ref_cast %0b : $MyActor to $AnyObject
|
|
%0d = unchecked_ref_cast %0c : $AnyObject to $MyActor
|
|
%0e = enum $Optional<MyActor>, #Optional.some!enumelt, %0d : $MyActor
|
|
%2 = apply %1(%0e) : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> @owned NonSendableKlass
|
|
%3 = function_ref @$s5infer7MyActorC11doSomethingAA16NonSendableKlassCyYaF : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
%4 = apply %3(%0) : $@convention(method) @async (@sil_isolated @guaranteed MyActor) -> @owned NonSendableKlass
|
|
debug_value [trace] %2 : $NonSendableKlass
|
|
debug_value [trace] %4 : $NonSendableKlass
|
|
destroy_value %2 : $NonSendableKlass
|
|
destroy_value %4 : $NonSendableKlass
|
|
%9999 = tuple ()
|
|
return %9999 : $()
|
|
}
|