Merge pull request #71821 from slavapestov/inheritance-clause-fixes

Refactor protocol inheritance clauses and existential layout for non-copyable generics

Author: slavapestov

include/swift/AST/Decl.h

@@ -4389,10 +4389,6 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// Type if it `isEscapable` instead of using this.
   CanBeInvertible::Result canBeEscapable() const;
 
-  /// Determine whether this type has `: <target>` stated explicitly in
-  /// its inheritance clause.
-  bool hasMarking(InvertibleProtocolKind target) const;
-
   /// Determine whether this type has ~<target>` stated on
   /// itself, one of its inherited types or `Self` requirements.
   InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) const;
@@ -5188,6 +5184,10 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// Retrieve the set of protocols inherited from this protocol.
   ArrayRef<ProtocolDecl *> getInheritedProtocols() const;
 
+  /// Retrieve the transitive closure of the inherited protocols, not including
+  /// this protocol itself.
+  ArrayRef<ProtocolDecl *> getAllInheritedProtocols() const;
+
   /// Determine whether this protocol has a superclass.
   bool hasSuperclass() const { return (bool)getSuperclassDecl(); }
 
@@ -5255,10 +5255,6 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// Determine whether this protocol has ~<target>` stated on
   /// itself, one of its inherited types or `Self` requirements.
   InverseMarking::Mark hasInverseMarking(InvertibleProtocolKind target) 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 {

include/swift/AST/GenericSignature.h

@@ -225,9 +225,6 @@ class GenericSignature {
   /// requirement signature against the protocol generic signature
   /// <Self where Self : P>.
   void verify(ArrayRef<Requirement> reqts) const;
-
-  /// Returns a new signature with the given parameters erased
-  GenericSignature typeErased(ArrayRef<Type> typeErasedParams) const;
 };
 
 /// A reference to a canonical generic signature.

include/swift/AST/NameLookup.h

@@ -603,7 +603,7 @@ struct InheritedNominalEntry : Located<NominalTypeDecl *> {
 void getDirectlyInheritedNominalTypeDecls(
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
     unsigned i, llvm::SmallVectorImpl<InheritedNominalEntry> &result,
-    bool &anyObject);
+    InvertibleProtocolSet &inverses, bool &anyObject);
 
 /// Retrieve the set of nominal type declarations that are directly
 /// "inherited" by the given declaration, looking through typealiases
@@ -612,7 +612,7 @@ void getDirectlyInheritedNominalTypeDecls(
 /// If we come across the AnyObject type, set \c anyObject true.
 SmallVector<InheritedNominalEntry, 4> getDirectlyInheritedNominalTypeDecls(
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
-    bool &anyObject);
+    InvertibleProtocolSet &inverses, bool &anyObject);
 
 /// Retrieve the set of nominal type declarations that appear as the
 /// constraint type of any "Self" constraints in the where clause of the

include/swift/AST/NameLookupRequests.h

@@ -58,7 +58,8 @@ void simple_display(
 
 /// Describes a set of type declarations that are "direct" referenced by
 /// a particular type in the AST.
-using DirectlyReferencedTypeDecls = llvm::TinyPtrVector<TypeDecl *>;
+using DirectlyReferencedTypeDecls = std::pair<llvm::TinyPtrVector<TypeDecl *>,
+                                              InvertibleProtocolSet>;
 
 /// Request the set of declarations directly referenced by the an "inherited"
 /// type of a type or extension declaration.
@@ -198,6 +199,25 @@ class InheritedProtocolsRequest
                            ArrayRef<ProtocolDecl *> result) const;
 };
 
+class AllInheritedProtocolsRequest
+    : public SimpleRequest<
+          AllInheritedProtocolsRequest, ArrayRef<ProtocolDecl *>(ProtocolDecl *),
+          RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ArrayRef<ProtocolDecl *>
+  evaluate(Evaluator &evaluator, ProtocolDecl *PD) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 class ProtocolRequirementsRequest
     : public SimpleRequest<ProtocolRequirementsRequest,
                            ArrayRef<ValueDecl *>(ProtocolDecl *),
@@ -270,6 +290,7 @@ class ExtendedNominalRequest
 
 struct SelfBounds {
   llvm::TinyPtrVector<NominalTypeDecl *> decls;
+  InvertibleProtocolSet inverses;
   bool anyObject = false;
 };
 

include/swift/AST/NameLookupTypeIDZone.def

