[NCGenerics] fix existential conformances

I was not expanding default requirements in
AbstractGenericSignatureRequest.

Also fixes printing of composition types.

Author: kavon

include/swift/AST/Types.h

@@ -5790,8 +5790,6 @@ class ProtocolCompositionType final : public TypeBase,
     private llvm::TrailingObjects<ProtocolCompositionType, Type> {
   friend TrailingObjects;
 
-  // TODO(kavon): this could probably be folded into the existing Bits field
-  // or we could just store the InverseType's in the Members array.
   InvertibleProtocolSet Inverses;
 
 public:

lib/AST/ASTDumper.cpp

@@ -4340,6 +4340,14 @@ namespace {
 
       printFlag(T->hasExplicitAnyObject(), "any_object");
 
+      for (auto ip : T->getInverses()) {
+        switch (ip) {
+        case InvertibleProtocolKind::Copyable:
+          printFlag("inverse_copyable");
+          break;
+        }
+      }
+
       for (auto proto : T->getMembers()) {
         printRec(proto);
       }

lib/AST/ASTPrinter.cpp

@@ -7192,17 +7192,29 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitProtocolCompositionType(ProtocolCompositionType *T) {
-    if (T->getMembers().empty()) {
-      if (T->hasExplicitAnyObject())
-        Printer << "AnyObject";
-      else
-        Printer.printKeyword("Any", Options);
-    } else {
-      interleave(T->getMembers(), [&](Type Ty) { visit(Ty); },
-                 [&] { Printer << " & "; });
-      if (T->hasExplicitAnyObject())
-        Printer << " & AnyObject";
-    }
+    interleave(T->getMembers(), [&](Type Ty) { visit(Ty); },
+        [&] { Printer << " & "; });
+
+    bool printed = !T->getMembers().empty();
+    auto printSpecial = [&](llvm::StringRef str, bool tilde=false) {
+      if (printed)
+        Printer << " & ";
+
+      if (tilde)
+        Printer << "~";
+
+      Printer << str;
+      printed = true;
+    };
+
+    if (T->hasExplicitAnyObject())
+      printSpecial("AnyObject");
+
+    for (auto ip : T->getInverses())
+      printSpecial(getProtocolName(getKnownProtocolKind(ip)), true);
+
+    if (!printed)
+      Printer.printKeyword("Any", Options);
   }
 
   void visitParameterizedProtocolType(ParameterizedProtocolType *T) {

lib/AST/Module.cpp

@@ -1591,15 +1591,26 @@ ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   if (!protocol->existentialConformsToSelf())
     return ProtocolConformanceRef::forInvalid();
 
-  // All existentials are Copyable.
-  if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
-    return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol,
-                                  BuiltinConformanceKind::Synthesized));
-  }
-
   auto layout = type->getExistentialLayout();
 
+  // Handle conformance to invertible protocols.
+  if (auto known = protocol->getKnownProtocolKind()) {
+    if (auto ip = getInvertibleProtocolKind(*known)) {
+      switch (*ip) {
+      case InvertibleProtocolKind::Copyable: {
+        // It doesn't conform if there was a ~Copyable.
+        if (layout.hasInverseCopyable)
+          return ProtocolConformanceRef::forInvalid();
+
+        // Otherwise, it conforms concretely.
+        return ProtocolConformanceRef(
+            ctx.getBuiltinConformance(type, protocol,
+                                      BuiltinConformanceKind::Synthesized));
+      }
+      }
+    }
+  }
+
   // Due to an IRGen limitation, witness tables cannot be passed from an
   // existential to an archetype parameter, so for now we restrict this to
   // @objc protocols and marker protocols.

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -658,6 +658,13 @@ AbstractGenericSignatureRequest::evaluate(
       requirements.push_back({req, SourceLoc(), /*wasInferred=*/false});
   }
 
+  /// Next, we need to expand default requirements for the added parameters.
+  SmallVector<Type, 2> localGPs;
+  for (auto *gtpt : addedParameters)
+    localGPs.push_back(gtpt);
+
+  expandDefaultRequirements(ctx, localGPs, requirements, errors);
+
   auto &rewriteCtx = ctx.getRewriteContext();
 
   if (rewriteCtx.getDebugOptions().contains(DebugFlags::Timers)) {

test/Generics/inverse_copyable_generics.swift

@@ -177,3 +177,25 @@ extension EnumExtendo: ~Copyable {} // expected-error {{cannot apply inverse '~C
 
 extension NeedsCopyable where Self: ~Copyable {}
 // expected-error@-1 {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
+
+protocol NoCopyP: ~Copyable {}
+
+func needsCopyable<T>(_ t: T) {} // expected-note 2{{generic parameter 'T' has an implicit Copyable requirement}}
+func noCopyable(_ t: borrowing some ~Copyable) {}
+func noCopyableAndP(_ t: borrowing some NoCopyP & ~Copyable) {}
+
+func openingExistentials(_ a: borrowing any NoCopyP & ~Copyable,
+                         _ b: any NoCopyP,
+                         _ nc: borrowing any ~Copyable) {
+  needsCopyable(a) // expected-error {{noncopyable type 'any NoCopyP & ~Copyable' cannot be substituted for copyable generic parameter 'T' in 'needsCopyable'}}
+  noCopyable(a)
+  noCopyableAndP(a)
+
+  needsCopyable(b)
+  noCopyable(b)
+  noCopyableAndP(b)
+
+  needsCopyable(nc) // expected-error {{noncopyable type 'any ~Copyable' cannot be substituted for copyable generic parameter 'T' in 'needsCopyable'}}
+  noCopyable(nc)
+  noCopyableAndP(nc) // expected-error {{global function 'noCopyableAndP' requires that 'some NoCopyP & ~Copyable' conform to 'NoCopyP'}}
+}