[SourceKit][SymbolGraph] Add a 'ParentContexts' field the CursorInfo response

When the SymbolGraph json is requested via (key.retrieve_symbol_graph: 1) this adds
a new field in the response that lists all the parent contexts of the symbol under
the cursor with their symbol graph kind and name, and their USR:

key.parent_contexts: [
    {
      key.kind: "swift.struct",
      key.name: "Parent",
      key.usr: "s:27cursor_symbol_graph_parents6ParentV"
    },
    ...
  ]
}

Resolves rdar://problem/73904365

Author: Nathan Hawes

include/swift/SymbolGraphGen/PathComponent.h

@@ -0,0 +1,36 @@
+//===--- SymbolGraphPathComponent.h - Swift SymbolGraph Path Component ----===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SYMBOLGRAPHGEN_PATHCOMPONENT_H
+#define SWIFT_SYMBOLGRAPHGEN_PATHCOMPONENT_H
+
+#include "llvm/ADT/SmallString.h"
+
+namespace swift {
+class ValueDecl;
+
+namespace symbolgraphgen {
+
+/// Summary information for a node along a path through a symbol graph.
+struct PathComponent {
+  /// The title of the corresponding symbol graph node.
+  SmallString<32> Title;
+  /// The kind of the corresponding symbol graph node.
+  StringRef Kind;
+  /// The swift decl associated with the corresponding symbol graph node.
+  const ValueDecl *VD;
+};
+
+} // end namespace symbolgraphgen
+} // end namespace swift
+
+#endif // SWIFT_SYMBOLGRAPHGEN_PATHCOMPONENT_H

include/swift/SymbolGraphGen/SymbolGraphGen.h

@@ -16,6 +16,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/Type.h"
 #include "SymbolGraphOptions.h"
+#include "PathComponent.h"
 
 namespace swift {
 class ValueDecl;
@@ -25,14 +26,17 @@ namespace symbolgraphgen {
 /// Emit a Symbol Graph JSON file for a module.
 int emitSymbolGraphForModule(ModuleDecl *M, const SymbolGraphOptions &Options);
 
-/// Print a Symbol Graph containing a single node for the given decl.
+/// Print a Symbol Graph containing a single node for the given decl to \p OS.
+/// The \p ParentContexts out parameter will also be populated with information
+/// about each parent context of the given decl, from outermost to innermost.
 ///
-/// \returns \c EXIT_SUCCESS if the kind of the provided node is supported and
-/// its Symbo lGraph was printed, or \c EXIT_FAILURE otherwise.
+/// \returns \c EXIT_SUCCESS if the kind of the provided node is supported or
+/// \c EXIT_FAILURE otherwise.
 int printSymbolGraphForDecl(const ValueDecl *D, Type BaseTy,
-                             bool InSynthesizedExtensions,
-                             const SymbolGraphOptions &Options,
-                             llvm::raw_ostream &OS);
+                            bool InSynthesizedExtension,
+                            const SymbolGraphOptions &Options,
+                            llvm::raw_ostream &OS,
+                            SmallVectorImpl<PathComponent> &ParentContexts);
 
 } // end namespace symbolgraphgen
 } // end namespace swift

lib/SymbolGraphGen/Symbol.cpp

@@ -44,72 +44,58 @@ void Symbol::serializeKind(StringRef Identifier, StringRef DisplayName,
   });
 }
 
