// RUN: %target-sil-opt -enable-ossa-complete-lifetimes -test-runner -sil-disable-input-verify %s -o /dev/null 2>&1 | %FileCheck %s

sil_stage raw

import Builtin

class C {}

public enum FakeOptional<T> {
  case none
  case some(T)
}

sil @getC : $@convention(thin) () -> (@owned C)

// CHECK-LABEL: begin running test 1 of 1 on eagerConsumneOwnedArg: ossa-lifetime-completion with: @argument
// CHECK-LABEL: OSSA lifetime completion: %0 = argument of bb0 : $C
// CHECK: sil [ossa] @eagerConsumneOwnedArg : $@convention(thin) (@owned C) -> () {
// CHECK: bb0(%0 : @_eagerMove @owned $C):
// CHECK-NEXT:   destroy_value %0 : $C
// CHECK-LABEL: end running test 1 of 1 on eagerConsumneOwnedArg: ossa-lifetime-completion with: @argument
sil [ossa] @eagerConsumneOwnedArg : $@convention(thin) (@owned C) -> () {
entry(%0 : @_eagerMove @owned $C):
  specify_test "ossa-lifetime-completion @argument"
  br exit

exit:
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: begin running test 1 of 1 on lexicalOwnedArg: ossa-lifetime-completion with: @argument
// CHECK: OSSA lifetime completion: %0 = argument of bb0 : $C                         // user: %4
// CHECK: sil [ossa] @lexicalOwnedArg : $@convention(thin) (@owned C) -> () {
// CHECK: bb0(%0 : @owned $C):
// CHECK:   cond_br undef, bb1, bb2
// CHECK: bb2:
// CHECK-NEXT:   destroy_value %0 : $C
// CHECK-NEXT:   unreachable
// CHECK: } // end sil function 'lexicalOwnedArg'
// CHECK-LABEL: end running test 1 of 1 on lexicalOwnedArg: ossa-lifetime-completion with: @argument
sil [ossa] @lexicalOwnedArg : $@convention(thin) (@owned C) -> () {
bb0(%0 : @owned $C):
  specify_test "ossa-lifetime-completion @argument"
  cond_br undef, bb1, bb2
bb1:
  br bb3
bb2:
  unreachable
bb3:
  destroy_value %0 : $C
  %r = tuple ()
  return %r : $()
}

// CHECK-LABEL: sil [ossa] @borrowTest : $@convention(method) (@owned C) -> () {
// CHECK: bb1:
// CHECK-NEXT: end_borrow
// CHECK-NEXT: br bb3
// CHECK-LABEL: } // end sil function 'borrowTest'
sil [ossa] @borrowTest : $@convention(method) (@owned C) -> () {
bb0(%0 : @owned $C):
  specify_test "ossa-lifetime-completion @instruction[0]"
  %borrow = begin_borrow %0 : $C
  cond_br undef, bb1, bb2

bb1:
  end_borrow %borrow : $C
  br bb3

bb2:
  end_borrow %borrow : $C
  br bb3

bb3:
  destroy_value %0 : $C
  %r = tuple ()
  return %r : $()
}

// CHECK-LABEL: sil [ossa] @enumTest : $@convention(method) (@guaranteed FakeOptional<C>) -> () {
// CHECK: bb2
// CHECK: destroy_value
// CHECK: br bb3
// CHECK-LABEL: } // end sil function 'enumTest'
sil [ossa] @enumTest : $@convention(method) (@guaranteed FakeOptional<C>) -> () {
bb0(%0 : @guaranteed $FakeOptional<C>):
  specify_test "ossa-lifetime-completion @instruction[0]"
  %copy = copy_value %0 : $FakeOptional<C>
  %borrow = begin_borrow %copy : $FakeOptional<C>
  switch_enum %borrow : $FakeOptional<C>, case #FakeOptional.some!enumelt: bb1, case #FakeOptional.none!enumelt: bb2

bb1(%some : @guaranteed $C):
  end_borrow %borrow : $FakeOptional<C>
  destroy_value %copy : $FakeOptional<C>
  br bb3

bb2:
  end_borrow %borrow : $FakeOptional<C>
  br bb3

bb3:
  %r = tuple ()
  return %r : $()
}

sil @use_guaranteed : $@convention(thin) (@guaranteed C) -> ()

sil [ossa] @argTest : $@convention(method) (@owned C) -> () {
bb0(%0 : @owned $C):
  specify_test "ossa-lifetime-completion @argument"
  debug_value %0 : $C
  cond_br undef, bb1, bb2

bb1:
  br bb4

bb2:
  br bb3

bb3:
  %3 = function_ref @use_guaranteed : $@convention(thin) (@guaranteed C) -> ()
  %4 = apply %3(%0) : $@convention(thin) (@guaranteed C) -> ()
  destroy_value %0 : $C
  %r = tuple ()
  return %r : $()

bb4:
  unreachable
}

// Ensure no assert fires while inserting dead end blocks to the worklist
sil [ossa] @testLexicalLifetimeCompletion : $@convention(thin) (@owned C) -> () {
bb0(%0 : @owned $C):
  specify_test "ossa-lifetime-completion @argument"
  debug_value %0 : $C, let, name "newElements", argno 1
  cond_br undef, bb1, bb2

bb1:
  cond_br undef, bb3, bb4

bb2:
  cond_br undef, bb9, bb10

bb3:
  br bb8

bb4:
  cond_br undef, bb5, bb6

bb5:
  br bb7

bb6:
  br bb7

bb7:
  unreachable

bb8:
  %77 = apply undef(%0) : $@convention(method) (@guaranteed C) -> ()
  destroy_value %0 : $C
  %79 = tuple ()
  return %79 : $()

bb9:
  br bb8

bb10:
  br bb8
}

sil @foo : $@convention(thin) (@guaranteed C) -> ()

// Ensure no assert fires while handling lifetime end of partial_apply
sil [ossa] @testPartialApplyStack1 : $@convention(thin) (@guaranteed C) -> () {
bb0(%0 : @guaranteed $C):
  specify_test "ossa-lifetime-completion @instruction[0]"
  %8 = copy_value %0 : $C
  %9 = begin_borrow %8 : $C
  %80 = function_ref @foo : $@convention(thin) (@guaranteed C) -> ()
  %81 = partial_apply [callee_guaranteed] [on_stack] %80(%9) : $@convention(thin) (@guaranteed C) -> ()
  cond_br undef, bb1, bb2

bb1:
  destroy_value %81 : $@noescape @callee_guaranteed () -> ()
  br bb3

bb2:
  unreachable

bb3:
  end_borrow %9 : $C
  destroy_value %8 : $C
  %180 = tuple ()
  return %180 : $()
}

// Ensure no assert fires while handling lifetime end of partial_apply
sil [ossa] @testPartialApplyStack2 : $@convention(thin) (@guaranteed C) -> () {
bb0(%0 : @guaranteed $C):
  specify_test "ossa-lifetime-completion @instruction[1]"
  %2 = alloc_stack $C
  %3 = copy_value %0 : $C
  %4 = begin_borrow %3 : $C
  %5 = function_ref @foo : $@convention(thin) (@guaranteed C) -> ()
  %6 = partial_apply [callee_guaranteed] [on_stack] %5(%4) : $@convention(thin) (@guaranteed C) -> ()
  %7 = mark_dependence %6 : $@noescape @callee_guaranteed () -> () on %2 : $*C
  destroy_value %7 : $@noescape @callee_guaranteed () -> ()
  end_borrow %4 : $C
  destroy_value %3 : $C
  dealloc_stack %2 : $*C
  %12 = tuple ()
  return %12 : $()
}

// Insert destroy on availability boundary of `value` within the region after
// the non-lifetime-ending boundary of `value`.  Namely, in to_die_11.
// CHECK-LABEL: sil [ossa] @availability_boundary_1 : {{.*}} {
// CHECK:         [[VALUE:%[^,]+]] = move_value [lexical]
// CHECK:         br [[CONDITION_1:bb[0-9]+]]
// CHECK:       [[CONDITION_1]]:
// CHECK:         cond_br undef, [[CONDITION_2:bb[0-9]+]], [[TO_DIE_1:bb[0-9]+]]
// CHECK:       [[CONDITION_2]]:
// CHECK:         destroy_value [[VALUE]]
// CHECK:         cond_br undef, [[EXIT:bb[0-9]+]], [[TO_DIE_2:bb[0-9]+]]
// CHECK:       [[TO_DIE_1]]:
// CHECK:         br [[TO_DIE_11:bb[0-9]+]]
// CHECK:       [[TO_DIE_11]]:
// CHECK:         destroy_value [[VALUE]]
// CHECK:         br [[DIE:bb[0-9]+]]
// CHECK:       [[TO_DIE_2]]:
// CHECK:         br [[DIE]]
// CHECK:       [[DIE]]:
// CHECK:         unreachable
// CHECK:       [[EXIT]]:
// CHECK-LABEL: } // end sil function 'availability_boundary_1'
sil [ossa] @availability_boundary_1 : $@convention(thin) () -> () {
entry:
  %value = apply undef() : $@convention(thin) () -> @owned C
  %lexical = move_value [lexical] %value : $C // required (for lexicality)
  specify_test "ossa-lifetime-completion %lexical"
  br condition_1

condition_1:
  cond_br undef, condition_2, to_die_1

condition_2:
  destroy_value %lexical : $C
  cond_br undef, exit, to_die_2

to_die_1:
  br to_die_11

to_die_11:
  // End lifetime here.
  br die

to_die_2:
  br die

die:
  unreachable

exit:
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil [ossa] @availability_boundary_2_after_loop : {{.*}} {
// CHECK:         [[REGISTER_1:%[^,]+]] = move_value [lexical]
// CHECK:         br [[CONDITION_1:bb[0-9]+]]
// CHECK:       [[CONDITION_1]]:
// CHECK:         cond_br undef, [[CONDITION_2:bb[0-9]+]], [[PREHEADER:bb[0-9]+]]
// CHECK:       [[CONDITION_2]]:
// CHECK:         destroy_value [[REGISTER_1]]
// CHECK:         cond_br undef, [[EXIT:bb[0-9]+]], [[TO_DIE_2:bb[0-9]+]]
// CHECK:       [[PREHEADER]]:
// CHECK:         br [[HEADER:bb[0-9]+]]
// CHECK:       [[HEADER]]:
// CHECK:         br [[LATCH:bb[0-9]+]]
// CHECK:       [[LATCH]]:
// CHECK:         cond_br undef, [[BACKEDGE:bb[0-9]+]], [[TO_DIE_1:bb[0-9]+]]
// CHECK:       [[BACKEDGE]]:
// CHECK:         br [[HEADER]]
// CHECK:       [[TO_DIE_1]]:
// CHECK:         destroy_value [[REGISTER_1]]
// CHECK:         br [[DIE:bb[0-9]+]]
// CHECK:       [[TO_DIE_2]]:
// CHECK:         br [[DIE]]
// CHECK:       [[DIE]]:
// CHECK:         unreachable
// CHECK:       [[EXIT]]:
// CHECK-LABEL: } // end sil function 'availability_boundary_2_after_loop'
sil [ossa] @availability_boundary_2_after_loop : $@convention(thin) () -> () {
entry:
  %value = apply undef() : $@convention(thin) () -> @owned C
  %lexical = move_value [lexical] %value : $C // required (for lexicality)
  specify_test "ossa-lifetime-completion %lexical"
  br condition_1

condition_1:
  cond_br undef, condition_2, preheader

condition_2:
  destroy_value %lexical : $C
  cond_br undef, exit, to_die_2

preheader:
  br header

header:
  br latch

latch:
  cond_br undef, backedge, to_die_1

backedge:
  br header

to_die_1:
  br die

to_die_2:
  br die

die:
  unreachable

exit:
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil [ossa] @availability_boundary_3_after_loop : {{.*}} {
// CHECK:         [[VALUE:%[^,]+]] = move_value [lexical]
// CHECK:         br [[CONDITION_1:bb[0-9]+]]
// CHECK:       [[CONDITION_1]]:
// CHECK:         cond_br undef, [[CONDITION_2:bb[0-9]+]], [[PREHEADER:bb[0-9]+]]
// CHECK:       [[CONDITION_2]]:
// CHECK:         destroy_value [[VALUE]]
// CHECK:         cond_br undef, [[EXIT:bb[0-9]+]], [[TO_BODY:bb[0-9]+]]
// CHECK:       [[TO_BODY]]:
// CHECK:         br [[BODY:bb[0-9]+]]
// CHECK:       [[PREHEADER]]:
// CHECK:         destroy_value [[VALUE]]
// CHECK:         br [[HEADER:bb[0-9]+]]
// CHECK:       [[HEADER]]:
// CHECK:         br [[BODY]]
// CHECK:       [[BODY]]:
// CHECK:         br [[LATCH:bb[0-9]+]]
// CHECK:       [[LATCH]]:
// CHECK:         cond_br undef, [[BACKEDGE:bb[0-9]+]], [[DIE:bb[0-9]+]]
// CHECK:       [[BACKEDGE]]:
// CHECK:         br [[HEADER]]
// CHECK:       [[DIE]]:
// CHECK:         unreachable
// CHECK:       [[EXIT]]:
// CHECK-LABEL: } // end sil function 'availability_boundary_3_after_loop'
sil [ossa] @availability_boundary_3_after_loop : $@convention(thin) () -> () {
entry:
  %value = apply undef() : $@convention(thin) () -> @owned C
  %lexical = move_value [lexical] %value : $C // required (for lexicality)
  specify_test "ossa-lifetime-completion %lexical"
  br condition_1

condition_1:
  cond_br undef, condition_2, preheader

condition_2:
  destroy_value %lexical : $C
  cond_br undef, exit, to_body2

to_body2:
  br body

preheader:
  // End lifetime here.
  br header

header:
  br body

body:
  br latch

latch:
  cond_br undef, backedge, die

backedge:
  br header

die:
  unreachable

exit:
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: begin running test {{.*}} on root_of_reborrow: ossa-lifetime-completion
// Verify that no instructions were inserted after backedge2's terminator.  (In
// fact, if they were, the test would crash.)
// CHECK-LABEL: sil [ossa] @root_of_reborrow : {{.*}} {
// CHECK:       bb1([[C0:%[^,]+]] : @owned $C, [[B0:%[^,]+]] : @reborrow @guaranteed $C):
// CHECK-NEXT:    end_borrow [[B0]]
// CHECK-NEXT:    destroy_value [[C0]]
// CHECK-NEXT:    br
// CHECK-LABEL: } // end sil function 'root_of_reborrow'
// CHECK-LABEL: end running test {{.*}} on root_of_reborrow: ossa-lifetime-completion
sil [ossa] @root_of_reborrow : $@convention(thin) () -> () {
entry:
  %getC = function_ref @getC : $@convention(thin) () -> (@owned C)
  %c = apply %getC() : $@convention(thin) () -> (@owned C)
  %b = begin_borrow %c : $C
  br header(%c : $C, %b : $C)
header(%c0 : @owned $C, %b0 : @reborrow @guaranteed $C):
  end_borrow %b0 : $C
  destroy_value %c0 : $C
  br body
body:
  br latch
latch:
  cond_br undef, backedge, exit
backedge:
  %c1 = apply %getC() : $@convention(thin) () -> (@owned C)
  %b1 = begin_borrow %c1 : $C
  br backedge2(%c1 : $C, %b1 : $C)
backedge2(%c2 : @owned $C, %b2 : @reborrow @guaranteed $C):
  specify_test "ossa-lifetime-completion %c2"
  br header(%c2 : $C, %b2 : $C)
exit:
  unreachable
}