[lifetimes] add same-type default lifetime inference

Infer @Lifetime(result: copy arg) for every (result: R, arg: A) pair
such that R == A and 'arg' is not 'inout'.

Author: atrick

docs/ReferenceGuides/LifetimeAnnotation.md

@@ -18,7 +18,7 @@ The `@lifetime` annotation is enforced both in the body of the function and at e
 
 ## Default lifetimes
 
-The Swift 6.2 compiler provided default `@_lifetime` behavior whenever it can do so without ambiguity. Often, despite ambiguity, an "obvious" default exists, but we wanted to introduce defaults slowly after developers have enough experience to inform discussion about them. This document tracks the current state of the implementation as it progresses from the original 6.2 implementation. Corresponding tests are in `test/Sema/lifetime_depend_infer.swift`; searching for "DEFAULT:" highlights the rules defined below...
+The Swift 6.2 compiler provided default `@_lifetime` behavior whenever it can do so without ambiguity. Often, despite ambiguity, an obvious default exists, but we wanted to introduce defaults slowly after developers have enough experience to inform discussion about them. This document tracks the current state of the implementation as it progresses from the original 6.2 implementation. Corresponding tests are in `test/Sema/lifetime_depend_infer.swift`; searching for "DEFAULT:" highlights the rules defined below...
 
 ### Same-type default lifetime (unimplemented)
 

lib/AST/LifetimeDependence.cpp

