Merge pull request #73258 from lorentey/you-cannot-escape-optionals

[stdlib] Generalize some constructs for non-escapable types

Author: lorentey

include/swift/AST/ASTContext.h

@@ -682,6 +682,11 @@ class ASTContext final {
   /// Retrieve the type Swift.Any as an existential type.
   CanType getAnyExistentialType() const;
 
+  /// Retrieve the existential type 'any ~Copyable & ~Escapable'.
+  ///
+  /// This is the most permissive existential type.
+  CanType getUnconstrainedAnyExistentialType() const;
+
   /// Retrieve the type Swift.AnyObject as a constraint.
   CanType getAnyObjectConstraint() const;
 
@@ -1043,6 +1048,9 @@ class ASTContext final {
   const CanType TheEmptyTupleType;        /// This is '()', aka Void
   const CanType TheEmptyPackType;
   const CanType TheAnyType;               /// This is 'Any', the empty protocol composition
+  const CanType TheUnconstrainedAnyType;  /// This is 'any ~Copyable & ~Escapable',
+                                          /// the empty protocol composition
+                                          /// without any implicit constraints.
 #define SINGLETON_TYPE(SHORT_ID, ID) \
   const CanType The##SHORT_ID##Type;
 #include "swift/AST/TypeNodes.def"

include/swift/AST/ASTSynthesis.h

@@ -57,7 +57,8 @@ enum SingletonTypeSynthesizer {
   _taskExecutor,   // the '_Concurrency.TaskExecutor' protocol
   _actor,          // the '_Concurrency.Actor' protocol
   _distributedActor,  // the 'Distributed.DistributedActor' protocol
-  _unsafeRawBufferPointer // UnsafeRawBufferPointer
+  _unsafeRawBufferPointer, // UnsafeRawBufferPointer
+  _unconstrainedAny, // any ~Copyable & ~Escapable
 };
 inline Type synthesizeType(SynthesisContext &SC,
                            SingletonTypeSynthesizer kind) {
@@ -98,6 +99,8 @@ inline Type synthesizeType(SynthesisContext &SC,
   case _escapable:
     return SC.Context.getProtocol(KnownProtocolKind::Escapable)
         ->getDeclaredInterfaceType();
+  case _unconstrainedAny:
+    return SC.Context.getUnconstrainedAnyExistentialType();
   }
 }
 

include/swift/AST/Builtins.def

@@ -582,7 +582,8 @@ BUILTIN_MISC_OPERATION(IsConcrete, "isConcrete", "n", Special)
 /// IsBitwiseTakable has type T.Type -> Bool
 BUILTIN_MISC_OPERATION(IsBitwiseTakable, "isbitwisetakable", "n", Special)
 
-/// IsSameMetatype has type (Any.Type, Any.Type) -> Bool
+/// IsSameMetatype has type
+/// (any (~Copyable & ~Escapable).Type, any (~Copyable & ~Escapable).Type) -> Bool
 BUILTIN_MISC_OPERATION(IsSameMetatype, "is_same_metatype", "n", Special)
 
 /// AllocRaw has type (Int, Int) -> Builtin.RawPointer

include/swift/AST/LifetimeDependence.h

@@ -247,8 +247,12 @@ class LifetimeDependenceInfo {
         targetIndex(targetIndex) {
     assert(this->isImmortal() || inheritLifetimeParamIndices ||
            scopeLifetimeParamIndices);
-    assert(!inheritLifetimeParamIndices ||
-           !inheritLifetimeParamIndices->isEmpty());
+    // FIXME: This assert can trigger when Optional/Result support ~Escapable use (rdar://147765187)
+    // assert(!inheritLifetimeParamIndices ||
+    //        !inheritLifetimeParamIndices->isEmpty());
+    if (inheritLifetimeParamIndices && inheritLifetimeParamIndices->isEmpty()) {
+      inheritLifetimeParamIndices = nullptr;
+    }
     assert(!scopeLifetimeParamIndices || !scopeLifetimeParamIndices->isEmpty());
     assert((!addressableParamIndices
             || !conditionallyAddressableParamIndices

include/swift/AST/Types.h

@@ -6362,6 +6362,12 @@ class ProtocolCompositionType final : public TypeBase,
   /// Constructs a protocol composition corresponding to the `Any` type.
   static Type theAnyType(const ASTContext &C);
 
+  /// Constructs a protocol composition corresponding to the `any ~Copyable &
+  /// ~Escapable` type.
+  ///
+  /// Note: This includes the inverse of all current invertible protocols.
+  static Type theUnconstrainedAnyType(const ASTContext &C);
+
   /// Constructs a protocol composition corresponding to the `AnyObject` type.
   static Type theAnyObjectType(const ASTContext &C);
 

lib/AST/ASTContext.cpp

@@ -815,6 +815,8 @@ ASTContext::ASTContext(
       TheEmptyTupleType(TupleType::get(ArrayRef<TupleTypeElt>(), *this)),
       TheEmptyPackType(PackType::get(*this, {})),
       TheAnyType(ProtocolCompositionType::theAnyType(*this)),
+      TheUnconstrainedAnyType(
+          ProtocolCompositionType::theUnconstrainedAnyType(*this)),
 #define SINGLETON_TYPE(SHORT_ID, ID) \
     The##SHORT_ID##Type(new (*this, AllocationArena::Permanent) \
                           ID##Type(*this)),
@@ -1326,6 +1328,10 @@ CanType ASTContext::getAnyExistentialType() const {
   return ExistentialType::get(TheAnyType)->getCanonicalType();
 }
 
+CanType ASTContext::getUnconstrainedAnyExistentialType() const {
+  return ExistentialType::get(TheUnconstrainedAnyType)->getCanonicalType();
+}
+
 CanType ASTContext::getAnyObjectConstraint() const {
   if (getImpl().AnyObjectType) {
     return getImpl().AnyObjectType;

lib/AST/Builtins.cpp

@@ -1108,8 +1108,8 @@ static ValueDecl *getIsOptionalOperation(ASTContext &ctx, Identifier id) {
 
 static ValueDecl *getIsSameMetatypeOperation(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id, _thin,
-                            _parameters(_existentialMetatype(_any),
-                                        _existentialMetatype(_any)),
+                            _parameters(_existentialMetatype(_unconstrainedAny),
+                                        _existentialMetatype(_unconstrainedAny)),
                             _int(1));
 }
 

lib/AST/Type.cpp

@@ -3858,6 +3858,15 @@ Type ProtocolCompositionType::theAnyType(const ASTContext &C) {
                                       /*HasExplicitAnyObject=*/false);
 }
 
+/// Constructs a protocol composition corresponding to the `any ~Copyable &
+/// ~Escapable` type.
+///
+/// Note: This includes the inverse of all current invertible protocols.
+Type ProtocolCompositionType::theUnconstrainedAnyType(const ASTContext &C) {
+  return ProtocolCompositionType::get(C, {}, InvertibleProtocolSet::allKnown(),
+                                      /*HasExplicitAnyObject=*/false);
+}
+
 /// Constructs a protocol composition containing the `AnyObject` constraint.
 Type ProtocolCompositionType::theAnyObjectType(const ASTContext &C) {
   return ProtocolCompositionType::get(C, {}, /*Inverses=*/{},

stdlib/public/core/Builtin.swift

@@ -165,13 +165,19 @@ internal func != (lhs: Builtin.RawPointer, rhs: Builtin.RawPointer) -> Bool {
 ///   - t1: Another type to compare.
 /// - Returns: `true` if both `t0` and `t1` are `nil` or if they represent the
 ///   same type; otherwise, `false`.
-@inlinable @_transparent
-public func == (t0: Any.Type?, t1: Any.Type?) -> Bool {
+@_alwaysEmitIntoClient
+@_transparent
+public func == (
+  t0: (any (~Copyable & ~Escapable).Type)?,
+  t1: (any (~Copyable & ~Escapable).Type)?
+) -> Bool {
   switch (t0, t1) {
-  case (.none, .none): return true
+  case (.none, .none):
+    return true
   case let (.some(ty0), .some(ty1)):
     return Bool(Builtin.is_same_metatype(ty0, ty1))
-  default: return false
+  default:
+    return false
   }
 }
 
@@ -182,11 +188,35 @@ public func == (t0: Any.Type?, t1: Any.Type?) -> Bool {
 ///   - t1: Another type to compare.
 /// - Returns: `true` if one, but not both, of `t0` and `t1` are `nil`, or if
 ///   they represent different types; otherwise, `false`.
-@inlinable @_transparent
-public func != (t0: Any.Type?, t1: Any.Type?) -> Bool {
-  return !(t0 == t1)
+@_alwaysEmitIntoClient
+@_transparent
+public func != (
+  t0: (any (~Copyable & ~Escapable).Type)?,
+  t1: (any (~Copyable & ~Escapable).Type)?
+) -> Bool {
+  !(t0 == t1)
 }
 
+#if !$Embedded
+// Embedded Swift is unhappy about conversions from `Any.Type` to
+// `any (~Copyable & ~Escapable).Type` (rdar://145706221)
+@usableFromInline
+@_spi(SwiftStdlibLegacyABI) @available(swift, obsoleted: 1)
+internal func == (t0: Any.Type?, t1: Any.Type?) -> Bool {
+  switch (t0, t1) {
+  case (.none, .none): return true
+  case let (.some(ty0), .some(ty1)):
+    return Bool(Builtin.is_same_metatype(ty0, ty1))
+  default: return false
+  }
+}
+
+@usableFromInline
+@_spi(SwiftStdlibLegacyABI) @available(swift, obsoleted: 1)
+internal func != (t0: Any.Type?, t1: Any.Type?) -> Bool {
+  !(t0 == t1)
+}
+#endif
 
 /// Tell the optimizer that this code is unreachable if condition is
 /// known at compile-time to be true.  If condition is false, or true
@@ -940,9 +970,11 @@ func _trueAfterDiagnostics() -> Builtin.Int1 {
 ///
 /// - Parameter value: The value for which to find the dynamic type.
 /// - Returns: The dynamic type, which is a metatype instance.
-@_transparent
+@_alwaysEmitIntoClient
 @_semantics("typechecker.type(of:)")
-public func type<T, Metatype>(of value: T) -> Metatype {
+public func type<T: ~Copyable & ~Escapable, Metatype>(
+  of value: borrowing T
+) -> Metatype {
   // This implementation is never used, since calls to `Swift.type(of:)` are
   // resolved as a special case by the type checker.
   unsafe Builtin.staticReport(_trueAfterDiagnostics(), true._value,
@@ -951,6 +983,17 @@ public func type<T, Metatype>(of value: T) -> Metatype {
   Builtin.unreachable()
 }
 
+@_spi(SwiftStdlibLegacyABI) @available(swift, obsoleted: 1)
+@_silgen_name("$ss4type2ofq_x_tr0_lF")
+@usableFromInline
+func __abi_type<T, Metatype>(of value: T) -> Metatype {
+  // This is a legacy entry point for the original definition of `type(of:)`
+  // that the stdlib originally exported for no good reason. The current
+  // definition no longer exports a symbol, and nothing is expected to link to
+  // it, but we keep it around anyway.
+  Builtin.unreachable()
+}
+
 /// Allows a nonescaping closure to temporarily be used as if it were allowed
 /// to escape.
 ///

stdlib/public/core/CompilerProtocols.swift

@@ -266,8 +266,9 @@ public protocol CaseIterable {
 /// `Optional` type conforms to `ExpressibleByNilLiteral`.
 /// `ExpressibleByNilLiteral` conformance for types that use `nil` for other
 /// purposes is discouraged.
-public protocol ExpressibleByNilLiteral: ~Copyable {
+public protocol ExpressibleByNilLiteral: ~Copyable, ~Escapable {
   /// Creates an instance initialized with `nil`.
+  @lifetime(immortal)
   init(nilLiteral: ())
 }