Lifetime dependence: add inferrence for setters.

A nonescapable computed property should always depend on 'newValue'. We simply
infer that now. There's no way to explicitly spell the dependence.

Author: atrick

SwiftCompilerSources/Sources/Optimizer/Utilities/LifetimeDependenceUtils.swift

@@ -215,7 +215,7 @@ extension LifetimeDependence {
     if (value.definingInstructionOrTerminator as! FullApplySite).hasResultDependence {
       return nil
     }
-    assert(value.ownership == .owned, "apply result must be owned")
+    assert(value.ownership == .owned, "unsafe apply result must be owned")
     self.scope = Scope(base: value, context)!
     self.dependentValue = value
   }

include/swift/AST/LifetimeDependence.h

@@ -159,6 +159,10 @@ class LifetimeDependenceInfo {
   /// Infer LifetimeDependenceInfo on result
   static std::optional<LifetimeDependenceInfo> infer(AbstractFunctionDecl *afd);
 
+  /// Infer LifetimeDependenceInfo on setter
+  static std::optional<LifetimeDependenceInfo>
+  inferSetter(AbstractFunctionDecl *afd);
+
   /// Builds LifetimeDependenceInfo from SIL function type
   static std::optional<LifetimeDependenceInfo>
   fromTypeRepr(LifetimeDependentTypeRepr *lifetimeDependentRepr,

lib/AST/LifetimeDependence.cpp

@@ -80,6 +80,8 @@ getLifetimeDependenceKindFromType(Type sourceType) {
   return LifetimeDependenceKind::Inherit;
 }
 
+// Warning: this is incorrect for Setter 'newValue' parameters. It should only
+// be called for a Setter's 'self'.
 static ValueOwnership getLoweredOwnership(AbstractFunctionDecl *afd) {
   if (isa<ConstructorDecl>(afd)) {
     return ValueOwnership::Owned;
@@ -437,6 +439,13 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
     return std::nullopt;
   }
 
+  // Setters infer 'self' dependence on 'newValue'.
+  if (auto accessor = dyn_cast<AccessorDecl>(afd)) {
+    if (accessor->getAccessorKind() == AccessorKind::Set) {
+      return inferSetter(accessor);
+    }
+  }
+
   if (hasEscapableResultOrYield(afd)) {
     return std::nullopt;
   }
@@ -542,6 +551,53 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
       afd, resultIndex, *candidateParamIndex, *candidateLifetimeKind);
 }
 
+/// Infer LifetimeDependenceInfo on a setter where 'self' is nonescapable.
+std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::inferSetter(
+  AbstractFunctionDecl *afd) {
+
+  auto *param = afd->getParameters()->get(0);
+  Type paramTypeInContext =
+    afd->mapTypeIntoContext(param->getInterfaceType());
+  if (paramTypeInContext->hasError()) {
+    return std::nullopt;
+  }
+  if (paramTypeInContext->isEscapable()) {
+    return std::nullopt;
+  }
+  auto kind = getLifetimeDependenceKindFromType(paramTypeInContext);
+  return LifetimeDependenceInfo::getForIndex(
+    afd, /*selfIndex */ afd->getParameters()->size(), 0, kind);
+}
+
+/// Infer LifetimeDependenceInfo on a mutating method where 'self' is
+/// nonescapable and the result is 'void'. For now, we'll assume that 'self'
+/// depends on a single nonescapable argument.
+std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::inferMutatingSelf(
+  AbstractFunctionDecl *afd) {
+  std::optional<LifetimeDependenceInfo> dep;
+  for (unsigned paramIndex : range(afd->getParameters()->size())) {
+    auto *param = afd->getParameters()->get(paramIndex);
+    Type paramTypeInContext =
+      afd->mapTypeIntoContext(param->getInterfaceType());
+    if (paramTypeInContext->hasError()) {
+      continue;
+    }
+    if (paramTypeInContext->isEscapable()) {
+      continue;
+    }
+    if (dep) {
+      // Don't infer dependence on multiple nonescapable parameters. We may want
+      // to do this in the future if dependsOn(self: arg1, arg2) syntax is too
+      // cumbersome.
+      return std::nullopt;
+    }
+    int selfIndex = afd->getParameters()->size();
+    dep = LifetimeDependenceInfo::getForIndex(
+      afd, selfIndex, paramIndex, LifetimeDependenceKind::Inherit);
+  }
+  return dep;
+}
+
 std::optional<llvm::ArrayRef<LifetimeDependenceInfo>>
 LifetimeDependenceInfo::get(AbstractFunctionDecl *afd) {
   if (!afd->getASTContext().LangOpts.hasFeature(Feature::NonescapableTypes)) {

test/SIL/implicit_lifetime_dependence.swift

@@ -168,3 +168,25 @@ func tupleLifetimeDependence(_ x: borrowing BufferView) -> (BufferView, BufferVi
   return (BufferView(x.ptr, x.c), BufferView(x.ptr, x.c))
 }
 
+public struct OuterNE: ~Escapable {
+  // A public property generates an implicit setter with an infered dependence on 'newValue'.
+  //
+  // CHECK-LABEL: sil [transparent] @$s28implicit_lifetime_dependence7OuterNEV5innerAC05InnerE0Vvs : $@convention(method) (@owned OuterNE.InnerNE, _inherit(0) @inout OuterNE) -> () {
+  public var inner1: InnerNE
+
+  // Explicit setter with an infered dependence on 'newValue'.
+  public var inner2: InnerNE {
+    get { inner1 }
+    set { inner1 = newValue }
+  }
+
+  public struct InnerNE: ~Escapable {
+    init<Owner: ~Escapable & ~Copyable>(
+      owner: borrowing Owner
+    ) -> dependsOn(owner) Self {}
+  }
+
+  init<Owner: ~Copyable & ~Escapable>(owner: borrowing Owner) -> dependsOn(owner) Self {
+    self.inner1 = InnerNE(owner: owner)
+  }
+}

test/SILOptimizer/lifetime_dependence/inout.swift

@@ -37,3 +37,24 @@ extension Array {
 func mayReassign(span: dependsOn(a) inout Span<Int>, to a: Array<Int>) {
   span = a.span()
 }
+
+public struct OuterNE: ~Escapable {
+  // Generates a setter with an inferred dependence on the new value.
+  public var inner1: InnerNE
+
+  // Explicit setter with an infered dependence on 'newValue'.
+  public var inner2: InnerNE {
+    _read { yield inner1 }
+    _modify { yield &inner1 }
+  }
+
+  public struct InnerNE: ~Escapable {
+    init<Owner: ~Escapable & ~Copyable>(
+      owner: borrowing Owner
+    ) -> dependsOn(owner) Self {}
+  }
+
+  init<Owner: ~Copyable & ~Escapable>(owner: borrowing Owner) -> dependsOn(owner) Self {
+    self.inner1 = InnerNE(owner: owner)
+  }
+}