Merge pull request #71697 from meg-gupta/enableinference

Enable lifetime dependence inference when NonescapableTypes is on

Author: meg-gupta

include/swift/AST/DiagnosticsSema.def

@@ -7845,6 +7845,10 @@ ERROR(lifetime_dependence_cannot_use_infer, none,
        (StringRef))
 ERROR(lifetime_dependence_on_bitwise_copyable, none,
       "invalid lifetime dependence on bitwise copyable type", ())
+ERROR(lifetime_dependence_cannot_infer_implicit_init, none,
+      "cannot infer lifetime dependence on implicit initializer of ~Escapable"
+      " type, define an initializer with explicit lifetime dependence"
+      " specifiers", ())
 
 //===----------------------------------------------------------------------===//
 //                             MARK: Transferring

include/swift/Basic/LangOptions.h

@@ -563,7 +563,7 @@ namespace swift {
     bool EnableExperimentalAssociatedTypeInference = false;
 
     /// Enable implicit lifetime dependence for ~Escapable return types.
-    bool EnableExperimentalLifetimeDependenceInference = false;
+    bool EnableExperimentalLifetimeDependenceInference = true;
 
     /// Enables dumping type witness systems from associated type inference.
     bool DumpTypeWitnessSystems = false;

lib/Sema/LifetimeDependence.cpp

@@ -317,6 +317,11 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd, Type resultType) {
                                                     ownership);
   }
 
+  auto *cd = dyn_cast<ConstructorDecl>(afd);
+  if (cd && cd->isImplicit() && cd->getParameters()->size() == 0) {
+    return std::nullopt;
+  }
+
   LifetimeDependenceInfo lifetimeDependenceInfo;
   ParamDecl *candidateParam = nullptr;
   unsigned paramIndex = 0;
@@ -349,6 +354,11 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd, Type resultType) {
 
     paramIndex++;
   }
