AST: Update callers of ProtocolCompositionType::get() to handle inverses

And remove the old overload.

Author: slavapestov

include/swift/AST/Types.h

@@ -5943,24 +5943,21 @@ class ProtocolCompositionType final : public TypeBase,
 
 public:
   /// Retrieve an instance of a protocol composition type with the
-  /// given set of members. A "hidden member" is an implicit constraint that
-  /// is present for all protocol compositions.
-  ///
-  /// \param Members the regular members of this composition.
-  /// \param Inverses the set of inverses that are a member of the composition,
-  ///                 i.e., if \c IP is in this set, then \c ~IP is a member of
-  ///                 this composition.
-  /// \param HasExplicitAnyObject indicates whether this composition should be
-  /// treated as if \c AnyObject was a member.
+  /// given set of members.
+  ///
+  /// This presents a syntactic view of the world, where an empty composition
+  /// has implicit Copyable and Escapable members, unless they are supressed
+  /// with the Inverses field.
+  ///
+  /// The list of members consists of zero or more ProtocolType,
+  /// ProtocolCompositionType, ParameterizedProtocolType, together with at
+  /// most one ClassType or BoundGenericClassType.
+  ///
+  /// HasExplicitAnyObject is the 'AnyObject' member.
   static Type get(const ASTContext &C, ArrayRef<Type> Members,
                   InvertibleProtocolSet Inverses,
                   bool HasExplicitAnyObject);
 
-  /// Retrieve an instance of a protocol composition type with the
-  /// given set of members. Assumes no inverses are present in \c Members.
-  static Type get(const ASTContext &C, ArrayRef<Type> Members,
-                  bool HasExplicitAnyObject);
-
   /// Constructs a protocol composition corresponding to the `Any` type.
   static Type theAnyType(const ASTContext &C);
 

lib/AST/ASTContext.cpp

