// RUN: %target-sil-opt -enable-sil-verify-all -enable-expand-all %s -lower-aggregate-instrs | %FileCheck %s

// This file makes sure that the mechanics of expanding aggregate instructions
// work. With that in mind, we expand all structs here ignoring code-size
// trade-offs.

sil_stage canonical

import Swift
import Builtin

class C1 {
  var data : Builtin.Int64
  init()
}

class C2 {
  var data : Builtin.FPIEEE32
  init()
}

class C3 {
  var data : Builtin.FPIEEE64
  init()
}

struct S2 {
  var cls1 : C1
  var cls2 : C2
  var trivial : Builtin.FPIEEE32
}

struct S {
  var trivial : Builtin.Int64
  var cls : C3
  var inner_struct : S2
}

enum E {
  case NoElement(Void)
  case TrivialElement(Builtin.Int64)
  case ReferenceElement(C1)
  case StructNonTrivialElt(S)
  case TupleNonTrivialElt((Builtin.Int64, S, C3))
}

// A struct for testing that aggregate rebuilding works.
struct S3 {
  var trivial1 : Builtin.Int64
  var cls : S
  var trivial2 : Builtin.Int64
  var e : E
  var trivial3 : Builtin.Int64
}

//////////////////
// Destroy Addr //
//////////////////