-void Symbol::serializeKind(llvm::json::OStream &OS) const {
-  // supportsKind and serializeKind must agree.
+std::pair<StringRef, StringRef> Symbol::getKind(const ValueDecl *VD) const {
+  // Make sure supportsKind stays in sync with getKind.
   assert(Symbol::supportsKind(VD->getKind()) && "unsupported decl kind");
-
-  AttributeRAII A("kind", OS);
   switch (VD->getKind()) {
   case swift::DeclKind::Class:
-    serializeKind("swift.class", "Class", OS);
-    break;
+    return {"swift.class", "Class"};
   case swift::DeclKind::Struct:
-    serializeKind("swift.struct", "Structure", OS);
-    break;
+    return {"swift.struct", "Structure"};
   case swift::DeclKind::Enum:
-    serializeKind("swift.enum", "Enumeration", OS);
-    break;
+    return {"swift.enum", "Enumeration"};
   case swift::DeclKind::EnumElement:
-    serializeKind("swift.enum.case", "Case", OS);
-    break;
+    return {"swift.enum.case", "Case"};
   case swift::DeclKind::Protocol:
-    serializeKind("swift.protocol", "Protocol", OS);
-    break;
+    return {"swift.protocol", "Protocol"};
   case swift::DeclKind::Constructor:
-    serializeKind("swift.init", "Initializer", OS);
-    break;
+    return {"swift.init", "Initializer"};
   case swift::DeclKind::Destructor:
-    serializeKind("swift.deinit", "Deinitializer", OS);
-    break;
+    return {"swift.deinit", "Deinitializer"};
   case swift::DeclKind::Func:
-    if (VD->isOperator()) {
-      serializeKind("swift.func.op", "Operator", OS);
-    } else if (VD->isStatic()) {
-      serializeKind("swift.type.method", "Type Method", OS);
-    } else if (VD->getDeclContext()->getSelfNominalTypeDecl()){
-      serializeKind("swift.method", "Instance Method", OS);
-    } else {
-      serializeKind("swift.func", "Function", OS);
-    }
-    break;
+    if (VD->isOperator())
+      return {"swift.func.op", "Operator"};
+    if (VD->isStatic())
+      return {"swift.type.method", "Type Method"};
+    if (VD->getDeclContext()->getSelfNominalTypeDecl())
+      return {"swift.method", "Instance Method"};
+    return {"swift.func", "Function"};
   case swift::DeclKind::Var:
-    if (VD->isStatic()) {
-      serializeKind("swift.type.property", "Type Property", OS);
-    } else if (VD->getDeclContext()->getSelfNominalTypeDecl()) {
-      serializeKind("swift.property", "Instance Property", OS);
-    } else {
-      serializeKind("swift.var", "Global Variable", OS);
-    }
-    break;
+    if (VD->isStatic())
+      return {"swift.type.property", "Type Property"};
+    if (VD->getDeclContext()->getSelfNominalTypeDecl())
+      return {"swift.property", "Instance Property"};
+    return {"swift.var", "Global Variable"};
   case swift::DeclKind::Subscript:
-    if (VD->isStatic()) {
-      serializeKind("swift.type.subscript", "Type Subscript", OS);
-    } else {
-      serializeKind("swift.subscript", "Instance Subscript", OS);
-    }
-    break;
+    if (VD->isStatic())
+      return {"swift.type.subscript", "Type Subscript"};
+    return {"swift.subscript", "Instance Subscript"};
   case swift::DeclKind::TypeAlias:
-    serializeKind("swift.typealias", "Type Alias", OS);
-    break;
+    return {"swift.typealias", "Type Alias"};
   case swift::DeclKind::AssociatedType:
-    serializeKind("swift.associatedtype", "Associated Type", OS);
-    break;
+    return {"swift.associatedtype", "Associated Type"};
   default:
     llvm::errs() << "Unsupported kind: " << VD->getKindName(VD->getKind());
     llvm_unreachable("Unsupported declaration kind for symbol graph");
   }
 }
 
+void Symbol::serializeKind(llvm::json::OStream &OS) const {
+  AttributeRAII A("kind", OS);
+  std::pair<StringRef, StringRef> IDAndName = getKind(VD);
+  serializeKind(IDAndName.first, IDAndName.second, OS);
+}
+
 void Symbol::serializeIdentifier(llvm::json::OStream &OS) const {
   OS.attributeObject("identifier", [&](){
     SmallString<256> USR;
@@ -121,17 +107,17 @@ void Symbol::serializeIdentifier(llvm::json::OStream &OS) const {
 
 void Symbol::serializePathComponents(llvm::json::OStream &OS) const {
   OS.attributeArray("pathComponents", [&](){
-    SmallVector<SmallString<32>, 8> PathComponents;
+    SmallVector<PathComponent, 8> PathComponents;
     getPathComponents(PathComponents);
     for (auto Component : PathComponents) {
-      OS.value(Component);
+      OS.value(Component.Title);
     }
   });
 }
 
 void Symbol::serializeNames(llvm::json::OStream &OS) const {
   OS.attributeObject("names", [&](){
-    SmallVector<SmallString<32>, 8> PathComponents;
+    SmallVector<PathComponent, 8> PathComponents;
     getPathComponents(PathComponents);
 
     if (isa<GenericTypeDecl>(VD)) {    
@@ -141,12 +127,12 @@ void Symbol::serializeNames(llvm::json::OStream &OS) const {
         if (It != PathComponents.begin()) {
           FullyQualifiedTitle.push_back('.');
         }
-        FullyQualifiedTitle.append(*It);
+        FullyQualifiedTitle.append(It->Title);
       }
 
       OS.attribute("title", FullyQualifiedTitle.str());
     } else {
-      OS.attribute("title", PathComponents.back());
+      OS.attribute("title", PathComponents.back().Title);
     }
 
     Graph->serializeNavigatorDeclarationFragments("navigator", *this, OS);
@@ -481,16 +467,27 @@ void Symbol::serialize(llvm::json::OStream &OS) const {
 }
 
 void
-Symbol::getPathComponents(SmallVectorImpl<SmallString<32>> &Components) const {
+Symbol::getPathComponents(SmallVectorImpl<PathComponent> &Components) const {
+  // Note: this is also used for sourcekit's cursor-info request, so can be
+  // called on local symbols too. For such symbols, the path contains all parent
+  // decl contexts that are currently representable in the symbol graph,
+  // skipping over the rest (e.g. containing closures and accessors).
 
   auto collectPathComponents = [&](const ValueDecl *Decl,
-                                   SmallVectorImpl<SmallString<32>> &DeclComponents) {
-    // Collect the spellings of the fully qualified identifier components.
+                                   SmallVectorImpl<PathComponent> &DeclComponents) {
+    // Collect the spellings, kinds, and decls of the fully qualified identifier
+    // components.
     while (Decl && !isa<ModuleDecl>(Decl)) {
       SmallString<32> Scratch;
       Decl->getName().getString(Scratch);
-      DeclComponents.push_back(Scratch);
-      if (const auto *DC = Decl->getDeclContext()) {
+      if (supportsKind(Decl->getKind()))
+        DeclComponents.push_back({Scratch, getKind(Decl).first, Decl});
+
+      // Find the next parent.
+      auto *DC = Decl->getDeclContext();
+      while (DC && DC->getContextKind() == DeclContextKind::AbstractClosureExpr)
+        DC = DC->getParent();
+      if (DC) {
         if (const auto *Nominal = DC->getSelfNominalTypeDecl()) {
           Decl = Nominal;
         } else {
@@ -508,7 +505,8 @@ Symbol::getPathComponents(SmallVectorImpl<SmallString<32>> &Components) const {
     // a protocol. Build a path as if it were defined in the base type.
     SmallString<32> LastPathComponent;
     VD->getName().getString(LastPathComponent);
-    Components.push_back(LastPathComponent);
+    if (supportsKind(VD->getKind()))
+      Components.push_back({LastPathComponent, getKind(VD).first, VD});
     collectPathComponents(BaseTypeDecl, Components);
   } else {
     // Otherwise, this is just a normal declaration, so we can build
@@ -521,13 +519,13 @@ Symbol::getPathComponents(SmallVectorImpl<SmallString<32>> &Components) const {
 }
 
 void Symbol::printPath(llvm::raw_ostream &OS) const {
-  SmallVector<SmallString<32>, 8> Components;
+  SmallVector<PathComponent, 8> Components;
   getPathComponents(Components);
   for (auto it = Components.begin(); it != Components.end(); ++it) {
     if (it != Components.begin()) {
       OS << '.';
     }
-    OS << it->str();
+    OS << it->Title.str();
   }
 }
 

lib/SymbolGraphGen/Symbol.h

@@ -18,6 +18,7 @@
 #include "swift/AST/Type.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Markup/Markup.h"
+#include "swift/SymbolGraphGen/PathComponent.h"
 
 namespace swift {
 namespace symbolgraphgen {
@@ -34,6 +35,8 @@ class Symbol {
   Type BaseType;
   const NominalTypeDecl *SynthesizedBaseTypeDecl;
 
+  std::pair<StringRef, StringRef> getKind(const ValueDecl *VD) const;
+
   void serializeKind(StringRef Identifier, StringRef DisplayName,
                      llvm::json::OStream &OS) const;
 
@@ -95,7 +98,7 @@ class Symbol {
     return SynthesizedBaseTypeDecl;
   }
 
-  void getPathComponents(SmallVectorImpl<SmallString<32>> &Components) const;
+  void getPathComponents(SmallVectorImpl<PathComponent> &Components) const;
 
   /// Print the symbol path to an output stream.
   void printPath(llvm::raw_ostream &OS) const;

lib/SymbolGraphGen/SymbolGraphGen.cpp

@@ -104,7 +104,8 @@ int symbolgraphgen::
 printSymbolGraphForDecl(const ValueDecl *D, Type BaseTy,
                         bool InSynthesizedExtension,
                         const SymbolGraphOptions &Options,
-                        llvm::raw_ostream &OS) {
+                        llvm::raw_ostream &OS,
+                        SmallVectorImpl<PathComponent> &ParentContexts) {
   if (!Symbol::supportsKind(D->getKind()))
     return EXIT_FAILURE;
 
@@ -119,6 +120,11 @@ printSymbolGraphForDecl(const ValueDecl *D, Type BaseTy,
       : nullptr;
 
   Symbol MySym(&Graph, D, NTD, BaseTy);
+
+  MySym.getPathComponents(ParentContexts);
+  assert(!ParentContexts.empty() && "doesn't have node for MySym?");
+  ParentContexts.pop_back();
+
   Graph.recordNode(MySym);
   Graph.serialize(JOS);
   return EXIT_SUCCESS;