Infer lifetime dependence info for functions that return ~Escapable type

Author: meg-gupta

include/swift/AST/DiagnosticsSema.def

@@ -7811,5 +7811,18 @@ ERROR(pack_iteration_where_clause_not_supported, none,
  ERROR(lifetime_dependence_missing_ownership_modifier, none,
        "lifetime dependence can only be specified on parameters with ownership "
        "modifiers (borrowing, consuming, inout)", ())
+ ERROR(lifetime_dependence_cannot_infer_wo_ownership_modifier_on_method, none,
+       "cannot infer lifetime dependence, specify ownership modifier for the "
+       "method",
+       ())
+ ERROR(lifetime_dependence_cannot_infer_wo_ambiguous_candidate, none,
+       "cannot infer lifetime dependence, multiple ~Escapable or ~Copyable "
+       "parameters with ownership modifiers, specify explicit lifetime "
+       "dependence",
+       ())
+ ERROR(lifetime_dependence_cannot_infer_no_candidates, none,
+       "cannot infer lifetime dependence, no ~Escapable or ~Copyable "
+       "parameters with ownership modifiers present",
+       ())
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/LifetimeDependence.h

@@ -19,6 +19,7 @@
 
 #include "swift/AST/Identifier.h"
 #include "swift/AST/IndexSubset.h"
+#include "swift/AST/Ownership.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/OptionSet.h"
 #include "swift/Basic/SourceLoc.h"
@@ -133,9 +134,16 @@ class LifetimeDependenceInfo {
   IndexSubset *borrowLifetimeParamIndices;
   IndexSubset *mutateLifetimeParamIndices;
 
+  static LifetimeDependenceInfo getForParamIndex(AbstractFunctionDecl *afd,
+                                                 unsigned index,
+                                                 ValueOwnership ownership);
+
   static llvm::Optional<LifetimeDependenceInfo>
   fromTypeRepr(AbstractFunctionDecl *afd, Type resultType, bool allowIndex);
 
+  static llvm::Optional<LifetimeDependenceInfo> infer(AbstractFunctionDecl *afd,
+                                                      Type resultType);
+
 public:
   LifetimeDependenceInfo()
       : inheritLifetimeParamIndices(nullptr),

lib/Sema/LifetimeDependence.cpp

@@ -10,10 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "swift/AST/LifetimeDependence.h"
 #include "TypeChecker.h"
+
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
+#include "swift/AST/LifetimeDependence.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeRepr.h"
@@ -62,6 +63,28 @@ void LifetimeDependenceInfo::Profile(llvm::FoldingSetNodeID &ID) const {
   }
 }
 
+LifetimeDependenceInfo LifetimeDependenceInfo::getForParamIndex(
+    AbstractFunctionDecl *afd, unsigned index, ValueOwnership ownership) {
+  auto *dc = afd->getDeclContext();
+  auto &ctx = dc->getASTContext();
+  unsigned capacity = afd->getParameters()->size() + 1;
+  auto indexSubset = IndexSubset::get(ctx, capacity, {index});
+  if (ownership == ValueOwnership::Owned) {
+    return LifetimeDependenceInfo{/*inheritLifetimeParamIndices*/ indexSubset,
+                                  /*borrowLifetimeParamIndices*/ nullptr,
+                                  /*mutateLifetimeParamIndices*/ nullptr};
+  }
+  if (ownership == ValueOwnership::Shared) {
+    return LifetimeDependenceInfo{/*inheritLifetimeParamIndices*/ nullptr,
+                                  /*borrowLifetimeParamIndices*/ indexSubset,
+                                  /*mutateLifetimeParamIndices*/ nullptr};
+  }
+  assert(ownership == ValueOwnership::InOut);
+  return LifetimeDependenceInfo{/*inheritLifetimeParamIndices*/ nullptr,
+                                /*borrowLifetimeParamIndices*/ nullptr,
+                                /*mutateLifetimeParamIndices*/ indexSubset};
+}
+
 llvm::Optional<LifetimeDependenceInfo>
 LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd, Type resultType,
                                      bool allowIndex) {
@@ -81,8 +104,8 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd, Type resultType,
                                           ValueOwnership ownership) {
     auto loc = specifier.getLoc();
     auto kind = specifier.getLifetimeDependenceKind();
-
-    if (resultType->isEscapable()) {
+    Type resultTypeInContext = afd->mapTypeIntoContext(resultType);
+    if (resultTypeInContext->isEscapable()) {
       diags.diagnose(loc, diag::lifetime_dependence_invalid_return_type);
       return true;
     }
@@ -187,6 +210,78 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd, Type resultType,
       IndexSubset::get(ctx, mutateLifetimeParamIndices));
 }
 
