Merge pull request #72020 from slavapestov/ncgenerics-fixes-7

Non-copyable generics fixes

Author: slavapestov

lib/AST/ASTMangler.cpp

@@ -3697,14 +3697,21 @@ static unsigned conformanceRequirementIndex(
     if (req.getKind() != RequirementKind::Conformance)
       continue;
 
+    // This is an ABI compatibility hack for noncopyable generics.
+    // We should have really been skipping marker protocols here all along,
+    // but it's too late now, so skip Copyable and Escapable specifically.
+    if (req.getProtocolDecl()->getInvertibleProtocolKind())
+      continue;
+
     if (req.getFirstType()->isEqual(entry.first) &&
         req.getProtocolDecl() == entry.second)
       return result;
 
     ++result;
   }
 
-  llvm_unreachable("Conformance access path step is missing from requirements");
+  llvm::errs() <<"Conformance access path step is missing from requirements";
+  abort();
 }
 
 void ASTMangler::appendDependentProtocolConformance(

lib/AST/ASTPrinter.cpp

@@ -7722,11 +7722,69 @@ void swift::printEnumElementsAsCases(
                   OS << ": " << getCodePlaceholder() << "\n";
                 });
 }
+/// For a protocol, don't consult getInherited() at all. Instead, rebuild
+/// the inherited types from getInheritedProtocols(), getSuperclass(), and
+/// the inverse requirement transform.
+///
+/// FIXME: This seems generally useful and should be moved elsewhere.
+static void getSyntacticInheritanceClause(const ProtocolDecl *proto,
+                                          llvm::SmallVectorImpl<InheritedEntry> &Results) {
+  auto &ctx = proto->getASTContext();
+
+  if (auto superclassTy = proto->getSuperclass()) {
+    Results.emplace_back(TypeLoc::withoutLoc(superclassTy),
+                         /*isUnchecked=*/false,
+                         /*isRetroactive=*/false,
+                         /*isPreconcurrency=*/false);
+  }
+
+  InvertibleProtocolSet inverses = InvertibleProtocolSet::full();
+
+  for (auto *inherited : proto->getInheritedProtocols()) {
+    if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+      if (auto ip = inherited->getInvertibleProtocolKind()) {
+        inverses.remove(*ip);
+        continue;
+      }
+
+      for (auto ip : InvertibleProtocolSet::full()) {
+        auto *proto = ctx.getProtocol(getKnownProtocolKind(ip));
+        if (inherited->inheritsFrom(proto))
+          inverses.remove(ip);
+      }
+    }
+
+    Results.emplace_back(TypeLoc::withoutLoc(inherited->getDeclaredInterfaceType()),
+                         /*isUnchecked=*/false,
+                         /*isRetroactive=*/false,
+                         /*isPreconcurrency=*/false);
+  }
+
+  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+    for (auto ip : inverses) {
+      InvertibleProtocolSet singleton;
+      singleton.insert(ip);
+
+      auto inverseTy = ProtocolCompositionType::get(
+          ctx, ArrayRef<Type>(), singleton,
+          /*hasExplicitAnyObject=*/false);
+      Results.emplace_back(TypeLoc::withoutLoc(inverseTy),
+                           /*isUnchecked=*/false,
+                           /*isRetroactive=*/false,
+                           /*isPreconcurrency=*/false);
+    }
+  }
+}
 
 void
 swift::getInheritedForPrinting(
     const Decl *decl, const PrintOptions &options,
     llvm::SmallVectorImpl<InheritedEntry> &Results) {
+  if (auto *proto = dyn_cast<ProtocolDecl>(decl)) {
+    getSyntacticInheritanceClause(proto, Results);
+    return;
+  }
+
   InheritedTypes inherited = InheritedTypes(decl);
 
   // Collect explicit inherited types.
@@ -7753,6 +7811,10 @@ swift::getInheritedForPrinting(
   llvm::TinyPtrVector<ProtocolDecl *> uncheckedProtocols;
   for (auto attr : decl->getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
     if (auto *proto = attr->getProtocol()) {
+      // FIXME: Reconstitute inverses here
+      if (proto->getInvertibleProtocolKind())
+        continue;
+
       // The SerialExecutor conformance is only synthesized on the root
       // actor class, so we can just test resilience immediately.
       if (proto->isSpecificProtocol(KnownProtocolKind::SerialExecutor) &&
@@ -7788,6 +7850,10 @@ swift::getInheritedForPrinting(
       continue;
     }
 
+    // FIXME: Reconstitute inverses here
+    if (proto->getInvertibleProtocolKind())
+      continue;
+
     Results.push_back({TypeLoc::withoutLoc(proto->getDeclaredInterfaceType()),
                        isUnchecked,
                        /*isRetroactive=*/false,

lib/AST/Decl.cpp

@@ -1563,6 +1563,15 @@ InheritedEntry::InheritedEntry(const TypeLoc &typeLoc)
   }
 }
 
+InheritedTypes::InheritedTypes(const TypeDecl *typeDecl) : Decl(typeDecl) {
+  Entries = typeDecl->Inherited;
+}
+
+InheritedTypes::InheritedTypes(const ExtensionDecl *extensionDecl)
+    : Decl(extensionDecl) {
+  Entries = extensionDecl->Inherited;
+}
+
 InheritedTypes::InheritedTypes(
     llvm::PointerUnion<const TypeDecl *, const ExtensionDecl *> decl)
     : Decl(decl) {
@@ -1641,15 +1650,6 @@ SourceRange InheritedTypes::getRemovalRange(unsigned i) const {
   return SourceRange(afterPriorLoc, afterMyEndLoc);
 }
 
-InheritedTypes::InheritedTypes(const TypeDecl *typeDecl) : Decl(typeDecl) {
-  Entries = typeDecl->Inherited;
-}
-
-InheritedTypes::InheritedTypes(const ExtensionDecl *extensionDecl)
-    : Decl(extensionDecl) {
-  Entries = extensionDecl->Inherited;
-}
-
 Type InheritedTypes::getResolvedType(unsigned i,
                                      TypeResolutionStage stage) const {
   ASTContext &ctx = Decl.is<const ExtensionDecl *>()

lib/ConstExtract/ConstExtract.cpp

@@ -776,6 +776,10 @@ void writeResultBuilderInformation(llvm::json::OStream &JSON,
 
   for (ProtocolDecl *Decl :
        TypeDecl->getLocalProtocols(ConformanceLookupKind::All)) {
+    // FIXME(noncopyable_generics): Should these be included?
+    if (Decl->getInvertibleProtocolKind())
+      continue;
+
     for (auto Member : Decl->getMembers()) {
       if (auto *VD = dyn_cast<swift::VarDecl>(Member)) {
         if (VD->getName() != VarDecl->getName())
@@ -840,9 +844,16 @@ void writeSubstitutedOpaqueTypeAliasDetails(
       // Ignore requirements whose subject type is that of the owner decl
       if (!Requirement.getFirstType()->isEqual(OpaqueTy.getInterfaceType()))
         continue;
-      if (Requirement.getKind() == RequirementKind::Conformance)
-        JSON.value(
-            toFullyQualifiedProtocolNameString(*Requirement.getProtocolDecl()));
+
+      if (Requirement.getKind() != RequirementKind::Conformance)
+        continue;
+
+      // FIXME(noncopyable_generics): Should these be included?
+      if (Requirement.getProtocolDecl()->getInvertibleProtocolKind())
+        continue;
+
+      JSON.value(
+          toFullyQualifiedProtocolNameString(*Requirement.getProtocolDecl()));
     }
   });
 
@@ -920,7 +931,11 @@ void writeProperties(llvm::json::OStream &JSON,
 void writeConformances(llvm::json::OStream &JSON,
                        const NominalTypeDecl &NomTypeDecl) {
   JSON.attributeArray("conformances", [&] {
-    for (auto &Protocol : NomTypeDecl.getAllProtocols()) {
+    for (auto *Protocol : NomTypeDecl.getAllProtocols()) {
+      // FIXME(noncopyable_generics): Should these be included?
+      if (Protocol->getInvertibleProtocolKind())
+        continue;
+
       JSON.value(toFullyQualifiedProtocolNameString(*Protocol));
     }
   });

lib/Index/Index.cpp

@@ -1589,8 +1589,22 @@ bool IndexSwiftASTWalker::report(ValueDecl *D) {
           return false;
       }
     } else if (auto NTD = dyn_cast<NominalTypeDecl>(D)) {
-      if (!reportInheritedTypeRefs(NTD->getInherited(), NTD))
-        return false;
+      auto *PD = dyn_cast<ProtocolDecl>(D);
+      if (PD && PD->wasDeserialized()) {
+        // Deserialized protocols don't have an inheritance clause.
+        for (auto *inherited : PD->getInheritedProtocols()) {
+          // FIXME(noncopyable_generics): Do we want to include these?
+          if (inherited->getInvertibleProtocolKind())
+            continue;
+
+          if (!reportRelatedRef(inherited, SourceLoc(), /*isImplicit=*/false,
+                                (SymbolRoleSet) SymbolRole::RelationBaseOf, PD))
+            return false;
+        }
+      } else {
+        if (!reportInheritedTypeRefs(NTD->getInherited(), NTD))
+          return false;
+      }
     }
   } else {
     // Even if we don't record a local property we still need to walk its

lib/Sema/TypeCheckAvailability.cpp

@@ -4234,6 +4234,9 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
                                        bool warnIfConformanceUnavailablePreSwift6) {
   assert(!where.isImplicit());
 
+  if (conformance.isInvalid() || conformance.isAbstract())
+    return false;
+
   if (conformance.isPack()) {
     bool diagnosed = false;
     auto *pack = conformance.getPack();
@@ -4245,12 +4248,14 @@ swift::diagnoseConformanceAvailability(SourceLoc loc,
     return diagnosed;
   }
 
-  if (conformance.isInvalid() || conformance.isAbstract())
-    return false;
-
   const ProtocolConformance *concreteConf = conformance.getConcrete();
   const RootProtocolConformance *rootConf = concreteConf->getRootConformance();
 
+  // Conformance to Copyable and Escapable doesn't have its own availability
+  // independent of the type.
+  if (rootConf->getProtocol()->getInvertibleProtocolKind())
+    return false;
+
   // Diagnose "missing" conformances where we needed a conformance but
   // didn't have one.
   auto *DC = where.getDeclContext();

lib/Serialization/Deserialization.cpp

@@ -3216,21 +3216,6 @@ class DeclDeserializer {
       decl.get<ExtensionDecl *>()->setInherited(inherited);
   }
 
-  void handleInherited(ProtocolDecl *P,
-                       ArrayRef<ProtocolDecl *> inherited) {
-    SmallVector<InheritedEntry, 2> inheritedTypes;
-    llvm::transform(inherited, std::back_inserter(inheritedTypes), [](auto *I) {
-      return InheritedEntry(TypeLoc::withoutLoc(I->getDeclaredInterfaceType()),
-                            /*isUnchecked=*/false,
-                            /*isRetroactive=*/false,
-                            /*isPreconcurrency=*/false);
-    });
-
-    P->setInherited(ctx.AllocateCopy(inheritedTypes));
-    ctx.evaluator.cacheOutput(InheritedProtocolsRequest{P},
-                              ctx.AllocateCopy(inherited));
-  }
-
 public:
   DeclDeserializer(ModuleFile &MF, Serialized<Decl *> &declOrOffset)
       : MF(MF), ctx(MF.getContext()), declOrOffset(declOrOffset) {}
@@ -4517,7 +4502,8 @@ class DeclDeserializer {
     if (!MF.readInheritedProtocols(inherited))
       return MF.diagnoseFatal();
 
-    handleInherited(proto, inherited);
+    ctx.evaluator.cacheOutput(InheritedProtocolsRequest{proto},
+                              ctx.AllocateCopy(inherited));
 
     auto genericParams = MF.maybeReadGenericParams(DC);
     assert(genericParams && "protocol with no generic parameters?");
@@ -8256,7 +8242,7 @@ void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,
     auto maybeConformance = getConformanceChecked(conformanceID);
     if (maybeConformance) {
       reqConformances.push_back(maybeConformance.get());
-    } else if (allowCompilerErrors()) {
+    } else if (getContext().LangOpts.EnableDeserializationRecovery) {
       diagnoseAndConsumeError(maybeConformance.takeError());
       reqConformances.push_back(ProtocolConformanceRef::forInvalid());
     } else {

lib/SymbolGraphGen/Edge.cpp

@@ -47,13 +47,11 @@ void Edge::serialize(llvm::json::OStream &OS) const {
       SmallVector<Requirement, 4> FilteredRequirements;
       filterGenericRequirements(
           ConformanceExtension->getGenericRequirements(),
-          ConformanceExtension->getExtendedNominal()
-              ->getDeclContext()->getSelfNominalTypeDecl(),
+          ConformanceExtension->getExtendedProtocolDecl(),
           FilteredRequirements);
       if (!FilteredRequirements.empty()) {
         OS.attributeArray("swiftConstraints", [&](){
-          for (const auto &Req :
-               ConformanceExtension->getGenericRequirements()) {
+          for (const auto &Req : FilteredRequirements) {
             ::serialize(Req, OS);
           }
         });

lib/SymbolGraphGen/JSON.cpp

@@ -216,6 +216,9 @@ swift::symbolgraphgen::filterGenericParams(
   }
 }
 
+// FIXME: This is wrong. We should instead compute the new requirements of a
+// member declaration by comparing against the generic signature of its
+// parent, with getRequirementsNotSatisfiedBy().
 static bool containsParams(swift::Type Ty, llvm::ArrayRef<const swift::GenericTypeParamType*> Others) {
   return Ty.findIf([&](swift::Type T) -> bool {
     if (auto AT = T->getAs<swift::ArchetypeType>()) {
@@ -232,20 +235,23 @@ static bool containsParams(swift::Type Ty, llvm::ArrayRef<const swift::GenericTy
 
 void swift::symbolgraphgen::filterGenericRequirements(
     ArrayRef<Requirement> Requirements,
-    const NominalTypeDecl *Self,
+    const ProtocolDecl *Self,
     SmallVectorImpl<Requirement> &FilteredRequirements,
     SubstitutionMap SubMap,
     ArrayRef<const GenericTypeParamType *> FilteredParams) {
 
   for (const auto &Req : Requirements) {
+    // FIXME: We're just dropping "Self: AnyObject", etc.
     if (Req.getKind() == RequirementKind::Layout) {
       continue;
     }
     // extension /* protocol */ Q {
     // func foo() {}
     // }
     // ignore Self : Q, obvious
-    if (Req.getSecondType()->getAnyNominal() == Self) {
+    if (Self &&
+        Req.getKind() == RequirementKind::Conformance &&
+        Req.getProtocolDecl() == Self) {
       continue;
     }
 
@@ -274,21 +280,31 @@ void swift::symbolgraphgen::filterGenericRequirements(
 void
 swift::symbolgraphgen::filterGenericRequirements(const ExtensionDecl *Extension,
     SmallVectorImpl<Requirement> &FilteredRequirements) {
-  for (const auto &Req : Extension->getGenericRequirements()) {
-    if (Req.getKind() == RequirementKind::Layout) {
-      continue;
-    }
+  auto Sig = Extension->getGenericSignature();
+  if (!Sig)
+    return;
 
-    if (!isa<ProtocolDecl>(Extension->getExtendedNominal()) &&
-        Req.getFirstType()->isEqual(Extension->getExtendedType())) {
+  SmallVector<Requirement, 2> Reqs;
+  SmallVector<InverseRequirement, 2> InverseReqs;
+  Sig->getRequirementsWithInverses(Reqs, InverseReqs);
+  // FIXME(noncopyable_generics): Do something with InverseReqs, or just use
+  // getRequirements() above and update the tests.
+
+  for (const auto &Req : Reqs) {
+    if (Req.getKind() == RequirementKind::Layout) {
       continue;
     }
 
     // extension /* protocol */ Q
     // ignore Self : Q, obvious
-    if (Req.getSecondType()->isEqual(Extension->getExtendedType())) {
-      continue;
+    if (auto *Proto = Extension->getExtendedProtocolDecl()) {
+      if (Req.getKind() == RequirementKind::Conformance &&
+          Req.getFirstType()->isEqual(Extension->getSelfInterfaceType()) &&
+          Req.getProtocolDecl() == Proto) {
+        continue;
+      }
     }
+
     FilteredRequirements.push_back(Req);
   }
 }

lib/SymbolGraphGen/JSON.h

@@ -53,7 +53,7 @@ void filterGenericParams(
 /// Filter generic requirements on an extension that aren't relevant
 /// for documentation.
 void filterGenericRequirements(
-    ArrayRef<Requirement> Requirements, const NominalTypeDecl *Self,
+    ArrayRef<Requirement> Requirements, const ProtocolDecl *Self,
     SmallVectorImpl<Requirement> &FilteredRequirements,
     SubstitutionMap SubMap = {},
     ArrayRef<const GenericTypeParamType *> FilteredParams = {});