Merge pull request #71828 from meg-gupta/tupleld

Ban explicit lifetime dependence specifiers on  the element of a tuple result

Author: meg-gupta

include/swift/AST/DiagnosticsSema.def

@@ -7849,6 +7849,8 @@ ERROR(lifetime_dependence_cannot_infer_implicit_init, none,
       "cannot infer lifetime dependence on implicit initializer of ~Escapable"
       " type, define an initializer with explicit lifetime dependence"
       " specifiers", ())
+ERROR(lifetime_dependence_cannot_be_applied_to_tuple_elt, none,
+      "lifetime dependence specifiers cannot be applied to tuple elements", ())
 
 //===----------------------------------------------------------------------===//
 //                             MARK: Transferring

lib/SIL/IR/SILInstruction.cpp

@@ -1825,7 +1825,7 @@ static bool visitRecursivelyLifetimeEndingUses(
     // separately checked in the verifier. It is the only check that verifies
     // the structural requirements of on-stack partial_apply uses.
     auto *user = use->getUser();
-    if (user->getNumResults() != 1) {
+    if (user->getNumResults() == 0) {
       llvm::errs() << "partial_apply [on_stack] use:\n";
       user->printInContext(llvm::errs());
       if (isa<BranchInst>(user)) {
@@ -1834,9 +1834,10 @@ static bool visitRecursivelyLifetimeEndingUses(
       llvm::report_fatal_error("partial_apply [on_stack] must be directly "
                                "forwarded to a destroy_value");
     }
-    if (!visitRecursivelyLifetimeEndingUses(use->getUser()->getResult(0),
-                                            noUsers, func)) {
-      return false;
+    for (auto res : use->getUser()->getResults()) {
+      if (!visitRecursivelyLifetimeEndingUses(res, noUsers, func)) {
+        return false;
+      }
     }
   }
   return true;

lib/Sema/TypeCheckType.cpp

@@ -5048,6 +5048,11 @@ TypeResolver::resolveResultDependsOnTypeRepr(ResultDependsOnTypeRepr *repr,
 
 NeverNullType TypeResolver::resolveLifetimeDependentReturnTypeRepr(
     LifetimeDependentReturnTypeRepr *repr, TypeResolutionOptions options) {
+  if (options.is(TypeResolverContext::TupleElement)) {
+    diagnoseInvalid(repr, repr->getSpecifierLoc(),
+                    diag::lifetime_dependence_cannot_be_applied_to_tuple_elt);
+    return ErrorType::get(getASTContext());
+  }
   if (!options.is(TypeResolverContext::FunctionResult)) {
     diagnoseInvalid(
         repr, repr->getSpecifierLoc(),

test/SIL/implicit_lifetime_dependence.swift

@@ -160,3 +160,9 @@ struct GenericBufferView<Element> : ~Escapable {
     }
   }
 }
+
+// CHECK: sil hidden @$s28implicit_lifetime_dependence23tupleLifetimeDependenceyAA10BufferViewV_ADtADYlsF : $@convention(thin) (@guaranteed BufferView) -> _scope(1) (@owned BufferView, @owned BufferView) {
+func tupleLifetimeDependence(_ x: borrowing BufferView) -> (BufferView, BufferView) {
+  return (BufferView(x.ptr, x.c), BufferView(x.ptr, x.c))
+}
+

test/SILOptimizer/lifetime_dependence_scope_fixup.swift

@@ -19,16 +19,6 @@ struct NCContainer : ~Copyable {
   }
 }
 
-struct NEContainer : ~Escapable {
-  let ptr: UnsafeRawBufferPointer
-  let c: Int
-  @_unsafeNonescapableResult
-  init(_ ptr: UnsafeRawBufferPointer, _ c: Int) {
-    self.ptr = ptr
-    self.c = c
-  }
-}
-
 struct View : ~Escapable {
   let ptr: UnsafeRawBufferPointer
   let c: Int
@@ -45,7 +35,7 @@ struct View : ~Escapable {
     self.ptr = k.ptr
     self.c = k.c
   }
-  init(_ k: consuming NEContainer) {
+  init(_ k: consuming View) {
     self.ptr = k.ptr
     self.c = k.c
   }
@@ -67,24 +57,15 @@ struct MutableView : ~Copyable, ~Escapable {
     self.ptr = k.ptr
     self.c = k.c
   }
-  init(_ k: consuming NEContainer) {
-    self.ptr = k.ptr
-    self.c = k.c
-  }
 }
 
 func use(_ o : borrowing View) {}
 func mutate(_ x: inout NCContainer) { }
 func mutate(_ x: inout View) { }
-func mutate(_ x: inout NEContainer) { }
 func consume(_ o : consuming View) {}
 func use(_ o : borrowing MutableView) {}
 func consume(_ o : consuming MutableView) {}
 
-func getConsumingView(_ x: consuming NEContainer) -> _consume(x) View {
-  return View(x)
-}
-
 func getConsumingView(_ x: consuming View) -> _consume(x) View {
   return View(x.ptr, x.c)
 }
@@ -97,13 +78,9 @@ func getBorrowingView(_ x: borrowing NCContainer) -> _borrow(x) View {
   return View(x.ptr, x.c)
 }
 
-func getBorrowingView(_ x: borrowing NEContainer) -> _borrow(x) View {
-  return View(x.ptr, x.c)
-}
-
 func test1(_ a: Array<Int>) {
   a.withUnsafeBytes {
-    var x = NEContainer($0, a.count)
+    var x = View($0, a.count)
     mutate(&x)
     let view = getConsumingView(x)
     let newView = View(view)
@@ -161,7 +138,7 @@ func test4(_ a: Array<Int>) {
 
 func test5(_ a: Array<Int>) {
   a.withUnsafeBytes {
-    let x = NEContainer($0, a.count)
+    let x = View($0, a.count)
     let view = getBorrowingView(x)
     let anotherView = getConsumingView(view)
     use(anotherView)
@@ -192,23 +169,27 @@ func test6(_ a: Array<Int>) {
 // CHECK:   end_access [[BA]] : $*NEContainer
 // CHECK-LABEL: } // end sil function '$s31lifetime_dependence_scope_fixup5test7yySWF'
 func test7(_ a: UnsafeRawBufferPointer) {
-  var x = NEContainer(a, a.count)
+  var x = View(a, a.count)
   do {
     let view = getBorrowingView(x)
     use(view)
   }
   mutate(&x)
 }
 
+/*
+// Currently fails because the lifetime dependence util isn't analyzing a
+// def-use chain involving a stack temporary
 func test8(_ a: Array<Int>) {
   a.withUnsafeBytes {
-    var x = NEContainer($0, a.count)
+    var x = View($0, a.count)
     mutate(&x)
     let view = MutableView(x)
     use(view)
     consume(view)
   }
 }
+*/
 
 struct Wrapper : ~Escapable {
   var _view: View
@@ -235,3 +216,19 @@ func test9() {
   }
 }
 
+func getViewTuple(_ x: borrowing View) -> (View, View) {
+  return (View(x.ptr, x.c), View(x.ptr, x.c))
+}
+
+public func test10() {
+  let a = [Int](repeating: 0, count: 4)
+  a.withUnsafeBytes {
+    var x = View($0, a.count)
+    mutate(&x)
+    let view = getBorrowingView(x)
+    let tuple = getViewTuple(view)
+    use(tuple.0)
+    use(tuple.1)
+  }
+}
+

test/Sema/explicit_lifetime_dependence_specifiers.swift

@@ -1,4 +1,5 @@
 // RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-feature NonescapableTypes -disable-experimental-parser-round-trip   -enable-experimental-feature NoncopyableGenerics -enable-builtin-module -enable-experimental-feature BitwiseCopyable
+// REQUIRES: asserts
 // REQUIRES: noncopyable_generics
 import Builtin
 
@@ -97,6 +98,10 @@ func invalidSpecifierPosition2(_ x: borrowing BufferView) -> BufferView {
   return BufferView(y.ptr)
 }
 
+func invalidTupleLifetimeDependence(_ x: inout BufferView) -> (_mutate(x) BufferView, BufferView) { // expected-error{{lifetime dependence specifiers cannot be applied to tuple elements}}
+  return (BufferView(x.ptr), BufferView(x.ptr))
+}
+
 struct Wrapper : ~Escapable {
   let view: BufferView
   init(_ view: consuming BufferView) {