@@ -47,6 +47,9 @@ SWIFT_REQUEST(NameLookup, InheritedDeclsReferencedRequest,
 SWIFT_REQUEST(NameLookup, InheritedProtocolsRequest,
               ArrayRef<ProtocolDecl *>(ProtocolDecl *), SeparatelyCached,
               NoLocationInfo)
+SWIFT_REQUEST(NameLookup, AllInheritedProtocolsRequest,
+              ArrayRef<ProtocolDecl *>(ProtocolDecl *), Cached,
+              NoLocationInfo)
 SWIFT_REQUEST(NameLookup, ProtocolRequirementsRequest,
               ArrayRef<ValueDecl *>(ProtocolDecl *), SeparatelyCached,
               NoLocationInfo)

include/swift/AST/Requirement.h

@@ -251,31 +251,11 @@ struct InverseRequirement {
 
   InvertibleProtocolKind getKind() const;
 
-  /// Adds the type parameters of this generic context to the result if
-  /// it has default requirements.
-  static void enumerateDefaultedParams(GenericContext *decl,
-                                       SmallVectorImpl<Type> &result);
-
   /// Appends additional requirements corresponding to defaults for the given
   /// generic parameters.
   static void expandDefaults(ASTContext &ctx,
                              ArrayRef<Type> gps,
                              SmallVectorImpl<StructuralRequirement> &result);
-
-  /// Adds the inferred default protocols for an assumed generic parameter with
-  /// respect to that parameter's inverses and existing required 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 applied to the generic param.
-  /// \param protocols the existing required protocols, to which defaults will
-  ///                  be appended.
-  static void expandDefaults(ASTContext &ctx,
-                             InvertibleProtocolSet inverses,
-                             SmallVectorImpl<ProtocolDecl*> &protocols);
 };
 
 } // end namespace swift

include/swift/AST/Types.h

