Merge pull request #72106 from meg-gupta/lifetimedepdiag

Loosen some lifetime dependence diagnostics

Author: meg-gupta

CMakeLists.txt

@@ -657,6 +657,10 @@ option(SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS
   "Enable experimental NoncopyableGenerics"
   FALSE)
 
+option(SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES
+  "Enable experimental NonescapableTypes"
+  FALSE)
+
 option(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING
   "Enable experimental string processing"
   FALSE)
@@ -1253,6 +1257,7 @@ if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
   message(STATUS "Concurrency Support:                ${SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY}")
   message(STATUS "Distributed Support:                ${SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED}")
   message(STATUS "NoncopyableGenerics Support:        ${SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS}")
+  message(STATUS "NonEscapableTypes Support:          ${SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES}")
   message(STATUS "String Processing Support:          ${SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING}")
   message(STATUS "Backtracing Support:                ${SWIFT_ENABLE_BACKTRACING}")
   message(STATUS "Unicode Support:                    ${SWIFT_STDLIB_ENABLE_UNICODE_DATA}")

include/swift/AST/DiagnosticsSema.def

@@ -7653,8 +7653,6 @@ NOTE(note_non_bitwise_copyable_type_indirect_enum_element,none,
      "indirect case is here", ())
 ERROR(non_bitwise_copyable_type_noncopyable,none,
       "noncopyable type cannot conform to 'BitwiseCopyable'", ())
-ERROR(non_bitwise_copyable_type_nonescapable,none,
-      "nonescapable type cannot conform to 'BitwiseCopyable'", ())
 ERROR(non_bitwise_copyable_type_cxx_nontrivial,none,
       "non-trivial C++ type cannot conform to 'BitwiseCopyable'", ())
 ERROR(non_bitwise_copyable_c_type_nontrivial,none,

lib/Sema/LifetimeDependence.cpp

@@ -178,12 +178,20 @@ LifetimeDependenceInfo::fromTypeRepr(AbstractFunctionDecl *afd, Type resultType,
       }
     }
 
