Merge pull request #71303 from slavapestov/ncgenerics-fixes-2

Non-copyable generics fixes part 2

Author: slavapestov

include/swift/AST/GenericSignature.h

@@ -465,9 +465,22 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Given a type parameter, compute the most specific supertype (upper bound),
   /// possibly dependent on other type parameters.
   ///
+  ///
+  /// \param forExistentialSelf If true, we ensure the result does not include
+  /// any type parameters rooted in the same generic parameter as the one given.
+  ///
+  /// \param includeParameterizedProtocols If true, we form parameterized
+  /// protocol types if we find that the given type's primary associated types
+  /// are sufficiently constrained.
+  ///
   /// \note If the upper bound is a protocol or protocol composition,
   /// will return an instance of \c ExistentialType.
-  Type getUpperBound(Type type) const;
+  Type getUpperBound(Type type,
+                     bool forExistentialSelf,
+                     bool includeParameterizedProtocols) const;
+
+  /// Utility wrapper for use when this is an opened existential signature.
+  Type getExistentialType(Type type) const;
 
   static void Profile(llvm::FoldingSetNodeID &ID,
                       ArrayRef<GenericTypeParamType *> genericParams,

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

@@ -3842,6 +3842,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/GenericSignature.cpp

@@ -667,58 +667,91 @@ unsigned GenericSignatureImpl::getGenericParamOrdinal(
   return GenericParamKey(param).findIndexIn(getGenericParams());
 }
 
-Type GenericSignatureImpl::getUpperBound(Type type) const {
+Type GenericSignatureImpl::getUpperBound(Type type,
+                                         bool forExistentialSelf,
+                                         bool includeParameterizedProtocols) const {
   assert(type->isTypeParameter());
 
   llvm::SmallVector<Type, 2> types;
   unsigned rootDepth = type->getRootGenericParam()->getDepth();
 
+  auto accept = [forExistentialSelf, rootDepth](Type t) {
+    if (!forExistentialSelf)
+      return true;
+
+    return !t.findIf([rootDepth](Type t) {
+      if (auto *paramTy = t->getAs<GenericTypeParamType>())
+        return (paramTy->getDepth() == rootDepth);
+      return false;
+    });
+  };
+
+  // We start with the assumption we'll add a '& AnyObject' member to our
+  // composition, but we might clear this below.
   bool hasExplicitAnyObject = requiresClass(type);
 
-  if (Type superclass = getSuperclassBound(type)) {
+  // Look for the most derived superclass that does not involve the type
+  // being erased.
+  Type superclass = getSuperclassBound(type);
+  if (superclass) {
     do {
       superclass = getReducedType(superclass);
-
-      if (!superclass.findIf([&](Type t) {
-            if (auto *paramTy = t->getAs<GenericTypeParamType>())
-              return (paramTy->getDepth() == rootDepth);
-            return false;
-          })) {
+      if (accept(superclass))
         break;
-      }
     } while ((superclass = superclass->getSuperclass()));
 
+    // If we're going to have a superclass, we can drop the '& AnyObject'.
     if (superclass) {
-      types.push_back(superclass);
+      types.push_back(getSugaredType(superclass));
       hasExplicitAnyObject = false;
     }
   }
 
+  auto &ctx = getASTContext();
+
+  // Record the absence of Copyable and Escapable conformance, but only if
+  // we didn't have a superclass or require AnyObject.
+  InvertibleProtocolSet inverses;
+
+  if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS ||
+      ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    if (!superclass && !hasExplicitAnyObject) {
+      for (auto ip : InvertibleProtocolSet::full()) {
+        auto *kp = ctx.getProtocol(::getKnownProtocolKind(ip));
+        if (!requiresProtocol(type, kp))
+          inverses.insert(ip);
+      }
+    }
+  }
+
   for (auto *proto : getRequiredProtocols(type)) {
+    if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS ||
+      ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+      // Don't add invertible protocols to the composition, because we recorded
+      // their absence above.
+      if (proto->getInvertibleProtocolKind())
+        continue;
+    }
+
     if (proto->requiresClass())
       hasExplicitAnyObject = false;
 
     auto *baseType = proto->getDeclaredInterfaceType()->castTo<ProtocolType>();
 
     auto primaryAssocTypes = proto->getPrimaryAssociatedTypes();
-    if (!primaryAssocTypes.empty()) {
+    if (includeParameterizedProtocols && !primaryAssocTypes.empty()) {
       SmallVector<Type, 2> argTypes;
 
       // Attempt to recover same-type requirements on primary associated types.
       for (auto *assocType : primaryAssocTypes) {
         // For each primary associated type A of P, compute the reduced type
         // of T.[P]A.
-        auto *memberType = DependentMemberType::get(type, assocType);
-        auto reducedType = getReducedType(memberType);
+        auto memberType = getReducedType(DependentMemberType::get(type, assocType));
 
         // If the reduced type is at a lower depth than the root generic
         // parameter of T, then it's constrained.
-        if (!reducedType.findIf([&](Type t) {
-            if (auto *paramTy = t->getAs<GenericTypeParamType>())
-              return (paramTy->getDepth() == rootDepth);
-            return false;
-          })) {
-          argTypes.push_back(reducedType);
+        if (accept(memberType)) {
+          argTypes.push_back(getSugaredType(memberType));
         }
       }
 
@@ -740,15 +773,18 @@ Type GenericSignatureImpl::getUpperBound(Type type) const {
     types.push_back(baseType);
   }
 
-  auto constraint = ProtocolCompositionType::get(getASTContext(), types,
-                                                 hasExplicitAnyObject);
-
-  if (!constraint->isConstraintType()) {
-    assert(constraint->getClassOrBoundGenericClass());
-    return constraint;
-  }
+  return ProtocolCompositionType::get(ctx, types, inverses,
+                                      hasExplicitAnyObject);
+}
 
-  return ExistentialType::get(constraint);
+Type GenericSignatureImpl::getExistentialType(Type paramTy) const {
+  auto upperBound = getUpperBound(paramTy,
+                                  /*forExistentialSelf=*/true,
+                                  /*includeParameterizedProtocols=*/true);
+  if (upperBound->isConstraintType())
+    return ExistentialType::get(upperBound);
+  assert(upperBound->getClassOrBoundGenericClass());
+  return upperBound;
 }
 
 void GenericSignature::Profile(llvm::FoldingSetNodeID &id) const {

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;
@@ -3727,9 +3731,8 @@ Type ArchetypeType::getExistentialType() const {
   auto interfaceType = getInterfaceType();
   auto genericSig = genericEnv->getGenericSignature();
 
-  auto upperBound = genericSig->getUpperBound(interfaceType);
-
-  return genericEnv->mapTypeIntoContext(upperBound);
+  auto existentialType = genericSig->getExistentialType(interfaceType);
+  return genericEnv->mapTypeIntoContext(existentialType);
 }
 
 bool ArchetypeType::requiresClass() const {
@@ -4010,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,
@@ -4056,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.
@@ -5347,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));
       }