// RUN: %target-sil-opt -enable-sil-verify-all -global-property-opt %s | %FileCheck %s

sil_stage canonical

import Builtin
import Swift
import SwiftShims

public class X {
}


public class Holder {
  init()

  private var arrFieldNative: [X]
  public var arrFieldPublic: [X]
  private var arrFieldUnknown: [X]
  private var arrFieldEscaped: [X]
}

public struct StructHolder {
  init()

  private var arrFieldNative: [X]
  public var arrFieldPublic: [X]
  private var arrFieldUnknown: [X]
  private var arrFieldEscaped: [X]
}

struct DepStruct {
  private var depField: [X]
  private var depField2: [X]
}

// CHECK-LABEL: sil @test_alloc_stack
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
// CHECK: return [[R]]
sil @test_alloc_stack : $@convention(thin) () -> Bool {
bb0:
  %1 = alloc_stack $Array<X>
  %3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %4 = apply %3() : $@convention(thin) () -> @owned Array<X>
  store %4 to %1 : $*Array<X>

  %m1 = function_ref @_array_X_mutate : $@convention(method) (@inout Array<X>) -> ()
  %m2 = apply %m1(%1) : $@convention(method) (@inout Array<X>) -> ()

  %5 = load %1 : $*Array<X>
  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%5) : $@convention(method) (@guaranteed Array<X>) -> Bool
  dealloc_stack %1 : $*Array<X>
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_alloc_stack_escapes
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_alloc_stack_escapes : $@convention(thin) () -> Bool {
bb0:
  %1 = alloc_stack $Array<X>
  %3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %4 = apply %3() : $@convention(thin) () -> @owned Array<X>
  store %4 to %1 : $*Array<X>

  %m1 = function_ref @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()
  %m2 = apply %m1(%1) : $@convention(method) (@inout Array<X>) -> ()

  %5 = load %1 : $*Array<X>
  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%5) : $@convention(method) (@guaranteed Array<X>) -> Bool
  dealloc_stack %1 : $*Array<X>
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_alloc_write_unknown
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_alloc_write_unknown : $@convention(thin) (@owned Array<X>) -> Bool {
bb0(%0 : $Array<X>):
  %1 = alloc_stack $Array<X>
  %3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %4 = apply %3() : $@convention(thin) () -> @owned Array<X>
  store %4 to %1 : $*Array<X>

  store %0 to %1 : $*Array<X>

  %5 = load %1 : $*Array<X>
  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%5) : $@convention(method) (@guaranteed Array<X>) -> Bool
  dealloc_stack %1 : $*Array<X>
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_phi
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
// CHECK: return [[R]]
sil @test_phi : $@convention(thin) (Bool) -> Bool {
bb0(%0 : $Bool):
  %2 = struct_extract %0 : $Bool, #Bool._value
  %3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  cond_br %2, bb1, bb2

bb1:
  %4 = apply %3() : $@convention(thin) () -> @owned Array<X>
  br bb3(%4 : $Array<X>)

bb2:
  %6 = apply %3() : $@convention(thin) () -> @owned Array<X>
  br bb3(%6 : $Array<X>)

bb3(%a1 : $Array<X>):
  %f1 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %f1(%a1) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @negative_test_phi
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @negative_test_phi : $@convention(thin) (Bool, @owned Array<X>) -> Bool {
bb0(%0 : $Bool, %1 : $Array<X>):
  %2 = struct_extract %0 : $Bool, #Bool._value
  cond_br %2, bb1, bb2

bb1:
  %3 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %4 = apply %3() : $@convention(thin) () -> @owned Array<X>
  br bb3(%4 : $Array<X>)

bb2:
  br bb3(%1 : $Array<X>)

bb3(%a1 : $Array<X>):
  %f1 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %f1(%a1) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_tuple
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
// CHECK: return [[R]]
sil @test_tuple : $@convention(thin) () -> Bool {
bb0:
  %f1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %a1 = apply %f1() : $@convention(thin) () -> @owned Array<X>
  %i1 = integer_literal $Builtin.Int64, 0
  %t1 = tuple (%a1 : $Array<X>, %i1 : $Builtin.Int64)

  %a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
  %f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %r1 : $Bool
}

// CHECK-LABEL: sil @test_tuple_unknown_member
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_tuple_unknown_member : $@convention(thin) (@owned Array<X>) -> Bool {
bb0(%0 : $Array<X>):
  %i1 = integer_literal $Builtin.Int64, 0
  %t1 = tuple (%0 : $Array<X>, %i1 : $Builtin.Int64)

  %a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
  %f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %r1 : $Bool
}

// CHECK-LABEL: sil @test_unknown_tuple
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_unknown_tuple : $@convention(thin) () -> Bool {
bb0:
  %f1 = function_ref @provide_tuple : $@convention(thin) () -> @owned (Array<X>, Builtin.Int64)
  %t1 = apply %f1() : $@convention(thin) () -> @owned (Array<X>, Builtin.Int64)

  %a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
  %f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %r1 : $Bool
}

// CHECK-LABEL: sil @test_tuple_member_escapes
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_tuple_member_escapes : $@convention(thin) () -> Bool {
bb0:
  %s1 = alloc_stack $(Array<X>, Builtin.Int64)
  %a1 = tuple_element_addr %s1 : $*(Array<X>, Builtin.Int64), 0
  %f1 = function_ref @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()
  %x1 = apply %f1(%a1) : $@convention(method) (@inout Array<X>) -> ()

  %t1 = load %s1 : $*(Array<X>, Builtin.Int64)
  %a2 = tuple_extract %t1 : $(Array<X>, Builtin.Int64), 0
  %f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %r1 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
  dealloc_stack %s1 : $*(Array<X>, Builtin.Int64)
  return %r1 : $Bool
}

// CHECK-LABEL: sil @test_tuple_phi
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
// CHECK: return [[R]]
sil @test_tuple_phi : $@convention(thin) (Bool) -> Bool {
bb0(%0 : $Bool):
  %i1 = integer_literal $Builtin.Int64, 0
  %f1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %2 = struct_extract %0 : $Bool, #Bool._value
  cond_br %2, bb1, bb2

bb1:
  %a1 = apply %f1() : $@convention(thin) () -> @owned Array<X>
  %t1 = tuple (%a1 : $Array<X>, %i1 : $Builtin.Int64)
  br bb3(%t1 : $(Array<X>, Builtin.Int64))

bb2:
  %a2 = apply %f1() : $@convention(thin) () -> @owned Array<X>
  %t2 = tuple (%a2 : $Array<X>, %i1 : $Builtin.Int64)
  br bb3(%t2 : $(Array<X>, Builtin.Int64))

bb3(%t3 : $(Array<X>, Builtin.Int64)):
  %a3 = tuple_extract %t3 : $(Array<X>, Builtin.Int64), 0
  %f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %f2(%a3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_tuple_phi_unknown
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_tuple_phi_unknown : $@convention(thin) (Bool, @owned Array<X>) -> Bool {
bb0(%0 : $Bool, %1 : $Array<X>):
  %i1 = integer_literal $Builtin.Int64, 0
  %f1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %2 = struct_extract %0 : $Bool, #Bool._value
  cond_br %2, bb1, bb2

bb1:
  %a1 = apply %f1() : $@convention(thin) () -> @owned Array<X>
  %t1 = tuple (%a1 : $Array<X>, %i1 : $Builtin.Int64)
  br bb3(%t1 : $(Array<X>, Builtin.Int64))

bb2:
  %t2 = tuple (%1 : $Array<X>, %i1 : $Builtin.Int64)
  br bb3(%t2 : $(Array<X>, Builtin.Int64))

bb3(%t3 : $(Array<X>, Builtin.Int64)):
  %a2 = tuple_extract %t3 : $(Array<X>, Builtin.Int64), 0
  %f2 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %f2(%a2) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_arrFieldNative
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
// CHECK: return [[R]]
sil @test_arrFieldNative : $@convention(thin) (@owned Holder) -> Bool {
bb0(%0 : $Holder):
  %2 = ref_element_addr %0 : $Holder, #Holder.arrFieldNative
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_arrFieldPublic
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_arrFieldPublic : $@convention(thin) (@owned Holder) -> Bool {
bb0(%0 : $Holder):
  %2 = ref_element_addr %0 : $Holder, #Holder.arrFieldPublic
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_arrFieldUnknown
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_arrFieldUnknown : $@convention(thin) (@owned Holder) -> Bool {
bb0(%0 : $Holder):
  %2 = ref_element_addr %0 : $Holder, #Holder.arrFieldUnknown
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_arrFieldEscaped
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_arrFieldEscaped : $@convention(thin) (@owned Holder) -> Bool {
bb0(%0 : $Holder):
  %2 = ref_element_addr %0 : $Holder, #Holder.arrFieldEscaped
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_struct_arrFieldNative
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
// CHECK: return [[R]]
sil @test_struct_arrFieldNative : $@convention(thin) (@inout StructHolder) -> Bool {
bb0(%0 : $*StructHolder):
  %2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldNative
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_struct_arrFieldPublic
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_struct_arrFieldPublic : $@convention(thin) (@inout StructHolder) -> Bool {
bb0(%0 : $*StructHolder):
  %2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldPublic
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_struct_arrFieldUnknown
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_struct_arrFieldUnknown : $@convention(thin) (@inout StructHolder) -> Bool {
bb0(%0 : $*StructHolder):
  %2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldUnknown
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_struct_arrFieldEscaped
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_struct_arrFieldEscaped : $@convention(thin) (@inout StructHolder) -> Bool {
bb0(%0 : $*StructHolder):
  %2 = struct_element_addr %0 : $*StructHolder, #StructHolder.arrFieldEscaped
  %3 = load %2 : $*Array<X>

  %6 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %10 = apply %6(%3) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %10 : $Bool
}

// CHECK-LABEL: sil @test_dependencies
// CHECK: [[I:%[0-9]+]] = integer_literal $Builtin.Int1, -1
// CHECK: [[R:%[0-9]+]] = struct $Bool ([[I]] : $Builtin.Int1)
// CHECK: return [[R]]
sil @test_dependencies : $@convention(thin) (@owned Holder, Bool) -> Bool {
bb0(%0 : $Holder, %1 : $Bool):
  %2 = ref_element_addr %0 : $Holder, #Holder.arrFieldNative
  %3 = load %2 : $*Array<X>

  %i1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %c1 = struct_extract %1 : $Bool, #Bool._value
  cond_br %c1, bb1, bb2

bb1:
  br bb3(%3 : $Array<X>)

bb2:
  %i2 = apply %i1() : $@convention(thin) () -> @owned Array<X>
  br bb3(%i2 : $Array<X>)

bb3(%a1 : $Array<X>):

  %i3 = apply %i1() : $@convention(thin) () -> @owned Array<X>

  %f1 = function_ref @_take_struct : $@convention(thin) (@owned DepStruct) -> ()
  %s1 = struct $DepStruct (%a1 : $Array<X>, %i3 : $Array<X>)
  %s2 = apply %f1(%s1) : $@convention(thin) (@owned DepStruct) -> ()

  %f2 = function_ref @_provide_struct : $@convention(thin) () -> @owned DepStruct
  %s3 = apply %f2() : $@convention(thin) () -> @owned DepStruct

  %x1 = struct_extract %s3 : $DepStruct, #DepStruct.depField

  %f3 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %r1 = apply %f3(%x1) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %r1 : $Bool
}

// Check dependency chain: load -> argument -> struct -> extract

// CHECK-LABEL: sil @test_dependencies2
// CHECK: [[F:%[0-9]+]] = function_ref @_is_native_X_no_type_check
// CHECK: [[R:%[0-9]+]] = apply [[F]]
// CHECK: return [[R]]
sil @test_dependencies2 : $@convention(thin) (@owned Holder, Bool) -> Bool {
bb0(%0 : $Holder, %1 : $Bool):
  %2 = ref_element_addr %0 : $Holder, #Holder.arrFieldUnknown
  %3 = load %2 : $*Array<X>

  %i1 = function_ref @_array_X_init : $@convention(thin) () -> @owned Array<X>
  %c1 = struct_extract %1 : $Bool, #Bool._value
  cond_br %c1, bb1, bb2

bb1:
  br bb3(%3 : $Array<X>)

bb2:
  %i2 = apply %i1() : $@convention(thin) () -> @owned Array<X>
  br bb3(%i2 : $Array<X>)

bb3(%a1 : $Array<X>):

  %i3 = apply %i1() : $@convention(thin) () -> @owned Array<X>

  %f1 = function_ref @_take_struct : $@convention(thin) (@owned DepStruct) -> ()
  %s1 = struct $DepStruct (%i3 : $Array<X>, %a1 : $Array<X>)
  %s2 = apply %f1(%s1) : $@convention(thin) (@owned DepStruct) -> ()

  %f2 = function_ref @_provide_struct : $@convention(thin) () -> @owned DepStruct
  %s3 = apply %f2() : $@convention(thin) () -> @owned DepStruct

  %x1 = struct_extract %s3 : $DepStruct, #DepStruct.depField2

  %f3 = function_ref @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool
  %r1 = apply %f3(%x1) : $@convention(method) (@guaranteed Array<X>) -> Bool
  return %r1 : $Bool
}

sil @setArrayFields : $@convention(thin) (@owned Holder, @inout StructHolder, @owned Array<X>) -> () {
bb0(%0 : $Holder, %1 : $*StructHolder, %2 : $Array<X>):
  %l1 = integer_literal $Builtin.Word, 0           // user: %3
  %f1 = function_ref @_allocate_uninitialized_X : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
  %f2 = function_ref @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()

  %c3 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
  %c4 = tuple_extract %c3 : $(Array<X>, Builtin.RawPointer), 0
  %c5 = ref_element_addr %0 : $Holder, #Holder.arrFieldNative
  store %c4 to %c5 : $*Array<X>

  %c6 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
  %c7 = tuple_extract %c6 : $(Array<X>, Builtin.RawPointer), 0
  %c8 = ref_element_addr %0 : $Holder, #Holder.arrFieldPublic
  store %c7 to %c8 : $*Array<X>

  %c9 = ref_element_addr %0 : $Holder, #Holder.arrFieldUnknown
  store %2 to %c9 : $*Array<X>

  %c11 = ref_element_addr %0 : $Holder, #Holder.arrFieldEscaped
  %c12 = apply %f2(%c11) : $@convention(method) (@inout Array<X>) -> ()

  %s3 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
  %s4 = tuple_extract %s3 : $(Array<X>, Builtin.RawPointer), 0
  %s5 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldNative
  store %s4 to %s5 : $*Array<X>

  %s6 = apply %f1(%l1) : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)
  %s7 = tuple_extract %s6 : $(Array<X>, Builtin.RawPointer), 0
  %s8 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldPublic
  store %s7 to %s8 : $*Array<X>

  %s9 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldUnknown
  store %2 to %s9 : $*Array<X>

  %s11 = struct_element_addr %1 : $*StructHolder, #StructHolder.arrFieldEscaped
  %s12 = apply %f2(%s11) : $@convention(method) (@inout Array<X>) -> ()

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

sil [_semantics "array.init"] @_array_X_init : $@convention(thin) () -> @owned Array<X>

sil [_semantics "array.mutate_unknown"] @_array_X_mutate : $@convention(method) (@inout Array<X>) -> ()

sil [_semantics "array.props.isNativeTypeChecked"] @_is_native_X_no_type_check : $@convention(method) (@guaranteed Array<X>) -> Bool

sil [_semantics "array.uninitialized"] @_allocate_uninitialized_X : $@convention(thin) (Builtin.Word) -> @owned (Array<X>, Builtin.RawPointer)

sil @_take_array_addr : $@convention(method) (@inout Array<X>) -> ()

sil @_take_struct : $@convention(thin) (@owned DepStruct) -> ()

sil @_provide_struct : $@convention(thin) () -> @owned DepStruct

sil @provide_tuple : $@convention(thin) () -> @owned (Array<X>, Builtin.Int64)