// RUN: %target-sil-opt -sil-print-types -enable-sil-verify-all %s -inline -enable-lexical-lifetimes | %FileCheck %s

import Swift

class C {}

@_eagerMove
class EagerC {}

struct InferredEagerD1S1 {
  var c1: EagerC
  var c2: EagerC
}

struct InferredEagerD1S2 {
  @_eagerMove var c1: C
  var c2: EagerC
}

struct InferredEagerD1S3 {
  @_eagerMove var c1: C
  @_eagerMove let c2: C
}

struct InferredEagerD1S4 {
  @_eagerMove var c1: (one: C, two: C)
  @_eagerMove let c2: C
}

struct InferredEagerD2S1 {
  var i1: InferredEagerD1S1
  var i2: InferredEagerD1S2
  var i3: InferredEagerD1S3
  var i4: InferredEagerD1S4
}

@_noEagerMove
struct LexicalS {
  var i: InferredEagerD2S1
}

struct InferredLexicalD1S1 {
  var c1: C
  var c2: C
  var c3: C
  var c4: C
}

struct InferredLexicalD1S2 {
  @_noEagerMove var i: InferredEagerD2S1
}

struct InferredLexicalD1S3 {
  @_noEagerMove var i: InferredEagerD2S1
  var j: InferredEagerD2S1
}

struct InferredLexicalD1S4 {
  var i: C
  var j: InferredEagerD2S1
}

struct S {}

////////////////////////////////////////////////////////////////////////////////
// apply
////////////////////////////////////////////////////////////////////////////////

// declarations

