[NCGenerics] ensure ExistentialLayout is minimal

Instead of injecting Copyable & Escapable protocols into every
ExistentialLayout, only add those protocols if the existing protocols
don't already imply them. This simplifies things like `any Error`
protocol, so it still only lists one protocol in its existential layout.
But existentials like `any NoCopyP` still end up with a Copyable in its
layout.

Author: kavon

include/swift/AST/Decl.h

@@ -5171,6 +5171,10 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// Determine whether this protocol inherits from the given ("super")
   /// protocol.
   bool inheritsFrom(const ProtocolDecl *Super) const;
+
+  /// Determine whether this protocol requires conformance to `IP`, without
+  /// querying a generic signature.
+  bool requiresInvertible(InvertibleProtocolKind ip) const;
 
   SourceLoc getStartLoc() const { return ProtocolLoc; }
   SourceRange getSourceRange() const {
@@ -5216,9 +5220,9 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// semantics but has no corresponding witness table.
   bool isMarkerProtocol() const;
 
-  /// Determine whether this is an invertible protocol,
-  /// i.e., for a protocol P, the inverse constraint ~P exists.
-  bool isInvertibleProtocol() const;
+  /// Determine if this is an invertible protocol and return its kind,
+  /// i.e., for a protocol P, returns the kind if inverse constraint ~P exists.
+  llvm::Optional<InvertibleProtocolKind> getInvertibleProtocolKind() const;
 
 private:
   void computeKnownProtocolKind() const;

include/swift/AST/Types.h

@@ -5873,6 +5873,7 @@ class ProtocolCompositionType final : public TypeBase,
     private llvm::TrailingObjects<ProtocolCompositionType, Type> {
   friend TrailingObjects;
 
+  // The inverse constraints `& ~IP` that are part of this composition.
   InvertibleProtocolSet Inverses;
 
 public:

lib/AST/Decl.cpp

@@ -6414,14 +6414,12 @@ bool ProtocolDecl::isMarkerProtocol() const {
   return getAttrs().hasAttribute<MarkerAttr>();
 }
 
-bool ProtocolDecl::isInvertibleProtocol() const {
-  if (auto kp = getKnownProtocolKind()) {
-    if (getInvertibleProtocolKind(*kp)) {
-      assert(isMarkerProtocol());
-      return true;
-    }
-  }
-  return false;
+llvm::Optional<InvertibleProtocolKind>
+ProtocolDecl::getInvertibleProtocolKind() const {
+  if (auto kp = getKnownProtocolKind())
+    return ::getInvertibleProtocolKind(*kp);
+
+  return llvm::None;
 }
 
 ArrayRef<ProtocolDecl *> ProtocolDecl::getInheritedProtocols() const {
@@ -6563,6 +6561,9 @@ bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
   if (this == super)
     return false;
 
+  if (auto ip = super->getInvertibleProtocolKind())
+    return requiresInvertible(*ip);
+
   return walkInheritedProtocols([super](ProtocolDecl *inherited) {
     if (inherited == super)
       return TypeWalker::Action::Stop;
@@ -6571,6 +6572,30 @@ bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
   });
 }
 
+bool ProtocolDecl::requiresInvertible(InvertibleProtocolKind ip) const {
+  // HACK: until we enable Feature::NoncopyableGenerics in the stdlib,
+  // hardcode the fact that an invertible protocol does not require any other!
+  if (getInvertibleProtocolKind())
+    return false;
+
+  auto kp = ::getKnownProtocolKind(ip);
+  return walkInheritedProtocols([kp, ip](ProtocolDecl *proto) {
+    if (proto->isSpecificProtocol(kp))
+      return TypeWalker::Action::Stop; // it is required.
+
+    switch (proto->getMarking(ip).getInverse().getKind()) {
+    case InverseMarking::Kind::None:
+      return TypeWalker::Action::Stop; // it is required.
+
+    case InverseMarking::Kind::LegacyExplicit:
+    case InverseMarking::Kind::Explicit:
+    case InverseMarking::Kind::Inferred:
+      // the implicit requirement was suppressed on this protocol, keep looking.
+      return TypeWalker::Action::Continue;
+    }
+  });
+}
+
 bool ProtocolDecl::requiresClass() const {
   return evaluateOrDefault(getASTContext().evaluator,
     ProtocolRequiresClassRequest{const_cast<ProtocolDecl *>(this)}, false);

lib/AST/Type.cpp

@@ -345,8 +345,11 @@ bool TypeBase::allowsOwnership(const GenericSignatureImpl *sig) {
 }
 
 /// Adds the inferred default protocols for an ExistentialLayout with respect
-/// to that existential's inverses. For example, if an inverse ~P exists, then
-/// P will not be added to the protocols list.
+/// to that existential's inverses and existing protocols. For example, if an
+/// inverse ~P exists, then P will not be added to the protocols list.
+///
+/// Similarly, if the protocols list has a protocol Q that already implies
+/// Copyable, then we will not add `Copyable` to the protocols list.
 ///
 /// \param inverses the inverses '& ~P' that are in the existential's type.
 /// \param protocols the output vector of protocols for an ExistentialLayout
@@ -360,11 +363,25 @@ static void expandDefaultProtocols(
   if (!ctx.LangOpts.hasFeature(swift::Feature::NoncopyableGenerics))
     return;
 
-  // Try to add all invertible protocols, unless an inverse was provided.
+  // Try to add all invertible protocols, unless:
+  //  - an inverse was provided
+  //  - an existing protocol already requires it
   for (auto ip : InvertibleProtocolSet::full()) {
     if (inverses.contains(ip))
       continue;
 
+    // This matches with `lookupExistentialConformance`'s use of 'inheritsFrom'.
+    bool alreadyRequired = false;
+    for (auto proto : protocols) {
+      if (proto->requiresInvertible(ip)) {
+        alreadyRequired = true;
+        break;
+      }
+    }
+
+    if (alreadyRequired)
+      continue;
+
     auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
     assert(proto);
 

lib/Sema/MiscDiagnostics.cpp

@@ -415,7 +415,7 @@ static void diagSyntacticUseRestrictions(const Expr *E, const DeclContext *DC,
 
       auto layout = castType->getExistentialLayout();
       for (auto proto : layout.getProtocols()) {
-        if (proto->isMarkerProtocol() && !proto->isInvertibleProtocol()) {
+        if (proto->isMarkerProtocol() && !proto->getInvertibleProtocolKind()) {
           // can't conditionally cast to a marker protocol
           Ctx.Diags.diagnose(cast->getLoc(), diag::marker_protocol_cast,
                              proto->getName());