+llvm::Optional<LifetimeDependenceInfo>
+LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd, Type resultType) {
+  auto *dc = afd->getDeclContext();
+  auto &ctx = dc->getASTContext();
+
+  if (!ctx.LangOpts.hasFeature(Feature::NonescapableTypes)) {
+    return llvm::None;
+  }
+
+  auto &diags = ctx.Diags;
+  auto returnTypeRepr = afd->getResultTypeRepr();
+  auto returnLoc = returnTypeRepr->getLoc();
+  Type returnTyInContext = afd->mapTypeIntoContext(resultType);
+
+  if (returnTyInContext->isEscapable()) {
+    return llvm::None;
+  }
+  if (afd->getAttrs().hasAttribute<UnsafeNonEscapableResultAttr>()) {
+    return llvm::None;
+  }
+
+  if (afd->hasImplicitSelfDecl()) {
+    auto ownership = afd->getImplicitSelfDecl()->getValueOwnership();
+    if (ownership == ValueOwnership::Default) {
+      diags.diagnose(
+          returnLoc,
+          diag::
+              lifetime_dependence_cannot_infer_wo_ownership_modifier_on_method);
+      return llvm::None;
+    }
+    return LifetimeDependenceInfo::getForParamIndex(afd, /*selfIndex*/ 0,
+                                                    ownership);
+  }
+
+  LifetimeDependenceInfo lifetimeDependenceInfo;
+  ParamDecl *candidateParam = nullptr;
+  unsigned paramIndex = 0;
+  bool hasParamError = false;
+  for (auto *param : *afd->getParameters()) {
+    Type paramTypeInContext =
+        afd->mapTypeIntoContext(param->getInterfaceType());
+
+    if (paramTypeInContext->hasError()) {
+      hasParamError = true;
+      continue;
+    }
+    if (param->getValueOwnership() == ValueOwnership::Default) {
+      continue;
+    }
+
+    if (!paramTypeInContext->isEscapable() ||
+        paramTypeInContext->isNoncopyable()) {
+      if (candidateParam) {
+        diags.diagnose(
+            returnLoc,
+            diag::lifetime_dependence_cannot_infer_wo_ambiguous_candidate);
+        return llvm::None;
+      }
+      candidateParam = param;
+      lifetimeDependenceInfo = LifetimeDependenceInfo::getForParamIndex(
+          afd, paramIndex + 1, param->getValueOwnership());
+    }
+    paramIndex++;
+  }
+  if (!candidateParam && !hasParamError) {
+    diags.diagnose(returnLoc,
+                   diag::lifetime_dependence_cannot_infer_no_candidates);
+    return llvm::None;
+  }
+  return lifetimeDependenceInfo;
+}
+
 llvm::Optional<LifetimeDependenceInfo>
 LifetimeDependenceInfo::get(AbstractFunctionDecl *afd, Type resultType,
                             bool allowIndex) {
@@ -195,7 +290,7 @@ LifetimeDependenceInfo::get(AbstractFunctionDecl *afd, Type resultType,
     return llvm::None;
   }
   if (!isa<LifetimeDependentReturnTypeRepr>(returnTypeRepr)) {
-    return llvm::None;
+    return LifetimeDependenceInfo::infer(afd, resultType);
   }
   return LifetimeDependenceInfo::fromTypeRepr(afd, resultType, allowIndex);
 }