-    if (ctx.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
-      auto *bitwiseCopyableProtocol =
-          ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
-      if (bitwiseCopyableProtocol && mod->checkConformance(type, bitwiseCopyableProtocol)) {
-        diags.diagnose(loc, diag::lifetime_dependence_on_bitwise_copyable);
-        return true;
+    // Diagnose when we have lifetime dependence on a type that is
+    // BitwiseCopyable & Escapable.
+    // ~Escapable types are non-trivial in SIL and we should not raise this
+    // error.
+    // TODO: Diagnose ~Escapable types are always non-trivial in SIL.
+    if (type->isEscapable()) {
+      if (ctx.LangOpts.hasFeature(Feature::BitwiseCopyable)) {
+        auto *bitwiseCopyableProtocol =
+            ctx.getProtocol(KnownProtocolKind::BitwiseCopyable);
+        if (bitwiseCopyableProtocol &&
+            mod->checkConformance(type, bitwiseCopyableProtocol)) {
+          diags.diagnose(loc, diag::lifetime_dependence_on_bitwise_copyable);
+          return true;
+        }
       }
     }
 
@@ -379,7 +387,7 @@ LifetimeDependenceInfo::infer(AbstractFunctionDecl *afd, Type resultType) {
     // TODO: rdar://123555720: Remove this check after another round of
     // surveying builtins
     if (auto *fd = dyn_cast<FuncDecl>(afd)) {
-      if (fd->isImplicit()) {
+      if (fd->isImplicit() && fd->getModuleContext()->isBuiltinModule()) {
         return std::nullopt;
       }
     }

lib/Sema/TypeCheckBitwise.cpp

@@ -239,13 +239,6 @@ static bool checkBitwiseCopyableInstanceStorage(NominalTypeDecl *nominal,
     return true;
   }
 
-  if (!dc->mapTypeIntoContext(nominal->getDeclaredInterfaceType())->isEscapable()) {
-    if (!isImplicit(check)) {
-      nominal->diagnose(diag::non_bitwise_copyable_type_nonescapable);
-    }
-    return true;
-  }
-
   if (isa<ClassDecl>(nominal)) {
     if (!isImplicit(check)) {
       nominal->diagnose(diag::non_bitwise_copyable_type_class);

stdlib/cmake/modules/SwiftSource.cmake

@@ -617,6 +617,10 @@ function(_compile_swift_files
     list(APPEND swift_flags "-Xfrontend" "-enable-experimental-associated-type-inference")
   endif()
 
+  if(SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES)
+    list(APPEND swift_flags "-enable-experimental-feature" "NonescapableTypes")
+  endif()
+
   if (SWIFT_STDLIB_ENABLE_STRICT_CONCURRENCY_COMPLETE)
     list(APPEND swift_flags "-strict-concurrency=complete")
   endif()

stdlib/public/core/Misc.swift

@@ -173,4 +173,8 @@ func _rethrowsViaClosure(_ fn: () throws -> ()) rethrows {
 
 @_marker public protocol Escapable {}
 
-@_marker public protocol _BitwiseCopyable {}
+#if $NoncopyableGenerics && $NonescapableTypes
+@_marker public protocol _BitwiseCopyable: ~Escapable { }
+#else
+@_marker public protocol _BitwiseCopyable { }
+#endif

test/CMakeLists.txt

@@ -192,6 +192,7 @@ normalize_boolean_spelling(SWIFT_ENABLE_EXPERIMENTAL_DIFFERENTIABLE_PROGRAMMING)
 normalize_boolean_spelling(SWIFT_ENABLE_EXPERIMENTAL_CONCURRENCY)
 normalize_boolean_spelling(SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED)
 normalize_boolean_spelling(SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS)
+normalize_boolean_spelling(SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES)
 normalize_boolean_spelling(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
 normalize_boolean_spelling(SWIFT_ENABLE_EXPERIMENTAL_OBSERVATION)
 normalize_boolean_spelling(SWIFT_ENABLE_MACCATALYST)
@@ -404,6 +405,10 @@ foreach(SDK ${SWIFT_SDKS})
           list(APPEND LIT_ARGS "--param" "noncopyable_generics")
         endif()
 
+        if(SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES)
+          list(APPEND LIT_ARGS "--param" "nonescapable_types")
+        endif()
+
         if(SWIFT_ENABLE_EXPERIMENTAL_STRING_PROCESSING)
           list(APPEND LIT_ARGS "--param" "string_processing")
         endif()

test/Sema/explicit_lifetime_dependence_specifiers.swift

@@ -1,11 +1,20 @@
 // RUN: %target-typecheck-verify-swift -disable-availability-checking -enable-experimental-feature NonescapableTypes -disable-experimental-parser-round-trip   -enable-experimental-feature NoncopyableGenerics -enable-experimental-feature BitwiseCopyable
 // REQUIRES: asserts
 // REQUIRES: noncopyable_generics
+// REQUIRES: nonescapable_types
 
 struct Container {
   let ptr: UnsafeRawBufferPointer
 }
 
+struct AnotherBufferView : ~Escapable, _BitwiseCopyable {
+  let ptr: UnsafeRawBufferPointer
+  @_unsafeNonescapableResult
+  init(_ ptr: UnsafeRawBufferPointer) {
+    self.ptr = ptr
+  }
+}
+
 struct BufferView : ~Escapable {
   let ptr: UnsafeRawBufferPointer
   @_unsafeNonescapableResult
@@ -16,6 +25,10 @@ struct BufferView : ~Escapable {
     self.ptr = c.ptr
     return self
   }
+  init(_ bv: borrowing AnotherBufferView) -> _borrow(bv) Self {
+    self.ptr = bv.ptr
+    return self
+  }
 }
 
 struct MutableBufferView : ~Escapable, ~Copyable {

test/lit.site.cfg.in

@@ -145,6 +145,8 @@ if "@SWIFT_ENABLE_EXPERIMENTAL_DISTRIBUTED@" == "TRUE":
     config.available_features.add('distributed')
 if "@SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS@" == "TRUE":
     config.available_features.add('noncopyable_generics')
+if "@SWIFT_ENABLE_EXPERIMENTAL_NONESCAPABLE_TYPES@" == "TRUE":
+    config.available_features.add('nonescapable_types')
 if "@SWIFT_STDLIB_STATIC_PRINT@" == "TRUE":
     config.available_features.add('stdlib_static_print')
 if "@SWIFT_STDLIB_ENABLE_UNICODE_DATA" == "TRUE":

utils/build_swift/build_swift/driver_arguments.py

@@ -1351,6 +1351,10 @@ def create_argument_parser():
            default=False,
            help='Enable experimental NoncopyableGenerics.')
 
+    option('--enable-experimental-nonescapable-types', toggle_true,
+           default=False,
+           help='Enable experimental NonescapableTypes.')
+
     option('--enable-experimental-string-processing', toggle_true,
            default=True,
            help='Enable experimental Swift string processing.')