[NCGenerics] fix existential conformances

I was not expanding default requirements in
AbstractGenericSignatureRequest or ExistentialLayout.

Also fixes printing of composition types.

Author: kavon

include/swift/AST/Decl.h

@@ -5179,6 +5179,10 @@ 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;
+
 private:
   void computeKnownProtocolKind() const;
 

include/swift/AST/ExistentialLayout.h

@@ -31,9 +31,9 @@ struct ExistentialLayout {
 
   ExistentialLayout() {
     hasExplicitAnyObject = false;
-    hasInverseCopyable = false;
     containsNonObjCProtocol = false;
     containsParameterized = false;
+    representsAnyObject = false;
   }
 
   ExistentialLayout(CanProtocolType type);
@@ -47,15 +47,15 @@ struct ExistentialLayout {
   /// Whether the existential contains an explicit '& AnyObject' constraint.
   bool hasExplicitAnyObject : 1;
 
-  /// Whether the existential contains an explicit '& ~Copyable' constraint.
-  bool hasInverseCopyable : 1;
-
   /// Whether any protocol members are non-@objc.
   bool containsNonObjCProtocol : 1;
 
   /// Whether any protocol members are parameterized.s
   bool containsParameterized : 1;
 
+  /// Whether this layout is the canonical layout for plain-old 'AnyObject'.
+  bool representsAnyObject : 1;
+
   /// Return the kind of this existential (class/error/opaque).
   Kind getKind() {
     if (requiresClass())
@@ -69,7 +69,7 @@ struct ExistentialLayout {
     return Kind::Opaque;
   }
 
-  bool isAnyObject() const;
+  bool isAnyObject() const { return representsAnyObject; }
 
   bool isObjC() const {
     // FIXME: Does the superclass have to be @objc?

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/Decl.cpp

@@ -6383,6 +6383,16 @@ 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;
+}
+
 ArrayRef<ProtocolDecl *> ProtocolDecl::getInheritedProtocols() const {
   auto *mutThis = const_cast<ProtocolDecl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,

lib/AST/Module.cpp

@@ -1591,11 +1591,12 @@ 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));
+  if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)
+      && !ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    // Prior to noncopyable generics, all existentials conform to Copyable.
+        return ProtocolConformanceRef(
+            ctx.getBuiltinConformance(type, protocol,
+                                      BuiltinConformanceKind::Synthesized));
   }
 
   auto layout = type->getExistentialLayout();

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)) {

lib/AST/Type.cpp

@@ -335,44 +335,65 @@ bool TypeBase::allowsOwnership(const GenericSignatureImpl *sig) {
   return getCanonicalType().allowsOwnership(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.
+///
+/// \param inverses the inverses '& ~P' that are in the existential's type.
+/// \param protocols the output vector of protocols for an ExistentialLayout
+///                  to be modified.
+static void expandDefaultProtocols(
+    ASTContext &ctx,
+    InvertibleProtocolSet inverses,
+    SmallVectorImpl<ProtocolDecl*> &protocols) {
+
+  // Skip unless noncopyable generics is enabled
+  if (!ctx.LangOpts.hasFeature(swift::Feature::NoncopyableGenerics))
+    return;
+
+  // Try to add all invertible protocols, unless an inverse was provided.
+  for (auto ip : InvertibleProtocolSet::full()) {
+    if (inverses.contains(ip))
+      continue;
+
+    auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
+    assert(proto);
+
+    protocols.push_back(proto);
+  }
+}
+
 ExistentialLayout::ExistentialLayout(CanProtocolType type) {
   auto *protoDecl = type->getDecl();
 
   hasExplicitAnyObject = false;
-  hasInverseCopyable = false;
   containsNonObjCProtocol = !isObjCProtocol(protoDecl);
   containsParameterized = false;
+  representsAnyObject = false;
 
   protocols.push_back(protoDecl);
+
+  // NOTE: all the invertible protocols are usable from ObjC.
+  expandDefaultProtocols(type->getASTContext(), {}, protocols);
 }
 
 ExistentialLayout::ExistentialLayout(CanInverseType type) {
   hasExplicitAnyObject = false;
-  hasInverseCopyable = false;
   containsNonObjCProtocol = false;
   containsParameterized = false;
+  representsAnyObject = false;
 
-  // Handle inverse.
-  switch (type->getInverseKind()) {
-  case InvertibleProtocolKind::Copyable:
-    hasInverseCopyable = true;
-  }
+  // NOTE: all the invertible protocols are usable from ObjC.
+  expandDefaultProtocols(type->getASTContext(),
+                         {type->getInverseKind()},
+                         protocols);
 }
 
 ExistentialLayout::ExistentialLayout(CanProtocolCompositionType type) {
   hasExplicitAnyObject = type->hasExplicitAnyObject();
-  hasInverseCopyable = false;
   containsNonObjCProtocol = false;
   containsParameterized = false;
 
-  // Handle inverses.
-  for (auto ip : type->getInverses()) {
-    switch (ip) {
-    case InvertibleProtocolKind::Copyable:
-      hasInverseCopyable = true;
-    }
-  }
-
   auto members = type.getMembers();
   if (!members.empty() &&
       (members[0].getClassOrBoundGenericClass() ||
@@ -393,6 +414,12 @@ ExistentialLayout::ExistentialLayout(CanProtocolCompositionType type) {
     containsNonObjCProtocol |= !isObjCProtocol(protoDecl);
     protocols.push_back(protoDecl);
   }
+
+  representsAnyObject =
+      hasExplicitAnyObject && !explicitSuperclass && getProtocols().empty();
+
+  // NOTE: all the invertible protocols are usable from ObjC.
+  expandDefaultProtocols(type->getASTContext(), type->getInverses(), protocols);
 }
 
 ExistentialLayout::ExistentialLayout(CanParameterizedProtocolType type)
@@ -466,10 +493,6 @@ Type ExistentialLayout::getSuperclass() const {
   return Type();
 }
 
-bool ExistentialLayout::isAnyObject() const {
-  return (hasExplicitAnyObject && !explicitSuperclass && getProtocols().empty());
-}
-
 bool TypeBase::isObjCExistentialType() {
   return getCanonicalType().isObjCExistentialType();
 }

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()) {
+        if (proto->isMarkerProtocol() && !proto->isInvertibleProtocol()) {
           // can't conditionally cast to a marker protocol
           Ctx.Diags.diagnose(cast->getLoc(), diag::marker_protocol_cast,
                              proto->getName());

test/Generics/inverse_copyable_generics.swift

@@ -177,3 +177,30 @@ 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'}}
+}
+
+func project<CurValue>(_ base: CurValue) { }
+func testSpecial(_ a: Any) {
+  _openExistential(a, do: project)
+}