[AST] Generalize is_same_metatype builtin to take unconstrained metatypes

The builtin’s current is signature is:

```
(Any.Type, Any.Type) -> Bool
```

This needs to be changed to this:

```
(any (~Copyable & ~Escapable).Type, any (~Copyable & ~Escapable).Type) -> Bool
```

This requires a bit of support work in AST synthesis.

rdar://145707064

Co-authored-by: Alejandro Alonso <[email protected]>

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/Types.h

@@ -6359,6 +6359,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

@@ -3860,6 +3860,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=*/{},