| // RUN: %target-swift-frontend -emit-silgen %s | %FileCheck %s |
| |
| func takeClosure(_ fn: () -> Int) {} |
| |
| class C { |
| func f() -> Int { return 42 } |
| } |
| |
| struct A { |
| unowned var x: C |
| } |
| _ = A(x: C()) |
| // CHECK-LABEL: sil hidden @_TFV7unowned1AC |
| // CHECK: bb0([[X:%.*]] : $C, %1 : $@thin A.Type): |
| // CHECK: [[X_UNOWNED:%.*]] = ref_to_unowned [[X]] : $C to $@sil_unowned C |
| // CHECK: unowned_retain [[X_UNOWNED]] |
| // CHECK: strong_release [[X]] |
| // CHECK: [[A:%.*]] = struct $A ([[X_UNOWNED]] : $@sil_unowned C) |
| // CHECK: return [[A]] |
| // CHECK: } |
| |
| protocol P {} |
| struct X: P {} |
| |
| struct AddressOnly { |
| unowned var x: C |
| var p: P |
| } |
| _ = AddressOnly(x: C(), p: X()) |
| // CHECK-LABEL: sil hidden @_TFV7unowned11AddressOnlyC |
| // CHECK: bb0([[RET:%.*]] : $*AddressOnly, [[X:%.*]] : $C, {{.*}}): |
| // CHECK: [[X_ADDR:%.*]] = struct_element_addr [[RET]] : $*AddressOnly, #AddressOnly.x |
| // CHECK: [[X_UNOWNED:%.*]] = ref_to_unowned [[X]] : $C to $@sil_unowned C |
| // CHECK: unowned_retain [[X_UNOWNED]] : $@sil_unowned C |
| // CHECK: store [[X_UNOWNED]] to [[X_ADDR]] |
| // CHECK: strong_release [[X]] |
| // CHECK: } |
| |
| // CHECK-LABEL: sil hidden @_TF7unowned5test0FT1cCS_1C_T_ : $@convention(thin) (@owned C) -> () { |
| func test0(c c: C) { |
| // CHECK: bb0(%0 : $C): |
| |
| var a: A |
| // CHECK: [[A1:%.*]] = alloc_box $A |
| // CHECK: [[PBA:%.*]] = project_box [[A1]] |
| // CHECK: [[A:%.*]] = mark_uninitialized [var] [[PBA]] |
| |
| unowned var x = c |
| // CHECK: [[X:%.*]] = alloc_box $@sil_unowned C |
| // CHECK-NEXT: [[PBX:%.*]] = project_box [[X]] |
| // CHECK-NEXT: [[T2:%.*]] = ref_to_unowned %0 : $C to $@sil_unowned C |
| // CHECK-NEXT: unowned_retain [[T2]] : $@sil_unowned C |
| // CHECK-NEXT: store [[T2]] to [[PBX]] : $*@sil_unowned C |
| |
| a.x = c |
| // CHECK-NEXT: [[T1:%.*]] = struct_element_addr [[A]] : $*A, #A.x |
| // CHECK-NEXT: [[T2:%.*]] = ref_to_unowned %0 : $C |
| // CHECK-NEXT: unowned_retain [[T2]] : $@sil_unowned C |
| // CHECK-NEXT: assign [[T2]] to [[T1]] : $*@sil_unowned C |
| |
| a.x = x |
| // CHECK-NEXT: [[T2:%.*]] = load [[PBX]] : $*@sil_unowned C |
| // CHECK-NEXT: strong_retain_unowned [[T2]] : $@sil_unowned C |
| // CHECK-NEXT: [[T3:%.*]] = unowned_to_ref [[T2]] : $@sil_unowned C to $C |
| // CHECK-NEXT: [[XP:%.*]] = struct_element_addr [[A]] : $*A, #A.x |
| // CHECK-NEXT: [[T4:%.*]] = ref_to_unowned [[T3]] : $C to $@sil_unowned C |
| // CHECK-NEXT: unowned_retain [[T4]] : $@sil_unowned C |
| // CHECK-NEXT: assign [[T4]] to [[XP]] : $*@sil_unowned C |
| // CHECK-NEXT: strong_release [[T3]] : $C |
| } |
| |
| // CHECK-LABEL: sil hidden @{{.*}}unowned_local |
| func unowned_local() -> C { |
| // CHECK: [[c:%.*]] = apply |
| let c = C() |
| |
| // CHECK: [[uc:%.*]] = alloc_box $@sil_unowned C, let, name "uc" |
| // CHECK-NEXT: [[PB:%.*]] = project_box [[uc]] |
| // CHECK-NEXT: [[tmp1:%.*]] = ref_to_unowned [[c]] : $C to $@sil_unowned C |
| // CHECK-NEXT: unowned_retain [[tmp1]] |
| // CHECK-NEXT: store [[tmp1]] to [[PB]] |
| unowned let uc = c |
| |
| // CHECK-NEXT: [[tmp2:%.*]] = load [[PB]] |
| // CHECK-NEXT: strong_retain_unowned [[tmp2]] |
| // CHECK-NEXT: [[tmp3:%.*]] = unowned_to_ref [[tmp2]] |
| return uc |
| |
| // CHECK-NEXT: strong_release [[uc]] |
| // CHECK-NEXT: strong_release [[c]] |
| // CHECK-NEXT: return [[tmp3]] |
| } |
| |
| // <rdar://problem/16877510> capturing an unowned let crashes in silgen |
| func test_unowned_let_capture(_ aC : C) { |
| unowned let bC = aC |
| takeClosure { bC.f() } |
| } |
| |
| // CHECK-LABEL: sil shared @_TFF7unowned24test_unowned_let_captureFCS_1CT_U_FT_Si : $@convention(thin) (@owned @sil_unowned C) -> Int { |
| // CHECK: bb0([[ARG:%.*]] : $@sil_unowned C): |
| // CHECK-NEXT: debug_value %0 : $@sil_unowned C, let, name "bC", argno 1 |
| // CHECK-NEXT: strong_retain_unowned [[ARG]] : $@sil_unowned C |
| // CHECK-NEXT: [[UNOWNED_ARG:%.*]] = unowned_to_ref [[ARG]] : $@sil_unowned C to $C |
| // CHECK-NEXT: [[FUN:%.*]] = class_method [[UNOWNED_ARG]] : $C, #C.f!1 : (C) -> () -> Int , $@convention(method) (@guaranteed C) -> Int |
| // CHECK-NEXT: [[RESULT:%.*]] = apply [[FUN]]([[UNOWNED_ARG]]) : $@convention(method) (@guaranteed C) -> Int |
| // CHECK-NEXT: strong_release [[UNOWNED_ARG]] |
| // CHECK-NEXT: unowned_release [[ARG]] : $@sil_unowned C |
| // CHECK-NEXT: return [[RESULT]] : $Int |
| |
| |
| |
| // <rdar://problem/16880044> unowned let properties don't work as struct and class members |
| class TestUnownedMember { |
| unowned let member : C |
| init(inval: C) { |
| self.member = inval |
| } |
| } |
| |
| // CHECK-LABEL: sil hidden @_TFC7unowned17TestUnownedMemberc |
| // CHECK: bb0(%0 : $C, %1 : $TestUnownedMember): |
| // CHECK: [[SELF:%.*]] = mark_uninitialized [rootself] %1 : $TestUnownedMember |
| // CHECK: [[FIELDPTR:%.*]] = ref_element_addr [[SELF]] : $TestUnownedMember, #TestUnownedMember.member |
| // CHECK: [[INVAL:%.*]] = ref_to_unowned %0 : $C to $@sil_unowned C |
| // CHECK: unowned_retain [[INVAL]] : $@sil_unowned C |
| // CHECK: assign [[INVAL]] to [[FIELDPTR]] : $*@sil_unowned C |
| // CHECK: strong_release %0 : $C |
| // CHECK: return [[SELF]] : $TestUnownedMember |
| |
| // Just verify that lowering an unowned reference to a type parameter |
| // doesn't explode. |
| struct Unowned<T: AnyObject> { |
| unowned var object: T |
| } |
| func takesUnownedStruct(_ z: Unowned<C>) {} |
| // CHECK-LABEL: sil hidden @_TF7unowned18takesUnownedStructFGVS_7UnownedCS_1C_T_ : $@convention(thin) (@owned Unowned<C>) -> () |