+  if (cd && cd->isImplicit()) {
+    diags.diagnose(cd->getLoc(),
+                   diag::lifetime_dependence_cannot_infer_implicit_init);
+    return std::nullopt;
+  }
   if (!candidateParam && !hasParamError) {
     diags.diagnose(returnLoc,
                    diag::lifetime_dependence_cannot_infer_no_candidates);

test/Generics/inverse_extension_signatures.swift

@@ -63,14 +63,14 @@
 // CHECK-NEXT: (normal_conformance type="Outer<A>" protocol="Copyable"
 // CHECK-NEXT:   (requirement "A" conforms_to "Copyable"))
 
-// CHECK-LABEL: ExtensionDecl line=0 base=Freestanding<T>
-// CHECK-NEXT: (normal_conformance type="Freestanding<T>" protocol="Copyable"
-// CHECK-NEXT:   (requirement "T" conforms_to "Copyable"))
-  
 // CHECK-LABEL: ExtensionDecl line=0 base=Freestanding<T>
 // CHECK-NEXT: (normal_conformance type="Freestanding<T>" protocol="Escapable"
 // CHECK-NEXT:   (requirement "T" conforms_to "Escapable"))
 
+// CHECK-LABEL: ExtensionDecl line=0 base=Freestanding<T>
+// CHECK-NEXT: (normal_conformance type="Freestanding<T>" protocol="Copyable"
+// CHECK-NEXT:   (requirement "T" conforms_to "Copyable"))
+  
 public struct Outer<A: ~Copyable> {
   public func innerFn<B: ~Copyable>(_ b: borrowing B) {}
   public struct InnerStruct<C: ~Copyable> {

test/Generics/inverse_generics.swift

@@ -266,10 +266,16 @@ struct NonescapingType: ~Escapable {}
 
 struct Wraps: ~Escapable {
   let x: MaybeEscapes<NonescapingType>
+  init(_ x: consuming MaybeEscapes<NonescapingType>) {
+    self.x = x
+  }
 }
 
 struct NonescapeDoesNotAllowNoncopyable: ~Escapable { // expected-note {{consider adding '~Copyable' to struct 'NonescapeDoesNotAllowNoncopyable'}}
   let x: NC // expected-error {{stored property 'x' of 'Copyable'-conforming struct 'NonescapeDoesNotAllowNoncopyable' has non-Copyable type 'NC'}}
+  init(_ x: borrowing NC) {
+    self.x = x
+  }
 }
 
 enum MaybeEscapes<T: ~Escapable> { // expected-note {{generic enum 'MaybeEscapes' has '~Escapable' constraint on a generic parameter, making its 'Escapable' conformance conditional}}

test/ModuleInterface/noncopyable_generics.swift

@@ -123,7 +123,13 @@ import NoncopyableGenerics_Misc
 // Synthesized conditional conformances are next
 
 // CHECK-MISC: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-MISC-NEXT: extension {{.*}}.Hello : Swift.Copyable where T : ~Escapable {
+// CHECK-MISC-NEXT: extension NoncopyableGenerics_Misc.Hello : Swift.Escapable where T : ~Copyable {
+// CHECK-MISC-NEXT: }
+// CHECK-MISC-NEXT: #endif
+// CHECK-MISC: #if compiler(>=5.3) && $NoncopyableGenerics
+// CHECK-MISC-NEXT: extension NoncopyableGenerics_Misc.Hello : Swift.Copyable where T : ~Escapable {
+// CHECK-MISC-NEXT: }
+// CHECK-MISC-NEXT: #endif
 
 // FIXME: (rdar://123293620) inner struct extensions are not feature-guarded correctly
 // CHECK-MISC: extension {{.*}}.Outer.InnerStruct : Swift.Copyable {
@@ -132,10 +138,10 @@ import NoncopyableGenerics_Misc
 // CHECK-MISC: extension {{.*}}.Outer : Swift.Copyable {
 
 // CHECK-MISC: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-MISC-NEXT: extension {{.*}}.Freestanding : Swift.Copyable where T : ~Escapable {
+// CHECK-MISC-NEXT: extension {{.*}}.Freestanding : Swift.Escapable where T : ~Copyable {
 
 // CHECK-MISC: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-MISC-NEXT: extension {{.*}}.Freestanding : Swift.Escapable where T : ~Copyable {
+// CHECK-MISC-NEXT: extension {{.*}}.Freestanding : Swift.Copyable where T : ~Escapable {
 
 ////////////////////////////////////////////////////////////////////////
 //    At the end, ensure there are no synthesized Copyable extensions

test/SIL/Parser/basic2_noncopyable_generics.sil

@@ -26,8 +26,11 @@ struct NCG<T> : ~Copyable {
   deinit
 }
 
-// CHECK-LABEL: struct NEG<T> : ~Escapable {
+// CHECK-LABEL: struct NEG<T> : ~Escapable where T : ~Escapable {
 // CHECK-NEXT:    var t: T
-struct NEG<T> : ~Escapable {
+struct NEG<T : ~Escapable> : ~Escapable {
   var t: T
+  init(_ t: consuming T) {
+    self.t = t
+  }
 }

test/SILOptimizer/lifetime_dependence_borrow.swift

@@ -28,6 +28,12 @@ struct BV {
 struct NCNE : ~Copyable {
   let p: UnsafeRawPointer
   let c: Int
+  
+  @_unsafeNonescapableResult
+  init(_ p: UnsafeRawPointer, _ c: Int) {
+    self.p = p
+    self.c = c
+  }
 
   // Requires a borrow.
   borrowing func getBV() -> _borrow(self) BV {

test/SILOptimizer/lifetime_dependence_diagnostics.swift

@@ -13,6 +13,11 @@
 struct BV {
   let p: UnsafeRawPointer
   let c: Int
+  @_unsafeNonescapableResult
+  init(_ p: UnsafeRawPointer, _ c: Int) {
+    self.p = p
+    self.c = c
+  }
 }
 
 func bv_copy(_ bv: borrowing BV) -> _copy(bv) BV {

test/SILOptimizer/lifetime_dependence_util.sil

@@ -39,11 +39,15 @@ sil_vtable D {
 @_nonescapable
 struct NE {
   var d: D
+  @_unsafeNonescapableResult
+  init() { }
 }
 
 @_nonescapable
 struct NEWrap {
   var ne: NE
+  @_unsafeNonescapableResult
+  init() { }
 }
 
 sil @coroutine : $@yield_once @convention(method) (@guaranteed NE) -> @yields @guaranteed NE