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: ())
 }