@@ -1084,6 +1084,8 @@ class LifetimeDependenceChecker {
 
     // Infer non-Escapable results.
     if (isDiagnosedNonEscapable(getResultOrYield())) {
+      inferNonEscapableResultOnSameTypeParam();
+
       if (isInit() && isImplicitOrSIL()) {
         inferImplicitInit();
       } else if (hasImplicitSelfParam()) {
@@ -1105,6 +1107,41 @@ class LifetimeDependenceChecker {
     inferInoutParams();
   }
 
+  // Infer a dependency to the ~Escapable result from all parameters of the same
+  // type.
+  void inferNonEscapableResultOnSameTypeParam() {
+    CanType resultTy = getResultOrYield()->getCanonicalType();
+
+    TargetDeps *targetDeps = depBuilder.getInferredTargetDeps(resultIndex);
+    if (!targetDeps)
+      return;
+
+    if (hasImplicitSelfParam()
+        && !afd->getImplicitSelfDecl()->isInOut()
+        && dc->getSelfTypeInContext()->getCanonicalType() == resultTy) {
+      targetDeps->inheritIndices.set(selfIndex);
+    }
+
+    unsigned paramIndex = 0;
+    for (auto *param : *afd->getParameters()) {
+      SWIFT_DEFER { paramIndex++; };
+
+      // Ignore inout parameters--they are effectively considered to be a
+      // different type when applying the same-type rule. An inout parameter is
+      // only a default dependency source or target for the dependency on
+      // itself, which is covered by the 'inout' rule.
+      if (param->isInOut())
+        continue;
+
+      CanType paramTy = afd->mapTypeIntoEnvironment(
+        param->getInterfaceType())->getCanonicalType();
+      if (paramTy != resultTy)
+        continue;
+
+      targetDeps->inheritIndices.set(paramIndex);
+    }
+  }
+
   // Infer dependence for an accessor whose non-escapable result depends on
   // self. This includes _read and _modify.
   //

test/Parse/lifetime_attr.swift

@@ -20,12 +20,12 @@ func derive(_ ne1: NE, _ ne2: NE) -> NE {
 }
 
 @_lifetime // expected-error{{expected '(' after lifetime dependence specifier}}
-func testMissingLParenError(_ ne: NE) -> NE { // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
+func testMissingLParenError(_ ne: NE) -> NE {
   ne
 }
 
 @_lifetime() // expected-error{{expected 'copy', 'borrow', or '&' followed by an identifier, index or 'self' in lifetime dependence specifier}}
-func testMissingDependence(_ ne: NE) -> NE { // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
+func testMissingDependence(_ ne: NE) -> NE {
   ne
 }
 

test/Sema/lifetime_depend_infer.swift

@@ -21,6 +21,40 @@ struct NEImmortal: ~Escapable {
 
 struct MutNE: ~Copyable & ~Escapable {}
 
+// =============================================================================
+// Same-type default rule
+// =============================================================================
+
+func sameTypeParam(ne: NE) -> NE { ne }
+
+func sameTypeConsumingParam(ne: consuming NE) -> NE { ne }
+
+func sameTypeBorrowingParam(ne: borrowing NE) -> NE { ne }
+
+func sameTypeInoutParam(ne: inout NE) -> NE { ne } // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
+
+func sameTypeParam_sameTypeParam(ne1: NE, ne2: NE) -> NE { ne1 }
+
+func sameTypeParam_otherTypeParam(ne: NE, c: C) -> NE { ne }
+
+func sameTypeParam_sameTypeInoutParam(ne: NE, mutNE: inout NE) -> NE { ne }
+
+struct NonEscapableSelf: ~Escapable {
+  func sameTypeSelf_noParam() -> Self { self }
+
+  consuming func sameTypeConsumingSelf_noParam() -> Self { self }
+
+  borrowing func sameTypeBorrowingSelf_noParam() -> Self { self }
+
+  func sameTypeSelf_InoutParam(ne: inout NE) -> NE { ne } // expected-error{{a method with a ~Escapable result requires '@_lifetime(...)'}}
+
+  func sameTypeSelf_sameTypeParam(ne: NonEscapableSelf) -> Self { self }
+
+  func sameTypeSelf_otherTypeParam(c: C) -> Self { self }
+
+  func sameTypeSelf_sameTypeInoutParam(mutNE: inout NonEscapableSelf) -> Self { self }
+}
+
 // =============================================================================
 // Single parameter default rule for functions
 // =============================================================================
@@ -71,22 +105,22 @@ func twoParamsBorrow_NEResult(c: borrowing C, _: Int) -> NEImmortal { NEImmortal
 
 func twoParamsInout_NEResult(c: inout C, _: Int) -> NEImmortal { NEImmortal() } // expected-error{{a function with a ~Escapable result requires '@_lifetime(...)'}}
 
-func neParam_NEResult(ne: NE) -> NE { ne } // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
+func neParam_NEResult(ne: NE) -> NE { ne }
 
 @_lifetime(ne) // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
 func neParamLifetime_NEResult(ne: NE) -> NE { ne }
 
-func neParamBorrow_NEResult(ne: borrowing NE) -> NE { ne } // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
+func neParamBorrow_NEResult(ne: borrowing NE) -> NE { ne }
 
 @_lifetime(ne) // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
 func neParamBorrowLifetime_NEResult(ne: borrowing NE) -> NE { ne }
 
-func neParamConsume_NEResult(ne: consuming NE) -> NE { ne } // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
+func neParamConsume_NEResult(ne: consuming NE) -> NE { ne }
 
 @_lifetime(ne) // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
 func neParamConsumeLifetime_NEResult(ne: consuming NE) -> NE { ne }
 
-func neParam_IntParam_NEResult(ne: NE, _:Int) -> NE { ne } // expected-error{{a function with a ~Escapable result requires '@_lifetime(...)'}}
+func neParam_IntParam_NEResult(ne: NE, _:Int) -> NE { ne }
 
 func inoutParam_inoutParam_NEResult(a: inout C, b: inout C) -> NEImmortal { NEImmortal() }
 // expected-error@-1{{a function with a ~Escapable result requires '@_lifetime(...)'}}
@@ -201,8 +235,8 @@ struct EscapableTrivialSelf {
   mutating func mutating_oneParamBorrow_NEResult(_: Int) -> NEImmortal { NEImmortal() }
 }
 
-struct NonEscapableSelf: ~Escapable {
-  func noParam_NEResult() -> NonEscapableSelf { self } // expected-error{{cannot infer the lifetime dependence scope on a method with a ~Escapable parameter, specify '@_lifetime(borrow self)' or '@_lifetime(copy self)'}}
+extension NonEscapableSelf /* where Self: ~Escapable */ {
+  func noParam_NEResult() -> NonEscapableSelf { self }
 
   @_lifetime(self) // expected-error{{cannot infer the lifetime dependence scope on a method with a ~Escapable parameter, specify '@_lifetime(borrow self)' or '@_lifetime(copy self)'}}
   func noParamLifetime_NEResult() -> NonEscapableSelf { self }
@@ -224,7 +258,7 @@ struct NonEscapableSelf: ~Escapable {
   @_lifetime(&self) // OK
   mutating func mutating_noParamBorrow_NEResult() -> NonEscapableSelf { self }
 
-  func oneParam_NEResult(_: Int) -> NonEscapableSelf { self } // expected-error{{a method with a ~Escapable result requires '@_lifetime(...)'}}
+  func oneParam_NEResult(_: Int) -> NonEscapableSelf { self }
 
   @_lifetime(self) // expected-error{{cannot infer the lifetime dependence scope on a method with a ~Escapable parameter, specify '@_lifetime(borrow self)' or '@_lifetime(copy self)'}}
   func oneParamLifetime_NEResult(_: Int) -> NonEscapableSelf { self }
@@ -263,6 +297,7 @@ func inoutNEParam_NEParam_void(_: inout NE, _: NE) {} // OK
 /* DEFAULT: @_lifetime(1: copy 1) */
 func inoutParam_inoutNEParam_void(_: inout NE, _: inout NE) {} // OK
 
+
 func inoutNEParam_NEResult(ne: inout NE) -> NE { ne } // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow ne)' or '@_lifetime(copy ne)'}}
 
 /* DEFAULT: @_lifetime(ne: copy ne) */

test/Sema/lifetime_depend_infer_defaults.swift

@@ -18,6 +18,60 @@ struct NEImmortal: ~Escapable {
 
 struct MutNE: ~Copyable & ~Escapable {}
 
+// =============================================================================
+// Same-type default rule
+// =============================================================================
+
+/* DEFAULT: @_lifetime(copy ne) */
+// CHECK: @$s30lifetime_depend_infer_defaults13sameTypeParam2neAA2NEVAE_tF : $@convention(thin) (@guaranteed NE) -> @lifetime(copy 0) @owned NE
+func sameTypeParam(ne: NE) -> NE { ne }
+
+/* DEFAULT: @_lifetime(copy ne) */
+// CHECK: @$s30lifetime_depend_infer_defaults22sameTypeConsumingParam2neAA2NEVAEn_tF : $@convention(thin) (@owned NE) -> @lifetime(copy 0) @owned NE
+func sameTypeConsumingParam(ne: consuming NE) -> NE { ne }
+
+/* DEFAULT: @_lifetime(copy ne) */
+// CHECK: @$s30lifetime_depend_infer_defaults22sameTypeBorrowingParam2neAA2NEVAE_tF : $@convention(thin) (@guaranteed NE) -> @lifetime(copy 0) @owned NE
+func sameTypeBorrowingParam(ne: borrowing NE) -> NE { ne }
+
+/* DEFAULT: @_lifetime(copy ne, copy ne2) */
+// CHECK: @$s30lifetime_depend_infer_defaults014sameTypeParam_efG03ne13ne2AA2NEVAF_AFtF : $@convention(thin) (@guaranteed NE, @guaranteed NE) -> @lifetime(copy 0, copy 1) @owned NE
+func sameTypeParam_sameTypeParam(ne1: NE, ne2: NE) -> NE { ne1 }
+
+/* DEFAULT: @_lifetime(copy ne) */
+// CHECK: @$s30lifetime_depend_infer_defaults019sameTypeParam_otherfG02ne1cAA2NEVAF_AA1CCtF : $@convention(thin) (@guaranteed NE, @guaranteed C) -> @lifetime(copy 0) @owned NE
+func sameTypeParam_otherTypeParam(ne: NE, c: C) -> NE { ne }
+
+/* DEFAULT: @_lifetime(copy ne) */
+// CHECK: @$s30lifetime_depend_infer_defaults014sameTypeParam_ef5InoutG02ne5mutNEAA0K0VAF_AFztF : $@convention(thin) (@guaranteed NE, @lifetime(copy 1) @inout NE) -> @lifetime(copy 0) @owned NE
+func sameTypeParam_sameTypeInoutParam(ne: NE, mutNE: inout NE) -> NE { ne }
+
+struct NonEscapableSelf: ~Escapable {
+  /* DEFAULT: @_lifetime(copy self) */
+  // CHECK: $s30lifetime_depend_infer_defaults16NonEscapableSelfV08sameTypeG8_noParamACyF : $@convention(method) (@guaranteed NonEscapableSelf) -> @lifetime(copy 0) @owned NonEscapableSelf
+  func sameTypeSelf_noParam() -> Self { self }
+
+  /* DEFAULT: @_lifetime(copy self) */
+  // CHECK: @$s30lifetime_depend_infer_defaults16NonEscapableSelfV017sameTypeConsumingG8_noParamACyF : $@convention(method) (@owned NonEscapableSelf) -> @lifetime(copy 0) @owned NonEscapableSelf
+  consuming func sameTypeConsumingSelf_noParam() -> Self { self }
+
+  /* DEFAULT: @_lifetime(copy self) */
+  // CHECK: @$s30lifetime_depend_infer_defaults16NonEscapableSelfV017sameTypeBorrowingG8_noParamACyF : $@convention(method) (@guaranteed NonEscapableSelf) -> @lifetime(copy 0) @owned NonEscapableSelf
+  borrowing func sameTypeBorrowingSelf_noParam() -> Self { self }
+
+  /* DEFAULT: @_lifetime(copy self, copy ne) */
+  // CHECK: @$s30lifetime_depend_infer_defaults16NonEscapableSelfV08sameTypeg1_hI5Param2neA2C_tF : $@convention(method) (@guaranteed NonEscapableSelf, @guaranteed NonEscapableSelf) -> @lifetime(copy 0, copy 1) @owned NonEscapableSelf
+  func sameTypeSelf_sameTypeParam(ne: NonEscapableSelf) -> Self { self }
+
+  /* DEFAULT: @_lifetime(copy self) */
+  // CHECK: @$s30lifetime_depend_infer_defaults16NonEscapableSelfV08sameTypeg6_otherI5Param1cAcA1CC_tF : $@convention(method) (@guaranteed C, @guaranteed NonEscapableSelf) -> @lifetime(copy 1) @owned NonEscapableSelf
+  func sameTypeSelf_otherTypeParam(c: C) -> Self { self }
+
+  /* DEFAULT: @_lifetime(copy self) */
+  // CHECK: @$s30lifetime_depend_infer_defaults16NonEscapableSelfV08sameTypeg1_hI10InoutParam5mutNEA2Cz_tF : $@convention(method) (@lifetime(copy 0) @inout NonEscapableSelf, @guaranteed NonEscapableSelf) -> @lifetime(copy 1) @owned NonEscapableSelf
+  func sameTypeSelf_sameTypeInoutParam(mutNE: inout NonEscapableSelf) -> Self { self }
+}
+
 // =============================================================================
 // Single parameter default rule for functions
 // =============================================================================
@@ -112,7 +166,8 @@ struct EscapableTrivialSelf {
 func inoutNEParam_void(ne: inout NE) {} // OK
 
 /* DEFAULT: @_lifetime(0: copy 0) */
-// CHECK: @$s30lifetime_depend_infer_defaults013inoutNEParam_F5_voidyyAA2NEVz_ADtF : $@convention(thin) (@lifetime(copy 0) @inout NE, @guaranteed NE) -> ()
+// CHECK: @$s30lifetime_depend_infer_defaults013inoutNEParam_F5_voidyyAA2NEVz_ADtF : $@convention(thin) (@lifetime(copy
+// 0, copy 1) @inout NE, @guaranteed NE) -> ()
 func inoutNEParam_NEParam_void(_: inout NE, _: NE) {} // OK
 
 /* DEFAULT: @_lifetime(0: copy 0) */

test/Sema/lifetime_depend_noattr.swift

@@ -13,18 +13,18 @@
 struct EmptyNonEscapable: ~Escapable {} // OK - no dependence
 
 // Don't allow non-Escapable return values.
-func neReturn(span: RawSpan) -> RawSpan { span } // expected-error{{cannot infer the lifetime dependence scope on a function with a ~Escapable parameter, specify '@_lifetime(borrow span)' or '@_lifetime(copy span)'}}
+func neReturn(span: RawSpan) -> RawSpan { span }
 
 func neInout(span: inout RawSpan) {} // OK - inferred
 
 struct S {
-  func neReturn(span: RawSpan) -> RawSpan { span } // expected-error{{a method with a ~Escapable result requires '@_lifetime(...)}}
+  func neReturn(span: RawSpan) -> RawSpan { span }
 
   func neInout(span: inout RawSpan) {} // OK - inferred
 }
 
 class C {
-  func neReturn(span: RawSpan) -> RawSpan { span } // expected-error{{a method with a ~Escapable result requires '@_lifetime(...)'}}
+  func neReturn(span: RawSpan) -> RawSpan { span }
 
   func neInout(span: inout RawSpan) {} // OK - inferred
 }