Merge pull request swiftlang#70548 from kavon/ncgenerics-stdlib-building-v3

[NCGenerics] Even more fixes for building the stdlib (Part 3)

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/DiagnosticsSema.def

@@ -7586,6 +7586,10 @@ WARNING(redundant_inverse_constraint,none,
 ERROR(inverse_on_class, none,
       "classes cannot be '~%0'",
       (StringRef))
+ERROR(inverse_with_class_constraint, none,
+      "composition involving %select{class requirement %2|'AnyObject'}0 "
+      "cannot contain '~%1'",
+      (bool, StringRef, Type))
 ERROR(inverse_extension, none,
       "cannot apply inverse %0 to extension",
       (Type))

include/swift/AST/Expr.h

@@ -3393,6 +3393,10 @@ class ErasureExpr final : public ImplicitConversionExpr,
     Bits.ErasureExpr.NumArgumentConversions = argConversions.size();
     std::uninitialized_copy(argConversions.begin(), argConversions.end(),
                             getTrailingObjects<ConversionPair>());
+
+    assert(llvm::all_of(conformances, [](ProtocolConformanceRef ref) {
+      return !ref.isInvalid();
+    }));
   }
 
 public:

include/swift/AST/Module.h

@@ -853,6 +853,13 @@ class ModuleDecl
   ProtocolConformanceRef conformsToProtocol(Type sourceTy,
                                             ProtocolDecl *targetProtocol);
 
+  /// Collect the conformances of \c fromType each of the protocols of an
+  /// existential type's layout.
+  ArrayRef<ProtocolConformanceRef>
+  collectExistentialConformances(CanType fromType, CanType existential,
+                                 bool skipConditionalRequirements = true,
+                                 bool allowMissing = false);
+
   /// Find a member named \p name in \p container that was declared in this
   /// module.
   ///

include/swift/AST/ProtocolConformanceRef.h

@@ -128,7 +128,7 @@ class ProtocolConformanceRef {
   /// Determine whether this conformance (or a conformance it depends on)
   /// involves a "missing" conformance anywhere. Such conformances
   /// cannot be depended on to always exist.
-  bool hasMissingConformance(ModuleDecl *module) const;
+  bool hasMissingConformance() const;
 
   /// Enumerate the missing conformances in this conformance.
   ///
@@ -140,7 +140,6 @@ class ProtocolConformanceRef {
   /// \returns \c true if any invocation of \c fn returned true,
   /// \c false otherwise.
   bool forEachMissingConformance(
-      ModuleDecl *module,
       llvm::function_ref<bool(BuiltinProtocolConformance *missing)> fn) const;
 
   using OpaqueValue = void*;

include/swift/AST/TypeCheckRequests.h

@@ -323,6 +323,34 @@ class ExistentialConformsToSelfRequest :
   void cacheResult(bool value) const;
 };
 
+class CollectExistentialConformancesRequest
+    : public SimpleRequest<CollectExistentialConformancesRequest,
+                           ArrayRef<ProtocolConformanceRef>(ModuleDecl*,
+                                                            CanType,
+                                                            CanType,
+                                                            bool,
+                                                            bool),
+                           RequestFlags::Uncached> { // TODO: maybe cache this?
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ArrayRef<ProtocolConformanceRef>
+      evaluate(Evaluator &evaluator,
+               ModuleDecl *module,
+               CanType fromType,
+               CanType existential,
+               bool skipConditionalRequirements,
+               bool allowMissing) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 /// Determine whether an existential type conforming to this protocol
 /// requires the \c any syntax.
 class HasSelfOrAssociatedTypeRequirementsRequest :

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -100,6 +100,13 @@ SWIFT_REQUEST(TypeChecker, EnumRawTypeRequest,
               Type(EnumDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ExistentialConformsToSelfRequest,
               bool(ProtocolDecl *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CollectExistentialConformancesRequest,
+            ArrayRef<ProtocolConformanceRef>(ModuleDecl*,
+                                             CanType,
+                                             CanType,
+                                             bool,
+                                             bool),
+            Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasSelfOrAssociatedTypeRequirementsRequest,
               bool(ProtocolDecl *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ExtendedTypeRequest, Type(ExtensionDecl *), Cached,

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

@@ -1470,6 +1470,10 @@ static void reconstituteInverses(GenericSignature genericSig,
   for (auto tp : typeParams) {
     assert(tp);
 
+    // Any generic parameter with a superclass bound could not have an inverse.
+    if (genericSig->getSuperclassBound(tp))
+      continue;
+
     auto defaults = InverseRequirement::expandDefault(tp);
     for (auto ip : defaults) {
       auto *proto = ctx.getProtocol(getKnownProtocolKind(ip));

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 {
@@ -6560,9 +6558,14 @@ bool ProtocolDecl::walkInheritedProtocols(
 }
 
 bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
+  assert(super);
+
   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 +6574,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);