opaque_values_serialize.sil

// First parse this and then emit a *.sib. Then read in the *.sib, then recreate
// RUN: %empty-directory(%t)
// FIXME: <rdar://problem/29281364> sil-opt -verify is broken
// RUN: %target-sil-opt -sil-print-types %s -enable-sil-opaque-values -emit-sib -o %t/tmp.sib -module-name opaqueval
// RUN: %target-sil-opt -sil-print-types %t/tmp.sib -enable-sil-opaque-values -verify -o %t/tmp.2.sib -module-name opaqueval
// RUN: %target-sil-opt -sil-print-types %t/tmp.2.sib -enable-sil-opaque-values -emit-sorted-sil -verify -module-name opaqueval | %FileCheck %s

sil_stage raw

import Builtin
import Swift

protocol Foo {
  func foo()
}

struct S : Foo {
  func foo()
  init()
}

// CHECK-LABEL: sil [serialized] @initDeinitExistentialValue : $@convention(thin) <T> (@in T) -> () {
// CHECK: bb0([[ARG:%.*]] : $T):
// CHECK:  [[IE:%.*]] = init_existential_value [[ARG]] : $T, $T, $Any
// CHECK:  deinit_existential_value [[IE]] : $Any
// CHECK-LABEL: } // end sil function 'initDeinitExistentialValue'
sil [serialized] @initDeinitExistentialValue : $@convention(thin) <T> (@in T) -> () {
bb0(%0 : $T):
  %i = init_existential_value %0 : $T, $T, $Any
  deinit_existential_value %i : $Any
  %t = tuple ()
  return %t : $()
}

// CHECK-LABEL: sil [serialized] @openExistentialBoxValue : $@convention(thin) (@in any Error) -> () {
// CHECK: bb0([[ARG:%.*]] : $any Error):
// CHECK:  open_existential_box_value [[ARG]] : $any Error to $@opened({{.*}}, any Error) Self
// CHECK-LABEL: } // end sil function 'openExistentialBoxValue'
sil [serialized] @openExistentialBoxValue : $@convention(thin) (@in Error) -> () {
bb0(%0 : $Error):
  %o = open_existential_box_value %0 : $Error to $@opened("2E9EACA6-FD59-11E6-B016-685B3593C495", Error) Self
  %t = tuple ()
  return %t : $()
}

// CHECK-LABEL: sil [serialized] @openExistentialValue : $@convention(thin) (@in any Foo) -> () {
// CHECK: bb0([[ARG:%.*]] : $any Foo):
// CHECK:  open_existential_value [[ARG]] : $any Foo to $@opened({{.*}}, any Foo) Self
// CHECK-LABEL: } // end sil function 'openExistentialValue'
sil [serialized] @openExistentialValue : $@convention(thin) (@in Foo) -> () {
bb0(%0 : $Foo):
  %o = open_existential_value %0 : $Foo to $@opened("2E9EACA6-FD59-11E6-B016-685B3593C496", Foo) Self
  %t = tuple ()
  return %t : $()
}

// Test @in/@out serialization.
// ----

// CHECK-LABEL: sil [serialized] @serialize_identity : $@convention(thin) <T> (@in T) -> @out T {
sil [serialized] @serialize_identity : $@convention(thin) <T> (@in T) -> @out T {
// CHECK: bb0(%0 : $T):
bb0(%0 : $T):
  // CHECK: return %0 : $T
  return %0 : $T
}
// CHECK-LABEL: } // end sil function 'serialize_identity'

// Test @in_guaranteed serialization.
// ----

sil @doWithS : $@convention(method) (S) -> ()

// CHECK-LABEL: sil [transparent] [serialized] [thunk] @serialize_mutating : $@convention(witness_method: Foo) (@in_guaranteed S) -> () {
sil [transparent] [serialized] [thunk] @serialize_mutating : $@convention(witness_method: Foo) (@in_guaranteed S) -> () {
// CHECK: bb0(%0 : $S):
bb0(%0 : $S):
  %f = function_ref @doWithS : $@convention(method) (S) -> ()
  // CHECK: apply %{{.*}}(%0) : $@convention(method) (S) -> ()
  %a = apply %f(%0) : $@convention(method) (S) -> ()
  %t = tuple ()
  return %t : $()
}
// CHECK-LABEL: } // end sil function 'serialize_mutating'

struct WeakBox<T : AnyObject> {
  weak var t: T?
}

// CHECK-LABEL: sil [ossa] @test_strong_copy_weak_value : {{.*}} {
// CHECK:       bb0([[INSTANCE:%[^,]+]] :
// CHECK:         [[WEAK_OPTIONAL:%[^,]+]] = struct_extract [[INSTANCE]]
// CHECK:         strong_copy_weak_value [[WEAK_OPTIONAL]]
// CHECK-LABEL: } // end sil function 'test_strong_copy_weak_value'
sil [ossa] @test_strong_copy_weak_value : $@convention(thin) <T where T : AnyObject> (@in_guaranteed WeakBox<T>) -> @owned Optional<T> {
bb0(%instance : @guaranteed $WeakBox<T>):
  %weak_optional = struct_extract %instance : $WeakBox<T>, #WeakBox.t
  %strong_optional = strong_copy_weak_value %weak_optional : $@sil_weak Optional<T>
  return %strong_optional : $Optional<T>
}

// Test tuple_pack_extract parsing.

// CHECK-LABEL: sil [ossa] @test_tuple_pack_extract : {{.*}} {
// CHECK:       bb0([[TUPLE_ADDR:%[^,]+]] :
// CHECK:         [[TUPLE:%[^,]+]] = load_borrow [[TUPLE_ADDR]]
// CHECK:         [[ZERO:%[^,]+]] = integer_literal
// CHECK:         [[INDEX:%[^,]+]] = dynamic_pack_index [[ZERO]]
// CHECK:         [[ELT:%[^,]+]] = tuple_pack_extract [[INDEX]] of [[TUPLE]]
// CHECK-LABEL: } // end sil function 'test_tuple_pack_extract'
sil [ossa] @test_tuple_pack_extract : $@convention(thin) <each T> (@in_guaranteed (repeat each T)) -> () {
entry(%tuple_addr : $*(repeat each T)):
  %tuple = load_borrow %tuple_addr : $*(repeat each T)
  %zero = integer_literal $Builtin.Word, 0
  %index = dynamic_pack_index %zero of $Pack{repeat each T}
  %opened = open_pack_element %index of <each U_1> at <Pack{repeat each T}>, shape $U_1, uuid "00000000-0000-0000-0000-000000000000"
  %elt = tuple_pack_extract %index of %tuple : $(repeat each T) as $@pack_element("00000000-0000-0000-0000-000000000000") U_1
  end_borrow %tuple : $(repeat each T)
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil [ossa] @test_weak_copy_value_1 : {{.*}} {
// CHECK:       bb0([[VALUE:%[^,]+]] :
// CHECK:         weak_copy_value [[VALUE]]
// CHECK-LABEL: } // end sil function 'test_weak_copy_value_1'
sil [ossa] @test_weak_copy_value_1 : $@convention(thin) <T where T : AnyObject> (@owned Optional<T>) -> @out WeakBox<T> {
bb0(%value : @owned $Optional<T>):
  %weak_value = weak_copy_value %value : $Optional<T>
  destroy_value %value : $Optional<T>
  %retval = struct $WeakBox<T> (%weak_value : $@sil_weak Optional<T>)
  return %retval : $WeakBox<T>
}