// CHECK-LABEL: sil @expand_destroy_addr_trivial
// CHECK: bb0
// CHECK: tuple ()
// CHECK: return
sil @expand_destroy_addr_trivial : $@convention(thin) (@inout Builtin.Int64) -> () {
bb0(%0 : $*Builtin.Int64):
  destroy_addr %0 : $*Builtin.Int64
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @expand_destroy_addr_aggstructnontrivial
// CHECK: bb0([[INPTR:%[0-9]+]] : $*S):
// CHECK: [[IN:%[0-9]+]] = load [[INPTR]] : $*S
// CHECK: [[cls:%[0-9]+]] = struct_extract [[IN]] : $S, #S.cls
// CHECK: strong_release [[cls]] : $C3
// CHECK: [[innerstruct:%[0-9]+]] = struct_extract [[IN]] : $S, #S.inner_struct
// CHECK: [[innerstruct_cls1:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls1
// CHECK: strong_release [[innerstruct_cls1]] : $C1
// CHECK: [[innerstruct_cls2:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls2
// CHECK: strong_release [[innerstruct_cls2]] : $C2
// CHECK: tuple
// CHECK: return
sil @expand_destroy_addr_aggstructnontrivial : $@convention(thin) (@inout S) -> () {
bb0(%0 : $*S):
  destroy_addr %0 : $*S
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @expand_destroy_addr_aggtuplenontrivial
// CHECK: bb0([[INPTR:%[0-9]+]] : $*(S, S2, C1)):
// CHECK: [[IN:%[0-9]+]] = load [[INPTR]] : $*(S, S2, C1)
// CHECK: [[ELT0:%[0-9]+]] = tuple_extract [[IN]] : $(S, S2, C1), 0
// CHECK: [[ELT0cls:%[0-9]+]] = struct_extract [[ELT0]] : $S, #S.cls
// CHECK: strong_release [[ELT0cls]] : $C3
// CHECK: [[ELT0innerstruct:%[0-9]+]] = struct_extract [[ELT0]] : $S, #S.inner_struct
// CHECK: [[ELT0innerstructcls1:%[0-9]+]] = struct_extract [[ELT0innerstruct]] : $S2, #S2.cls1
// CHECK: strong_release [[ELT0innerstructcls1]] : $C1
// CHECK: [[ELT0innerstructcls2:%[0-9]+]] = struct_extract [[ELT0innerstruct]] : $S2, #S2.cls2
// CHECK: strong_release [[ELT0innerstructcls2]]
// CHECK: [[ELT1:%[0-9]+]] = tuple_extract [[IN]] : $(S, S2, C1), 1
// CHECK: [[ELT1cls1:%[0-9]+]] = struct_extract [[ELT1]] : $S2, #S2.cls1
// CHECK: strong_release [[ELT1cls1]] : $C1
// CHECK: [[ELT1cls2:%[0-9]+]] = struct_extract [[ELT1]] : $S2, #S2.cls2
// CHECK: strong_release [[ELT1cls2]] : $C2
// CHECK: [[ELT2:%[0-9]+]] = tuple_extract [[IN]] : $(S, S2, C1), 2
// CHECK: strong_release [[ELT2]]
// CHECK: tuple ()
// CHECK: return
sil @expand_destroy_addr_aggtuplenontrivial : $@convention(thin) (@inout (S, S2, C1)) -> () {
bb0(%0 : $*(S, S2, C1)):
  destroy_addr %0 : $*(S, S2, C1)
  %1 = tuple()
  return %1 : $()
}

// Do not do anything.
/*
sil @expand_destroy_addr_addressonly : $@convention(thin) <T> (@inout T) -> () {
bb0(%0 : $*T):
  destroy_addr %0 : $*T
  %1 = tuple()
  return %1 : $()
}
*/

// CHECK-LABEL: sil @expand_destroy_addr_reference
// CHECK: bb0
// CHECK: load
// CHECK: strong_release
// CHECK: tuple
// CHECK: return
sil @expand_destroy_addr_reference : $@convention(thin) (@inout C1) -> () {
bb0(%0 : $*C1):
  destroy_addr %0 : $*C1
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @expand_destroy_addr_enum
// CHECK: bb0
// CHECK: load
// CHECK: release_value
// CHECK: tuple
// CHECK: return
sil @expand_destroy_addr_enum : $@convention(thin) (@inout E) -> () {
bb0(%0 : $*E):
  destroy_addr %0 : $*E
  %1 = tuple()
  return %1 : $()
}

///////////////
// Copy Addr //
///////////////

// CHECK-LABEL: sil @expand_copy_addr_takeinit
// CHECK: bb0([[IN1:%[0-9]+]] : $*S, [[IN2:%[0-9]+]] : $*S):
// CHECK: [[LOAD1:%[0-9]+]] = load [[IN1]] : $*S
// CHECK: store [[LOAD1]] to [[IN2]]
// CHECK: tuple
// CHECK: return
sil @expand_copy_addr_takeinit : $@convention(thin) (@inout S, @inout S) -> () {
bb0(%0 : $*S, %1 : $*S):
  copy_addr [take] %0 to [initialization] %1 : $*S
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil @expand_copy_addr_init
// CHECK: bb0([[IN1PTR:%[0-9]+]] : $*S, [[IN2PTR:%[0-9]+]] : $*S):
// CHECK: [[IN1:%[0-9]+]] = load [[IN1PTR]] : $*S
// CHECK: [[IN1trivial:%[0-9]+]] = struct_extract [[IN1]] : $S, #S.trivial
// CHECK: [[IN1cls:%[0-9]+]] = struct_extract [[IN1]] : $S, #S.cls
// CHECK: strong_retain [[IN1cls]] : $C3
// CHECK: [[innerstruct:%[0-9]+]] = struct_extract [[IN1]] : $S, #S.inner_struct
// CHECK: [[innerstructIN11:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls1
// CHECK: strong_retain [[innerstructIN11]] : $C1
// CHECK: [[innerstructIN12:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls2
// CHECK: strong_retain [[innerstructIN12]] : $C2
// CHECK: [[innerstructtrivial:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.trivial
// CHECK: store [[IN1]] to [[IN2PTR]]
// CHECK: tuple
// CHECK: return
sil @expand_copy_addr_init : $@convention(thin) (@inout S, @inout S) -> () {
bb0(%0 : $*S, %1 : $*S):
  copy_addr %0 to [initialization] %1 : $*S
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil @expand_copy_addr_take
// CHECK: bb0([[IN1PTR:%[0-9]+]] : $*S, [[IN2PTR:%[0-9]+]] : $*S):
// CHECK: [[IN1:%[0-9]+]] = load [[IN1PTR]] : $*S
// CHECK: [[IN2:%[0-9]+]] = load [[IN2PTR]] : $*S
// CHECK: [[cls:%[0-9]+]] = struct_extract [[IN2]] : $S, #S.cls
// CHECK: strong_release [[cls]] : $C3
// CHECK: [[innerstruct:%[0-9]+]] = struct_extract [[IN2]] : $S, #S.inner_struct
// CHECK: [[innerstructcls1:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls1
// CHECK: strong_release [[innerstructcls1]] : $C1
// CHECK: [[innerstructcls2:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls2
// CHECK: strong_release [[innerstructcls2]]
// CHECK: store [[IN1]] to [[IN2PTR]]
// CHECK: tuple
// CHECK: return
sil @expand_copy_addr_take : $@convention(thin) (@inout S, @inout S) -> () {
bb0(%0 : $*S, %1 : $*S):
  copy_addr [take] %0 to %1 : $*S
  %2 = tuple()
  return %2 : $()
}

// Test expansions for various types (these will become more
// interesting when I introduce the actual chopping work).

// CHECK-LABEL: sil @expand_copy_addr_trivial
// CHECK: bb0
// CHECK: load
// CHECK: store
// CHECK: tuple
// CHECK: return
sil @expand_copy_addr_trivial : $@convention(thin) (@inout Builtin.Int64, @inout Builtin.Int64) -> () {
bb0(%0 : $*Builtin.Int64, %1 : $*Builtin.Int64):
  copy_addr %0 to %1 : $*Builtin.Int64
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil @expand_copy_addr_aggstructnontrivial
// CHECK: bb0([[IN1PTR:%[0-9]+]] : $*S, [[IN2PTR:%[0-9]+]] : $*S):
// CHECK: [[IN1:%[0-9]+]] = load [[IN1PTR]] : $*S
// CHECK: [[IN2:%[0-9]+]] = load [[IN2PTR]] : $*S
// CHECK: [[IN1trivial:%[0-9]+]] = struct_extract [[IN1]] : $S, #S.trivial
// CHECK: [[IN1cls:%[0-9]+]] = struct_extract [[IN1]] : $S, #S.cls
// CHECK: strong_retain [[IN1cls]] : $C3
// CHECK: [[IN1innerstruct:%[0-9]+]] = struct_extract [[IN1]] : $S, #S.inner_struct
// CHECK: [[IN1innerstructcls1:%[0-9]+]] = struct_extract [[IN1innerstruct]] : $S2, #S2.cls1
// CHECK: strong_retain [[IN1innerstructcls1]] : $C1
// CHECK: [[IN1innerstructcls2:%[0-9]+]] = struct_extract [[IN1innerstruct]] : $S2, #S2.cls2
// CHECK: strong_retain [[IN1innerstructcls2]] : $C2
// CHECK: [[IN1innerstructtrivial:%[0-9]+]] = struct_extract [[IN1innerstruct]] : $S2, #S2.trivial
// CHECK: [[IN2cls:%[0-9]+]] = struct_extract [[IN2]] : $S, #S.cls
// CHECK: strong_release [[IN2cls]] : $C3
// CHECK: [[IN2innerstruct:%[0-9]+]] = struct_extract [[IN2]] : $S, #S.inner_struct
// CHECK: [[IN2innerstructcls1:%[0-9]+]] = struct_extract [[IN2innerstruct]] : $S2, #S2.cls1
// CHECK: strong_release [[IN2innerstructcls1]] : $C1
// CHECK: [[IN2innerstructcls2:%[0-9]+]] = struct_extract [[IN2innerstruct]] : $S2, #S2.cls2
// CHECK: strong_release [[IN2innerstructcls2]]
// CHECK: store [[IN1]] to [[IN2PTR]]
// CHECK: tuple
// CHECK: return
sil @expand_copy_addr_aggstructnontrivial : $@convention(thin) (@inout S, @inout S) -> () {
bb0(%0 : $*S, %1 : $*S):
  copy_addr %0 to %1 : $*S
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil @expand_copy_addr_aggtuplenontrivial
// CHECK: bb0([[IN1PTR:%[0-9]+]] : $*(S, S2, C1, E), [[IN2PTR:%[0-9]+]] : $*(S, S2, C1, E)):
// CHECK: [[IN1:%[0-9]+]] = load [[IN1PTR]] : $*(S, S2, C1, E)
// CHECK: [[IN2:%[0-9]+]] = load [[IN2PTR]] : $*(S, S2, C1, E)
// CHECK: [[IN1ELT0:%[0-9]+]] = tuple_extract [[IN1]] : $(S, S2, C1, E), 0
// CHECK: [[IN1ELT0trivial:%[0-9]+]] = struct_extract [[IN1ELT0]] : $S, #S.trivial
// CHECK: [[IN1ELT0cls:%[0-9]+]] = struct_extract [[IN1ELT0]] : $S, #S.cls
// CHECK: strong_retain [[IN1ELT0cls]] : $C3
// CHECK: [[IN1ELT0innerstruct:%[0-9]+]] = struct_extract [[IN1ELT0]] : $S, #S.inner_struct
// CHECK: [[IN1ELT0innerstructcls1:%[0-9]+]] = struct_extract [[IN1ELT0innerstruct]] : $S2, #S2.cls1
// CHECK: strong_retain [[IN1ELT0innerstructcls1]] : $C1
// CHECK: [[IN1ELT0innerstructcls2:%[0-9]+]] = struct_extract [[IN1ELT0innerstruct]] : $S2, #S2.cls2
// CHECK: strong_retain [[IN1ELT0innerstructcls2]]
// CHECK: [[IN1ELT0innerstructtrivial:%[0-9]+]] = struct_extract [[IN1ELT0innerstruct]] : $S2, #S2.trivial
// CHECK: [[IN1ELT1:%[0-9]+]] = tuple_extract [[IN1]] : $(S, S2, C1, E), 1
// CHECK: [[IN1ELT1cls1:%[0-9]+]] = struct_extract [[IN1ELT1]] : $S2, #S2.cls1
// CHECK: strong_retain [[IN1ELT1cls1]] : $C1
// CHECK: [[IN1ELT1cls2:%[0-9]+]] = struct_extract [[IN1ELT1]] : $S2, #S2.cls2
// CHECK: strong_retain [[IN1ELT1cls2]] : $C2
// CHECK: [[IN1ELT1trivial:%[0-9]+]] = struct_extract [[IN1ELT1]] : $S2, #S2.trivial
// CHECK: [[IN1ELT2:%[0-9]+]] = tuple_extract [[IN1]] : $(S, S2, C1, E), 2
// CHECK: strong_retain [[IN1ELT2]]
// CHECK: [[IN1ELT3:%[0-9]+]] = tuple_extract [[IN1]] : $(S, S2, C1, E), 3
// CHECK: retain_value [[IN1ELT3]] : $E
// CHECK: [[IN2ELT0:%[0-9]+]] = tuple_extract [[IN2]] : $(S, S2, C1, E), 0
// CHECK: [[IN2ELT0cls:%[0-9]+]] = struct_extract [[IN2ELT0]] : $S, #S.cls
// CHECK: strong_release [[IN2ELT0cls]] : $C3
// CHECK: [[IN2ELT0innerstruct:%[0-9]+]] = struct_extract [[IN2ELT0]] : $S, #S.inner_struct
// CHECK: [[IN2ELT0innerstructcls1:%[0-9]+]] = struct_extract [[IN2ELT0innerstruct]] : $S2, #S2.cls1
// CHECK: strong_release [[IN2ELT0innerstructcls1]] : $C1
// CHECK: [[IN2ELT0innerstructcls2:%[0-9]+]] = struct_extract [[IN2ELT0innerstruct]] : $S2, #S2.cls2
// CHECK: strong_release [[IN2ELT0innerstructcls2]]
// CHECK: [[IN2ELT1:%[0-9]+]] = tuple_extract [[IN2]] : $(S, S2, C1, E), 1
// CHECK: [[IN2ELT1cls1:%[0-9]+]] = struct_extract [[IN2ELT1]] : $S2, #S2.cls1
// CHECK: strong_release [[IN2ELT1cls1]] : $C1
// CHECK: [[IN2ELT1cls2:%[0-9]+]] = struct_extract [[IN2ELT1]] : $S2, #S2.cls2
// CHECK: strong_release [[IN2ELT1cls2]] : $C2
// CHECK: [[IN2ELT2:%[0-9]+]] = tuple_extract [[IN2]] : $(S, S2, C1, E), 2
// CHECK: strong_release [[IN2ELT2]]
// CHECK: [[IN2ELT3:%[0-9]+]] = tuple_extract [[IN2]] : $(S, S2, C1, E), 3
// CHECK: release_value [[IN2ELT3]] : $E
// CHECK: store [[IN1]] to [[IN2PTR]] : $*(S, S2, C1, E)
// CHECK: tuple ()
// CHECK: return


sil @expand_copy_addr_aggtuplenontrivial : $@convention(thin) (@inout (S, S2, C1, E), @inout (S, S2, C1, E)) -> () {
bb0(%0 : $*(S, S2, C1, E), %1 : $*(S, S2, C1, E)):
  copy_addr %0 to %1 : $*(S, S2, C1, E)
  %2 = tuple()
  return %2 : $()
}

// Do not do anything.
/*
sil @expand_copy_addr_addressonly : $@convention(thin) <T> (@inout T) -> () {
bb0(%0 : $*T):
  copy_addr %0 : $*T
  %1 = tuple()
  return %1 : $()
}
*/

// Just turn into a load + strong_release.
// CHECK-LABEL: sil @expand_copy_addr_reference
// CHECK: bb0([[IN1:%[0-9]+]] : $*C1, [[IN2:%[0-9]+]] : $*C1):
// CHECK: [[LOAD1:%[0-9]+]] = load [[IN1]] : $*C1
// CHECK: [[LOAD2:%[0-9]+]] = load [[IN2]] : $*C1
// CHECK: strong_retain [[LOAD1]]
// CHECK: strong_release [[LOAD2]]
// CHECK: store [[LOAD1]] to [[IN2]]
// CHECK: tuple
// CHECK: return
sil @expand_copy_addr_reference : $@convention(thin) (@inout C1, @inout C1) -> () {
bb0(%0 : $*C1, %1 : $*C1):
  copy_addr %0 to %1 : $*C1
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil @expand_copy_addr_enum
// CHECK: bb0([[IN1:%[0-9]+]] : $*E, [[IN2:%[0-9]+]] : $*E):
// CHECK: [[LOAD1:%[0-9]+]] = load [[IN1]] : $*E
// CHECK: [[LOAD2:%[0-9]+]] = load [[IN2]] : $*E
// CHECK: retain_value [[LOAD1]]
// CHECK: release_value [[LOAD2]]
// CHECK: store [[LOAD1]] to [[IN2]]
// CHECK: tuple
// CHECK: return
sil @expand_copy_addr_enum : $@convention(thin) (@inout E, @inout E) -> () {
bb0(%0 : $*E, %1 : $*E):
  copy_addr %0 to %1 : $*E
  %2 = tuple()
  return %2 : $()
}

///////////////////
// Destroy Value //
///////////////////

// Test expansions for various types (these will become more
// interesting when I introduce the actual chopping work).

// CHECK-LABEL: sil @expand_release_value_trivial
// CHECK: bb0
// CHECK: tuple
// CHECK: return
sil @expand_release_value_trivial : $@convention(thin) (Builtin.Int64) -> () {
bb0(%0 : $Builtin.Int64):
  release_value %0 : $Builtin.Int64
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @expand_release_value_aggstructnontrivial
// CHECK: bb0([[IN:%[0-9]+]] : $S):
// CHECK: [[cls:%[0-9]+]] = struct_extract [[IN]] : $S, #S.cls
// CHECK: strong_release [[cls]] : $C3
// CHECK: [[innerstruct:%[0-9]+]] = struct_extract [[IN]] : $S, #S.inner_struct
// CHECK: [[innerstructcls1:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls1
// CHECK: strong_release [[innerstructcls1]] : $C1
// CHECK: [[innerstructcls2:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls2
// CHECK: strong_release [[innerstructcls2]]
sil @expand_release_value_aggstructnontrivial : $@convention(thin) (S) -> () {
bb0(%0 : $S):
  release_value %0 : $S
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @expand_release_value_aggtuplenontrivial
// CHECK: bb0([[IN:%[0-9]+]] : $(S, S2, C1, E)):
// CHECK: [[ELT0:%[0-9]+]] = tuple_extract [[IN]] : $(S, S2, C1, E), 0
// CHECK: [[ELT0cls:%[0-9]+]] = struct_extract [[ELT0]] : $S, #S.cls
// CHECK: strong_release [[ELT0cls]] : $C3
// CHECK: [[ELT0innerstruct:%[0-9]+]] = struct_extract [[ELT0]] : $S, #S.inner_struct
// CHECK: [[ELT0innerstructcls1:%[0-9]+]] = struct_extract [[ELT0innerstruct]] : $S2, #S2.cls1
// CHECK: strong_release [[ELT0innerstructcls1]] : $C1
// CHECK: [[ELT0innerstructcls2:%[0-9]+]] = struct_extract [[ELT0innerstruct]] : $S2, #S2.cls2
// CHECK: strong_release [[ELT0innerstructcls2]]
// CHECK: [[ELT1:%[0-9]+]] = tuple_extract [[IN]] : $(S, S2, C1, E), 1
// CHECK: [[ELT1cls1:%[0-9]+]] = struct_extract [[ELT1]] : $S2, #S2.cls1
// CHECK: strong_release [[ELT1cls1]] : $C1
// CHECK: [[ELT1cls2:%[0-9]+]] = struct_extract [[ELT1]] : $S2, #S2.cls2
// CHECK: strong_release [[ELT1cls2]] : $C2
// CHECK: [[ELT2:%[0-9]+]] = tuple_extract [[IN]] : $(S, S2, C1, E), 2
// CHECK: strong_release [[ELT2]]
// CHECK: [[ELT3:%[0-9]+]] = tuple_extract [[IN]] : $(S, S2, C1, E), 3
// CHECK: release_value [[ELT3]] : $E
// CHECK: tuple ()
// CHECK: return
sil @expand_release_value_aggtuplenontrivial : $@convention(thin) ((S, S2, C1, E)) -> () {
bb0(%0 : $(S, S2, C1, E)):
  release_value %0 : $(S, S2, C1, E)
  %1 = tuple()
  return %1 : $()
}

// Just turn into a load + strong_release.
// CHECK-LABEL: sil @expand_release_value_reference
// CHECK: bb0([[IN:%[0-9]+]] : $C1):
// CHECK: strong_release [[IN]]
// CHECK: tuple
// CHECK: return
sil @expand_release_value_reference : $@convention(thin) (C1) -> () {
bb0(%0 : $C1):
  release_value %0 : $C1
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil @expand_release_value_enum
// CHECK: bb0([[IN1:%[0-9]+]] : $E):
// CHECK: release_value
// CHECK: tuple ()
// CHECK: return
sil @expand_release_value_enum : $@convention(thin) (E) -> () {
bb0(%0 : $E):
  release_value %0 : $E
  %1 = tuple()
  return %1 : $()
}


////////////////
// Copy Value //
////////////////

// Test expansions for various types (these will become more
// interesting when I introduce the actual chopping work).

// CHECK-LABEL: sil @expand_retain_value_trivial
// CHECK: bb0
// CHECK: return
sil @expand_retain_value_trivial : $@convention(thin) (Builtin.Int64) -> (Builtin.Int64) {
bb0(%0 : $Builtin.Int64):
  retain_value %0 : $Builtin.Int64
  return %0 : $Builtin.Int64
}

// CHECK-LABEL: sil @expand_retain_value_aggstructnontrivial
// CHECK: bb0([[IN:%[0-9]+]] : $S3):
// CHECK: [[trivial:%[0-9]+]] = struct_extract [[IN]] : $S3, #S3.trivial1
// CHECK: [[cls:%[0-9]+]] = struct_extract [[IN]] : $S3, #S3.cls
// CHECK: [[clstrivial:%[0-9]+]] = struct_extract [[cls]] : $S, #S.trivial
// CHECK: [[clscls:%[0-9]+]] = struct_extract [[cls]] : $S, #S.cls
// CHECK: strong_retain [[clscls]] : $C3
// CHECK: [[innerstruct:%[0-9]+]] = struct_extract [[cls]] : $S, #S.inner_struct
// CHECK: [[innerstructcls1:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls1
// CHECK: strong_retain [[innerstructcls1]] : $C1
// CHECK: [[innerstructcls2:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.cls2
// CHECK: strong_retain [[innerstructcls2]] : $C2
// CHECK: [[innerstructtrivial:%[0-9]+]] = struct_extract [[innerstruct]] : $S2, #S2.trivial
// CHECK: [[trivial2:%[0-9]+]] = struct_extract [[IN]] : $S3, #S3.trivial2
// CHECK: [[enum:%[0-9]+]] = struct_extract [[IN]] : $S3, #S3.e
// CHECK: retain_value [[enum]] : $E
// CHECK: [[trivial3:%[0-9]+]] = struct_extract [[IN]] : $S3, #S3.trivial3
// CHECK: return [[IN]] : $S3
sil @expand_retain_value_aggstructnontrivial : $@convention(thin) (S3) -> (S3) {
bb0(%0 : $S3):
  retain_value %0 : $S3
  return %0 : $S3
}

// CHECK-LABEL: sil @expand_retain_value_aggtuplenontrivial
// CHECK: bb0([[IN:%[0-9]+]] : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E)):
// CHECK: [[ELT0:%[0-9]+]] = tuple_extract [[IN]] : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E), 0
// CHECK: [[ELT0trivial:%[0-9]+]] = struct_extract [[ELT0]] : $S, #S.trivial
// CHECK: [[ELT0cls:%[0-9]+]] = struct_extract [[ELT0]] : $S, #S.cls
// CHECK: strong_retain [[ELT0cls]] : $C3
// CHECK: [[ELT0innerstruct:%[0-9]+]] = struct_extract [[ELT0]] : $S, #S.inner_struct
// CHECK: [[ELT0innerstructcls1:%[0-9]+]] = struct_extract [[ELT0innerstruct]] : $S2, #S2.cls1
// CHECK: strong_retain [[ELT0innerstructcls1]] : $C1
// CHECK: [[ELT0innerstructcls2:%[0-9]+]] = struct_extract [[ELT0innerstruct]] : $S2, #S2.cls2
// CHECK: strong_retain [[ELT0innerstructcls2]]
// CHECK: [[ELT0innerstructtrivial:%[0-9]+]] = struct_extract [[ELT0innerstruct]] : $S2, #S2.trivial
// CHECK: [[ELT1:%[0-9]+]] = tuple_extract [[IN]] : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E), 1
// CHECK: [[ELT2:%[0-9]+]] = tuple_extract [[IN]] : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E), 2
// CHECK: [[ELT2cls1:%[0-9]+]] = struct_extract [[ELT2]] : $S2, #S2.cls1
// CHECK: strong_retain [[ELT2cls1]] : $C1
// CHECK: [[ELT2cls2:%[0-9]+]] = struct_extract [[ELT2]] : $S2, #S2.cls2
// CHECK: strong_retain [[ELT2cls2]] : $C2
// CHECK: [[ELT2trivial:%[0-9]+]] = struct_extract [[ELT2]] : $S2, #S2.trivial
// CHECK: [[ELT3:%[0-9]+]] = tuple_extract [[IN]] : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E), 3
// CHECK: strong_retain [[ELT3]]
// CHECK: [[ELT4:%[0-9]+]] = tuple_extract [[IN]] : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E), 4
// CHECK: [[ELT5:%[0-9]+]] = tuple_extract [[IN]] : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E), 5
// CHECK: retain_value [[ELT5]] : $E
// CHECK: return [[IN]]

sil @expand_retain_value_aggtuplenontrivial : $@convention(thin) ((S, Builtin.Int64, S2, C1, Builtin.Int64, E)) -> ((S, Builtin.Int64, S2, C1, Builtin.Int64, E)) {
bb0(%0 : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E)):
  retain_value %0 : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E)
  return %0 : $(S, Builtin.Int64, S2, C1, Builtin.Int64, E)
}

// CHECK-LABEL: sil @expand_retain_value_reference
// CHECK: bb0([[IN:%[0-9]+]] : $C1):
// CHECK: strong_retain [[IN]]
// CHECK: return
sil @expand_retain_value_reference : $@convention(thin) (C1) -> (C1) {
bb0(%0 : $C1):
  retain_value %0 : $C1
  return %0 : $C1
}

// CHECK-LABEL: sil @expand_retain_value_enum
// CHECK: bb0([[IN1:%[0-9]+]] : $E):
// CHECK: retain_value
// CHECK: return
sil @expand_retain_value_enum : $@convention(thin) (E) -> (E) {
bb0(%0 : $E):
  retain_value %0 : $E
  return %0 : $E
}