Infer LifetimeDependenceInfo on a mutating method

We need this at least until we have 'dependsOn(self)' syntax.

When 'self' is nonescapable and the result is 'void', assume that 'self' depends
on a single nonescapable argument.

Author: atrick

include/swift/AST/LifetimeDependence.h

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

lib/AST/LifetimeDependence.cpp

@@ -20,6 +20,7 @@
 #include "swift/AST/TypeRepr.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/Defer.h"
+#include "swift/Basic/Range.h"
 
 namespace swift {
 
@@ -444,6 +445,16 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
     if (accessor->getAccessorKind() == AccessorKind::Set) {
       return inferSetter(accessor);
     }
+  } else if (auto *fd = dyn_cast<FuncDecl>(afd)) {
+    // Infer self dependence for a mutating function with no result.
+    //
+    // FIXME: temporary hack until we have dependsOn(self: param) syntax.
+    // Do not apply this to accessors (_modify). _modify is handled below like a
+    // mutating method.
+    if (fd->isMutating() && fd->getResultInterfaceType()->isVoid()
+        && !dc->getSelfTypeInContext()->isEscapable()) {
+      return inferMutatingSelf(afd);
+    }
   }
 
   if (hasEscapableResultOrYield(afd)) {
@@ -487,6 +498,11 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
       return std::nullopt;
     }
 
+    // Infer method dependence: result depends on self.
+    //
+    // This includes _modify. A _modify's yielded value depends on self. The
+    // caller of the _modify ensures that the 'self' depends on any value stored
+    // to the yielded address.
     return LifetimeDependenceInfo::getForIndex(
         afd, resultIndex, /*selfIndex */ afd->getParameters()->size(), kind);
   }
@@ -551,7 +567,7 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd) {
       afd, resultIndex, *candidateParamIndex, *candidateLifetimeKind);
 }
 
-/// Infer LifetimeDependenceInfo on a setter where 'self' is nonescapable.
+/// Infer LifetimeDependence on a setter where 'self' is nonescapable.
 std::optional<LifetimeDependenceInfo> LifetimeDependenceInfo::inferSetter(
   AbstractFunctionDecl *afd) {
 

test/SIL/implicit_lifetime_dependence.swift

@@ -172,7 +172,7 @@ 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
+  var inner1: InnerNE
 
   // Explicit setter with an infered dependence on 'newValue'.
   public var inner2: InnerNE {
@@ -189,4 +189,11 @@ public struct OuterNE: ~Escapable {
   init<Owner: ~Copyable & ~Escapable>(owner: borrowing Owner) -> dependsOn(owner) Self {
     self.inner1 = InnerNE(owner: owner)
   }
+
+  // Infer a dependence from 'self' on 'value'. We might revoke this rule once we have dependsOn(self:) syntax.
+  //
+  // CHECK-LABEL: sil hidden [ossa] @$s28implicit_lifetime_dependence7OuterNEV8setInner5valueyAC0gE0V_tF : $@convention(method) (@guaranteed OuterNE.InnerNE, _inherit(0) @inout OuterNE) -> () {
+  mutating func setInner(value: InnerNE) {
+    self.inner1 = value
+  }
 }