Merge pull request #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);

lib/AST/Module.cpp

@@ -1568,6 +1568,19 @@ void ModuleDecl::getDisplayDecls(SmallVectorImpl<Decl*> &Results, bool Recursive
 #endif
 }
 
+ArrayRef<ProtocolConformanceRef>
+ModuleDecl::collectExistentialConformances(CanType fromType,
+                                           CanType existential,
+                                           bool skipConditionalRequirements,
+                                           bool allowMissing) {
+  CollectExistentialConformancesRequest request{this,
+                                                fromType,
+                                                existential,
+                                                skipConditionalRequirements,
+                                                allowMissing};
+  return evaluateOrDefault(getASTContext().evaluator, request, /*default=*/{});
+}
+
 ProtocolConformanceRef
 ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   ASTContext &ctx = getASTContext();
@@ -1696,7 +1709,7 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
   // replace the result with an "invalid" result.
   if (!allowMissing &&
       shouldCreateMissingConformances(type, protocol) &&
-      result.hasMissingConformance(this))
+      result.hasMissingConformance())
     return ProtocolConformanceRef::forInvalid();
 
   return result;

lib/AST/ProtocolConformanceRef.cpp

@@ -118,6 +118,13 @@ ProtocolConformanceRef::subst(Type origType, InFlightSubstitution &IFS) const {
     return ProtocolConformanceRef::forInvalid();
   }
 
+  // If the type has been fully substituted and the requirement is for
+  // an invertible protocol, just do a module lookup. This avoids an infinite
+  // substitution issue by recognizing that these protocols are very simple
+  // (see rdar://119950540 for the general issue).
+  if (!substType->hasTypeParameter() && proto->getInvertibleProtocolKind())
+    return proto->getModuleContext()->lookupConformance(substType, proto);
+
   // Check the conformance map.
   // FIXME: Pack element level?
   return IFS.lookupConformance(origType->getCanonicalType(), substType, proto,
@@ -312,22 +319,21 @@ bool ProtocolConformanceRef::hasUnavailableConformance() const {
   return false;
 }
 
-bool ProtocolConformanceRef::hasMissingConformance(ModuleDecl *module) const {
-  return forEachMissingConformance(module,
+bool ProtocolConformanceRef::hasMissingConformance() const {
+  return forEachMissingConformance(
       [](BuiltinProtocolConformance *builtin) {
         return true;
       });
 }
 
 bool ProtocolConformanceRef::forEachMissingConformance(
-    ModuleDecl *module,
     llvm::function_ref<bool(BuiltinProtocolConformance *missing)> fn) const {
   if (isInvalid() || isAbstract())
     return false;
 
   if (isPack()) {
     for (auto conformance : getPack()->getPatternConformances()) {
-      if (conformance.forEachMissingConformance(module, fn))
+      if (conformance.forEachMissingConformance(fn))
         return true;
     }
 
@@ -345,7 +351,7 @@ bool ProtocolConformanceRef::forEachMissingConformance(
   // Check conformances that are part of this conformance.
   auto subMap = concreteConf->getSubstitutionMap();
   for (auto conformance : subMap.getConformances()) {
-    if (conformance.forEachMissingConformance(module, fn))
+    if (conformance.forEachMissingConformance(fn))
       return true;
   }
 

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -564,11 +564,23 @@ void RequirementMachine::computeRequirementDiagnostics(
                                                 getGenericParams());
 
   // Check that the generic parameters with inverses truly lack the conformance.
-  for (auto const& inverse : inverses)
-    if (requiresProtocol(inverse.subject, inverse.protocol))
+  for (auto const& inverse : inverses) {
+    // The Superclass and AnyObject checks here are based on the assumption that
+    // a class cannot have an inverse applied to it. As a result, the existence
+    // of a superclass bound always implies the existence of the conformance.
+    // Thus, an inverse being present is a conflict.
+    //
+    // While AnyObject doesn't imply the conformance in the signature, we don't
+    // want a generic parameter to be a class that can't be copied, since we
+    // don't allow that for concrete classes today. Thus, we artificially
+    // prevent AnyObject from being mixed with inverses.
+    if (requiresProtocol(inverse.subject, inverse.protocol) ||
+        getSuperclassBound(inverse.subject, getGenericParams()) ||
+        requiresClass(inverse.subject))
       errors.push_back(
           RequirementError::forConflictingInverseRequirement(inverse,
                                                              inverse.loc));
+  }
 }
 
 std::string RequirementMachine::getRuleAsStringForDiagnostics(

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -820,6 +820,11 @@ void swift::rewriting::applyInverses(
     inverses[canSubject] = state;
   }
 
+  // Fast-path: if there are no valid inverses, then there are no requirements
+  // to be removed.
+  if (inverses.empty())
+    return;
+
   // Scan the structural requirements and cancel out any inferred requirements
   // based on the inverses we saw.
   result.erase(llvm::remove_if(result, [&](StructuralRequirement structReq) {