averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
maxd/docc-compiler-docs
swift-mirror/test/Concurrency/silisolationinfo_inference.sil
Michael Gottesman 0ece31e4f6 [sil-isolation-info] When determining isolation of a function arg, use its VarDecl. 
Otherwise, we can be inconsistent with isolations returned by other parts of the
code. Previously we were just treating it always as self + nom decl, which is
clearly wrong if a type is not self (e.x.: if it is an isolated parameter).

rdar://135459885
2025-04-17 18:12:30 -07:00

898 lines
39 KiB
Plaintext
Raw Permalink Blame History

// 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 : $()
}
// CHECK-LABEL: begin running test 1 of 1 on sending_indirect_result_isnt_actor_isolated: sil_isolation_info_inference with: @trace[0]
// CHECK-NEXT: Input Value: %0 = argument of bb0 : $*Optional<τ_0_0> // user: %2
// CHECK-NEXT: Isolation: disconnected
// CHECK-NEXT: end running test 1 of 1 on sending_indirect_result_isnt_actor_isolated: sil_isolation_info_inference with: @trace[0]
sil [ossa] @sending_indirect_result_isnt_actor_isolated : $@convention(thin) @async <τ_0_0> (@sil_isolated @guaranteed MyActor) -> (@sil_sending @out Optional<τ_0_0>) {
bb0(%0 : $*Optional<τ_0_0>, %1 : @guaranteed $MyActor):
specify_test "sil_isolation_info_inference @trace[0]"
debug_value [trace] %0 : $*Optional<τ_0_0>
inject_enum_addr %0 : $*Optional<τ_0_0>, #Optional.none!enumelt
%9999 = tuple ()
return %9999 : $()
}
sil @myactor_sending_result_sync : $@convention(method) <τ_0_0> (@sil_isolated @guaranteed MyActor) -> @sil_sending @out τ_0_0
// CHECK: begin running test 1 of 1 on sending_indirect_result_isnt_actor_isolated_apply: sil_isolation_info_inference with: @trace[0]
// CHECK-NEXT: Input Value: %3 = alloc_stack $T // users: %6, %5, %4
// CHECK-NEXT: Isolation: disconnected
// CHECK-NEXT: end running test 1 of 1 on sending_indirect_result_isnt_actor_isolated_apply: sil_isolation_info_inference with: @trace[0]
sil [ossa] @sending_indirect_result_isnt_actor_isolated_apply : $@convention(method) @async <T> (@sil_isolated @guaranteed MyActor) -> @sil_sending @out T {
bb0(%0 : $*T, %1 : @guaranteed $MyActor):
specify_test "sil_isolation_info_inference @trace[0]"
%4 = function_ref @myactor_sending_result_sync : $@convention(method) <τ_0_0> (@sil_isolated @guaranteed MyActor) -> @sil_sending @out τ_0_0
%2 = alloc_stack $T
debug_value [trace] %2 : $*T
%5 = apply %4<T>(%2, %1) : $@convention(method) <τ_0_0> (@sil_isolated @guaranteed MyActor) -> @sil_sending @out τ_0_0
copy_addr [take] %2 to [init] %0 : $*T
dealloc_stack %2 : $*T
%6 = tuple ()
return %6 : $()
}
sil @myactor_sending_result_sync_throws : $@convention(method) <τ_0_0> (@sil_isolated @guaranteed MyActor) -> (@sil_sending @out τ_0_0, @error any Error)
// CHECK-LABEL: begin running test 1 of 1 on sending_indirect_result_isnt_actor_isolated_try_apply: sil_isolation_info_inference with: @trace[0]
// CHECK-NEXT: Input Value: %3 = alloc_stack $T
// CHECK-NEXT: Isolation: disconnected
// CHECK-NEXT: end running test 1 of 1 on sending_indirect_result_isnt_actor_isolated_try_apply: sil_isolation_info_inference with: @trace[0]
sil [ossa] @sending_indirect_result_isnt_actor_isolated_try_apply : $@convention(method) @async <T> (@sil_isolated @guaranteed MyActor) -> (@sil_sending @out T, @error any Error) {
bb0(%0 : $*T, %1 : @guaranteed $MyActor):
specify_test "sil_isolation_info_inference @trace[0]"
%5 = function_ref @myactor_sending_result_sync_throws : $@convention(method) <τ_0_0> (@sil_isolated @guaranteed MyActor) -> (@sil_sending @out τ_0_0, @error any Error)
%2 = alloc_stack $*T
try_apply %5<T>(%2, %1) : $@convention(method) <τ_0_0> (@sil_isolated @guaranteed MyActor) -> (@sil_sending @out τ_0_0, @error any Error), normal bb1, error bb2
bb1(%7 : $()):
copy_addr [take] %2 to [init] %0 : $*T
debug_value [trace] %2 : $*T
dealloc_stack %2 : $*T
%8 = tuple ()
return %8 : $()
bb2(%10 : @owned $any Error):
dealloc_stack %2 : $*T
throw %10 : $any Error
}
// CHECK-LABEL: begin running test 1 of 1 on optional_test: sil_isolation_info_inference with: @trace[0]
// CHECK-NEXT: Input Value: %5 = ref_element_addr %4 : $MyActor, #MyActor.ns
// CHECK-NEXT: Isolation: 'argument'-isolated
// CHECK-NEXT: end running test 1 of 1 on optional_test: sil_isolation_info_inference with: @trace[0]
sil [ossa] @optional_test : $@convention(thin) (@sil_isolated @guaranteed Optional<MyActor>) -> () {
bb0(%0 : @guaranteed $Optional<MyActor>):
specify_test "sil_isolation_info_inference @trace[0]"
debug_value %0 : $Optional<MyActor>, let, name "argument"
%1a = copy_value %0 : $Optional<MyActor>
%1b = begin_borrow %1a
%1c = unchecked_enum_data %1b : $Optional<MyActor>, #Optional.some!enumelt
%1d = ref_element_addr %1c : $MyActor, #MyActor.ns
debug_value [trace] %1d
end_borrow %1b
destroy_value %1a
%9999 = tuple ()
return %9999 : $()
}
Reference in New Issue View Git Blame Copy Permalink