@@ -5926,16 +5926,6 @@ class ProtocolType : public NominalType {
   /// in the protocol list, then sorting them in some stable order.
   static void canonicalizeProtocols(SmallVectorImpl<ProtocolDecl *> &protocols);
 
-  /// Visit all of the protocols in the given list of protocols, along with their
-  ///
-  /// \param fn Visitor function called for each protocol (just once). If it
-  /// returns \c true, the visit operation will abort and return \c true.
-  ///
-  /// \returns \c true if any invocation of \c fn returns \c true, and \c false
-  /// otherwise.
-  static bool visitAllProtocols(ArrayRef<ProtocolDecl *> protocols,
-                                llvm::function_ref<bool(ProtocolDecl *)> fn);
-
 private:
   friend class NominalTypeDecl;
   ProtocolType(ProtocolDecl *TheDecl, Type Parent, const ASTContext &Ctx,

include/swift/SIL/SILFunction.h

@@ -99,6 +99,9 @@ class SILSpecializeAttr final {
     Partial
   };
 
+  static GenericSignature buildTypeErasedSignature(
+      GenericSignature sig, ArrayRef<Type> typeErasedParams);
+
   static SILSpecializeAttr *create(SILModule &M,
                                    GenericSignature specializedSignature,
                                    ArrayRef<Type> typeErasedParams,

lib/APIDigester/ModuleAnalyzerNodes.cpp

@@ -1959,16 +1959,14 @@ void swift::ide::api::
 SwiftDeclCollector::addConformancesToTypeDecl(SDKNodeDeclType *Root,
                                               NominalTypeDecl *NTD) {
   if (auto *PD = dyn_cast<ProtocolDecl>(NTD)) {
-    PD->walkInheritedProtocols([&](ProtocolDecl *inherited) {
-      if (PD != inherited && !Ctx.shouldIgnore(inherited)) {
+    for (auto *inherited : PD->getAllInheritedProtocols()) {
+      if (!Ctx.shouldIgnore(inherited)) {
         ProtocolConformanceRef Conf(inherited);
         auto ConfNode = SDKNodeInitInfo(Ctx, Conf)
             .createSDKNode(SDKNodeKind::Conformance);
         Root->addConformance(ConfNode);
       }
-
-      return TypeWalker::Action::Continue;
-    });
+    }
   } else {
     // Avoid adding the same conformance twice.
     SmallPtrSet<ProtocolConformance*, 4> Seen;

lib/AST/ASTContext.cpp

@@ -3914,15 +3914,6 @@ ProtocolCompositionType::build(const ASTContext &C, ArrayRef<Type> Members,
                                bool HasExplicitAnyObject) {
   assert(Members.size() != 1 || HasExplicitAnyObject || !Inverses.empty());
 
-#ifndef NDEBUG
-  for (auto member : Members) {
-    if (auto *proto = member->getAs<ProtocolType>()) {
-      assert(!proto->getDecl()->getInvertibleProtocolKind() &&
-             "Should have been folded away");
-    }
-  }
-#endif
-
   // Check to see if we've already seen this protocol composition before.
   void *InsertPos = nullptr;
   llvm::FoldingSetNodeID ID;

lib/AST/AccessRequests.cpp

@@ -248,7 +248,7 @@ DefaultAndMaxAccessLevelRequest::evaluate(Evaluator &evaluator,
 
     // Try to scope the extension's access to the least public type mentioned
     // in its where clause.
-    for (auto *typeDecl : typeDecls) {
+    for (auto *typeDecl : typeDecls.first) {
       if (isa<TypeAliasDecl>(typeDecl) || isa<NominalTypeDecl>(typeDecl)) {
         auto scope = typeDecl->getFormalAccessScope(ED->getDeclContext());
         maxScope = maxScope->intersectWith(scope);

lib/AST/ConformanceLookupTable.cpp

@@ -209,9 +209,10 @@ void ConformanceLookupTable::forEachInStage(ConformanceStage stage,
       }
     } else if (next->getParentSourceFile() ||
                next->getParentModule()->isBuiltinModule()) {
+      InvertibleProtocolSet inverses;
       bool anyObject = false;
       for (const auto &found :
-               getDirectlyInheritedNominalTypeDecls(next, anyObject)) {
+               getDirectlyInheritedNominalTypeDecls(next, inverses, anyObject)) {
         if (auto proto = dyn_cast<ProtocolDecl>(found.Item))
           protocols.push_back(
               {proto, found.Loc, found.uncheckedLoc, found.preconcurrencyLoc});
@@ -497,9 +498,10 @@ void ConformanceLookupTable::addInheritedProtocols(
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl,
     ConformanceSource source) {
   // Find all of the protocols in the inheritance list.
+  InvertibleProtocolSet inverses;
   bool anyObject = false;
   for (const auto &found :
-          getDirectlyInheritedNominalTypeDecls(decl, anyObject)) {
+          getDirectlyInheritedNominalTypeDecls(decl, inverses, anyObject)) {
     if (auto proto = dyn_cast<ProtocolDecl>(found.Item)) {
       addProtocol(proto, found.Loc,
                   source.withUncheckedLoc(found.uncheckedLoc)
@@ -525,6 +527,8 @@ void ConformanceLookupTable::addMacroGeneratedProtocols(
 
 void ConformanceLookupTable::expandImpliedConformances(NominalTypeDecl *nominal,
                                                        DeclContext *dc) {
+  ASTContext &ctx = nominal->getASTContext();
+
   // Note: recursive type-checking implies that AllConformances
   // may be reallocated during this traversal, so pay the lookup cost
   // during each iteration.
@@ -544,16 +548,23 @@ void ConformanceLookupTable::expandImpliedConformances(NominalTypeDecl *nominal,
         isa<EnumDecl>(nominal) && nominal->isObjC() &&
         cast<EnumDecl>(nominal)->hasCases() &&
         cast<EnumDecl>(nominal)->hasOnlyCasesWithoutAssociatedValues()) {
-      ASTContext &ctx = nominal->getASTContext();
       if (auto bridgedNSError
             = ctx.getProtocol(KnownProtocolKind::BridgedNSError)) {
         addProtocol(bridgedNSError, SourceLoc(),
                     ConformanceSource::forImplied(conformanceEntry));
       }
     }
 
-    addInheritedProtocols(conformingProtocol,
-                          ConformanceSource::forImplied(conformanceEntry));
+    auto source = ConformanceSource::forImplied(conformanceEntry);
+    for (auto *inherited : conformingProtocol->getInheritedProtocols()) {
+      // Conforming a ~Copyable nominal to a protocol that inherits Copyable
+      // should not imply a Copyable conformance on the nominal.
+      if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics))
+        if (inherited->getInvertibleProtocolKind())
+          continue;
+
+      addProtocol(inherited, SourceLoc(), source);
+    }
   }
 }