Add test: SIL lifetime dependence diagnostic passes

Author: atrick

test/SILOptimizer/lifetime_dependence/diagnostic_passes.sil

@@ -0,0 +1,133 @@
+// RUN: %target-sil-opt -test-runner %s \
+// RUN:     -diagnostics -sil-verify-all \
+// RUN:     -enable-experimental-feature LifetimeDependence \
+// RUN:     -enable-experimental-feature LifetimeDependenceDiagnoseTrivial \
+// RUN:     2>&1 | %FileCheck %s
+
+// Test SIL expected from SILGen output. Run all diagnostic passes which includes lifetime dependence handling:
+// -lifetime-dependence-insertion
+// -lifetime-dependence-scopefixup
+// -lifetime-dependence-diagnostics
+//
+// This is a good place to put reduced .sil tests.
+
+// REQUIRES: swift_in_compiler
+// REQUIRES: swift_feature_LifetimeDependence
+// REQUIRES: swift_feature_LifetimeDependenceDiagnoseTrivial
+
+sil_stage raw
+
+import Builtin
+import Swift
+import SwiftShims
+
+struct Owner {}
+struct NE: ~Escapable {}
+struct OtherNE: ~Escapable {}
+
+sil @getNE : $@convention(c) (@in_guaranteed Owner) -> @lifetime(borrow 0) @autoreleased NE
+sil @copyNE : $@convention(c) (NE, @lifetime(copy 0) @inout NE) -> ()
+sil @makeOwner : $@convention(c) () -> Owner
+
+// Modify a local via 'inout' assignment.
+// Do not insert a mark_dep.
+// Do not extend any scopes.
+// Consider all uses of the local to be potential uses of the argument.
+//
+// CHECK-LABEL: sil [ossa] @copyToLocal : $@convention(thin) (@owned NE) -> () {
+// CHECK: bb0(%0 : @owned $NE):
+// CHECK:   [[ALLOC:%.*]] = alloc_stack [var_decl] $NE, var, name "v1"
+// CHECK:   [[MV:%.*]] = move_value [var_decl] %0
+// CHECK:   [[ACCESS:%.*]] = begin_access [modify] [static] [[ALLOC]]
+// CHECK:   apply %{{.*}}([[MV]], [[ACCESS]]) : $@convention(c) (NE, @lifetime(copy 0) @inout NE) -> ()
+// CHECK:   end_access [[ACCESS]]
+// CHECK:   destroy_value [[MV]]
+// CHECK:   destroy_addr [[ALLOC]]
+// CHECK-LABEL: } // end sil function 'copyToLocal'
+sil [ossa] @copyToLocal : $@convention(thin) (@owned NE) -> () {
+bb0(%0 : @owned $NE):
+  %1 = alloc_box ${ var NE }, var, name "v1"
+  %2 = begin_borrow [var_decl] %1
+  %3 = project_box %2, 0
+  %4 = move_value [var_decl] %0
+  %5 = begin_borrow %4
+  // assign the local to the argument
+  %6 = begin_access [modify] [unknown] %3
+  %7 = function_ref @copyNE : $@convention(c) (NE, @lifetime(copy 0) @inout NE) -> ()
+  %8 = apply %7(%5, %6) : $@convention(c) (NE, @lifetime(copy 0) @inout NE) -> ()
+  end_access %6
+  end_borrow %5
+  // destroy the argument
+  destroy_value %4
+  end_borrow %2
+  // destroy the local
+  destroy_value %1
+  %14 = tuple ()
+  return %14
+}
+
+// rdar://140424699
+//
+// Reassign into a local that outlives the original.
+//
+// CHECK-LABEL: sil [ossa] @testInoutReassign : $@convention(thin) () -> () {
+// CHECK:   [[V1:%.*]] = alloc_stack [var_decl] $NE, var, name "v1", type $NE
+// CHECK:   [[MD1:%.*]] = mark_dependence [nonescaping]
+// CHECK:   store [[MD1]] to [init] [[V1]]
+// CHECK:   [[MD2:%.*]] = mark_dependence [nonescaping]
+// CHECK:   [[MV:%.*]] = move_value [var_decl] [[MD2]]
+// CHECK:   debug_value [[MV]], let, name "v2"
+// CHECK:   [[ACCESS:%.*]] = begin_access [modify] [static] [[V1]]
+// CHECK:   apply %{{.*}}([[MV]], [[ACCESS]]) : $@convention(c) (NE, @lifetime(copy 0) @inout NE) -> ()
+// CHECK:   end_access [[ACCESS]]
+// CHECK:   destroy_value [[MV]]
+// CHECK:   destroy_addr [[V1]]
+// CHECK-LABEL: } // end sil function 'testInoutReassign'
+sil [ossa] @testInoutReassign : $@convention(thin) () -> () {
+bb0:
+  %0 = function_ref @makeOwner : $@convention(c) () -> Owner // user: %1
+  %1 = apply %0() : $@convention(c) () -> Owner
+  %2 = move_value [var_decl] %1 : $Owner
+  debug_value %2 : $Owner, let, name "o"
+
+  // Declare v1: NE
+  %8 = alloc_box ${ var NE }, var, name "v1"
+  %9 = begin_borrow [var_decl] %8 : ${ var NE }
+  %10 = project_box %9 : ${ var NE }, 0
+
+  // v1 = owner.ne
+  %11 = alloc_stack $Owner
+  store %2 to [trivial] %11 : $*Owner
+  %13 = function_ref @getNE : $@convention(c) (@in_guaranteed Owner) -> @lifetime(borrow 0) @autoreleased NE
+  %14 = apply %13(%11) : $@convention(c) (@in_guaranteed Owner) -> @lifetime(borrow 0) @autoreleased NE
+  dealloc_stack %11 : $*Owner
+  store %14 to [init] %10 : $*NE
+
+  // v2 = owner.ne
+  %17 = alloc_stack $Owner
+  store %2 to [trivial] %17 : $*Owner
+  %22 = apply %13(%17) : $@convention(c) (@in_guaranteed Owner) -> @lifetime(borrow 0) @autoreleased NE
+  dealloc_stack %17 : $*Owner
+  %25 = move_value [var_decl] %22 : $NE
+  debug_value %25 : $NE, let, name "v2"
+
+  // copyView(v2, &v1)
+  %81 = begin_borrow %25 : $NE
+  %82 = begin_access [modify] [unknown] %10 : $*NE
+  %83 = function_ref @copyNE : $@convention(c) (NE, @lifetime(copy 0) @inout NE) -> ()
+  %84 = apply %83(%81, %82) : $@convention(c) (NE, @lifetime(copy 0) @inout NE) -> ()
+  end_access %82 : $*NE
+  end_borrow %81 : $NE
+
+  // destroy v2
+  destroy_value %25 : $NE
+
+  // destroy v1
+  end_borrow %9 : ${ var NE }
+  destroy_value %8 : ${ var NE }
+
+  // Owner covers all uses.
+  extend_lifetime %2 : $Owner
+  %93 = tuple ()
+  return %93 : $()
+}