// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -module-name Swift -enable-sil-verify-all %s -early-codemotion -retain-sinking -disable-with-critical-edge=1 | %FileCheck %s

import Builtin

enum Never {}

struct Int {
  var value : Builtin.Int64
}

struct Int32 {
  var value : Builtin.Int32
}

struct Int64 {
  var value : Builtin.Int64
}

struct UInt64 {
  var value : Builtin.Int64
}

struct Bool {
  var value : Builtin.Int1
}

class fuzz { }

enum Boo {
  case one
  case two
}

class B { }
class E : B { }

class C {}

enum Either {
  case First(Builtin.NativeObject)
  case Second(C)
}

enum ThreeCaseEnum {
  case A
  case B
  case C
}

struct S {
  var ptr : Builtin.NativeObject
}

enum ThreeCaseAbstractionDifference {
  case A(Builtin.Int32)
  case B(Builtin.NativeObject)
  case C(S)
}

struct foo {
  var a: Int
  init(a: Int)
  init()
}

enum Optional<T> {
  case none
  case some(T)
}

sil @user : $@convention(thin) (Builtin.NativeObject) -> ()
sil @user_int : $@convention(thin) (Int) -> ()
sil @optional_user : $@convention(thin) (Optional<Builtin.Int32>) -> ()
sil @blocker : $@convention(thin) () -> ()
sil @get_object : $@convention(thin) () -> Builtin.NativeObject
sil @foo_init : $@convention(thin) (@thin foo.Type) -> foo

// CHECK-LABEL: sil @sink_from_preds
// CHECK: bb1:
// CHECK-NEXT: br bb3
// CHECK: bb2:
// CHECK-NEXT: br bb3
// CHECK: bb3:
// CHECK: strong_retain
// CHECK: return
sil @sink_from_preds : $@convention(thin) (Builtin.Int1, B) -> () {
bb0(%0 : $Builtin.Int1, %1 : $B):
  cond_br %0, bb1, bb2

bb1:
  strong_retain %1 : $B
  br bb3

bb2:
  strong_retain %1 : $B
  br bb3

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

// CHECK-LABEL: sil @do_not_sink_local_uses
// CHECK: integer_literal
// CHECK: integer_literal
// CHECK: return
sil @do_not_sink_local_uses : $@convention(thin) (Builtin.Int1) -> Builtin.Int32 {
bb0(%0 : $Builtin.Int1):
  cond_br %0, bb1, bb3

bb1:
  %1 = integer_literal $Builtin.Int32, 7
  br bb2(%1 : $Builtin.Int32)

bb3:
  %2 = integer_literal $Builtin.Int32, 8
  br bb2(%2 : $Builtin.Int32)

bb2(%3 : $Builtin.Int32):
  return %3 : $Builtin.Int32
}

// CHECK-LABEL: sil @deep_sink1
// CHECK: integer_literal
// CHECK: br bb3
// CHECK: integer_literal
// CHECK: br bb3
// CHECK: bb3
// CHECK: strong_retain
// CHECK-NEXT: return
sil @deep_sink1 : $@convention(thin) (Builtin.Int1, B) -> Builtin.Int32 {
bb0(%0 : $Builtin.Int1, %1 : $B):
  cond_br %0, bb1, bb2

bb1:
  strong_retain %1 : $B
  %3 = integer_literal $Builtin.Int32, 9
  br bb3(%3 : $Builtin.Int32)

bb2:
  strong_retain %1 : $B
  %5 = integer_literal $Builtin.Int32, 7
  br bb3(%5 : $Builtin.Int32)

bb3(%6 : $Builtin.Int32):
  return %6 : $Builtin.Int32
}

// CHECK-LABEL: sil @deep_sink2
// CHECK-NOT: integer_literal
// CHECK: br bb3
// CHECK-NOT: integer_literal
// CHECK: br bb3
// CHECK: bb3
// CHECK: integer_literal
// CHECK: strong_retain
// CHECK-NEXT: return
sil @deep_sink2 : $@convention(thin) (Builtin.Int1, B) -> Builtin.Int32 {
bb0(%0 : $Builtin.Int1, %1 : $B):
  cond_br %0, bb1, bb2

bb1:
  strong_retain %1 : $B
  %3 = integer_literal $Builtin.Int32, 7
  br bb3(%3 : $Builtin.Int32)

bb2:
  strong_retain %1 : $B
  %5 = integer_literal $Builtin.Int32, 7
  br bb3(%5 : $Builtin.Int32)

bb3(%6 : $Builtin.Int32):
  return %6 : $Builtin.Int32
}

// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_switch_enum_1 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0({{.*}}):
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: retain_value
// CHECK-NEXT: apply
// CHECK-NEXT: alloc_stack
// CHECK-NEXT: dealloc_stack
// CHECK-NEXT: switch_enum
// CHECK: bb1({{.*}}):
// CHECK: strong_retain
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK-NOT: strong_retain
// CHECK: bb3:
// CHECK-NOT: retain_value
// CHECK-NOT: strong_retain
sil @sink_ref_count_ops_enum_over_switch_enum_1 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  retain_value %0 : $Optional<Builtin.NativeObject>
  apply %1() : $@convention(thin) () -> ()
  %3 = alloc_stack $Builtin.Int32
  retain_value %0 : $Optional<Builtin.NativeObject>
  dealloc_stack %3 : $*Builtin.Int32
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1(%2 : $Builtin.NativeObject):
  apply %1() : $@convention(thin) () -> ()
  br bb3

bb2:
  br bb3

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

// This test makes sure that if any of the switches targets have a predecessor
// besides the switch enum, we don't do anything.
//
// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_switch_enum_2 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0({{.*}}):
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: cond_br
// CHECK: bb1:
// CHECK-NEXT: retain_value
// CHECK-NEXT: switch_enum
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb4:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
sil @sink_ref_count_ops_enum_over_switch_enum_2 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  cond_br undef, bb1, bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb3

bb2:
  br bb4

bb3:
  br bb4

bb4:
  %2 = tuple()
  return %2 : $()
}

