Address some review feedback

[evelez7]

Summary

Delete unnecessary includes, revert SymbolGraphSerializer hidden
namespace function names, move IgnoresList, Options to SGS

Depends on D151293

clang/include/clang/ExtractAPI/Serialization/SerializerBase.h

 /// This file defines the ExtractAPI APISetVisitor interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SERIALIZERBASE_H
 #define LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SERIALIZERBASE_H
 
 #include "clang/ExtractAPI/API.h"
-#include "clang/ExtractAPI/APIIgnoresList.h"
-#include "llvm/Support/JSON.h"
-#include "llvm/Support/raw_ostream.h"
-
-using namespace llvm::json;
 
 namespace clang {
 namespace extractapi {
 
-/// Common options to customize the visitor output.
-struct APISetVisitorOption {
-  /// Do not include unnecessary whitespaces to save space.
-  bool Compact;
-};
-
 /// The base interface of visitors for API information.
 template <typename Derived> class APISetVisitor {
 public:
-  /// Traverse the API information to output to \p os.
-  void traverseAPISet(raw_ostream &os){};
-
   void traverseAPISet() {
     getDerived()->traverseGlobalVariableRecords();
 
     getDerived()->traverseGlobalFunctionRecords();
 
     getDerived()->traverseEnumRecords();
 
     getDerived()->traverseStructRecords();
void traverseMacroDefinitionRecords() {
     for (const auto &Macro : API.getMacros())
       getDerived()->visitMacroDefinitionRecord(*Macro.second);
   }
 
   void traverseTypedefRecords() {
     for (const auto &Typedef : API.getTypedefs())
       getDerived()->visitTypedefRecord(*Typedef.second);
   }
+
   /// Visit a global function record.
   void visitGlobalFunctionRecord(const GlobalFunctionRecord &Record){};
 
   /// Visit a global variable record.
-  void visitGlobalVariableRecord(const GlobalVariableRecord &Record);
+  void visitGlobalVariableRecord(const GlobalVariableRecord &Record){};
 
   /// Visit an enum record.
   void visitEnumRecord(const EnumRecord &Record){};
 
   /// Visit a struct record.
   void visitStructRecord(const StructRecord &Record){};
 
   /// Visit an Objective-C container record.
   void visitObjCContainerRecord(const ObjCContainerRecord &Record){};
 
   /// Visit a macro definition record.
   void visitMacroDefinitionRecord(const MacroDefinitionRecord &Record){};
 
   /// Visit a typedef record.
   void visitTypedefRecord(const TypedefRecord &Record){};
 
   /// Visit a single record.
   void visitSingleRecord(const APIRecord *Record){};
 
 protected:
   const APISet &API;
 
-  /// The list of symbols to ignore.
-  ///
-  /// Note: This should be consulted before emitting a symbol.
-  const APIIgnoresList &IgnoresList;
-
-  APISetVisitorOption Options;
-
 public:
   APISetVisitor() = delete;
   APISetVisitor(const APISetVisitor &) = delete;
   APISetVisitor(APISetVisitor &&) = delete;
   APISetVisitor &operator=(const APISetVisitor &) = delete;
   APISetVisitor &operator=(APISetVisitor &&) = delete;
 
 protected:
-  APISetVisitor(const APISet &API, const APIIgnoresList &IgnoresList,
-                APISetVisitorOption Options = {})
-      : API(API), IgnoresList(IgnoresList), Options(Options) {}
+  APISetVisitor(const APISet &API) : API(API) {}
 
-  virtual ~APISetVisitor() = default;
   Derived *getDerived() { return static_cast<Derived *>(this); };
 };
 
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SERIALIZERBASE_H

clang/include/clang/ExtractAPI/Serialization/SymbolGraphSerializer.h

 //===- ExtractAPI/Serialization/SymbolGraphSerializer.h ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines the SymbolGraphSerializer class.
 ///
-/// Implement an APISetVisitor for the Symbol Graph format for ExtractAPI.
-/// See https://github.com/apple/swift-docc-symbolkit.
+/// Implement an APISetVisitor to serialize the APISet into the Symbol Graph
+/// format for ExtractAPI. See https://github.com/apple/swift-docc-symbolkit.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SYMBOLGRAPHSERIALIZER_H
 #define LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SYMBOLGRAPHSERIALIZER_H
 
-#include "clang/ExtractAPI/API.h"
 #include "clang/ExtractAPI/APIIgnoresList.h"
 #include "clang/ExtractAPI/Serialization/SerializerBase.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 namespace clang {
 namespace extractapi {
 
 using namespace llvm::json;
 
+/// Common options to customize the visitor output.
+struct SymbolGraphSerializerOption {
+  /// Do not include unnecessary whitespaces to save space.
+  bool Compact;
+};
+
 /// The visitor that organizes API information in the Symbol Graph format.
 ///
 /// The Symbol Graph format (https://github.com/apple/swift-docc-symbolkit)
 /// models an API set as a directed graph, where nodes are symbol declarations,
 /// and edges are relationships between the connected symbols.
 class SymbolGraphSerializer : public APISetVisitor<SymbolGraphSerializer> {
-  virtual void anchor();
-
   /// A JSON array of formatted symbols in \c APISet.
   Array Symbols;
 
   /// A JSON array of formatted symbol relationships in \c APISet.
   Array Relationships;
 
   /// The Symbol Graph format version used by this serializer.
   static const VersionTuple FormatVersion;
 
   /// Indicates whether child symbols should be visited. This is mainly
   /// useful for \c serializeSingleSymbolSGF.
   bool ShouldRecurse;
 
 public:
   /// Serialize the APIs in \c APISet in the Symbol Graph format.
   ///
   /// \returns a JSON object that contains the root of the formatted
   /// Symbol Graph.
-  Object traverse();
+  Object serialize();
 
-  /// Implement the APISetVisitor::traverseAPISet interface. Wrap
-  /// serialize(void) and write out the serialized JSON object to \p os.
-  void traverseAPISet(raw_ostream &os);
+  ///  Wrap serialize(void) and write out the serialized JSON object to \p os.
+  void serialize(raw_ostream &os);
 
   /// Serialize a single symbol SGF. This is primarily used for libclang.
   ///
   /// \returns an optional JSON Object representing the payload that libclang
   /// expects for providing symbol information for a single symbol. If this is
   /// not a known symbol returns \c std::nullopt.
   static std::optional<Object> serializeSingleSymbolSGF(StringRef USR,
                                                         const APISet &API);
enum RelationshipKind {
     ConformsTo,
   };
 
   /// Get the string representation of the relationship kind.
   static StringRef getRelationshipString(RelationshipKind Kind);
 
 private:
   /// Just serialize the currently recorded objects in Symbol Graph format.
-  Object visitCurrentGraph();
+  Object serializeCurrentGraph();
 
   /// Synthesize the metadata section of the Symbol Graph format.
   ///
   /// The metadata section describes information about the Symbol Graph itself,
   /// including the format version and the generator information.
-  Object visitMetadata() const;
+  Object serializeMetadata() const;
 
   /// Synthesize the module section of the Symbol Graph format.
   ///
   /// The module section contains information about the product that is defined
   /// by the given API set.
   /// Note that "module" here is not to be confused with the Clang/C++ module
   /// concept.
-  Object visitModule() const;
+  Object serializeModule() const;
 
   /// Determine if the given \p Record should be skipped during serialization.
   bool shouldSkip(const APIRecord &Record) const;
 
   /// Format the common API information for \p Record.
   ///
   /// This handles the shared information of all kinds of API records,
   /// for example identifier and source location. The resulting object is then
   /// augmented with kind-specific symbol information by the caller.
   /// This method also checks if the given \p Record should be skipped during
   /// serialization.
   ///
   /// \returns \c std::nullopt if this \p Record should be skipped, or a JSON
   /// object containing common symbol information of \p Record.
   template <typename RecordTy>
-  std::optional<Object> visitAPIRecord(const RecordTy &Record) const;
+  std::optional<Object> serializeAPIRecord(const RecordTy &Record) const;
 
   /// Helper method to serialize second-level member records of \p Record and
   /// the member-of relationships.
   template <typename MemberTy>
-  void visitMembers(const APIRecord &Record,
+  void serializeMembers(const APIRecord &Record,
                         const SmallVector<std::unique_ptr<MemberTy>> &Members);
 
   /// Serialize the \p Kind relationship between \p Source and \p Target.
   ///
   /// Record the relationship between the two symbols in
   /// SymbolGraphSerializer::Relationships.
-  void visitRelationship(RelationshipKind Kind, SymbolReference Source,
+  void serializeRelationship(RelationshipKind Kind, SymbolReference Source,
                              SymbolReference Target);
 
+protected:
+  /// The list of symbols to ignore.
+  ///
+  /// Note: This should be consulted before emitting a symbol.
+  const APIIgnoresList &IgnoresList;
+
+  SymbolGraphSerializerOption Options;
+
 public:
   /// Visit a global function record.
   void visitGlobalFunctionRecord(const GlobalFunctionRecord &Record);
 
   /// Visit a global variable record.
   void visitGlobalVariableRecord(const GlobalVariableRecord &Record);
 
   /// Visit an enum record.
public:
 
   /// Visit a typedef record.
   void visitTypedefRecord(const TypedefRecord &Record);
 
   /// Visit a single record.
   void visitSingleRecord(const APIRecord *Record);
 
   SymbolGraphSerializer(const APISet &API, const APIIgnoresList &IgnoresList,
-                        APISetVisitorOption Options = {},
+                        SymbolGraphSerializerOption Options = {},
                         bool ShouldRecurse = true)
-      : APISetVisitor(API, IgnoresList, Options), ShouldRecurse(ShouldRecurse) {
-  }
+      : APISetVisitor(API), ShouldRecurse(ShouldRecurse),
+        IgnoresList(IgnoresList), Options(Options) {}
 };
 
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_SERIALIZATION_SYMBOLGRAPHSERIALIZER_H

clang/lib/ExtractAPI/ExtractAPIConsumer.cpp

 void ExtractAPIAction::EndSourceFileAction() {
   if (!OS)
     return;
 
   // Setup a SymbolGraphSerializer to write out collected API information in
   // the Symbol Graph format.
   // FIXME: Make the kind of APISerializer configurable.
   SymbolGraphSerializer SGSerializer(*API, IgnoresList);
-  SGSerializer.traverseAPISet(*OS);
+  SGSerializer.serialize(*OS);
   OS.reset();
 }
 
 std::unique_ptr<raw_pwrite_stream>
 ExtractAPIAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile) {
   std::unique_ptr<raw_pwrite_stream> OS =
       CI.createDefaultOutputFile(/*Binary=*/false, InFile, /*Extension=*/"json",
                                  /*RemoveFileOnSignal=*/false);
   if (!OS)
     return nullptr;
   return OS;
 }

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

 //===- ExtractAPI/Serialization/SymbolGraphSerializer.cpp -------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file implements the SymbolGraphSerializer.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/ExtractAPI/Serialization/SymbolGraphSerializer.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/Version.h"
-#include "clang/ExtractAPI/API.h"
-#include "clang/ExtractAPI/APIIgnoresList.h"
 #include "clang/ExtractAPI/DeclarationFragments.h"
-#include "clang/ExtractAPI/Serialization/SerializerBase.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
-#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
-#include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VersionTuple.h"
 #include <optional>
 #include <type_traits>
 
 using namespace clang;
 using namespace clang::extractapi;
 using namespace llvm;
 using namespace llvm::json;
 
 namespace {
 
 /// Helper function to inject a JSON object \p Obj into another object \p Paren
 /// at position \p Key.
-void visitObject(Object &Paren, StringRef Key, std::optional<Object> Obj) {
+void serializeObject(Object &Paren, StringRef Key, std::optional<Object> Obj) {
   if (Obj)
     Paren[Key] = std::move(*Obj);
 }
 
 /// Helper function to inject a JSON array \p Array into object \p Paren at
 /// position \p Key.
-void visitArray(Object &Paren, StringRef Key, std::optional<Array> Array) {
+void serializeArray(Object &Paren, StringRef Key, std::optional<Array> Array) {
   if (Array)
     Paren[Key] = std::move(*Array);
 }
 
 /// Serialize a \c VersionTuple \p V with the Symbol Graph semantic version
 /// format.
 ///
 /// A semantic version object contains three numeric fields, representing the
 /// \c major, \c minor, and \c patch parts of the version tuple.
 /// For example version tuple 1.0.3 is serialized as:
 /// \code
 ///   {
 ///     "major" : 1,
 ///     "minor" : 0,
 ///     "patch" : 3
 ///   }
 /// \endcode
 ///
 /// \returns \c std::nullopt if the version \p V is empty, or an \c Object
 /// containing the semantic version representation of \p V.
-std::optional<Object> visitSemanticVersion(const VersionTuple &V) {
+std::optional<Object> serializeSemanticVersion(const VersionTuple &V) {
   if (V.empty())
     return std::nullopt;
 
   Object Version;
   Version["major"] = V.getMajor();
   Version["minor"] = V.getMinor().value_or(0);
   Version["patch"] = V.getSubminor().value_or(0);
   return Version;
 }
 
 /// Serialize the OS information in the Symbol Graph platform property.
 ///
 /// The OS information in Symbol Graph contains the \c name of the OS, and an
 /// optional \c minimumVersion semantic version field.
-Object visitOperatingSystem(const Triple &T) {
+Object serializeOperatingSystem(const Triple &T) {
   Object OS;
   OS["name"] = T.getOSTypeName(T.getOS());
-  visitObject(OS, "minimumVersion",
-              visitSemanticVersion(T.getMinimumSupportedOSVersion()));
+  serializeObject(OS, "minimumVersion",
+                  serializeSemanticVersion(T.getMinimumSupportedOSVersion()));
   return OS;
 }
 
 /// Serialize the platform information in the Symbol Graph module section.
 ///
 /// The platform object describes a target platform triple in corresponding
 /// three fields: \c architecture, \c vendor, and \c operatingSystem.
-Object visitPlatform(const Triple &T) {
+Object serializePlatform(const Triple &T) {
   Object Platform;
   Platform["architecture"] = T.getArchName();
   Platform["vendor"] = T.getVendorName();
-  Platform["operatingSystem"] = visitOperatingSystem(T);
+  Platform["operatingSystem"] = serializeOperatingSystem(T);
   return Platform;
 }
 
 /// Serialize a source position.
-Object visitSourcePosition(const PresumedLoc &Loc) {
+Object serializeSourcePosition(const PresumedLoc &Loc) {
   assert(Loc.isValid() && "invalid source position");
 
   Object SourcePosition;
   SourcePosition["line"] = Loc.getLine();
   SourcePosition["character"] = Loc.getColumn();
 
   return SourcePosition;
 }
 
 /// Serialize a source location in file.
 ///
 /// \param Loc The presumed location to serialize.
 /// \param IncludeFileURI If true, include the file path of \p Loc as a URI.
 /// Defaults to false.
-Object visitSourceLocation(const PresumedLoc &Loc,
+Object serializeSourceLocation(const PresumedLoc &Loc,
                                bool IncludeFileURI = false) {
   Object SourceLocation;
-  visitObject(SourceLocation, "position", visitSourcePosition(Loc));
+  serializeObject(SourceLocation, "position", serializeSourcePosition(Loc));
 
   if (IncludeFileURI) {
     std::string FileURI = "file://";
     // Normalize file path to use forward slashes for the URI.
     FileURI += sys::path::convert_to_slash(Loc.getFilename());
     SourceLocation["uri"] = FileURI;
   }
 
   return SourceLocation;
 }
 
 /// Serialize a source range with begin and end locations.
-Object visitSourceRange(const PresumedLoc &BeginLoc,
+Object serializeSourceRange(const PresumedLoc &BeginLoc,
                             const PresumedLoc &EndLoc) {
   Object SourceRange;
-  visitObject(SourceRange, "start", visitSourcePosition(BeginLoc));
-  visitObject(SourceRange, "end", visitSourcePosition(EndLoc));
+  serializeObject(SourceRange, "start", serializeSourcePosition(BeginLoc));
+  serializeObject(SourceRange, "end", serializeSourcePosition(EndLoc));
   return SourceRange;
 }
 
 /// Serialize the availability attributes of a symbol.
 ///
 /// Availability information contains the introduced, deprecated, and obsoleted
 /// versions of the symbol for a given domain (roughly corresponds to a
 /// platform) as semantic versions, if not default.  Availability information
 /// also contains flags to indicate if the symbol is unconditionally unavailable
 /// or deprecated, i.e. \c __attribute__((unavailable)) and \c
 /// __attribute__((deprecated)).
 ///
 /// \returns \c std::nullopt if the symbol has default availability attributes,
 /// or an \c Array containing the formatted availability information.
-std::optional<Array> visitAvailability(const AvailabilitySet &Availabilities) {
+std::optional<Array>
+serializeAvailability(const AvailabilitySet &Availabilities) {
   if (Availabilities.isDefault())
     return std::nullopt;
 
   Array AvailabilityArray;
 
   if (Availabilities.isUnconditionallyDeprecated()) {
     Object UnconditionallyDeprecated;
     UnconditionallyDeprecated["domain"] = "*";
     UnconditionallyDeprecated["isUnconditionallyDeprecated"] = true;
     AvailabilityArray.emplace_back(std::move(UnconditionallyDeprecated));
   }
 
   // Note unconditionally unavailable records are skipped.
 
   for (const auto &AvailInfo : Availabilities) {
     Object Availability;
     Availability["domain"] = AvailInfo.Domain;
     if (AvailInfo.Unavailable)
       Availability["isUnconditionallyUnavailable"] = true;
     else {
-      visitObject(Availability, "introducedVersion",
-                  visitSemanticVersion(AvailInfo.Introduced));
-      visitObject(Availability, "deprecatedVersion",
-                  visitSemanticVersion(AvailInfo.Deprecated));
-      visitObject(Availability, "obsoletedVersion",
-                  visitSemanticVersion(AvailInfo.Obsoleted));
+      serializeObject(Availability, "introducedVersion",
+                      serializeSemanticVersion(AvailInfo.Introduced));
+      serializeObject(Availability, "deprecatedVersion",
+                      serializeSemanticVersion(AvailInfo.Deprecated));
+      serializeObject(Availability, "obsoletedVersion",
+                      serializeSemanticVersion(AvailInfo.Obsoleted));
     }
     AvailabilityArray.emplace_back(std::move(Availability));
   }
 
   return AvailabilityArray;
 }
 
 /// Get the language name string for interface language references.
StringRef getLanguageName(Language Lang) {
 
   llvm_unreachable("Unhandled language kind");
 }
 
 /// Serialize the identifier object as specified by the Symbol Graph format.
 ///
 /// The identifier property of a symbol contains the USR for precise and unique
 /// references, and the interface language name.
-Object visitIdentifier(const APIRecord &Record, Language Lang) {
+Object serializeIdentifier(const APIRecord &Record, Language Lang) {
   Object Identifier;
   Identifier["precise"] = Record.USR;
   Identifier["interfaceLanguage"] = getLanguageName(Lang);
 
   return Identifier;
 }
 
 /// Serialize the documentation comments attached to a symbol, as specified by
 /// the Symbol Graph format.
 ///
 /// The Symbol Graph \c docComment object contains an array of lines. Each line
 /// represents one line of striped documentation comment, with source range
 /// information.
 /// e.g.
 /// \code
 ///   /// This is a documentation comment
 ///       ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~'  First line.
 ///   ///     with multiple lines.
 ///       ^~~~~~~~~~~~~~~~~~~~~~~'         Second line.
 /// \endcode
 ///
 /// \returns \c std::nullopt if \p Comment is empty, or an \c Object containing
 /// the formatted lines.
-std::optional<Object> visitDocComment(const DocComment &Comment) {
+std::optional<Object> serializeDocComment(const DocComment &Comment) {
   if (Comment.empty())
     return std::nullopt;
 
   Object DocComment;
   Array LinesArray;
   for (const auto &CommentLine : Comment) {
     Object Line;
     Line["text"] = CommentLine.Text;
-    visitObject(Line, "range",
-                visitSourceRange(CommentLine.Begin, CommentLine.End));
+    serializeObject(Line, "range",
+                    serializeSourceRange(CommentLine.Begin, CommentLine.End));
     LinesArray.emplace_back(std::move(Line));
   }
-  visitArray(DocComment, "lines", LinesArray);
+  serializeArray(DocComment, "lines", LinesArray);
 
   return DocComment;
 }
 
 /// Serialize the declaration fragments of a symbol.
 ///
 /// The Symbol Graph declaration fragments is an array of tagged important
 /// parts of a symbol's declaration. The fragments sequence can be joined to

 ///                        "kind" : "identifier",
 ///                        "spelling" : "pi"
 ///                      }
 ///                    ]
 /// \endcode
 ///
 /// \returns \c std::nullopt if \p DF is empty, or an \c Array containing the
 /// formatted declaration fragments array.
-std::optional<Array> visitDeclarationFragments(const DeclarationFragments &DF) {
+std::optional<Array>
+serializeDeclarationFragments(const DeclarationFragments &DF) {
   if (DF.getFragments().empty())
     return std::nullopt;
 
   Array Fragments;
   for (const auto &F : DF.getFragments()) {
     Object Fragment;
     Fragment["spelling"] = F.Spelling;
     Fragment["kind"] = DeclarationFragments::getFragmentKindString(F.Kind);

 /// format.
 ///
 /// The Symbol Graph names field contains multiple representations of a symbol
 /// that can be used for different applications:
 ///   - \c title : The simple declared name of the symbol;
 ///   - \c subHeading : An array of declaration fragments that provides tags,
 ///     and potentially more tokens (for example the \c +/- symbol for
 ///     Objective-C methods). Can be used as sub-headings for documentation.
-Object visitNames(const APIRecord &Record) {
+Object serializeNames(const APIRecord &Record) {
   Object Names;
   Names["title"] = Record.Name;
-  visitArray(Names, "subHeading", visitDeclarationFragments(Record.SubHeading));
+  serializeArray(Names, "subHeading",
+                 serializeDeclarationFragments(Record.SubHeading));
   DeclarationFragments NavigatorFragments;
   NavigatorFragments.append(Record.Name,
                             DeclarationFragments::FragmentKind::Identifier,
                             /*PreciseIdentifier*/ "");
-  visitArray(Names, "navigator", visitDeclarationFragments(NavigatorFragments));
+  serializeArray(Names, "navigator",
+                 serializeDeclarationFragments(NavigatorFragments));
 
   return Names;
 }
 
-Object visitSymbolKind(APIRecord::RecordKind RK, Language Lang) {
+Object serializeSymbolKind(APIRecord::RecordKind RK, Language Lang) {
   auto AddLangPrefix = [&Lang](StringRef S) -> std::string {
     return (getLanguageName(Lang) + "." + S).str();
   };
 
   Object Kind;
   switch (RK) {
   case APIRecord::RK_Unknown:
     llvm_unreachable("Records should have an explicit kind");
Object serializeSymbolKind(APIRecord::RecordKind RK, Language Lang) {
   return Kind;
 }
 
 /// Serialize the symbol kind information.
 ///
 /// The Symbol Graph symbol kind property contains a shorthand \c identifier
 /// which is prefixed by the source language name, useful for tooling to parse
 /// the kind, and a \c displayName for rendering human-readable names.
-Object visitSymbolKind(const APIRecord &Record, Language Lang) {
-  return visitSymbolKind(Record.getKind(), Lang);
+Object serializeSymbolKind(const APIRecord &Record, Language Lang) {
+  return serializeSymbolKind(Record.getKind(), Lang);
 }
 
 template <typename RecordTy>
-std::optional<Object> visitFunctionSignatureMixinImpl(const RecordTy &Record,
-                                                      std::true_type) {
+std::optional<Object>
+serializeFunctionSignatureMixinImpl(const RecordTy &Record, std::true_type) {
   const auto &FS = Record.Signature;
   if (FS.empty())
     return std::nullopt;
 
   Object Signature;
-  visitArray(Signature, "returns",
-             visitDeclarationFragments(FS.getReturnType()));
+  serializeArray(Signature, "returns",
+                 serializeDeclarationFragments(FS.getReturnType()));
 
   Array Parameters;
   for (const auto &P : FS.getParameters()) {
     Object Parameter;
     Parameter["name"] = P.Name;
-    visitArray(Parameter, "declarationFragments",
-               visitDeclarationFragments(P.Fragments));
+    serializeArray(Parameter, "declarationFragments",
+                   serializeDeclarationFragments(P.Fragments));
     Parameters.emplace_back(std::move(Parameter));
   }
 
   if (!Parameters.empty())
     Signature["parameters"] = std::move(Parameters);
 
   return Signature;
 }
 
 template <typename RecordTy>
-std::optional<Object> visitFunctionSignatureMixinImpl(const RecordTy &Record,
-                                                      std::false_type) {
+std::optional<Object>
+serializeFunctionSignatureMixinImpl(const RecordTy &Record, std::false_type) {
   return std::nullopt;
 }
 
 /// Serialize the function signature field, as specified by the
 /// Symbol Graph format.
 ///
 /// The Symbol Graph function signature property contains two arrays.
 ///   - The \c returns array is the declaration fragments of the return type;
 ///   - The \c parameters array contains names and declaration fragments of the
 ///     parameters.
 ///
 /// \returns \c std::nullopt if \p FS is empty, or an \c Object containing the
 /// formatted function signature.
 template <typename RecordTy>
-void visitFunctionSignatureMixin(Object &Paren, const RecordTy &Record) {
-  visitObject(Paren, "functionSignature",
-              visitFunctionSignatureMixinImpl(
+void serializeFunctionSignatureMixin(Object &Paren, const RecordTy &Record) {
+  serializeObject(Paren, "functionSignature",
+                  serializeFunctionSignatureMixinImpl(
                       Record, has_function_signature<RecordTy>()));
 }
 
 struct PathComponent {
   StringRef USR;
   StringRef Name;
   APIRecord::RecordKind Kind;
 
   PathComponent(StringRef USR, StringRef Name, APIRecord::RecordKind Kind)
bool generatePathComponents(
   }
 
   for (const auto &PC : reverse(ReverseComponenents))
     ComponentTransformer(PC);
 
   return FailedToFindParent;
 }
 
-Object visitParentContext(const PathComponent &PC, Language Lang) {
+Object serializeParentContext(const PathComponent &PC, Language Lang) {
   Object ParentContextElem;
   ParentContextElem["usr"] = PC.USR;
   ParentContextElem["name"] = PC.Name;
-  ParentContextElem["kind"] = visitSymbolKind(PC.Kind, Lang)["identifier"];
+  ParentContextElem["kind"] = serializeSymbolKind(PC.Kind, Lang)["identifier"];
   return ParentContextElem;
 }
 
 template <typename RecordTy>
 Array generateParentContexts(const RecordTy &Record, const APISet &API,
                              Language Lang) {
   Array ParentContexts;
   generatePathComponents(
       Record, API, [Lang, &ParentContexts](const PathComponent &PC) {
-        ParentContexts.push_back(visitParentContext(PC, Lang));
+        ParentContexts.push_back(serializeParentContext(PC, Lang));
       });
 
   return ParentContexts;
 }
 
 } // namespace
 
-void SymbolGraphSerializer::anchor() {}
-
 /// Defines the format version emitted by SymbolGraphSerializer.
 const VersionTuple SymbolGraphSerializer::FormatVersion{0, 5, 3};
 
-Object SymbolGraphSerializer::visitMetadata() const {
+Object SymbolGraphSerializer::serializeMetadata() const {
   Object Metadata;
-  visitObject(Metadata, "formatVersion", visitSemanticVersion(FormatVersion));
+  serializeObject(Metadata, "formatVersion",
+                  serializeSemanticVersion(FormatVersion));
   Metadata["generator"] = clang::getClangFullVersion();
   return Metadata;
 }
 
-Object SymbolGraphSerializer::visitModule() const {
+Object SymbolGraphSerializer::serializeModule() const {
   Object Module;
   // The user is expected to always pass `--product-name=` on the command line
   // to populate this field.
   Module["name"] = API.ProductName;
-  visitObject(Module, "platform", visitPlatform(API.getTarget()));
+  serializeObject(Module, "platform", serializePlatform(API.getTarget()));
   return Module;
 }
 
 bool SymbolGraphSerializer::shouldSkip(const APIRecord &Record) const {
   // Skip explicitly ignored symbols.
   if (IgnoresList.shouldIgnore(Record.Name))
     return true;
 
   // Skip unconditionally unavailable symbols
   if (Record.Availabilities.isUnconditionallyUnavailable())
     return true;
 
   // Filter out symbols prefixed with an underscored as they are understood to
   // be symbols clients should not use.
   if (Record.Name.startswith("_"))
     return true;
 
   return false;
 }
 
 template <typename RecordTy>
 std::optional<Object>
-SymbolGraphSerializer::visitAPIRecord(const RecordTy &Record) const {
+SymbolGraphSerializer::serializeAPIRecord(const RecordTy &Record) const {
   if (shouldSkip(Record))
     return std::nullopt;
 
   Object Obj;
-  visitObject(Obj, "identifier", visitIdentifier(Record, API.getLanguage()));
-  visitObject(Obj, "kind", visitSymbolKind(Record, API.getLanguage()));
-  visitObject(Obj, "names", visitNames(Record));
-  visitObject(Obj, "location",
-              visitSourceLocation(Record.Location, /*IncludeFileURI=*/true));
-  visitArray(Obj, "availability", visitAvailability(Record.Availabilities));
-  visitObject(Obj, "docComment", visitDocComment(Record.Comment));
-  visitArray(Obj, "declarationFragments",
-             visitDeclarationFragments(Record.Declaration));
+  serializeObject(Obj, "identifier",
+                  serializeIdentifier(Record, API.getLanguage()));
+  serializeObject(Obj, "kind", serializeSymbolKind(Record, API.getLanguage()));
+  serializeObject(Obj, "names", serializeNames(Record));
+  serializeObject(
+      Obj, "location",
+      serializeSourceLocation(Record.Location, /*IncludeFileURI=*/true));
+  serializeArray(Obj, "availability",
+                 serializeAvailability(Record.Availabilities));
+  serializeObject(Obj, "docComment", serializeDocComment(Record.Comment));
+  serializeArray(Obj, "declarationFragments",
+                 serializeDeclarationFragments(Record.Declaration));
   // TODO: Once we keep track of symbol access information serialize it
   // correctly here.
   Obj["accessLevel"] = "public";
   SmallVector<StringRef, 4> PathComponentsNames;
   // If this returns true it indicates that we couldn't find a symbol in the
   // hierarchy.
   if (generatePathComponents(Record, API,
                              [&PathComponentsNames](const PathComponent &PC) {
                                PathComponentsNames.push_back(PC.Name);
                              }))
     return {};
 
-  visitArray(Obj, "pathComponents", Array(PathComponentsNames));
+  serializeArray(Obj, "pathComponents", Array(PathComponentsNames));
 
-  visitFunctionSignatureMixin(Obj, Record);
+  serializeFunctionSignatureMixin(Obj, Record);
 
   return Obj;
 }
 
 template <typename MemberTy>
-void SymbolGraphSerializer::visitMembers(
+void SymbolGraphSerializer::serializeMembers(
     const APIRecord &Record,
     const SmallVector<std::unique_ptr<MemberTy>> &Members) {
   // Members should not be serialized if we aren't recursing.
   if (!ShouldRecurse)
     return;
   for (const auto &Member : Members) {
-    auto MemberRecord = visitAPIRecord(*Member);
+    auto MemberRecord = serializeAPIRecord(*Member);
     if (!MemberRecord)
       continue;
 
     Symbols.emplace_back(std::move(*MemberRecord));
-    visitRelationship(RelationshipKind::MemberOf, *Member, Record);
+    serializeRelationship(RelationshipKind::MemberOf, *Member, Record);
   }
 }
 
 StringRef SymbolGraphSerializer::getRelationshipString(RelationshipKind Kind) {
   switch (Kind) {
   case RelationshipKind::MemberOf:
     return "memberOf";
   case RelationshipKind::InheritsFrom:
     return "inheritsFrom";
   case RelationshipKind::ConformsTo:
     return "conformsTo";
   }
   llvm_unreachable("Unhandled relationship kind");
 }
 
-void SymbolGraphSerializer::visitRelationship(RelationshipKind Kind,
+void SymbolGraphSerializer::serializeRelationship(RelationshipKind Kind,
                                                   SymbolReference Source,
                                                   SymbolReference Target) {
   Object Relationship;
   Relationship["source"] = Source.USR;
   Relationship["target"] = Target.USR;
   Relationship["targetFallback"] = Target.Name;
   Relationship["kind"] = getRelationshipString(Kind);
 
   Relationships.emplace_back(std::move(Relationship));
 }
 
 void SymbolGraphSerializer::visitGlobalFunctionRecord(
     const GlobalFunctionRecord &Record) {
-  auto Obj = visitAPIRecord(Record);
+  auto Obj = serializeAPIRecord(Record);
   if (!Obj)
     return;
 
   Symbols.emplace_back(std::move(*Obj));
 }
 
 void SymbolGraphSerializer::visitGlobalVariableRecord(
     const GlobalVariableRecord &Record) {
-  auto Obj = visitAPIRecord(Record);
+  auto Obj = serializeAPIRecord(Record);
   if (!Obj)
     return;
 
   Symbols.emplace_back(std::move(*Obj));
 }
 
 void SymbolGraphSerializer::visitEnumRecord(const EnumRecord &Record) {
-  auto Enum = visitAPIRecord(Record);
+  auto Enum = serializeAPIRecord(Record);
   if (!Enum)
     return;
 
   Symbols.emplace_back(std::move(*Enum));
-  visitMembers(Record, Record.Constants);
+  serializeMembers(Record, Record.Constants);
 }
 
 void SymbolGraphSerializer::visitStructRecord(const StructRecord &Record) {
-  auto Struct = visitAPIRecord(Record);
+  auto Struct = serializeAPIRecord(Record);
   if (!Struct)
     return;
 
   Symbols.emplace_back(std::move(*Struct));
-  visitMembers(Record, Record.Fields);
+  serializeMembers(Record, Record.Fields);
 }
 
 void SymbolGraphSerializer::visitObjCContainerRecord(
     const ObjCContainerRecord &Record) {
-  auto ObjCContainer = visitAPIRecord(Record);
+  auto ObjCContainer = serializeAPIRecord(Record);
   if (!ObjCContainer)
     return;
 
   Symbols.emplace_back(std::move(*ObjCContainer));
 
-  visitMembers(Record, Record.Ivars);
-  visitMembers(Record, Record.Methods);
-  visitMembers(Record, Record.Properties);
+  serializeMembers(Record, Record.Ivars);
+  serializeMembers(Record, Record.Methods);
+  serializeMembers(Record, Record.Properties);
 
   for (const auto &Protocol : Record.Protocols)
     // Record that Record conforms to Protocol.
-    visitRelationship(RelationshipKind::ConformsTo, Record, Protocol);
+    serializeRelationship(RelationshipKind::ConformsTo, Record, Protocol);
 
   if (auto *ObjCInterface = dyn_cast<ObjCInterfaceRecord>(&Record)) {
     if (!ObjCInterface->SuperClass.empty())
       // If Record is an Objective-C interface record and it has a super class,
       // record that Record is inherited from SuperClass.
-      visitRelationship(RelationshipKind::InheritsFrom, Record,
+      serializeRelationship(RelationshipKind::InheritsFrom, Record,
                             ObjCInterface->SuperClass);
 
     // Members of categories extending an interface are serialized as members of
     // the interface.
     for (const auto *Category : ObjCInterface->Categories) {
-      visitMembers(Record, Category->Ivars);
-      visitMembers(Record, Category->Methods);
-      visitMembers(Record, Category->Properties);
+      serializeMembers(Record, Category->Ivars);
+      serializeMembers(Record, Category->Methods);
+      serializeMembers(Record, Category->Properties);
 
       // Surface the protocols of the category to the interface.
       for (const auto &Protocol : Category->Protocols)
-        visitRelationship(RelationshipKind::ConformsTo, Record, Protocol);
+        serializeRelationship(RelationshipKind::ConformsTo, Record, Protocol);
     }
   }
 }
 
 void SymbolGraphSerializer::visitMacroDefinitionRecord(
     const MacroDefinitionRecord &Record) {
-  auto Macro = visitAPIRecord(Record);
+  auto Macro = serializeAPIRecord(Record);
 
   if (!Macro)
     return;
 
   Symbols.emplace_back(std::move(*Macro));
 }
 
 void SymbolGraphSerializer::visitSingleRecord(const APIRecord *Record) {
case APIRecord::RK_ObjCProtocol:
     break;
   case APIRecord::RK_MacroDefinition:
     visitMacroDefinitionRecord(*cast<MacroDefinitionRecord>(Record));
     break;
   case APIRecord::RK_Typedef:
     visitTypedefRecord(*cast<TypedefRecord>(Record));
     break;
   default:
-    if (auto Obj = visitAPIRecord(*Record)) {
+    if (auto Obj = serializeAPIRecord(*Record)) {
       Symbols.emplace_back(std::move(*Obj));
       auto &ParentInformation = Record->ParentInformation;
       if (!ParentInformation.empty())
-        visitRelationship(RelationshipKind::MemberOf, *Record,
+        serializeRelationship(RelationshipKind::MemberOf, *Record,
                               *ParentInformation.ParentRecord);
     }
     break;
   }
 }
 
 void SymbolGraphSerializer::visitTypedefRecord(const TypedefRecord &Record) {
   // Typedefs of anonymous types have their entries unified with the underlying
   // type.
   bool ShouldDrop = Record.UnderlyingType.Name.empty();
   // enums declared with `NS_OPTION` have a named enum and a named typedef, with
   // the same name
   ShouldDrop |= (Record.UnderlyingType.Name == Record.Name);
   if (ShouldDrop)
     return;
 
-  auto Typedef = visitAPIRecord(Record);
+  auto Typedef = serializeAPIRecord(Record);
   if (!Typedef)
     return;
 
   (*Typedef)["type"] = Record.UnderlyingType.USR;
 
   Symbols.emplace_back(std::move(*Typedef));
 }
 
-Object SymbolGraphSerializer::traverse() {
+Object SymbolGraphSerializer::serialize() {
   APISetVisitor::traverseAPISet();
-  return visitCurrentGraph();
+  return serializeCurrentGraph();
 }
 
-Object SymbolGraphSerializer::visitCurrentGraph() {
+Object SymbolGraphSerializer::serializeCurrentGraph() {
   Object Root;
-  visitObject(Root, "metadata", visitMetadata());
-  visitObject(Root, "module", visitModule());
+  serializeObject(Root, "metadata", serializeMetadata());
+  serializeObject(Root, "module", serializeModule());
 
   Root["symbols"] = std::move(Symbols);
   Root["relationships"] = std::move(Relationships);
 
   return Root;
 }
 
-void SymbolGraphSerializer::traverseAPISet(raw_ostream &os) {
-  Object root = traverse();
+void SymbolGraphSerializer::serialize(raw_ostream &os) {
+  Object root = serialize();
   if (Options.Compact)
     os << formatv("{0}", Value(std::move(root))) << "\n";
   else
     os << formatv("{0:2}", Value(std::move(root))) << "\n";
 }
 
 std::optional<Object>
 SymbolGraphSerializer::serializeSingleSymbolSGF(StringRef USR,
                                                 const APISet &API) {
   APIRecord *Record = API.findRecordForUSR(USR);
   if (!Record)
     return {};
 
   if (isa<ObjCCategoryRecord>(Record))
     return {};
 
   Object Root;
   APIIgnoresList EmptyIgnores;
   SymbolGraphSerializer Serializer(API, EmptyIgnores,
                                    /*Options.Compact*/ {true},
                                    /*ShouldRecurse*/ false);
   Serializer.visitSingleRecord(Record);
-  visitObject(Root, "symbolGraph", Serializer.visitCurrentGraph());
+  serializeObject(Root, "symbolGraph", Serializer.serializeCurrentGraph());
 
   Language Lang = API.getLanguage();
-  visitArray(Root, "parentContexts",
+  serializeArray(Root, "parentContexts",
                  generateParentContexts(*Record, API, Lang));
 
   Array RelatedSymbols;
 
   for (const auto &Fragment : Record->Declaration.getFragments()) {
     // If we don't have a USR there isn't much we can do.
     if (Fragment.PreciseIdentifier.empty())
       continue;
 
     APIRecord *RelatedRecord = API.findRecordForUSR(Fragment.PreciseIdentifier);
 
     // If we can't find the record let's skip.
     if (!RelatedRecord)
       continue;
 
     Object RelatedSymbol;
     RelatedSymbol["usr"] = RelatedRecord->USR;
     RelatedSymbol["declarationLanguage"] = getLanguageName(Lang);
     // TODO: once we record this properly let's serialize it right.
     RelatedSymbol["accessLevel"] = "public";
     RelatedSymbol["filePath"] = RelatedRecord->Location.getFilename();
     RelatedSymbol["moduleName"] = API.ProductName;
     RelatedSymbol["isSystem"] = RelatedRecord->IsFromSystemHeader;
 
-    visitArray(RelatedSymbol, "parentContexts",
+    serializeArray(RelatedSymbol, "parentContexts",
                    generateParentContexts(*RelatedRecord, API, Lang));
     RelatedSymbols.push_back(std::move(RelatedSymbol));
   }
 
-  visitArray(Root, "relatedSymbols", RelatedSymbols);
+  serializeArray(Root, "relatedSymbols", RelatedSymbols);
   return Root;
 }