test/SILOptimizer/definite_init_crashes.sil

// RUN: %target-sil-opt -enable-sil-verify-all %s -definite-init | FileCheck %s

// These are all regression tests to ensure that the memory promotion pass
// doesn't crash.

import Builtin
import Swift


// Mixed combination of aggregate load/stores and elements.
struct Triple {
  var a, b, c : Int
}

// CHECK-LABEL: sil @TripleTest
sil @TripleTest : $@convention(method) (Int, @inout Triple) -> Triple {
bb0(%0 : $Int, %1 : $*Triple):
  %4 = alloc_box $Triple
  %5 = load %1 : $*Triple
  store %5 to %4#1 : $*Triple
  %8 = struct_element_addr %4#1 : $*Triple, #Triple.b
  store %0 to %8 : $*Int
  %10 = load %4#1 : $*Triple
  strong_release %4#0 : $@box Triple
  return %10 : $Triple
}


struct Single {
  var a : Int
}

// CHECK-LABEL: sil @SingleTest
sil @SingleTest : $@convention(method) (@inout  Single, Int) -> Single {
bb0(%0 : $*Single, %1 : $Int):
  %4 = alloc_box $Single
  %5 = load %0 : $*Single
  store %5 to %4#1 : $*Single
  
  %8 = struct_element_addr %4#1 : $*Single, #Single.a
  store %1 to %8 : $*Int

  %10 = load %4#1 : $*Single
  strong_release %4#0 : $@box Single
  return %10 : $Single
}


class SomeClass {}

enum SomeUnion {
  case x(Int)
  case y(SomeClass)
}

sil @getSomeClass : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass
sil @getSomeUnion : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion


// CHECK-LABEL: sil @test_union_release
sil @test_union_release : $@convention(thin) () -> () {
bb0:
  %0 = tuple ()
  %1 = alloc_box $SomeUnion                       // users: %9, %8
  %2 = function_ref @getSomeUnion : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion // user: %7
  %3 = metatype $@thin SomeUnion.Type               // user: %7
  %4 = function_ref @getSomeClass : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass // user: %6
  %5 = metatype $@thick SomeClass.Type               // user: %6
  %6 = apply %4(%5) : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass // user: %7
  %7 = apply %2(%6, %3) : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion // user: %8
  assign %7 to %1#1 : $*SomeUnion
  strong_release %1#0 : $@box SomeUnion
  %10 = tuple ()                                  // user: %11
  return %10 : $()
}