test/Generics/inverse_generics.swift

@@ -298,7 +298,7 @@ func conflict4(_ t: some NeedsCopyable & ~Copyable) {}
 // expected-error@-1 {{'some NeedsCopyable & ~Copyable' required to be 'Copyable' but is marked with '~Copyable'}}
 
 protocol Conflict5: ~Copyable {
-  func whatever() -> AlwaysCopyable<Self> // expected-error {{type 'Self' does not conform to protocol 'Copyable'}}
+  borrowing func whatever() -> AlwaysCopyable<Self> // expected-error {{type 'Self' does not conform to protocol 'Copyable'}}
 }
 
 // expected-warning@+1 {{same-type requirement makes generic parameters 'U' and 'T' equivalent}}

test/SIL/explicit_lifetime_dependence_specifiers.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend %s -emit-sil  -enable-builtin-module -enable-experimental-feature NonescapableTypes -disable-experimental-parser-round-trip -enable-experimental-feature NoncopyableGenerics
+// RUN: %target-swift-frontend %s -emit-sil  -enable-builtin-module -enable-experimental-feature NonescapableTypes -disable-experimental-parser-round-trip -enable-experimental-feature NoncopyableGenerics | %FileCheck %s
 // REQUIRES: asserts
 
 import Builtin

test/SIL/implicit_lifetime_dependence.swift

@@ -0,0 +1,55 @@
+// RUN: %target-swift-frontend %s -emit-sil  -enable-builtin-module -enable-experimental-feature NonescapableTypes -disable-experimental-parser-round-trip -enable-experimental-feature NoncopyableGenerics | %FileCheck %s
+// REQUIRES: asserts
+
+import Builtin
+
+struct BufferView : ~Escapable {
+  let ptr: UnsafeRawBufferPointer
+  init(_ ptr: UnsafeRawBufferPointer) {
+    self.ptr = ptr
+  }
+}
+
+struct MutableBufferView : ~Escapable, ~Copyable {
+  let ptr: UnsafeMutableRawBufferPointer
+  init(_ ptr: UnsafeMutableRawBufferPointer) {
+    self.ptr = ptr
+  }
+}
+
+func testBasic() {
+  let capacity = 4
+  let a = Array(0..<capacity)
+  a.withUnsafeBytes {
+    let view = BufferView($0)
+    let derivedView = derive(view)
+    let newView = consumeAndCreate(derivedView)
+    use(newView)    
+  }
+}
+
+// CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence6deriveyAA10BufferViewVADF : $@convention(thin) (@guaranteed BufferView) -> _borrow(1) @owned BufferView {
+func derive(_ x: borrowing BufferView) -> BufferView {
+  return BufferView(x.ptr)
+}
+
+// CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence16consumeAndCreateyAA10BufferViewVADnF : $@convention(thin) (@owned BufferView) -> _inherit(1) @owned BufferView {
+func consumeAndCreate(_ x: consuming BufferView) -> BufferView {
+  return BufferView(x.ptr)
+}
+
+func use(_ x: borrowing BufferView) {}
+
+struct Wrapper : ~Escapable {
+  let view: BufferView
+// CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence7WrapperV8getView1AA10BufferViewVyF : $@convention(method) (@guaranteed Wrapper) -> _borrow(0) @owned BufferView {
+  borrowing func getView1() -> BufferView {
+    return view
+  }
+
+// CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence7WrapperV8getView2AA10BufferViewVyF : $@convention(method) (@owned Wrapper) -> _inherit(0) @owned BufferView {
+  consuming func getView2() -> BufferView {
+    return view
+  }
+}
+