[stdlib] Optional: Allow non-escapable wrapped types

Author: lorentey

stdlib/public/core/Optional.swift

@@ -118,7 +118,7 @@
 /// Unconditionally unwrapping a `nil` instance with `!` triggers a runtime
 /// error.
 @frozen
-public enum Optional<Wrapped: ~Copyable>: ~Copyable {
+public enum Optional<Wrapped: ~Copyable & ~Escapable>: ~Copyable, ~Escapable {
   // The compiler has special knowledge of Optional<Wrapped>, including the fact
   // that it is an `enum` with cases named `none` and `some`.
 
@@ -132,14 +132,17 @@ public enum Optional<Wrapped: ~Copyable>: ~Copyable {
   case some(Wrapped)
 }
 
-extension Optional: Copyable where Wrapped: Copyable {}
+extension Optional: Copyable where Wrapped: Copyable /*& ~Escapable */ {}
+extension Optional: Escapable where Wrapped: Escapable /*& ~Copyable */ {}
 
-extension Optional: Sendable where Wrapped: ~Copyable & Sendable { }
+extension Optional: BitwiseCopyable where Wrapped: BitwiseCopyable {}
+// FIXME: Maybe BitwiseCopyable shouldn't require Escapability
+
+extension Optional: Sendable where Wrapped: ~Copyable & ~Escapable & Sendable {}
 
-extension Optional: BitwiseCopyable where Wrapped: BitwiseCopyable { }
 
 @_preInverseGenerics
-extension Optional: ExpressibleByNilLiteral where Wrapped: ~Copyable {
+extension Optional: ExpressibleByNilLiteral where Wrapped: ~Copyable & ~Escapable {
   /// Creates an instance initialized with `nil`.
   ///
   /// Do not call this initializer directly. It is used by the compiler when you
@@ -151,12 +154,12 @@ extension Optional: ExpressibleByNilLiteral where Wrapped: ~Copyable {
   /// initializer behind the scenes.
   @_transparent
   @_preInverseGenerics
-  public init(nilLiteral: ()) {
+  public init(nilLiteral: ()) -> dependsOn(immortal) Self {
     self = .none
   }
 }
 
-extension Optional where Wrapped: ~Copyable {
+extension Optional where Wrapped: ~Copyable & Escapable {
   /// Creates an instance that stores the given value.
   @_transparent
   @_preInverseGenerics

test/stdlib/Optional.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift
+// RUN: %target-run-simple-swift(-enable-experimental-feature NonescapableTypes)
 // REQUIRES: executable_test
 // REQUIRES: reflection
 
@@ -426,4 +426,62 @@ OptionalTests.test("unsafelyUnwrapped nil")
 }
 #endif
 
+func isCopyable<T: ~Copyable & ~Escapable>(_: T.Type) -> Bool { false }
+func isCopyable<T: ~Escapable>(_: T.Type) -> Bool { true }
+
+func isBitwiseCopyable<T: ~Copyable & ~Escapable>(_: T.Type) -> Bool { false }
+func isBitwiseCopyable<T: BitwiseCopyable & ~Escapable>(_: T.Type) -> Bool { true }
+
+#if $NonescapableTypes
+func isEscapable<T: ~Escapable & ~Copyable>(_: T.Type) -> Bool { false }
+func isEscapable<T: ~Copyable>(_: T.Type) -> Bool { true }
+#endif
+
+struct TrivialStruct {}
+struct NoncopyableStruct: ~Copyable {}
+class RegularClass {}
+
+#if $NonescapableTypes
+struct NonescapableStruct: ~Escapable, BitwiseCopyable {}
+struct NoncopyableNonescapableStruct: ~Copyable, ~Escapable {}
+struct NonescapableNontrivialStruct: ~Escapable {
+  let foo: RegularClass? = nil
+}
+#endif
+
+OptionalTests.test("Copyability") {
+  expectTrue(isCopyable(Optional<TrivialStruct>.self))
+  expectFalse(isCopyable(Optional<NoncopyableStruct>.self))
+  expectTrue(isCopyable(Optional<RegularClass>.self))
+#if $NonescapableTypes
+  expectTrue(isCopyable(Optional<NonescapableStruct>.self))
+  expectFalse(isCopyable(Optional<NoncopyableNonescapableStruct>.self))
+  expectTrue(isCopyable(Optional<NonescapableNontrivialStruct>.self))
+#endif
+}
+
+OptionalTests.test("BitwiseCopyability") {
+  expectTrue(isBitwiseCopyable(Optional<TrivialStruct>.self))
+  expectFalse(isBitwiseCopyable(Optional<NoncopyableStruct>.self))
+  expectFalse(isBitwiseCopyable(Optional<RegularClass>.self))
+#if $NonescapableTypes
+  // FIXME: Should this be true?
+  expectFalse(isBitwiseCopyable(Optional<NonescapableStruct>.self))
+
+  expectFalse(isBitwiseCopyable(Optional<NoncopyableNonescapableStruct>.self))
+  expectFalse(isBitwiseCopyable(Optional<NonescapableNontrivialStruct>.self))
+#endif
+}
+
+#if $NonescapableTypes
+OptionalTests.test("Escapability") {
+  expectTrue(isEscapable(Optional<TrivialStruct>.self))
+  expectTrue(isEscapable(Optional<NoncopyableStruct>.self))
+  expectTrue(isEscapable(Optional<RegularClass>.self))
+  expectFalse(isEscapable(Optional<NonescapableStruct>.self))
+  expectFalse(isEscapable(Optional<NoncopyableNonescapableStruct>.self))
+  expectFalse(isEscapable(Optional<NonescapableNontrivialStruct>.self))
+}
+#endif
+
 runAllTests()