// This test makes sure that if any of the switches targets have a predecessor
// besides the switch enum, we don't do anything.
//
// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_switch_enum_3 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
// CHECK: bb0({{.*}}):
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: cond_br
// CHECK: bb1:
// CHECK-NEXT: retain_value
// CHECK-NEXT: switch_enum
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb4:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
sil @sink_ref_count_ops_enum_over_switch_enum_3 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
bb0(%0 : $Optional<Builtin.Int32>):
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  cond_br undef, bb1, bb3

bb1:
  retain_value %0 : $Optional<Builtin.Int32>
  switch_enum %0 : $Optional<Builtin.Int32>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb3

bb2:
  br bb4

bb3:
  br bb4

bb4:
  %2 = tuple()
  return %2 : $()
}

// This test makes sure that we do move ref counts over instructions that cannot reference it.
// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_switch_enum_4 :
// CHECK: bb0({{%[0-9]+}} : $Optional<Builtin.NativeObject>, [[ARG1:%[0-9]+]] : $Optional<Builtin.NativeObject>):
// CHECK-NOT: retain_value [[ARG1]]
// CHECK: switch_enum
// CHECK: bb1:
// CHECK: retain_value
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value [[ARG1]]
// CHECK-NOT: strong_retain
// CHECK: bb3:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value [[ARG1]]
// CHECK-NOT: strong_retain
sil @sink_ref_count_ops_enum_over_switch_enum_4 : $@convention(thin) (Optional<Builtin.NativeObject>, Optional<Builtin.NativeObject>) -> Optional<Builtin.NativeObject> {
bb0(%0 : $Optional<Builtin.NativeObject>, %1 : $Optional<Builtin.NativeObject>):
  %2 = function_ref @blocker : $@convention(thin) () -> ()
  retain_value %1 : $Optional<Builtin.NativeObject>
  %3 = alloc_stack $Optional<Builtin.Int32>
  retain_value %0 : $Optional<Builtin.NativeObject>
  switch_enum %1 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  apply %2() : $@convention(thin) () -> ()
  br bb3

bb2:
  br bb3

bb3:
  dealloc_stack %3 : $*Optional<Builtin.Int32>
  return %1 : $Optional<Builtin.NativeObject>
}

/// This version does not work since we have a release before the terminator
/// even though we have the select_enum before it.
// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_switch_enum_5 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
// CHECK: bb0({{.*}}):
// CHECK: bb1:
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: alloc_stack
// CHECK-NEXT: dealloc_stack
// CHECK-NEXT: retain_value
// CHECK-NEXT: release_value
// CHECK-NEXT: switch_enum
// CHECK: bb2:
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK-NOT: retain_value
// CHECK: bb4:
// CHECK-NOT: retain_value
sil @sink_ref_count_ops_enum_over_switch_enum_5 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
bb0(%0 : $Optional<Builtin.Int32>):
  br bb10

bb10:
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  retain_value %0 : $Optional<Builtin.Int32>
  %3 = alloc_stack $Builtin.Int32
  dealloc_stack %3 : $*Builtin.Int32
  release_value %0 : $Optional<Builtin.Int32>
  switch_enum %0 : $Optional<Builtin.Int32>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  br bb3

bb2:
  br bb3

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

// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_select_enum_1 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0({{.*}}):
// CHECK-NEXT: integer_literal
// CHECK-NEXT: integer_literal
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: retain_value
// CHECK-NEXT: apply
// CHECK-NEXT: alloc_stack
// CHECK-NEXT: dealloc_stack
// CHECK-NEXT: select_enum
// CHECK-NEXT: cond_br
// CHECK: bb1:
// CHECK: strong_retain
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK-NOT: strong_retain
// CHECK: bb3:
// CHECK-NOT: retain_value
// CHECK-NOT: strong_retain
sil @sink_ref_count_ops_enum_over_select_enum_1 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  %t = integer_literal $Builtin.Int1, 1
  %f = integer_literal $Builtin.Int1, 0
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  retain_value %0 : $Optional<Builtin.NativeObject>
  apply %1() : $@convention(thin) () -> ()
  %3 = alloc_stack $Builtin.Int32
  retain_value %0 : $Optional<Builtin.NativeObject>
  dealloc_stack %3 : $*Builtin.Int32
  %100 = select_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: %t, case #Optional.none!enumelt: %f : $Builtin.Int1
  cond_br %100, bb1, bb2

bb1:
  apply %1() : $@convention(thin) () -> ()
  br bb3

bb2:
  br bb3

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

// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_select_enum_2 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
// CHECK: bb0({{.*}}):
// CHECK-NEXT: integer_literal
// CHECK-NEXT: integer_literal
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: cond_br
// CHECK: bb1:
// CHECK-NEXT: retain_value
// CHECK-NEXT: select_enum
// CHECK-NEXT: cond_br
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb4:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
sil @sink_ref_count_ops_enum_over_select_enum_2 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
bb0(%0 : $Optional<Builtin.Int32>):
  %t = integer_literal $Builtin.Int1, 1
  %f = integer_literal $Builtin.Int1, 0
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  cond_br undef, bb1, bb2

bb1:
  retain_value %0 : $Optional<Builtin.Int32>
  %100 = select_enum %0 : $Optional<Builtin.Int32>, case #Optional.some!enumelt.1: %t, case #Optional.none!enumelt: %f : $Builtin.Int1
  cond_br %100, bb2, bb3

bb2:
  br bb4

bb3:
  br bb4