sil [ossa] [always_inline] @callee_owned : $@convention(thin) (@owned C) -> () {
entry(%instance : @owned $C):
    destroy_value %instance : $C
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_eager_move : $@convention(thin) (@owned C) -> () {
entry(%instance : @_eagerMove @owned $C):
    destroy_value %instance : $C
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_eager_move__type_annotation : $@convention(thin) (@owned EagerC) -> () {
entry(%instance : @owned $EagerC):
    destroy_value %instance : $EagerC
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_eager_move__type_inferred_d1_s1 : $@convention(thin) (@owned InferredEagerD1S1) -> () {
entry(%instance : @owned $InferredEagerD1S1):
    destroy_value %instance : $InferredEagerD1S1
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_eager_move__type_inferred_d1_s2 : $@convention(thin) (@owned InferredEagerD1S2) -> () {
entry(%instance : @owned $InferredEagerD1S2):
    destroy_value %instance : $InferredEagerD1S2
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_eager_move__type_inferred_d1_s3 : $@convention(thin) (@owned InferredEagerD1S3) -> () {
entry(%instance : @owned $InferredEagerD1S3):
    destroy_value %instance : $InferredEagerD1S3
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_eager_move__type_inferred_d1_s4 : $@convention(thin) (@owned InferredEagerD1S4) -> () {
entry(%instance : @owned $InferredEagerD1S4):
    destroy_value %instance : $InferredEagerD1S4
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_eager_move__type_inferred_d2_s1 : $@convention(thin) (@owned InferredEagerD2S1) -> () {
entry(%instance : @owned $InferredEagerD2S1):
    destroy_value %instance : $InferredEagerD2S1
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_owned_lexical : $@convention(thin) (@owned InferredEagerD2S1) -> () {
entry(%instance : @_lexical @owned $InferredEagerD2S1):
    destroy_value %instance : $InferredEagerD2S1
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed : $@convention(thin) (@guaranteed C) -> () {
entry(%instance : @guaranteed $C):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_eager_move : $@convention(thin) (@guaranteed C) -> () {
entry(%instance : @_eagerMove @guaranteed $C):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_eager_move__type_annotation : $@convention(thin) (@guaranteed EagerC) -> () {
entry(%instance : @guaranteed $EagerC):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_eager_move__type_inferred_d1_s1 : $@convention(thin) (@guaranteed InferredEagerD1S1) -> () {
entry(%instance : @guaranteed $InferredEagerD1S1):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_eager_move__type_inferred_d1_s2 : $@convention(thin) (@guaranteed InferredEagerD1S2) -> () {
entry(%instance : @guaranteed $InferredEagerD1S2):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_eager_move__type_inferred_d1_s3 : $@convention(thin) (@guaranteed InferredEagerD1S3) -> () {
entry(%instance : @guaranteed $InferredEagerD1S3):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_eager_move__type_inferred_d1_s4 : $@convention(thin) (@guaranteed InferredEagerD1S4) -> () {
entry(%instance : @guaranteed $InferredEagerD1S4):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_eager_move__type_inferred_d2_s1 : $@convention(thin) (@guaranteed InferredEagerD2S1) -> () {
entry(%instance : @guaranteed $InferredEagerD2S1):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_lexical : $@convention(thin) (@guaranteed InferredEagerD2S1) -> () {
entry(%instance : @_lexical @guaranteed $InferredEagerD2S1):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_lexical__type_annotation : $@convention(thin) (@guaranteed LexicalS) -> () {
entry(%instance : @guaranteed $LexicalS):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_lexical__type_inferred_d1_s1 : $@convention(thin) (@guaranteed InferredLexicalD1S1) -> () {
entry(%instance : @guaranteed $InferredLexicalD1S1):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_lexical__type_inferred_d1_s2 : $@convention(thin) (@guaranteed InferredLexicalD1S2) -> () {
entry(%instance : @guaranteed $InferredLexicalD1S2):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_lexical__type_inferred_d1_s3 : $@convention(thin) (@guaranteed InferredLexicalD1S3) -> () {
entry(%instance : @guaranteed $InferredLexicalD1S3):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_guaranteed_lexical__type_inferred_d1_s4 : $@convention(thin) (@guaranteed InferredLexicalD1S4) -> () {
entry(%instance : @guaranteed $InferredLexicalD1S4):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_trivial : $@convention(thin) (S) -> () {
entry(%instance : $S):
    %retval = tuple ()
    return %retval : $()
}

sil [ossa] [always_inline] @callee_in : $@convention(thin) (@in S) -> () {
entry(%instance : $*S):
    %retval = tuple ()
    return %retval : $()
}

sil [always_inline] [ossa] @callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
entry(%arg : $*T):
  %retval = tuple ()
  return %retval : $()
}

// tests

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned : $@convention(thin) (@owned C) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned'
sil [ossa] @caller_owned_callee_owned : $@convention(thin) (@owned C) -> () {
entry(%instance : @owned $C):
    %callee_owned = function_ref @callee_owned : $@convention(thin) (@owned C) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned C) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_eager_move : $@convention(thin) (@owned C) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_eager_move'
sil [ossa] @caller_owned_callee_owned_eager_move : $@convention(thin) (@owned C) -> () {
entry(%instance : @owned $C):
    %callee_owned = function_ref @callee_owned_eager_move : $@convention(thin) (@owned C) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned C) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_eager_move__type_annotation : {{.*}} {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_eager_move__type_annotation'
sil [ossa] @caller_owned_callee_owned_eager_move__type_annotation : $@convention(thin) (@owned EagerC) -> () {
entry(%instance : @owned $EagerC):
    %callee_owned = function_ref @callee_owned_eager_move__type_annotation : $@convention(thin) (@owned EagerC) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned EagerC) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s1 : {{.*}} {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_eager_move__type_inferred_d1_s1'
sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s1 : $@convention(thin) (@owned InferredEagerD1S1) -> () {
entry(%instance : @owned $InferredEagerD1S1):
    %callee_owned = function_ref @callee_owned_eager_move__type_inferred_d1_s1 : $@convention(thin) (@owned InferredEagerD1S1) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned InferredEagerD1S1) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s2 : {{.*}} {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_eager_move__type_inferred_d1_s2'
sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s2 : $@convention(thin) (@owned InferredEagerD1S2) -> () {
entry(%instance : @owned $InferredEagerD1S2):
    %callee_owned = function_ref @callee_owned_eager_move__type_inferred_d1_s2 : $@convention(thin) (@owned InferredEagerD1S2) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned InferredEagerD1S2) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s3 : {{.*}} {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_eager_move__type_inferred_d1_s3'
sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s3 : $@convention(thin) (@owned InferredEagerD1S3) -> () {
entry(%instance : @owned $InferredEagerD1S3):
    %callee_owned = function_ref @callee_owned_eager_move__type_inferred_d1_s3 : $@convention(thin) (@owned InferredEagerD1S3) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned InferredEagerD1S3) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s4 : {{.*}} {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_eager_move__type_inferred_d1_s4'
sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d1_s4 : $@convention(thin) (@owned InferredEagerD1S4) -> () {
entry(%instance : @owned $InferredEagerD1S4):
    %callee_owned = function_ref @callee_owned_eager_move__type_inferred_d1_s4 : $@convention(thin) (@owned InferredEagerD1S4) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned InferredEagerD1S4) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d2_s1 : {{.*}} {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_eager_move__type_inferred_d2_s1'
sil [ossa] @caller_owned_callee_owned_eager_move__type_inferred_d2_s1 : $@convention(thin) (@owned InferredEagerD2S1) -> () {
entry(%instance : @owned $InferredEagerD2S1):
    %callee_owned = function_ref @callee_owned_eager_move__type_inferred_d2_s1 : $@convention(thin) (@owned InferredEagerD2S1) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned InferredEagerD2S1) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_owned_lexical : {{.*}} {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_owned_lexical'
sil [ossa] @caller_owned_callee_owned_lexical : $@convention(thin) (@owned InferredEagerD2S1) -> () {
entry(%instance : @owned $InferredEagerD2S1):
    %callee_owned = function_ref @callee_owned_lexical : $@convention(thin) (@owned InferredEagerD2S1) -> ()
    %result = apply %callee_owned(%instance) : $@convention(thin) (@owned InferredEagerD2S1) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed : $@convention(thin) (@owned C) -> () {
// CHECK:       {{bb[^,]+}}([[INSTANCE:%[^,]+]] : @owned $C):
// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [[INSTANCE]]
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         end_borrow [[LIFETIME]]
// CHECK:         destroy_value [[INSTANCE]]
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed'
sil [ossa] @caller_owned_callee_guaranteed : $@convention(thin) (@owned C) -> () {
entry(%instance : @owned $C):
    %callee_guaranteed = function_ref @callee_guaranteed : $@convention(thin) (@guaranteed C) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed C) -> ()
    destroy_value %instance : $C
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_eager_move : $@convention(thin) (@owned C) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_eager_move'
sil [ossa] @caller_owned_callee_guaranteed_eager_move : $@convention(thin) (@owned C) -> () {
entry(%instance : @owned $C):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move : $@convention(thin) (@guaranteed C) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed C) -> ()
    destroy_value %instance : $C
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_annotation : $@convention(thin) (@owned EagerC) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_eager_move__type_annotation'
sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_annotation : $@convention(thin) (@owned EagerC) -> () {
entry(%instance : @owned $EagerC):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move__type_annotation : $@convention(thin) (@guaranteed EagerC) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed EagerC) -> ()
    destroy_value %instance : $EagerC
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s1 : $@convention(thin) (@owned InferredEagerD1S1) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s1'
sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s1 : $@convention(thin) (@owned InferredEagerD1S1) -> () {
entry(%instance : @owned $InferredEagerD1S1):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move__type_inferred_d1_s1 : $@convention(thin) (@guaranteed InferredEagerD1S1) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredEagerD1S1) -> ()
    destroy_value %instance : $InferredEagerD1S1
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s2 : $@convention(thin) (@owned InferredEagerD1S2) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s2'
sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s2 : $@convention(thin) (@owned InferredEagerD1S2) -> () {
entry(%instance : @owned $InferredEagerD1S2):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move__type_inferred_d1_s2 : $@convention(thin) (@guaranteed InferredEagerD1S2) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredEagerD1S2) -> ()
    destroy_value %instance : $InferredEagerD1S2
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s3 : $@convention(thin) (@owned InferredEagerD1S3) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s3'
sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s3 : $@convention(thin) (@owned InferredEagerD1S3) -> () {
entry(%instance : @owned $InferredEagerD1S3):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move__type_inferred_d1_s3 : $@convention(thin) (@guaranteed InferredEagerD1S3) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredEagerD1S3) -> ()
    destroy_value %instance : $InferredEagerD1S3
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s4 : $@convention(thin) (@owned InferredEagerD1S4) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s4'
sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d1_s4 : $@convention(thin) (@owned InferredEagerD1S4) -> () {
entry(%instance : @owned $InferredEagerD1S4):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move__type_inferred_d1_s4 : $@convention(thin) (@guaranteed InferredEagerD1S4) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredEagerD1S4) -> ()
    destroy_value %instance : $InferredEagerD1S4
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d2_s1 : $@convention(thin) (@owned InferredEagerD2S1) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_eager_move__type_inferred_d2_s1'
sil [ossa] @caller_owned_callee_guaranteed_eager_move__type_inferred_d2_s1 : $@convention(thin) (@owned InferredEagerD2S1) -> () {
entry(%instance : @owned $InferredEagerD2S1):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move__type_inferred_d2_s1 : $@convention(thin) (@guaranteed InferredEagerD2S1) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredEagerD2S1) -> ()
    destroy_value %instance : $InferredEagerD2S1
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_lexical : {{.*}} {
// CHECK:         begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_lexical'
sil [ossa] @caller_owned_callee_guaranteed_lexical : $@convention(thin) (@owned InferredEagerD2S1) -> () {
entry(%instance : @owned $InferredEagerD2S1):
    %callee_guaranteed = function_ref @callee_guaranteed_lexical : $@convention(thin) (@guaranteed InferredEagerD2S1) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredEagerD2S1) -> ()
    destroy_value %instance : $InferredEagerD2S1
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_lexical__type_annotation : {{.*}} {
// CHECK:         begin_borrow
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_lexical__type_annotation'
sil [ossa] @caller_owned_callee_guaranteed_lexical__type_annotation : $@convention(thin) (@owned LexicalS) -> () {
entry(%instance : @owned $LexicalS):
    %callee_guaranteed = function_ref @callee_guaranteed_lexical__type_annotation : $@convention(thin) (@guaranteed LexicalS) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed LexicalS) -> ()
    destroy_value %instance : $LexicalS
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s1 : {{.*}} {
// CHECK:         begin_borrow
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_lexical__type_inferred_d1_s1'
sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s1 : $@convention(thin) (@owned InferredLexicalD1S1) -> () {
entry(%instance : @owned $InferredLexicalD1S1):
    %callee_guaranteed = function_ref @callee_guaranteed_lexical__type_inferred_d1_s1 : $@convention(thin) (@guaranteed InferredLexicalD1S1) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredLexicalD1S1) -> ()
    destroy_value %instance : $InferredLexicalD1S1
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s2 : {{.*}} {
// CHECK:         begin_borrow
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_lexical__type_inferred_d1_s2'
sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s2 : $@convention(thin) (@owned InferredLexicalD1S2) -> () {
entry(%instance : @owned $InferredLexicalD1S2):
    %callee_guaranteed = function_ref @callee_guaranteed_lexical__type_inferred_d1_s2 : $@convention(thin) (@guaranteed InferredLexicalD1S2) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredLexicalD1S2) -> ()
    destroy_value %instance : $InferredLexicalD1S2
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s3 : {{.*}} {
// CHECK:         begin_borrow
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_lexical__type_inferred_d1_s3'
sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s3 : $@convention(thin) (@owned InferredLexicalD1S3) -> () {
entry(%instance : @owned $InferredLexicalD1S3):
    %callee_guaranteed = function_ref @callee_guaranteed_lexical__type_inferred_d1_s3 : $@convention(thin) (@guaranteed InferredLexicalD1S3) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredLexicalD1S3) -> ()
    destroy_value %instance : $InferredLexicalD1S3
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s4 : {{.*}} {
// CHECK:         begin_borrow
// CHECK-LABEL: } // end sil function 'caller_owned_callee_guaranteed_lexical__type_inferred_d1_s4'
sil [ossa] @caller_owned_callee_guaranteed_lexical__type_inferred_d1_s4 : $@convention(thin) (@owned InferredLexicalD1S4) -> () {
entry(%instance : @owned $InferredLexicalD1S4):
    %callee_guaranteed = function_ref @callee_guaranteed_lexical__type_inferred_d1_s4 : $@convention(thin) (@guaranteed InferredLexicalD1S4) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed InferredLexicalD1S4) -> ()
    destroy_value %instance : $InferredLexicalD1S4
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_guaranteed : $@convention(thin) (@guaranteed C) -> () {
// CHECK:       {{bb[^,]+}}([[INSTANCE:%[^,]+]] : @guaranteed $C):
// CHECK-NOT:     begin_borrow [[INSTANCE]]
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK-NOT:     end_borrow
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_guaranteed'
sil [ossa] @caller_guaranteed_callee_guaranteed : $@convention(thin) (@guaranteed C) -> () {
entry(%instance : @guaranteed $C):
    %callee_guaranteed = function_ref @callee_guaranteed : $@convention(thin) (@guaranteed C) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed C) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_guaranteed_eager_move : $@convention(thin) (@guaranteed C) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_guaranteed_eager_move'
sil [ossa] @caller_guaranteed_callee_guaranteed_eager_move : $@convention(thin) (@guaranteed C) -> () {
entry(%instance : @guaranteed $C):
    %callee_guaranteed = function_ref @callee_guaranteed_eager_move : $@convention(thin) (@guaranteed C) -> ()
    %result = apply %callee_guaranteed(%instance) : $@convention(thin) (@guaranteed C) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_owned : $@convention(thin) (@guaranteed C) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_owned'
sil [ossa] @caller_guaranteed_callee_owned : $@convention(thin) (@guaranteed C) -> () {
entry(%instance : @guaranteed $C):
    %copy = copy_value %instance : $C
    %callee_owned = function_ref @callee_owned : $@convention(thin) (@owned C) -> ()
    %result = apply %callee_owned(%copy) : $@convention(thin) (@owned C) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_owned_eager_move : $@convention(thin) (@guaranteed C) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_owned_eager_move'
sil [ossa] @caller_guaranteed_callee_owned_eager_move : $@convention(thin) (@guaranteed C) -> () {
entry(%instance : @guaranteed $C):
    %copy = copy_value %instance : $C
    %callee_owned = function_ref @callee_owned_eager_move : $@convention(thin) (@owned C) -> ()
    %result = apply %callee_owned(%copy) : $@convention(thin) (@owned C) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_trivial_callee_trivial : $@convention(thin) (S) -> () {
// CHECK:       {{bb[^,]+}}({{%[^,]+}} : $S):
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_trivial_callee_trivial'
sil [ossa] @caller_trivial_callee_trivial : $@convention(thin) (S) -> () {
entry(%instance : $S):
  %callee_trivial = function_ref @callee_trivial : $@convention(thin) (S) -> ()
  %result = apply %callee_trivial(%instance) : $@convention(thin) (S) -> ()
  return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_in_callee_in : $@convention(thin) (@in S) -> () {
// CHECK:       {{bb[^,]+}}({{%[^,]+}} : $*S):
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_in_callee_in'
sil [ossa] @caller_in_callee_in : $@convention(thin) (@in S) -> () {
entry(%instance : $*S):
    %callee_in = function_ref @callee_in : $@convention(thin) (@in S) -> ()
    %result = apply %callee_in(%instance) : $@convention(thin) (@in S) -> ()
    return %result : $()
}

// CHECK-LABEL: sil [ossa] @caller_inguaranteed_callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_inguaranteed_callee_inguaranteed'
sil [ossa] @caller_inguaranteed_callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
bb0(%instance : $*T):
  %callee_inguaranteed = function_ref @callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> ()
  %retval = apply %callee_inguaranteed<T>(%instance) : $@convention(thin) <T> (@in_guaranteed T) -> ()
  return %retval : $()
}

// CHECK-LABEL: sil [ossa] @caller_allocstack_callee_inguaranteed : $@convention(thin) <T> () -> () {
// CHECK:         alloc_stack [lexical]
// CHECK-LABEL: } // end sil function 'caller_allocstack_callee_inguaranteed'
sil [ossa] @caller_allocstack_callee_inguaranteed : $@convention(thin) <T> () -> () {
bb0:
  %addr = alloc_stack $T
  apply undef<T>(%addr) : $@convention(thin) <τ_0_0> () -> @out τ_0_0
  %callee_inguaranteed = function_ref @callee_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> ()
  %retval = apply %callee_inguaranteed<T>(%addr) : $@convention(thin) <T> (@in_guaranteed T) -> ()
  destroy_addr %addr : $*T
  dealloc_stack %addr : $*T
  return %retval : $()
}

////////////////////////////////////////////////////////////////////////////////
// begin_apply
////////////////////////////////////////////////////////////////////////////////

// declarations

sil [ossa] [always_inline] @callee_coro_owned : $@yield_once @convention(thin) (@owned C) -> @yields @inout C {
bb0(%instance : @owned $C):
  %addr = alloc_stack $C
  store %instance to [init] %addr : $*C
  yield %addr : $*C, resume bb1, unwind bb2
bb1:
  destroy_addr %addr : $*C
  dealloc_stack %addr : $*C
  %result = tuple ()
  return %result : $()
bb2:
  destroy_addr %addr : $*C
  dealloc_stack %addr : $*C
  unwind
}

sil [ossa] [always_inline] @callee_coro_guaranteed : $@yield_once @convention(thin) (@guaranteed C) -> @yields @inout C {
bb0(%instance : @guaranteed $C):
  %copy = copy_value %instance : $C
  %addr = alloc_stack $C
  store %copy to [init] %addr : $*C
  yield %addr : $*C, resume bb1, unwind bb2
bb1:
  destroy_addr %addr : $*C
  dealloc_stack %addr : $*C
  %result = tuple ()
  return %result : $()
bb2:
  destroy_addr %addr : $*C
  dealloc_stack %addr : $*C
  unwind
}

sil hidden [ossa] [always_inline] @callee_coro_trivial : $@yield_once @convention(thin) (S) -> @yields @inout S {
bb0(%instance : $S):
  %addr = alloc_stack $S
  store %instance to [trivial] %addr : $*S
  yield %addr : $*S, resume bb1, unwind bb2
bb1:
  dealloc_stack %addr : $*S
  %result = tuple ()
  return %result : $()
bb2:
  dealloc_stack %addr : $*S
  unwind
}

sil hidden [ossa] [always_inline] @callee_coro_in : $@yield_once @convention(thin) (@in S) -> @yields @inout S {
bb0(%instance : $*S):
  yield %instance : $*S, resume bb1, unwind bb2
bb1:
  %result = tuple ()
  return %result : $()
bb2:
  unwind
}

sil hidden [ossa] [always_inline] @callee_coro_inguaranteed : $@yield_once @convention(thin) <T> (@in_guaranteed T) -> @yields @inout T {
bb0(%instance : $*T):
  %addr = alloc_stack $T
  copy_addr %instance to [init] %addr : $*T
  yield %addr : $*T, resume bb1, unwind bb2
bb1:
  destroy_addr %addr : $*T
  dealloc_stack %addr : $*T
  %result = tuple ()
  return %result : $()
bb2:
  destroy_addr %addr : $*T
  dealloc_stack %addr : $*T
  unwind
}

// tests

// CHECK-LABEL: sil [ossa] @caller_owned_callee_coro_owned : $@convention(thin) (@owned C) -> () {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_coro_owned'
sil [ossa] @caller_owned_callee_coro_owned : $@convention(thin) (@owned C) -> () {
bb0(%instance : @owned $C):
  %callee_coro_owned = function_ref @callee_coro_owned : $@yield_once @convention(thin) (@owned C) -> @yields @inout C
  (%addr, %continuation) = begin_apply %callee_coro_owned(%instance) : $@yield_once @convention(thin) (@owned C) -> @yields @inout C
  end_apply %continuation as $()
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_coro_guaranteed : $@convention(thin) (@owned C) -> () {
// CHECK:       {{bb[^,]+}}([[INSTANCE:%[^,]+]] : @owned $C):
// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [[INSTANCE]]
// CHECK:         [[LIFETIME_OWNED:%[^,]+]] = copy_value [[LIFETIME]]
// CHECK:         [[ADDR:%[^,]+]] = alloc_stack $C
// CHECK:         store [[LIFETIME_OWNED]] to [init] [[ADDR]]
// CHECK:         destroy_addr [[ADDR]]
// CHECK:         dealloc_stack [[ADDR]]
// CHECK:         [[ORIGINAL_RETVAL:%[^,]+]] = tuple ()
// CHECK:         end_borrow [[LIFETIME]]
// CHECK:         destroy_value [[INSTANCE]]
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_coro_guaranteed'
sil [ossa] @caller_owned_callee_coro_guaranteed : $@convention(thin) (@owned C) -> () {
bb0(%instance : @owned $C):
  %callee_coro_guaranteed = function_ref @callee_coro_guaranteed : $@yield_once @convention(thin) (@guaranteed C) -> @yields @inout C
  (%addr, %continuation) = begin_apply %callee_coro_guaranteed(%instance) : $@yield_once @convention(thin) (@guaranteed C) -> @yields @inout C
  end_apply %continuation as $()
  destroy_value %instance : $C
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_coro_owned : $@convention(thin) (@guaranteed C) -> () {
// CHECK-NOT:         begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_coro_owned'
sil [ossa] @caller_guaranteed_callee_coro_owned : $@convention(thin) (@guaranteed C) -> () {
bb0(%instance : @guaranteed $C):
  %copy = copy_value %instance : $C
  %callee_coro_owned = function_ref @callee_coro_owned : $@yield_once @convention(thin) (@owned C) -> @yields @inout C
  (%addr, %continuation) = begin_apply %callee_coro_owned(%copy) : $@yield_once @convention(thin) (@owned C) -> @yields @inout C
  end_apply %continuation as $()
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_coro_guaranteed : $@convention(thin) (@guaranteed C) -> () {
// CHECK:       {{bb[^,]+}}([[INSTANCE:%[^,]+]] : @guaranteed $C):
// CHECK-NOT:     begin_borrow
// CHECK:         [[LIFETIME_OWNED:%[^,]+]] = copy_value [[INSTANCE]]
// CHECK:         [[ADDR:%[^,]+]] = alloc_stack $C
// CHECK:         store [[LIFETIME_OWNED]] to [init] [[ADDR]]
// CHECK:         destroy_addr [[ADDR]]
// CHECK:         dealloc_stack [[ADDR]]
// CHECK:         [[ORIGINAL_RETVAL:%[^,]+]] = tuple ()
// CHECK-NOT:     end_borrow
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_coro_guaranteed'
sil [ossa] @caller_guaranteed_callee_coro_guaranteed : $@convention(thin) (@guaranteed C) -> () {
bb0(%instance : @guaranteed $C):
  %callee_coro_guaranteed = function_ref @callee_coro_guaranteed : $@yield_once @convention(thin) (@guaranteed C) -> @yields @inout C
  (%addr, %continuation) = begin_apply %callee_coro_guaranteed(%instance) : $@yield_once @convention(thin) (@guaranteed C) -> @yields @inout C
  end_apply %continuation as $()
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil hidden [ossa] @caller_trivial_callee_coro_trivial : $@convention(thin) (S) -> () {
// CHECK:       {{bb[0-9]+}}([[REGISTER_0:%[^,]+]] : $S):
// CHECK:         [[REGISTER_1:%[^,]+]] = alloc_stack $S
// CHECK:         store [[REGISTER_0]] to [trivial] [[REGISTER_1]] : $*S
// CHECK:         dealloc_stack [[REGISTER_1]] : $*S
// CHECK:         [[REGISTER_4:%[^,]+]] = tuple ()
// CHECK:         [[REGISTER_5:%[^,]+]] = tuple ()
// CHECK:         return [[REGISTER_5]] : $()
// CHECK-LABEL: } // end sil function 'caller_trivial_callee_coro_trivial'
sil hidden [ossa] @caller_trivial_callee_coro_trivial : $@convention(thin) (S) -> () {
bb0(%instance : $S):
  %callee_coro_trivial = function_ref @callee_coro_trivial : $@yield_once @convention(thin) (S) -> @yields @inout S
  (%addr, %continuation) = begin_apply %callee_coro_trivial(%instance) : $@yield_once @convention(thin) (S) -> @yields @inout S
  end_apply %continuation as $()
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil hidden [ossa] @caller_in_callee_coro_in : $@convention(thin) (@in S) -> () {
// CHECK:       {{bb[^,]+}}({{%[^,]+}} : $*S):
// CHECK:         {{%[^,]+}} = tuple ()
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_in_callee_coro_in'
sil hidden [ossa] @caller_in_callee_coro_in : $@convention(thin) (@in S) -> () {
bb0(%instance : $*S):
  %callee_coro_in = function_ref @callee_coro_in : $@yield_once @convention(thin) (@in S) -> @yields @inout S
  (%addr, %continuation) = begin_apply %callee_coro_in(%instance) : $@yield_once @convention(thin) (@in S) -> @yields @inout S
  end_apply %continuation as $()
  %retval = tuple ()
  return %retval : $()
}

// CHECK-LABEL: sil hidden [ossa] @caller_inguaranteed_callee_coro_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
// CHECK-NOTE:    begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_inguaranteed_callee_coro_inguaranteed'
sil hidden [ossa] @caller_inguaranteed_callee_coro_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> () {
bb0(%instance : $*T):
  %callee_coro_inguaranteed = function_ref @callee_coro_inguaranteed : $@yield_once @convention(thin) <T> (@in_guaranteed T) -> @yields @inout T
  (%addr_out, %continuation) = begin_apply %callee_coro_inguaranteed<T>(%instance) : $@yield_once @convention(thin) <T> (@in_guaranteed T) -> @yields @inout T
  end_apply %continuation as $()
  %retval = tuple ()
  return %retval : $()
}

////////////////////////////////////////////////////////////////////////////////
// try_apply
////////////////////////////////////////////////////////////////////////////////

// declarations

sil [ossa] [always_inline] @callee_error_owned : $@convention(thin) (@owned C) -> @error Error {
bb0(%instance : @owned $C):
  cond_br undef, bb1, bb2
bb1:
  destroy_value %instance : $C
  throw undef : $Error
bb2:
  destroy_value %instance : $C
  %18 = tuple ()
  return %18 : $()
}

sil [ossa] [always_inline] @callee_error_guaranteed : $@convention(thin) (@guaranteed C) -> @error Error {
bb0(%0 : @guaranteed $C):
  cond_br undef, bb1, bb2
bb1:
  throw undef : $Error
bb2:
  %18 = tuple ()
  return %18 : $()
}

sil [ossa] @callee_error_trivial : $@convention(thin) (S) -> @error Error {
bb0(%0 : $S):
  cond_br undef, bb1, bb2
bb1:
  throw undef : $Error
bb2:
  %18 = tuple ()
  return %18 : $()
}

sil [ossa] @callee_error_in : $@convention(thin) (@in S) -> @error Error {
bb0(%0 : $*S):
  cond_br undef, bb1, bb2
bb1:
  throw undef : $Error
bb2:
  %18 = tuple ()
  return %18 : $()
}

sil [ossa] @callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error Error {
bb0(%0 : $*T):
  cond_br undef, bb1, bb2
bb1:
  throw undef : $Error
bb2:
  %18 = tuple ()
  return %18 : $()
}

// tests

// CHECK-LABEL: sil [ossa] @caller_owned_callee_error_owned : $@convention(thin) (@owned C) -> @error any Error {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_error_owned'
sil [ossa] @caller_owned_callee_error_owned : $@convention(thin) (@owned C) -> @error Error {
bb0(%instance : @owned $C):
  %callee_error_owned = function_ref @callee_error_owned : $@convention(thin) (@owned C) -> @error Error
  try_apply %callee_error_owned(%instance) : $@convention(thin) (@owned C) -> @error Error, normal bb1, error bb2

bb1(%9 : $()):
  %10 = tuple ()
  return %10 : $()
bb2(%12 : @owned $Error):
  throw %12 : $Error
}

// CHECK-LABEL: sil [ossa] @caller_owned_callee_error_guaranteed : $@convention(thin) (@owned C) -> @error any Error {
// CHECK:       {{bb[^,]+}}([[INSTANCE:%[^,]+]] : @owned $C):
// CHECK:         [[LIFETIME:%[^,]+]] = begin_borrow [[INSTANCE]]
// CHECK:         cond_br undef, [[THROW_BLOCK:bb[^,]+]], [[REGULAR_BLOCK:bb[0-9]+]]
// CHECK:       [[THROW_BLOCK]]:
// CHECK:         end_borrow [[LIFETIME]]
// CHECK:         destroy_value [[INSTANCE]]
// CHECK:         throw undef
// CHECK:       [[REGULAR_BLOCK]]:
// CHECK:         [[ORIGINAL_RETVAL:%[^,]+]] = tuple ()
// CHECK:         end_borrow [[LIFETIME]]
// CHECK:         destroy_value [[INSTANCE]]
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_owned_callee_error_guaranteed'
sil [ossa] @caller_owned_callee_error_guaranteed : $@convention(thin) (@owned C) -> @error Error {
bb0(%instance : @owned $C):
  %callee_error_guaranteed = function_ref @callee_error_guaranteed : $@convention(thin) (@guaranteed C) -> @error Error
  try_apply %callee_error_guaranteed(%instance) : $@convention(thin) (@guaranteed C) -> @error Error, normal bb1, error bb2
bb1(%9 : $()):
  destroy_value %instance : $C
  %10 = tuple ()
  return %10 : $()
bb2(%12 : @owned $Error):
  destroy_value %instance : $C
  throw %12 : $Error
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_error_owned : $@convention(thin) (@guaranteed C) -> @error any Error {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_error_owned'
sil [ossa] @caller_guaranteed_callee_error_owned : $@convention(thin) (@guaranteed C) -> @error Error {
bb0(%instance : @guaranteed $C):
  %copy = copy_value %instance : $C
  %callee_error_owned = function_ref @callee_error_owned : $@convention(thin) (@owned C) -> @error Error
  try_apply %callee_error_owned(%copy) : $@convention(thin) (@owned C) -> @error Error, normal bb1, error bb2
bb1(%9 : $()):
  %10 = tuple ()
  return %10 : $()
bb2(%12 : @owned $Error):
  throw %12 : $Error
}

// CHECK-LABEL: sil [ossa] @caller_guaranteed_callee_error_guaranteed : $@convention(thin) (@guaranteed C) -> @error any Error {
// CHECK:       {{bb[^,]+}}([[INSTANCE:%[^,]+]] : @guaranteed $C):
// CHECK-NOT:     begin_borrow
// CHECK:         cond_br undef, [[THROW_BLOCK:bb[^,]+]], [[REGULAR_BLOCK:bb[0-9]+]]
// CHECK:       [[THROW_BLOCK]]:
// CHECK-NOT:     end_borrow
// CHECK:         throw undef
// CHECK:       [[REGULAR_BLOCK]]:
// CHECK:         [[ORIGINAL_RETVAL:%[^,]+]] = tuple ()
// CHECK-NOT:     end_borrow
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_guaranteed_callee_error_guaranteed'
sil [ossa] @caller_guaranteed_callee_error_guaranteed : $@convention(thin) (@guaranteed C) -> @error Error {
bb0(%instance : @guaranteed $C):
  %callee_error_guaranteed = function_ref @callee_error_guaranteed : $@convention(thin) (@guaranteed C) -> @error Error
  try_apply %callee_error_guaranteed(%instance) : $@convention(thin) (@guaranteed C) -> @error Error, normal bb1, error bb2
bb1(%9 : $()):
  %10 = tuple ()
  return %10 : $()
bb2(%12 : @owned $Error):
  throw %12 : $Error
}

// CHECK-LABEL: sil hidden [ossa] @caller_trivial_callee_error_trivial : $@convention(thin) (S) -> @error any Error {
// CHECK:       {{bb[^,]+}}({{%[^,]+}} : $S):
// CHECK:         cond_br undef, [[THROW_BLOCK:bb[^,]+]], [[REGULAR_BLOCK:bb[0-9]+]]
// CHECK:       [[THROW_BLOCK]]:
// CHECK:         throw undef
// CHECK:       [[REGULAR_BLOCK]]:
// CHECK:         [[ORIGINAL_RETVAL:%[^,]+]] = tuple ()
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_trivial_callee_error_trivial'
sil hidden [ossa] @caller_trivial_callee_error_trivial : $@convention(thin) (S) -> @error Error {
bb0(%instance : $S):
  %callee_error_trivial = function_ref @callee_error_trivial : $@convention(thin) (S) -> @error Error
  try_apply %callee_error_trivial(%instance) : $@convention(thin) (S) -> @error Error, normal bb1, error bb2
bb1(%9 : $()):
  %10 = tuple ()
  return %10 : $()
bb2(%12 : @owned $Error):
  throw %12 : $Error
}

// CHECK-LABEL: sil hidden [ossa] @caller_in_callee_error_in : $@convention(thin) (@in S) -> @error any Error {
// CHECK:       {{bb[^,]+}}({{%[^,]+}} : $*S):
// CHECK:         cond_br undef, [[THROW_BLOCK:bb[0-9]+]], [[REGULAR_BLOCK:bb[0-9]+]]
// CHECK:       [[THROW_BLOCK]]:
// CHECK:         throw undef
// CHECK:       [[REGULAR_BLOCK]]:
// CHECK:         {{%[^,]+}} = tuple ()
// CHECK:         [[RETVAL:%[^,]+]] = tuple ()
// CHECK:         return [[RETVAL]]
// CHECK-LABEL: } // end sil function 'caller_in_callee_error_in'
sil hidden [ossa] @caller_in_callee_error_in : $@convention(thin) (@in S) -> @error Error {
bb0(%instance : $*S):
  %callee_error_in = function_ref @callee_error_in : $@convention(thin) (@in S) -> @error Error
  try_apply %callee_error_in(%instance) : $@convention(thin) (@in S) -> @error Error, normal bb1, error bb2
bb1(%9 : $()):
  %10 = tuple ()
  return %10 : $()
bb2(%12 : @owned $Error):
  throw %12 : $Error
}

// CHECK-LABEL: sil hidden [ossa] @caller_inguaranteed_callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error any Error {
// CHECK-NOT:     begin_borrow [lexical]
// CHECK-LABEL: // end sil function 'caller_inguaranteed_callee_error_inguaranteed'
sil hidden [ossa] @caller_inguaranteed_callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error Error {
bb0(%instance : $*T):
  %callee_error_inguaranteed = function_ref @callee_error_inguaranteed : $@convention(thin) <T> (@in_guaranteed T) -> @error Error
  try_apply %callee_error_inguaranteed<T>(%instance) : $@convention(thin) <T> (@in_guaranteed T) -> @error Error, normal bb1, error bb2
bb1(%9 : $()):
  %10 = tuple ()
  return %10 : $()
bb2(%12 : @owned $Error):
  throw %12 : $Error
}