AST/SourceKit: Fix printing of inheritance clauses (sort of)

This still needs a lot more cleanup.

Author: slavapestov

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,

test/SourceKit/DocSupport/doc_swift_module.swift

@@ -3,5 +3,3 @@
 // RUN: %sourcekitd-test -req=doc-info -module cake -- -Xfrontend -disable-implicit-concurrency-module-import -Xfrontend -disable-implicit-string-processing-module-import -I %t.mod > %t.response
 // RUN: %diff -u %s.response %t.response
 
-// XFAIL: noncopyable_generics
-

test/SourceKit/DocSupport/doc_swift_module1.swift

@@ -2,6 +2,3 @@
 // RUN: %swift -emit-module -o %t.mod/cake1.swiftmodule %S/Inputs/cake1.swift -disable-implicit-string-processing-module-import -disable-implicit-concurrency-module-import -parse-as-library
 // RUN: %sourcekitd-test -req=doc-info -module cake1 -- -Xfrontend -disable-implicit-concurrency-module-import -Xfrontend -disable-implicit-string-processing-module-import  -I %t.mod > %t.response
 // RUN: %diff -u %s.response %t.response
-
-// XFAIL: noncopyable_generics
-

test/SourceKit/DocSupport/doc_swift_module_class_extension.swift

@@ -4,6 +4,3 @@
 // RUN: %diff -u %s.response %t.response
 
 // rdar://76868074: Make sure we print the extensions for C.
-
-// XFAIL: noncopyable_generics
-

test/SourceKit/DocSupport/doc_system_module_underscored.swift

@@ -6,6 +6,3 @@
 
 // RUN: %sourcekitd-test -req=doc-info  -synthesized-extension -module UnderscoredProto -- -target %target-triple -Fsystem %t -module-cache-path %t/mcp > %t.response
 // RUN: %diff -u %s.response %t.response
-
-// XFAIL: noncopyable_generics
-

tools/SourceKit/lib/SwiftLang/SwiftDocSupport.cpp

@@ -335,7 +335,13 @@ static void initDocGenericParams(const Decl *D, DocEntityInfo &Info,
   if (auto *typeDC = GC->getInnermostTypeContext())
     Proto = typeDC->getSelfProtocolDecl();
 
-  for (auto Req: GenericSig.getRequirements()) {
+  SmallVector<Requirement, 2> Reqs;
+  SmallVector<InverseRequirement, 2> InverseReqs;
+  GenericSig->getRequirementsWithInverses(Reqs, InverseReqs);
+  // FIXME: Handle InverseReqs, or change the above to getRequirements()
+  // and update tests to include Copyable/Escapable
+
+  for (auto Req: Reqs) {
     if (Proto &&
         Req.getKind() == RequirementKind::Conformance &&
         Req.getFirstType()->isEqual(Proto->getSelfInterfaceType()) &&