bb4:
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_select_enum_3 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
// CHECK: bb0({{.*}}):
// CHECK-NEXT: integer_literal
// CHECK-NEXT: integer_literal
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: cond_br
// CHECK: bb1:
// CHECK-NEXT: retain_value
// CHECK-NEXT: select_enum
// CHECK-NEXT: cond_br
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
// CHECK: bb4:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value
sil @sink_ref_count_ops_enum_over_select_enum_3 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
bb0(%0 : $Optional<Builtin.Int32>):
  %t = integer_literal $Builtin.Int1, 1
  %f = integer_literal $Builtin.Int1, 0
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  cond_br undef, bb1, bb3

bb1:
  retain_value %0 : $Optional<Builtin.Int32>
  %100 = select_enum %0 : $Optional<Builtin.Int32>, case #Optional.some!enumelt.1: %t, case #Optional.none!enumelt: %f : $Builtin.Int1
  cond_br %100, bb2, bb3

bb2:
  br bb4

bb3:
  br bb4

bb4:
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_select_enum_4 : $@convention(thin) (Optional<Builtin.NativeObject>, Optional<Builtin.NativeObject>) -> Optional<Builtin.NativeObject> {
// CHECK: bb0({{%[0-9]+}} : $Optional<Builtin.NativeObject>, [[ARG1:%[0-9]+]] : $Optional<Builtin.NativeObject>):
// CHECK-NOT: retain_value [[ARG1]]
// CHECK: select_enum
// CHECK: cond_br
// CHECK: bb1:
// CHECK: retain_value
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value [[ARG1]]
// CHECK: bb3:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: retain_value [[ARG1]]
sil @sink_ref_count_ops_enum_over_select_enum_4 : $@convention(thin) (Optional<Builtin.NativeObject>, Optional<Builtin.NativeObject>) -> Optional<Builtin.NativeObject> {
bb0(%0 : $Optional<Builtin.NativeObject>, %1 : $Optional<Builtin.NativeObject>):
  %t = integer_literal $Builtin.Int1, 1
  %f = integer_literal $Builtin.Int1, 0
  %2 = function_ref @blocker : $@convention(thin) () -> ()
  retain_value %1 : $Optional<Builtin.NativeObject>
  retain_value %0 : $Optional<Builtin.NativeObject>
  %100 = select_enum %1 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: %t, case #Optional.none!enumelt: %f : $Builtin.Int1
  cond_br %100, bb1, bb2

bb1:
  apply %2() : $@convention(thin) () -> ()
  br bb3

bb2:
  br bb3

bb3:
  return %1 : $Optional<Builtin.NativeObject>
}

/// This version does not work since we have a release before the terminator
/// even though we have the select_enum before it.
// CHECK-LABEL: sil @sink_ref_count_ops_enum_over_select_enum_5 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
// CHECK: bb0({{.*}}):
// CHECK: bb1:
// CHECK-NEXT: function_ref blocker
// CHECK-NEXT: function_ref @blocker
// CHECK-NEXT: alloc_stack
// CHECK-NEXT: dealloc_stack
// CHECK-NEXT: select_enum
// CHECK-NEXT: retain_value
// CHECK-NEXT: release_value
// CHECK-NEXT: cond_br
// CHECK: bb2:
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK-NOT: retain_value
// CHECK: bb4:
// CHECK-NOT: retain_value
sil @sink_ref_count_ops_enum_over_select_enum_5 : $@convention(thin) (Optional<Builtin.Int32>) -> () {
bb0(%0 : $Optional<Builtin.Int32>):
  %t = integer_literal $Builtin.Int1, 1
  %f = integer_literal $Builtin.Int1, 0
  br bb10

bb10:
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  retain_value %0 : $Optional<Builtin.Int32>
  %3 = alloc_stack $Builtin.Int32
  dealloc_stack %3 : $*Builtin.Int32
  %100 = select_enum %0 : $Optional<Builtin.Int32>, case #Optional.some!enumelt.1: %t, case #Optional.none!enumelt: %f : $Builtin.Int1
  release_value %0 : $Optional<Builtin.Int32>
  cond_br %100, bb1, bb2

bb1:
  br bb3

bb2:
  br bb3

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

// Sink the struct instruction
// CHECK-LABEL: sil @sink_struct : $@convention(thin) (Optional<Builtin.Int32>) -> Bool {
// CHECK: bb0({{.*}}):
// CHECK: switch_enum
// CHECK: bb1:
// CHECK: integer_literal $Builtin.Int1, -1
// CHECK: br bb3({{.*}} : $Builtin.Int1)
// CHECK: bb2:
// CHECK: integer_literal $Builtin.Int1, 0
// CHECK: br bb3({{.*}} : $Builtin.Int1)
// CHECK: bb3({{.*}} : $Builtin.Int1):
// CHECK: struct $Bool
// CHECK: return
sil @sink_struct : $@convention(thin) (Optional<Builtin.Int32>) -> Bool {
bb0(%0 : $Optional<Builtin.Int32>):
  switch_enum %0 : $Optional<Builtin.Int32>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  %6 = integer_literal $Builtin.Int1, -1
  %7 = struct $Bool (%6 : $Builtin.Int1)
  br bb3(%7 : $Bool)

bb2:
  %9 = integer_literal $Builtin.Int1, 0
  %10 = struct $Bool (%9 : $Builtin.Int1)
  br bb3(%10 : $Bool)

bb3(%12 : $Bool):
  return %12 : $Bool
}

// Sink retain down the successors so we can pair up retain with release on the
// fast path.
class Test {
  func testing() -> UInt64
}
sil_global @test : $Test
sil_global @x    : $UInt64

// CHECK-LABEL: @sink_refcount_to_succs
sil @sink_refcount_to_succs : $@convention(thin) () -> () {
bb0:
  %0 = global_addr @test : $*Test
  %1 = alloc_ref $Test
  store %1 to %0 : $*Test
  %7 = global_addr @x : $*UInt64
  %8 = integer_literal $Builtin.Int64, 0
  %9 = struct $UInt64 (%8 : $Builtin.Int64)
  store %9 to %7 : $*UInt64
  br bb1
bb1:
// CHECK: bb1:
// CHECK-NOT: strong_retain
  %17 = load %0 : $*Test
  strong_retain %17 : $Test
  %19 = class_method %17 : $Test, #Test.testing!1 : (Test) -> () -> UInt64, $@convention(method) (@guaranteed Test) -> UInt64
  %20 = load %7 : $*UInt64
  checked_cast_br [exact] %17 : $Test to $Test, bb3, bb4
bb2:
// CHECK: bb2:
// CHECK-NOT: strong_retain
  %36 = tuple ()
  return %36 : $()
bb3(%38 : $Test):
// CHECK: bb3(
// CHECK: strong_retain
// CHECK: strong_release
  strong_release %17 : $Test
  br bb2
bb4:
// CHECK: bb4:
// CHECK: strong_retain
// CHECK: apply
  %65 = apply %19(%17) : $@convention(method) (@guaranteed Test) -> UInt64
  br bb2
}

sil @virtual_callee : $@convention(method) (@guaranteed Test) -> UInt64
sil_vtable Test {
  #Test.testing!1: virtual_callee
}

// CHECK-LABEL: sil @sink_retains_from_preds : $@convention(thin) (Builtin.NativeObject) -> () {
// CHECK: bb1:
// CHECK-NOT: retain_value
// CHECK: bb2:
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK: strong_retain
sil @sink_retains_from_preds : $@convention(thin) (Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  cond_br undef, bb1, bb2

bb1:
  retain_value %0 : $Builtin.NativeObject
  br bb3

bb2:
  retain_value %0 : $Builtin.NativeObject
  br bb3

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

// CHECK-LABEL: sil @enum_simplification_test1 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0
// CHECK-NEXT: retain_value
// CHECK-NEXT: release_value
sil @enum_simplification_test1 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  retain_value %0 : $Optional<Builtin.NativeObject>
  release_value %0 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil @enum_simplification_test3 : $@convention(thin) () -> () {
// CHECK: bb0
// CHECK-NEXT: enum
// CHECK-NOT: strong_retain
// CHECK-NOT: strong_release
// CHECK-NEXT: tuple
// CHECK-NEXT: return
sil @enum_simplification_test3 : $@convention(thin) () -> () {
bb0:
  %0 = enum $Optional<Builtin.NativeObject>, #Optional.none!enumelt
  retain_value %0 : $Optional<Builtin.NativeObject>
  release_value %0 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil @enum_simplification_test4 : $@convention(thin) () -> () {
// CHECK: bb0
// CHECK-NEXT: get_object
// CHECK-NEXT: function_ref @get_object
// CHECK-NEXT: apply
// CHECK-NEXT: enum
// CHECK: strong_retain
// CHECK: strong_release
sil @enum_simplification_test4 : $@convention(thin) () -> () {
bb0:
  %0 = function_ref @get_object : $@convention(thin) () -> Builtin.NativeObject
  %1 = apply %0() : $@convention(thin) () -> Builtin.NativeObject
  %2 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %1 : $Builtin.NativeObject
  retain_value %2 : $Optional<Builtin.NativeObject>
  release_value %2 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil @enum_simplification_test5 : $@convention(thin) () -> () {
// CHECK: bb1:
// CHECK-NOT: strong_retain
// CHECK: bb2:
// CHECK-NOT: strong_retain
// CHECK: bb3:
// CHECK: strong_retain
sil @enum_simplification_test5 : $@convention(thin) () -> () {
bb0:
  %0 = function_ref @get_object : $@convention(thin) () -> Builtin.NativeObject
  %1 = apply %0() : $@convention(thin) () -> Builtin.NativeObject
  %2 = enum $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1, %1 : $Builtin.NativeObject
  %3 = function_ref @blocker : $@convention(thin) () -> ()
  cond_br undef, bb1, bb2

bb1:
  retain_value %2 : $Optional<Builtin.NativeObject>
  apply %3() : $@convention(thin) () -> ()
  br bb3

bb2:
  retain_value %2 : $Optional<Builtin.NativeObject>
  apply %3() : $@convention(thin) () -> ()
  br bb3

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

// This test is testing that we can properly simplify unchecked_enum_data if we
// know the tag. We also sink it.
//
// CHECK-LABEL: sil @enum_simplification_test6a : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb1:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: strong_retain
// CHECK-NOT: retain_value
// CHECK: bb2:
// CHECK-NOT: unchecked_enum_data
// CHECK-NOT: strong_retain
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK: retain_value
sil @enum_simplification_test6a : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  %1 = unchecked_enum_data %0 : $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1
  cond_br undef, bb1, bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

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

// Because our enum is not local to this function, we cannot move retain_value
// %0 past blocker.
//
// CHECK-LABEL: sil @enum_simplification_test6b : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb1:
// CHECK: strong_retain
// CHECK: bb2:
// CHECK: strong_retain
// CHECK: bb3:
// CHECK-NOT: retain_value
sil @enum_simplification_test6b : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  %1 = unchecked_enum_data %0 : $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1
  %2 = function_ref @blocker : $@convention(thin) () -> ()
  cond_br undef, bb1, bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  apply %2() : $@convention(thin) () -> ()
  br bb3

bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

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


// CHECK-LABEL: sil @enum_simplification_test7 : $@convention(thin) () -> () {
// CHECK-NOT: retain
// CHECK-NOT: retain
// CHECK: return
sil @enum_simplification_test7 : $@convention(thin) () -> () {
bb0:
  %0 = enum $Optional<Builtin.NativeObject>, #Optional.none!enumelt
  cond_br undef, bb1, bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

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

// CHECK-LABEL: sil @enum_simplification_test8 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0([[INPUT:%[0-9]+]] : $Optional<Builtin.NativeObject>):
// CHECK: bb2:
// CHECK-NEXT: retain_value [[INPUT]]
// CHECK: bb3:
// CHECK-NEXT: [[PAYLOAD:%[0-9]+]] = unchecked_enum_data [[INPUT]]
// CHECK-NEXT: strong_retain [[PAYLOAD]]
// CHECK: bb4:
// CHECK: retain_value [[INPUT]]
sil @enum_simplification_test8 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  cond_br undef, bb1, bb2

bb1:
  %1 = unchecked_enum_data %0 : $Optional<Builtin.NativeObject>, #Optional.some!enumelt.1
  cond_br undef, bb2, bb3

bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb4

bb3:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb4

bb4:
  retain_value %0 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil @enum_simplification_test9 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0([[INPUT:%[0-9]+]] : $Optional<Builtin.NativeObject>):
// CHECK: bb1:
// CHECK: strong_retain
// CHECK: bb2:
// CHECK-NOT: retain
// CHECK: bb3:
// CHECK: retain_value [[INPUT]]
sil @enum_simplification_test9 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  %1 = function_ref @blocker : $@convention(thin) () -> ()
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  apply %1() : $@convention(thin) () -> ()
  br bb3

bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

bb3:
  retain_value %0 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

// Note, this is the same as test9, but for enums
// CHECK-LABEL: sil @enum_simplification_test9_enums : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0([[INPUT:%[0-9]+]] : $Optional<Builtin.NativeObject>):
// CHECK: bb1:
// CHECK: strong_retain
// CHECK: bb2:
// CHECK-NOT: retain
// CHECK: bb3:
// CHECK: retain_value [[INPUT]]
sil @enum_simplification_test9_enums : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  %t = integer_literal $Builtin.Int1, 1
  %f = integer_literal $Builtin.Int1, 0
  %2 = function_ref @blocker : $@convention(thin) () -> ()
  %1 = select_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: %t, case #Optional.none!enumelt: %f : $Builtin.Int1
  cond_br %1, bb1, bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  apply %2() : $@convention(thin) () -> ()
  br bb3

bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

bb3:
  retain_value %0 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

////////////////
// Loop Tests //
////////////////

// CHECK-LABEL: sil @enum_simplification_test10 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0([[INPUT:%[0-9]+]] : $Optional<Builtin.NativeObject>):
// CHECK: retain_value [[INPUT]]
// CHECK: retain_value [[INPUT]]
// CHECK: retain_value [[INPUT]]
// CHECK: retain_value [[INPUT]]
sil @enum_simplification_test10 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

// Single BB Loop
bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  cond_br undef, bb1, bb9999

// Two BB Loop. We can use loop or domination to handle this case. But we don't
// handle it now.
bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

bb3:
  retain_value %0 : $Optional<Builtin.NativeObject>
  cond_br undef, bb2, bb9999

bb9999:
  retain_value %0 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

// Make sure we don't propagate state out of loops.
// CHECK-LABEL: sil @enum_simplification_test11 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0([[INPUT:%[0-9]+]] : $Optional<Builtin.NativeObject>):
// CHECK: retain_value [[INPUT]]
// CHECK: retain_value [[INPUT]]
sil @enum_simplification_test11 : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  cond_br undef, bb1, bb2

bb2:
  retain_value %0 : $Optional<Builtin.NativeObject>
  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil @enum_simplification_test14 : $@convention(thin) (Either) -> () {
// CHECK: bb0(
// CHECK-NOT: release
// CHECK: bb1:
// CHECK: release
sil @enum_simplification_test14 : $@convention(thin) (Either) -> () {
bb0(%0 : $Either):
  %1 = unchecked_enum_data %0 : $Either, #Either.First!enumelt.1
  cond_br undef, bb1, bb2

bb1:
  release_value %0 : $Either
  br bb3

bb2:
  br bb3

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

// CHECK-LABEL: sil @enum_simplification_test15 : $@convention(thin) (Either, ThreeCaseEnum) -> () {
// CHECK: bb1:
// CHECK: release
// CHECK: bb2:
// CHECK-NOT: release
// CHECK: bb3:
// CHECK-NOT: release
sil @enum_simplification_test15 : $@convention(thin) (Either, ThreeCaseEnum) -> () {
bb0(%0 : $Either, %1 : $ThreeCaseEnum):
  %2 = unchecked_enum_data %0 : $Either, #Either.First!enumelt.1
  switch_enum %1 : $ThreeCaseEnum, case #ThreeCaseEnum.A!enumelt: bb1,
                  case #ThreeCaseEnum.B!enumelt: bb2,
                  case #ThreeCaseEnum.C!enumelt: bb3

bb1:
  release_value %0 : $Either
  br bb4

bb2:
  br bb4

bb3:
  br bb4

bb4:
  %9999 = tuple()
  return %9999 : $()
}

sil @unknown : $@convention(thin) () -> ()

// CHECK-LABEL: sil @sink_retains_out_of_switch_regions : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb1:
// CHECK-NOT: retain_value
// CHECK: bb2:
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK: retain_value
sil @sink_retains_out_of_switch_regions : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

bb2:
  br bb3

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

// CHECK-LABEL: sil @sink_retains_through_multiple_switches : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK-NOT: retain_value
// CHECK: bb9:
// CHECK: retain_value
sil @sink_retains_through_multiple_switches : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  retain_value %0 : $Optional<Builtin.NativeObject>
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  br bb3

bb2:
  br bb3

bb3:
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5

bb4:
  br bb6

bb5:
  br bb6

bb6:
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb7, case #Optional.none!enumelt: bb8

bb7:
  br bb9

bb8:
  br bb9

bb9:
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @sink_retains_through_switch_with_body : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK-NOT: retain_value
// CHECK: bb5:
// CHECK: retain_value
sil @sink_retains_through_switch_with_body : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  retain_value %0 : $Optional<Builtin.NativeObject>
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  br bb3

bb2:
  br bb4

bb3:
  br bb5

bb4:
  br bb5

bb5:
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @sink_retains_through_separated_switches : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK-NOT: retain_value
// CHECK: bb3:
// CHECK: retain_value
// CHECK: bb4:
// CHECK: retain_value
// CHECK: bb5:
// CHECK-NOT: retain_value
sil @sink_retains_through_separated_switches : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  retain_value %0 : $Optional<Builtin.NativeObject>
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  cond_br undef, bb3, bb4

bb2:
  br bb5

bb3:
  br bb5

bb4:
  br bb5

bb5:
  %1 = tuple()
  return %1 : $()
}

// Make sure that we blot pointers from the enumbbtoenumbbcaselist map after
// merging predecessors. This ensures that the failure to merge unrelating
// values does not stop sinking out of retain, release regions.
// CHECK-LABEL: sil @enumbbtoenumbbcaselist_invalidation_test : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb3:
// CHECK: retain_value
sil @enumbbtoenumbbcaselist_invalidation_test : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  switch_enum %0 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  retain_value %0 : $Optional<Builtin.NativeObject>
  br bb3

bb2:
  %1 = enum $Optional<Builtin.NativeObject>, #Optional.none!enumelt
  br bb3

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

// We can do the deletion in simplify-cfg.
//
// CHECK-LABEL: sil @delete_instead_of_sinkretainsintounreachable_bb : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
// CHECK: bb0(
// CHECK-NOT: retain_value
// CHECK: bb1:
// CHECK: retain_value
// CHECK: bb2:
// CHECK: retain_value
sil @delete_instead_of_sinkretainsintounreachable_bb : $@convention(thin) (Optional<Builtin.NativeObject>) -> () {
bb0(%0 : $Optional<Builtin.NativeObject>):
  retain_value %0 : $Optional<Builtin.NativeObject>
  cond_br undef, bb1, bb2

bb1:
  unreachable

bb2:
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @sink_retain_over_switch_enum_cast
// CHECK: bb0(
// CHECK-NOT: retain_value
// CHECK: switch_enum
// CHECK: bb1:
// CHECK-NOT: retain_value
// CHECK: br bb3
// CHECK: bb2:
// CHECK-NOT: retain_value
// CHECK: br bb3
// CHECK: bb3:
// CHECK: strong_retain
sil @sink_retain_over_switch_enum_cast : $@convention(thin) (Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  retain_value %0 : $Builtin.NativeObject
  %1 = unchecked_ref_cast %0 : $Builtin.NativeObject to $Optional<Builtin.NativeObject>
  switch_enum %1 : $Optional<Builtin.NativeObject>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

bb1:
  br bb3

bb2:
  br bb3

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

class F {}
class G {}

// CHECK-LABEL: sil @cast_consumption
// CHECK: store
// CHECK-NEXT: strong_retain
// CHECK-NEXT: unconditional_checked_cast_addr
// CHECK-NEXT: strong_release
sil @cast_consumption : $@convention(thin) (@owned F) -> () {
bb0(%0 : $F):
  %1 = alloc_stack $F
  store %0 to %1 : $*F
  strong_retain %0 : $F
  unconditional_checked_cast_addr F in %1 : $*F to G in %1 : $*F
  strong_release %0 : $F
  dealloc_stack %1 : $*F
  %2 = tuple ()
  return %2 : $()
}

// Make sure that is_unique stops code motion.
// CHECK-LABEL: sil @is_unique_stops_codemotion : $@convention(thin) (@inout Builtin.NativeObject) -> () {
// CHECK: bb0([[IN:%[0-9]+]] : $*Builtin.NativeObject):
// CHECK: [[LD:%[0-9]+]] = load [[IN]] : $*Builtin.NativeObject
// CHECK: strong_retain [[LD]] : $Builtin.NativeObject
// CHECK: is_unique [[IN]] : $*Builtin.NativeObject
sil @is_unique_stops_codemotion : $@convention(thin) (@inout Builtin.NativeObject) -> () {
bb0(%0 : $*Builtin.NativeObject):
  %1 = load %0 : $*Builtin.NativeObject
  strong_retain %1 : $Builtin.NativeObject
  is_unique %0 : $*Builtin.NativeObject
  %9999 = tuple()
  return %9999 : $()
}

sil @no_return_func : $@convention(thin) () -> Never

// Make sure that we do not move retains over noreturn functions.
// CHECK-LABEL: sil @no_return_stops_codemotion : $@convention(thin) (Builtin.NativeObject) -> () {
// CHECK: apply
// CHECK-NEXT: unreachable
sil @no_return_stops_codemotion : $@convention(thin) (Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  %1 = alloc_ref $C
  strong_retain %1 : $C
  %9999 = function_ref @no_return_func : $@convention(thin) () -> Never
  apply %9999() : $@convention(thin) () -> Never
  unreachable
}

class URefd {
}

class Cont {
  unowned var x : URefd
  unowned var y : URefd

  init()
}

// CHECK-LABEL: sil @sink_unowned_to_ref_through_args
// CHECK:        [[LD1:%[0-9]+]] = load
// CHECK-NEXT:   br bb3([[LD1]] : $@sil_unowned URefd)
// CHECK:        [[LD2:%[0-9]+]] = load
// CHECK-NEXT:   br bb3([[LD2]] : $@sil_unowned URefd)
// CHECK:      bb3([[ARG:%[0-9]+]] : $@sil_unowned URefd):
// CHECK-NEXT:   [[R:%[0-9]+]] = unowned_to_ref [[ARG]]
// CHECK-NEXT:   return [[R]]
sil @sink_unowned_to_ref_through_args : $@convention(thin) (Builtin.Int1, Cont) -> URefd {
bb0(%0 : $Builtin.Int1, %1 : $Cont):
  cond_br %0, bb1, bb2

bb1:
  %x1 = ref_element_addr %1 : $Cont, #Cont.x
  %x2 = load %x1 : $*@sil_unowned URefd
  %x3 = unowned_to_ref %x2 : $@sil_unowned URefd to $URefd
  br bb3(%x3 : $URefd)

bb2:
  %y1 = ref_element_addr %1 : $Cont, #Cont.y
  %y2 = load %y1 : $*@sil_unowned URefd
  %y3 = unowned_to_ref %y2 : $@sil_unowned URefd to $URefd
  br bb3(%y3 : $URefd)

bb3(%12 : $URefd):
  return %12 : $URefd
}

class X { func ping() {} }
class Y : X { }
// CHECK-LABEL: sil @canonicalize_releases

sil @canonicalize_releases : $@convention(thin) (@owned Optional<X>) -> () {
bb0(%0 : $Optional<X>):
  debug_value %0 : $Optional<X>, let, name "x" // id: %1
  switch_enum %0 : $Optional<X>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb3 // id: %2

bb1:                                              // Preds: bb0
  %3 = unchecked_enum_data %0 : $Optional<X>, #Optional.some!enumelt.1 // users: %4, %13, %14, %15
  checked_cast_br [exact] %3 : $X to $X, bb4, bb5 // id: %4

// Make sure we were able to sink the release.
// CHECK: strong_release
// CHECK-NEXT: tuple ()
// CHECK-NEXT: return

bb2:                                              // Preds: bb4 bb5
  %5 = tuple ()                                   // user: %6
  return %5 : $()                                 // id: %6

bb3:                                              // Preds: bb0
  %7 = integer_literal $Builtin.Int1, -1          // user: %8
  cond_fail %7 : $Builtin.Int1                    // id: %8
  unreachable                                     // id: %9

 // Canonicalize the re
bb4(%10 : $X):                                    // Preds: bb1
  strong_release %10 : $X                         // id: %11
  br bb2                                          // id: %12

bb5:                                              // Preds: bb1
  %13 = class_method %3 : $X, #X.ping!1 : (X) -> () -> (), $@convention(method) (@guaranteed X) -> () // user: %14
  %14 = apply %13(%3) : $@convention(method) (@guaranteed X) -> ()
  strong_release %3 : $X                          // id: %15
  br bb2                                          // id: %16
}


// The input swift code:
// func foo(x : X) -> Int {
//    if let z = x as? Y {
//       z.ping()
//       z.ping()
//    }
//   return 0
// }

//CHECK-LABEL: sil @canonicalize_casts
// Make sure we are replacing all uses of %3 with %0.
sil @canonicalize_casts: $@convention(thin) (@owned X) -> Int32 {
bb0(%0 : $X):
  debug_value %0 : $X, let, name "x" // id: %1
  checked_cast_br %0 : $X to $Y, bb1, bb3         // id: %2

bb1(%3 : $Y):                                     // Preds: bb0
  debug_value %3 : $Y, let, name "z" // id: %4
  %5 = upcast %3 : $Y to $X                       // users: %6, %7, %21, %23
  %6 = class_method %5 : $X, #X.ping!1 : (X) -> () -> (), $@convention(method) (@guaranteed X) -> () // users: %21, %23
  checked_cast_br [exact] %5 : $X to $Y, bb5, bb6 // id: %7

bb2:                                              // Preds: bb5 bb6
  //CHECK: strong_release %0
  //CHECK-NEXT: strong_release %0
  strong_release %0 : $X                          // id: %8
  strong_release %3 : $Y                          // id: %9
  br bb4                                          // id: %10

bb3:                                              // Preds: bb0
  br bb4                                          // id: %11

bb4:                                              // Preds: bb2 bb3
  %12 = integer_literal $Builtin.Int32, 0         // user: %13
  %13 = struct $Int32 (%12 : $Builtin.Int32)        // user: %15
  strong_release %0 : $X                          // id: %14
  return %13 : $Int32                               // id: %15

bb5(%16 : $Y):                                    // Preds: bb1
  //CHECK: strong_retain %0
  //CHECK-NEXT: strong_retain %0
  strong_retain %0 : $X                           // id: %17
  strong_retain %3 : $Y                           // id: %18
  br bb2                                          // id: %19

bb6:                                              // Preds: bb1
  //CHECK: strong_retain %0
  //CHECK-NEXT: apply
  //CHECK-NEXT: strong_retain %0
  //CHECK-NEXT: apply
  strong_retain %3 : $Y                           // id: %20
  %21 = apply %6(%5) : $@convention(method) (@guaranteed X) -> ()
  strong_retain %0 : $X                           // id: %22
  %23 = apply %6(%5) : $@convention(method) (@guaranteed X) -> ()
  br bb2                                          // id: %24
}


// Make sure we are not crashing on this one:
sil @direct_branch0: $@convention(thin) (@owned X) -> Int {
bb0(%0 : $X):
  br bb1(%0 : $X)

bb1(%1 : $X):
  strong_release %1 : $X
  br bb2(%1 : $X)

bb2(%4 : $X):
  strong_release %4 : $X
  br bb2(%4 : $X)
}

//CHECK-LABEL: @cond_branch0
sil @cond_branch0: $@convention(thin) (@owned X) -> Int {
bb0(%0 : $X):
  cond_br undef, bb1(%0 : $X), bb2(%0 : $X)

bb1(%1 : $X):
  //CHECK: strong_release %0
  strong_release %1 : $X
  br bb2(%1 : $X)

bb2(%5 : $X):
  //CHECK: strong_release %5
  strong_release %5 : $X
  br bb2(%5 : $X)
}


// CHECK-LABEL: sil @sink_literals_through_arguments
sil @sink_literals_through_arguments : $@convention(thin) (Builtin.Int1) -> Builtin.RawPointer {
bb0(%0 : $Builtin.Int1):
  cond_br %0, bb1, bb2

bb1:
  %x1 = string_literal utf8 "0"
  br bb3(%x1 : $Builtin.RawPointer)

bb2:
  %y1 = string_literal utf8 "0"
  br bb3(%y1 : $Builtin.RawPointer)

bb3(%z1 : $Builtin.RawPointer):
  //CHECK: string_literal utf8 "0"
  //CHECK-NEXT: return
  return %z1 : $Builtin.RawPointer
}

// CHECK-LABEL: sil hidden @sink_allocation_inst
sil hidden @sink_allocation_inst : $@convention(thin) (Boo, Boo) -> Bool {
bb0(%0 : $Boo, %1 : $Boo):
  debug_value %0 : $Boo, let, name "x" // id: %2
  debug_value %0 : $Boo                           // id: %3
  debug_value %0 : $Boo, let, name "self" // id: %4
  switch_enum %0 : $Boo, case #Boo.one!enumelt: bb1, case #Boo.two!enumelt: bb3 // id: %5

bb1:                                              // Preds: bb0
  %6 = alloc_ref $fuzz                            // users: %7, %8
  debug_value %6 : $fuzz, let, name "self" // id: %7
  br bb2(%6 : $fuzz)                              // id: %8

bb3:                                              // Preds: bb0
  %15 = alloc_ref $fuzz                           // users: %16, %17
  debug_value %15 : $fuzz, let, name "self" // id: %16
  br bb2(%15 : $fuzz)                             // id: %17

bb2(%9 : $fuzz):
  // Make sure we have a single alloc_ref instruction and not two.
  // CHECK: alloc_ref
  // CHECK-NOT: alloc_ref
  // CHECK: return
  debug_value %9 : $fuzz, let, name "lhs" // id: %10
  %11 = integer_literal $Builtin.Int1, -1         // user: %12
  %12 = struct $Bool (%11 : $Builtin.Int1)        // user: %14
  strong_release %9 : $fuzz                       // id: %13
  return %12 : $Bool                              // id: %14
}

// Make sure retain instruction is not sunk across copy_addr inst, as copy_addr
// may decrement the refcount of %0 here.
//
// CHECK-LABEL: retain_blocked_by_copyaddr
// CHECK: bb0
// CHECK-NEXT: retain_value
sil hidden @retain_blocked_by_copyaddr : $@convention(thin) <T> (@in T, B) -> @out T {
bb0(%0 : $*T, %1 : $*T, %2 : $B):
  retain_value %2 : $B
  copy_addr [take] %1 to %0 : $*T // id: %3
  %4 = tuple ()                                   // user: %5
  return %4 : $()                                 // id: %5
}

// Make sure retain instruction is sunk across copy_addr inst, as copy_addr
// dest is initialized.
//
// CHECK-LABEL: retain_not_blocked_by_copyaddrinit
// CHECK: bb0
// CHECK-NEXT: copy_addr
// CHECK-NEXT: tuple
// CHECK-NEXT: strong_retain
sil hidden @retain_not_blocked_by_copyaddrinit : $@convention(thin) <T> (@in T, B) -> @out T {
bb0(%0 : $*T, %1 : $*T, %2 : $B):
  retain_value %2 : $B
  copy_addr [take] %1 to [initialization] %0 : $*T // id: %3
  %4 = tuple ()                                   // user: %5
  return %4 : $()                                 // id: %5
}

// Make sure retain instruction is sunk across copy_addr inst, as copy_addr
// dest is initialized.
//
// CHECK-LABEL: retain_not_blocked_by_copyaddr_notake_init
// CHECK: bb0
// CHECK-NEXT: copy_addr
// CHECK-NEXT: tuple
// CHECK-NEXT: strong_retain
sil hidden @retain_not_blocked_by_copyaddr_notake_init : $@convention(thin) <T> (@in T, B) -> @out T {
bb0(%0 : $*T, %1 : $*T, %2 : $B):
  retain_value %2 : $B
  copy_addr %1 to [initialization] %0 : $*T // id: %3
  %4 = tuple ()                                   // user: %5
  return %4 : $()                                 // id: %5
}

// Make sure we do not sink the SILArgument for bb3.
//
// CHECK-LABEL: no_sinkargument_on_clobbered_load
// CHECK: bb3(%20 : $Int):
// CHECK-NOT: load
// CHECK: return
sil hidden @no_sinkargument_on_clobbered_load : $@convention(thin) (Bool) -> () {
// %0                                             // users: %2, %7
bb0(%0 : $Bool):
  %1 = alloc_stack $foo                           // users: %6, %11, %17, %24
  debug_value %0 : $Bool                          // id: %2
  // function_ref foo_init
  %3 = function_ref @foo_init : $@convention(thin) (@thin foo.Type) -> foo // user: %5
  %4 = metatype $@thin foo.Type                   // user: %5
  %5 = apply %3(%4) : $@convention(thin) (@thin foo.Type) -> foo // user: %6
  store %5 to %1 : $*foo                        // id: %6
  %7 = struct_extract %0 : $Bool, #Bool.value     // user: %8
  cond_br %7, bb1, bb2                            // id: %8

bb1:                                              // Preds: bb0
  %9 = integer_literal $Builtin.Int64, 11         // user: %10
  %10 = struct $Int (%9 : $Builtin.Int64)         // user: %13
  %11 = struct_element_addr %1 : $*foo, #foo.a  // users: %12, %13
  %12 = load %11 : $*Int                          // user: %14
  store %10 to %11 : $*Int                        // id: %13
  br bb3(%12 : $Int)                              // id: %14

bb2:                                              // Preds: bb0
  %15 = integer_literal $Builtin.Int64, 12        // user: %16
  %16 = struct $Int (%15 : $Builtin.Int64)
  %17 = struct_element_addr %1 : $*foo, #foo.a  // user: %18
  %18 = load %17 : $*Int                          // user: %19
  br bb3(%18 : $Int)                              // id: %19

// %20                                            // user: %22
bb3(%20 : $Int):                                  // Preds: bb1 bb2
  // function_ref user_int
  %21 = function_ref @user_int : $@convention(thin) (Int) -> () // user: %22
  %22 = apply %21(%20) : $@convention(thin) (Int) -> ()
  %23 = tuple ()                                  // user: %25
  dealloc_stack %1 : $*foo       // id: %24
  return %23 : $()                                // id: %25
}