[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

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,42 @@ 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()) {
+      CanType selfTy = dc->getSelfTypeInContext()->getCanonicalType();
+      if (selfTy == 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,46 @@ 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 {
+  init(ne: NonEscapableSelf) {}
+
+  init(c: C) {} // expected-error{{cannot borrow the lifetime of 'c', which has consuming ownership on an initializer}}
+
+  init(ne: NonEscapableSelf, c: C) {}
+
+  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 +111,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 +241,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 +264,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 +303,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,68 @@ 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 ne) */
+  // CHECK: @$s30lifetime_depend_infer_defaults16NonEscapableSelfV2neA2C_tcfC : $@convention(method) (@owned NonEscapableSelf, @thin NonEscapableSelf.Type) -> @lifetime(copy 0) @owned NonEscapableSelf
+  init(ne: NonEscapableSelf) {}
+
+  /* DEFAULT: @_lifetime(copy ne) */
+  // CHECK: @$s30lifetime_depend_infer_defaults16NonEscapableSelfV2ne1cA2C_AA1CCtcfC : $@convention(method) (@owned NonEscapableSelf, @owned C, @thin NonEscapableSelf.Type) -> @lifetime(copy 0) @owned NonEscapableSelf
+  init(ne: NonEscapableSelf, c: C) {}
+
+  /* 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 +174,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
 }