@@ -3837,6 +3837,15 @@ ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Members,
                                bool HasExplicitAnyObject) {
   assert(Members.size() != 1 || HasExplicitAnyObject || !Inverses.empty());
 
+#ifndef NDEBUG
+  for (auto member : Members) {
+    if (auto *proto = member->getAs<ProtocolType>()) {
+      assert(!proto->getDecl()->getInvertibleProtocolKind() &&
+             "Should have been folded away");
+    }
+  }
+#endif
+
   // Check to see if we've already seen this protocol composition before.
   void *InsertPos = nullptr;
   llvm::FoldingSetNodeID ID;

lib/AST/ASTDemangler.cpp

@@ -673,7 +673,10 @@ Type ASTBuilder::createProtocolCompositionType(
   if (superclass && superclass->getClassOrBoundGenericClass())
     members.push_back(superclass);
 
-  Type composition = ProtocolCompositionType::get(Ctx, members, isClassBound);
+  // FIXME: move-only generics
+  InvertibleProtocolSet inverses;
+  Type composition = ProtocolCompositionType::get(Ctx, members, inverses,
+                                                  isClassBound);
   if (forRequirement)
     return composition;
 

lib/AST/ExistentialGeneralization.cpp

@@ -107,6 +107,7 @@ class Generalizer : public CanTypeVisitor<Generalizer, Type> {
       newMembers.push_back(generalizeStructure(origMember));
     }
     return ProtocolCompositionType::get(ctx, newMembers,
+                                        origType->getInverses(),
                                         origType->hasExplicitAnyObject());
   }
 

lib/AST/Type.cpp

@@ -1141,6 +1141,7 @@ Type TypeBase::stripConcurrency(bool recurse, bool dropGlobalActor) {
     if (!newMembers.empty()) {
       return ProtocolCompositionType::get(
           getASTContext(), newMembers,
+          protocolCompositionType->getInverses(),
           protocolCompositionType->hasExplicitAnyObject());
     }
 
@@ -1606,18 +1607,20 @@ static void addProtocols(Type T,
                          SmallVectorImpl<ProtocolDecl *> &Protocols,
                          ParameterizedProtocolMap &Parameterized,
                          Type &Superclass,
+                         InvertibleProtocolSet &Inverses,
                          bool &HasExplicitAnyObject) {
   if (auto Proto = T->getAs<ProtocolType>()) {
     Protocols.push_back(Proto->getDecl());
     return;
   }
 
   if (auto PC = T->getAs<ProtocolCompositionType>()) {
-    if (PC->hasExplicitAnyObject())
-      HasExplicitAnyObject = true;
-    for (auto P : PC->getMembers())
-      addProtocols(P, Protocols, Parameterized, Superclass,
+    Inverses.insertAll(PC->getInverses());
+    HasExplicitAnyObject |= PC->hasExplicitAnyObject();
+    for (auto P : PC->getMembers()) {
+      addProtocols(P, Protocols, Parameterized, Superclass, Inverses,
                    HasExplicitAnyObject);
+    }
     return;
   }
 
@@ -1918,6 +1921,7 @@ CanType TypeBase::computeCanonicalType() {
     assert(!CanProtos.empty() && "Non-canonical empty composition?");
     const ASTContext &C = CanProtos[0]->getASTContext();
     Type Composition = ProtocolCompositionType::get(C, CanProtos,
+                                                    PCT->getInverses(),
                                                     PCT->hasExplicitAnyObject());
     Result = Composition.getPointer();
     break;
@@ -4009,27 +4013,22 @@ bool ProtocolCompositionType::requiresClass() {
 
 /// Constructs a protocol composition corresponding to the `Any` type.
 Type ProtocolCompositionType::theAnyType(const ASTContext &C) {
-  return ProtocolCompositionType::get(C, {}, /*HasExplicitAnyObject=*/false);
+  return ProtocolCompositionType::get(C, {}, /*Inverses=*/{},
+                                      /*HasExplicitAnyObject=*/false);
 }
 
 /// Constructs a protocol composition containing the `AnyObject` constraint.
 Type ProtocolCompositionType::theAnyObjectType(const ASTContext &C) {
-  return ProtocolCompositionType::get(C, {}, /*HasExplicitAnyObject=*/true);
+  return ProtocolCompositionType::get(C, {}, /*Inverses=*/{},
+                                      /*HasExplicitAnyObject=*/true);
 }
 
 Type ProtocolCompositionType::getInverseOf(const ASTContext &C,
                                            InvertibleProtocolKind IP) {
-  return ProtocolCompositionType::get(C, {}, {IP},
+  return ProtocolCompositionType::get(C, {}, /*Inverses=*/{IP},
                                       /*HasExplicitAnyObject=*/false);
 }
 
-Type ProtocolCompositionType::get(const ASTContext &C, ArrayRef<Type> Members,
-                                  bool HasExplicitAnyObject) {
-  return ProtocolCompositionType::get(C, Members,
-                                      /*Inverses=*/{},
-                                      HasExplicitAnyObject);
-}
-
 Type ProtocolCompositionType::get(const ASTContext &C,
                                   ArrayRef<Type> Members,
                                   InvertibleProtocolSet Inverses,
@@ -4055,29 +4054,29 @@ Type ProtocolCompositionType::get(const ASTContext &C,
     if (!t->isCanonical())
       return build(C, Members, Inverses, HasExplicitAnyObject);
   }
-    
+
   Type Superclass;
   SmallVector<ProtocolDecl *, 4> Protocols;
   ParameterizedProtocolMap Parameterized;
   for (Type t : Members) {
-    addProtocols(t, Protocols, Parameterized, Superclass, HasExplicitAnyObject);
+    addProtocols(t, Protocols, Parameterized, Superclass,
+                 Inverses, HasExplicitAnyObject);
   }
 
+  // Form the set of canonical component types.
+  SmallVector<Type, 4> CanTypes;
+
   // The presence of a superclass constraint makes AnyObject redundant.
-  if (Superclass)
+  if (Superclass) {
     HasExplicitAnyObject = false;
+    CanTypes.push_back(Superclass->getCanonicalType());
+  }
 
   // If there are any parameterized protocols, the canonicalization
   // algorithm gets more complex.
-
-  // Form the set of canonical component types.
-  SmallVector<Type, 4> CanTypes;
-  if (Superclass)
-    CanTypes.push_back(Superclass->getCanonicalType());
-
   canonicalizeProtocols(Protocols, &Parameterized);
 
-  for (auto proto: Protocols) {
+  for (auto proto : Protocols) {
     // If we have a parameterized type for this protocol, use the
     // canonical type of that.  Sema should prevent us from building
     // compositions with the same protocol and conflicting constraints.
@@ -5346,6 +5345,7 @@ case TypeKind::Id:
 
     return ProtocolCompositionType::get(Ptr->getASTContext(),
                                         substMembers,
+                                        pc->getInverses(),
                                         pc->hasExplicitAnyObject());
   }
 

lib/AST/TypeJoinMeet.cpp

@@ -404,7 +404,8 @@ CanType TypeJoin::computeProtocolCompositionJoin(ArrayRef<Type> firstMembers,
     return TheAnyType;
 
   auto &ctx = result[0]->getASTContext();
-  return ProtocolCompositionType::get(ctx, result, false)->getCanonicalType();
+  return ProtocolCompositionType::get(ctx, result, /*inverses=*/{},
+                                      false)->getCanonicalType();
 }
 
 CanType TypeJoin::visitProtocolCompositionType(CanType second) {
@@ -431,8 +432,12 @@ CanType TypeJoin::visitProtocolCompositionType(CanType second) {
     protocolType.push_back(First);
     firstMembers = protocolType;
   } else {
+    assert(cast<ProtocolCompositionType>(First)->getInverses().empty() &&
+           "FIXME: move-only generics");
     firstMembers = cast<ProtocolCompositionType>(First)->getMembers();
   }
+  assert(cast<ProtocolCompositionType>(second)->getInverses().empty() &&
+         "FIXME: move-only generics");
   auto secondMembers = cast<ProtocolCompositionType>(second)->getMembers();
 
   return computeProtocolCompositionJoin(firstMembers, secondMembers);

lib/ClangImporter/ImportType.cpp

@@ -1243,6 +1243,7 @@ namespace {
 
         importedType = ExistentialType::get(
             ProtocolCompositionType::get(Impl.SwiftContext, members,
+                                         /*Inverses=*/{},
                                          /*HasExplicitAnyObject=*/false));
       }
 

lib/Sema/CSBindings.cpp

@@ -593,7 +593,7 @@ static Type getKeyPathType(ASTContext &ctx, KeyPathCapability capability,
     auto *sendable = ctx.getProtocol(KnownProtocolKind::Sendable);
     keyPathTy = ProtocolCompositionType::get(
         ctx, {keyPathTy, sendable->getDeclaredInterfaceType()},
-        /*hasExplicitAnyObject=*/false);
+        /*inverses=*/{}, /*hasExplicitAnyObject=*/false);
     return ExistentialType::get(keyPathTy);
   }
 
@@ -2203,6 +2203,7 @@ static Type getOptionalSuperclass(Type type) {
 
       superclass = ExistentialType::get(
           ProtocolCompositionType::get(type->getASTContext(), members,
+                                       compositionTy->getInverses(),
                                        compositionTy->hasExplicitAnyObject()));
     } else {
       // Avoid producing superclass for situations like `any P` where `P` is