[clang][extract-api] Emit "functionSignature" in SGF for ObjC methods.

[zixuw]

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

512

I'd prefer not to use dyn_cast as MemberTy here is a concrete type. So maybe a type trait has_function_signature and a if constexpr?

[dang]

Address code review feedback.

Introduce has_function_signature type trait to distinguish records that have a
function signatures.

[dang]

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

512

if constexpr is c++17 which we don't support yet? Anyway I added the type trait and implemented this a bit lower down the "stack" (in serializeAPIRecord) as there are multiple record types that have signatures. This is done using tag dispatch based on the trait.

[zixuw]

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

512

Hmm.. That's a bummer. Didn't realize that when I made the suggestion. I actually don't have that strong an opinion regarding the dyn_cast.
What do you think? Do you think it's still worth going through all these to get the type trait working?

[dang]

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

512

I think it is still worth it, so that we can emit function signatures in APIRecord as multiple types of records need them (and the list of records will keep growing). This could be a useful way of dealing with things like availability information as well.

[zixuw]

LGTM!

clang/include/clang/ExtractAPI/API.h

struct APIRecord {
   ///
   /// SubHeading is an array of declaration fragments of tagged declaration
   /// name, with potentially more tokens (for example the \c +/- symbol for
   /// Objective-C class/instance methods).
   DeclarationFragments SubHeading;
 
   /// Discriminator for LLVM-style RTTI (dyn_cast<> et al.)
   enum RecordKind {
-    RK_Global,
+    RK_GlobalFunction,
+    RK_GlobalVariable,
     RK_EnumConstant,
     RK_Enum,
     RK_StructField,
     RK_Struct,
     RK_ObjCProperty,
     RK_ObjCIvar,
     RK_ObjCMethod,
     RK_ObjCInterface,
APIRecord(RecordKind Kind, StringRef Name, StringRef USR,
       : Name(Name), USR(USR), Location(Location), Availability(Availability),
         Linkage(Linkage), Comment(Comment), Declaration(Declaration),
         SubHeading(SubHeading), Kind(Kind) {}
 
   // Pure virtual destructor to make APIRecord abstract
   virtual ~APIRecord() = 0;
 };
 
-/// The kind of a global record.
-enum class GVKind : uint8_t {
-  Unknown = 0,
-  Variable = 1,
-  Function = 2,
-};
-
-/// This holds information associated with global variables or functions.
-struct GlobalRecord : APIRecord {
-  GVKind GlobalKind;
-
-  /// The function signature of the record if it is a function.
+/// This holds information associated with global functions.
+struct GlobalFunctionRecord : APIRecord {
   FunctionSignature Signature;
 
-  GlobalRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
-               const AvailabilityInfo &Availability, LinkageInfo Linkage,
-               const DocComment &Comment, DeclarationFragments Declaration,
-               DeclarationFragments SubHeading, GVKind Kind,
+  GlobalFunctionRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+                       const AvailabilityInfo &Availability,
+                       LinkageInfo Linkage, const DocComment &Comment,
+                       DeclarationFragments Declaration,
+                       DeclarationFragments SubHeading,
                        FunctionSignature Signature)
-      : APIRecord(RK_Global, Name, USR, Loc, Availability, Linkage, Comment,
-                  Declaration, SubHeading),
-        GlobalKind(Kind), Signature(Signature) {}
+      : APIRecord(RK_GlobalFunction, Name, USR, Loc, Availability, Linkage,
+                  Comment, Declaration, SubHeading),
+        Signature(Signature) {}
+
+  static bool classof(const APIRecord *Record) {
+    return Record->getKind() == RK_GlobalFunction;
+  }
+
+private:
+  virtual void anchor();
+};
+
+/// This holds information associated with global functions.
+struct GlobalVariableRecord : APIRecord {
+  GlobalVariableRecord(StringRef Name, StringRef USR, PresumedLoc Loc,
+                       const AvailabilityInfo &Availability,
+                       LinkageInfo Linkage, const DocComment &Comment,
+                       DeclarationFragments Declaration,
+                       DeclarationFragments SubHeading)
+      : APIRecord(RK_GlobalVariable, Name, USR, Loc, Availability, Linkage,
+                  Comment, Declaration, SubHeading) {}
 
   static bool classof(const APIRecord *Record) {
-    return Record->getKind() == RK_Global;
+    return Record->getKind() == RK_GlobalVariable;
   }
 
 private:
   virtual void anchor();
 };
 
 /// This holds information associated with enum constants.
 struct EnumConstantRecord : APIRecord {
struct TypedefRecord : APIRecord {
   static bool classof(const APIRecord *Record) {
     return Record->getKind() == RK_Typedef;
   }
 
 private:
   virtual void anchor();
 };
 
+/// Check if a record type has a function signature mixin.
+///
+/// This is denoted by the record type having a ``Signature`` field of type
+/// FunctionSignature.
+template <typename RecordTy>
+struct has_function_signature : public std::false_type {};
+template <>
+struct has_function_signature<GlobalFunctionRecord> : public std::true_type {};
+template <>
+struct has_function_signature<ObjCMethodRecord> : public std::true_type {};
+
 /// APISet holds the set of API records collected from given inputs.
 class APISet {
 public:
-  /// Create and add a GlobalRecord of kind \p Kind into the API set.
-  ///
-  /// Note: the caller is responsible for keeping the StringRef \p Name and
-  /// \p USR alive. APISet::copyString provides a way to copy strings into
-  /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
-  /// to generate the USR for \c D and keep it alive in APISet.
-  GlobalRecord *addGlobal(GVKind Kind, StringRef Name, StringRef USR,
-                          PresumedLoc Loc, const AvailabilityInfo &Availability,
-                          LinkageInfo Linkage, const DocComment &Comment,
-                          DeclarationFragments Declaration,
-                          DeclarationFragments SubHeading,
-                          FunctionSignature Signature);
-
   /// Create and add a global variable record into the API set.
   ///
   /// Note: the caller is responsible for keeping the StringRef \p Name and
   /// \p USR alive. APISet::copyString provides a way to copy strings into
   /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
   /// to generate the USR for \c D and keep it alive in APISet.
-  GlobalRecord *addGlobalVar(StringRef Name, StringRef USR, PresumedLoc Loc,
-                             const AvailabilityInfo &Availability,
-                             LinkageInfo Linkage, const DocComment &Comment,
-                             DeclarationFragments Declaration,
-                             DeclarationFragments SubHeading);
+  GlobalVariableRecord *
+  addGlobalVar(StringRef Name, StringRef USR, PresumedLoc Loc,
+               const AvailabilityInfo &Availability, LinkageInfo Linkage,
+               const DocComment &Comment, DeclarationFragments Declaration,
 
   /// Create and add a function record into the API set.
   ///
   /// Note: the caller is responsible for keeping the StringRef \p Name and
   /// \p USR alive. APISet::copyString provides a way to copy strings into
   /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
   /// to generate the USR for \c D and keep it alive in APISet.
-  GlobalRecord *addFunction(StringRef Name, StringRef USR, PresumedLoc Loc,
-                            const AvailabilityInfo &Availability,
-                            LinkageInfo Linkage, const DocComment &Comment,
-                            DeclarationFragments Declaration,
-                            DeclarationFragments SubHeading,
-                            FunctionSignature Signature);
+  GlobalFunctionRecord *
+  addGlobalFunction(StringRef Name, StringRef USR, PresumedLoc Loc,
+                    const AvailabilityInfo &Availability, LinkageInfo Linkage,
+                    const DocComment &Comment, DeclarationFragments Declaration,
 
   /// Create and add an enum constant record into the API set.
   ///
   /// Note: the caller is responsible for keeping the StringRef \p Name and
   /// \p USR alive. APISet::copyString provides a way to copy strings into
   /// APISet itself, and APISet::recordUSR(const Decl *D) is a helper method
   /// to generate the USR for \c D and keep it alive in APISet.
   EnumConstantRecord *addEnumConstant(EnumRecord *Enum, StringRef Name,
public:
   using RecordMap = llvm::MapVector<StringRef, std::unique_ptr<RecordTy>>;
 
   /// Get the target triple for the ExtractAPI invocation.
   const llvm::Triple &getTarget() const { return Target; }
 
   /// Get the language used by the APIs.
   Language getLanguage() const { return Lang; }
 
-  const RecordMap<GlobalRecord> &getGlobals() const { return Globals; }
+  const RecordMap<GlobalFunctionRecord> &getGlobalFunctions() const {
+    return GlobalFunctions;
+  }
+  const RecordMap<GlobalVariableRecord> &getGlobalVariables() const {
+    return GlobalVariables;
+  }
   const RecordMap<EnumRecord> &getEnums() const { return Enums; }
   const RecordMap<StructRecord> &getStructs() const { return Structs; }
   const RecordMap<ObjCCategoryRecord> &getObjCCategories() const {
     return ObjCCategories;
   }
   const RecordMap<ObjCInterfaceRecord> &getObjCInterfaces() const {
     return ObjCInterfaces;
   }
private:
   /// BumpPtrAllocator to store generated/copied strings.
   ///
   /// Note: The main use for this is being able to deduplicate strings.
   llvm::BumpPtrAllocator StringAllocator;
 
   const llvm::Triple Target;
   const Language Lang;
 
-  RecordMap<GlobalRecord> Globals;
+  RecordMap<GlobalFunctionRecord> GlobalFunctions;
+  RecordMap<GlobalVariableRecord> GlobalVariables;
   RecordMap<EnumRecord> Enums;
   RecordMap<StructRecord> Structs;
   RecordMap<ObjCCategoryRecord> ObjCCategories;
   RecordMap<ObjCInterfaceRecord> ObjCInterfaces;
   RecordMap<ObjCProtocolRecord> ObjCProtocols;
   RecordMap<MacroDefinitionRecord> Macros;
   RecordMap<TypedefRecord> Typedefs;
 };
 
 } // namespace extractapi
 } // namespace clang
 
 #endif // LLVM_CLANG_EXTRACTAPI_API_H

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

private:
   /// 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 None if this \p Record should be skipped, or a JSON object
   /// containing common symbol information of \p Record.
-  Optional<Object> serializeAPIRecord(const APIRecord &Record) const;
+  template <typename RecordTy>
+  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 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 serializeRelationship(RelationshipKind Kind, SymbolReference Source,
                              SymbolReference Target);
 
-  /// Serialize a global record.
-  void serializeGlobalRecord(const GlobalRecord &Record);
+  /// Serialize a global function record.
+  void serializeGlobalFunctionRecord(const GlobalFunctionRecord &Record);
+
+  /// Serialize a global variable record.
+  void serializeGlobalVariableRecord(const GlobalVariableRecord &Record);
 
   /// Serialize an enum record.
   void serializeEnumRecord(const EnumRecord &Record);
 
   /// Serialize a struct record.
   void serializeStructRecord(const StructRecord &Record);
 
   /// Serialize an Objective-C container record.

clang/lib/ExtractAPI/API.cpp

if (Result.second)
     Result.first->second =
         std::make_unique<RecordTy>(Name, std::forward<CtorArgsTy>(CtorArgs)...);
 
   return Result.first->second.get();
 }
 
 } // namespace
 
-GlobalRecord *APISet::addGlobal(GVKind Kind, StringRef Name, StringRef USR,
-                                PresumedLoc Loc,
-                                const AvailabilityInfo &Availability,
-                                LinkageInfo Linkage, const DocComment &Comment,
-                                DeclarationFragments Fragments,
-                                DeclarationFragments SubHeading,
-                                FunctionSignature Signature) {
-  return addTopLevelRecord(Globals, Name, USR, Loc, Availability, Linkage,
-                           Comment, Fragments, SubHeading, Kind, Signature);
-}
-
-GlobalRecord *
+GlobalVariableRecord *
 APISet::addGlobalVar(StringRef Name, StringRef USR, PresumedLoc Loc,
                      const AvailabilityInfo &Availability, LinkageInfo Linkage,
                      const DocComment &Comment, DeclarationFragments Fragments,
                      DeclarationFragments SubHeading) {
-  return addGlobal(GVKind::Variable, Name, USR, Loc, Availability, Linkage,
-                   Comment, Fragments, SubHeading, {});
+  return addTopLevelRecord(GlobalVariables, Name, USR, Loc, Availability,
+                           Linkage, Comment, Fragments, SubHeading);
 }
 
-GlobalRecord *
-APISet::addFunction(StringRef Name, StringRef USR, PresumedLoc Loc,
-                    const AvailabilityInfo &Availability, LinkageInfo Linkage,
-                    const DocComment &Comment, DeclarationFragments Fragments,
-                    DeclarationFragments SubHeading,
-                    FunctionSignature Signature) {
-  return addGlobal(GVKind::Function, Name, USR, Loc, Availability, Linkage,
-                   Comment, Fragments, SubHeading, Signature);
+GlobalFunctionRecord *APISet::addGlobalFunction(
+    StringRef Name, StringRef USR, PresumedLoc Loc,
+    DeclarationFragments SubHeading, FunctionSignature Signature) {
+  return addTopLevelRecord(GlobalFunctions, Name, USR, Loc, Availability,
+                           Linkage, Comment, Fragments, SubHeading, Signature);
 }
 
 EnumConstantRecord *APISet::addEnumConstant(
     EnumRecord *Enum, StringRef Name, StringRef USR, PresumedLoc Loc,
     const AvailabilityInfo &Availability, const DocComment &Comment,
     DeclarationFragments Declaration, DeclarationFragments SubHeading) {
   auto Record = std::make_unique<EnumConstantRecord>(
       Name, USR, Loc, Availability, Comment, Declaration, SubHeading);
StringRef APISet::copyString(StringRef String) {
   memcpy(Ptr, String.data(), String.size());
   return StringRef(reinterpret_cast<const char *>(Ptr), String.size());
 }
 
 APIRecord::~APIRecord() {}
 
 ObjCContainerRecord::~ObjCContainerRecord() {}
 
-void GlobalRecord::anchor() {}
+void GlobalFunctionRecord::anchor() {}
+void GlobalVariableRecord::anchor() {}
 void EnumConstantRecord::anchor() {}
 void EnumRecord::anchor() {}
 void StructFieldRecord::anchor() {}
 void StructRecord::anchor() {}
 void ObjCPropertyRecord::anchor() {}
 void ObjCInstanceVariableRecord::anchor() {}
 void ObjCMethodRecord::anchor() {}
 void ObjCCategoryRecord::anchor() {}
 void ObjCInterfaceRecord::anchor() {}
 void ObjCProtocolRecord::anchor() {}
 void MacroDefinitionRecord::anchor() {}
 void TypedefRecord::anchor() {}

clang/lib/ExtractAPI/ExtractAPIConsumer.cpp

bool VisitFunctionDecl(const FunctionDecl *Decl) {
     DeclarationFragments Declaration =
         DeclarationFragmentsBuilder::getFragmentsForFunction(Decl);
     DeclarationFragments SubHeading =
         DeclarationFragmentsBuilder::getSubHeading(Decl);
     FunctionSignature Signature =
         DeclarationFragmentsBuilder::getFunctionSignature(Decl);
 
     // Add the function record to the API set.
-    API.addFunction(Name, USR, Loc, Availability, Linkage, Comment, Declaration,
-                    SubHeading, Signature);
+    API.addGlobalFunction(Name, USR, Loc, Availability, Linkage, Comment,
+                          Declaration, SubHeading, Signature);
     return true;
   }
 
   bool VisitEnumDecl(const EnumDecl *Decl) {
     if (!Decl->isComplete())
       return true;
 
     // Skip forward declaration.

clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp

 
 #include "clang/ExtractAPI/Serialization/SymbolGraphSerializer.h"
 #include "clang/Basic/Version.h"
 #include "clang/ExtractAPI/API.h"
 #include "clang/ExtractAPI/DeclarationFragments.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/VersionTuple.h"
+#include <type_traits>
 
 using namespace clang;
 using namespace clang::extractapi;
 using namespace llvm;
 using namespace llvm::json;
 
 namespace {
 
for (const auto &F : DF.getFragments()) {
     if (!F.PreciseIdentifier.empty())
       Fragment["preciseIdentifier"] = F.PreciseIdentifier;
     Fragments.emplace_back(std::move(Fragment));
   }
 
   return Fragments;
 }
 
-/// Serialize the function signature field of a function, 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 None if \p FS is empty, or an \c Object containing the
-/// formatted function signature.
-Optional<Object> serializeFunctionSignature(const FunctionSignature &FS) {
-  if (FS.empty())
-    return None;
-
-  Object Signature;
-  serializeArray(Signature, "returns",
-                 serializeDeclarationFragments(FS.getReturnType()));
-
-  Array Parameters;
-  for (const auto &P : FS.getParameters()) {
-    Object Parameter;
-    Parameter["name"] = P.Name;
-    serializeArray(Parameter, "declarationFragments",
-                   serializeDeclarationFragments(P.Fragments));
-    Parameters.emplace_back(std::move(Parameter));
-  }
-
-  if (!Parameters.empty())
-    Signature["parameters"] = std::move(Parameters);
-
-  return Signature;
-}
-
 /// Serialize the \c names field of a symbol as specified by the Symbol Graph
 /// 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

 /// the kind, and a \c displayName for rendering human-readable names.
 Object serializeSymbolKind(const APIRecord &Record, Language Lang) {
   auto AddLangPrefix = [&Lang](StringRef S) -> std::string {
     return (getLanguageName(Lang) + "." + S).str();
   };
 
   Object Kind;
   switch (Record.getKind()) {
-  case APIRecord::RK_Global: {
-    auto *GR = dyn_cast<GlobalRecord>(&Record);
-    switch (GR->GlobalKind) {
-    case GVKind::Function:
-      Kind["identifier"] = AddLangPrefix("func");
-      Kind["displayName"] = "Function";
-      break;
-    case GVKind::Variable:
-      Kind["identifier"] = AddLangPrefix("var");
-      Kind["displayName"] = "Global Variable";
-      break;
-    case GVKind::Unknown:
-      // Unknown global kind
-      break;
-    }
-    break;
-  }
+  case APIRecord::RK_GlobalFunction:
+  case APIRecord::RK_GlobalVariable:
   case APIRecord::RK_EnumConstant:
     Kind["identifier"] = AddLangPrefix("enum.case");
     Kind["displayName"] = "Enumeration Case";
     break;
   case APIRecord::RK_Enum:
     Kind["identifier"] = AddLangPrefix("enum");
     Kind["displayName"] = "Enumeration";
     break;
case APIRecord::RK_Typedef:
     Kind["identifier"] = AddLangPrefix("typealias");
     Kind["displayName"] = "Type Alias";
     break;
   }
 
   return Kind;
 }
 
+template <typename RecordTy>
+Optional<Object> serializeFunctionSignatureMixinImpl(const RecordTy &Record,
+                                                     std::true_type) {
+  const auto &FS = Record.Signature;
+  if (FS.empty())
+    return None;
+
+  Object Signature;
+  serializeArray(Signature, "returns",
+                 serializeDeclarationFragments(FS.getReturnType()));
+
+  Array Parameters;
+  for (const auto &P : FS.getParameters()) {
+    Object Parameter;
+    Parameter["name"] = P.Name;
+    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>
+Optional<Object> serializeFunctionSignatureMixinImpl(const RecordTy &Record,
+                                                     std::false_type) {
+  return None;
+}
+
+/// 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 None if \p FS is empty, or an \c Object containing the
+/// formatted function signature.
+template <typename RecordTy>
+void serializeFunctionSignatureMixin(Object &Paren, const RecordTy &Record) {
+  serializeObject(Paren, "functionSignature",
+                  serializeFunctionSignatureMixinImpl(
+                      Record, has_function_signature<RecordTy>()));
+}
+
 } // namespace
 
 void SymbolGraphSerializer::anchor() {}
 
 /// Defines the format version emitted by SymbolGraphSerializer.
 const VersionTuple SymbolGraphSerializer::FormatVersion{0, 5, 3};
 
 Object SymbolGraphSerializer::serializeMetadata() const {

 bool SymbolGraphSerializer::shouldSkip(const APIRecord &Record) const {
   // Skip unconditionally unavailable symbols
   if (Record.Availability.isUnconditionallyUnavailable())
     return true;
 
   return false;
 }
 
+template <typename RecordTy>
 Optional<Object>
-SymbolGraphSerializer::serializeAPIRecord(const APIRecord &Record) const {
+SymbolGraphSerializer::serializeAPIRecord(const RecordTy &Record) const {
   if (shouldSkip(Record))
     return None;
 
   Object Obj;
   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));
   serializeObject(Obj, "availbility",
                   serializeAvailability(Record.Availability));
   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";
   serializeArray(Obj, "pathComponents", Array(PathComponents));
 
+  serializeFunctionSignatureMixin(Obj, Record);
+
   return Obj;
 }
 
 template <typename MemberTy>
 void SymbolGraphSerializer::serializeMembers(
     const APIRecord &Record,
     const SmallVector<std::unique_ptr<MemberTy>> &Members) {
   for (const auto &Member : Members) {
     auto MemberPathComponentGuard = makePathComponentGuard(Member->Name);
     auto MemberRecord = serializeAPIRecord(*Member);
     if (!MemberRecord)
       continue;
 
     Symbols.emplace_back(std::move(*MemberRecord));
     serializeRelationship(RelationshipKind::MemberOf, *Member, Record);
   }
 }
 
 StringRef SymbolGraphSerializer::getRelationshipString(RelationshipKind Kind) {
   switch (Kind) {
   case RelationshipKind::MemberOf:
     return "memberOf";
void SymbolGraphSerializer::serializeRelationship(RelationshipKind Kind,
   Object Relationship;
   Relationship["source"] = Source.USR;
   Relationship["target"] = Target.USR;
   Relationship["kind"] = getRelationshipString(Kind);
 
   Relationships.emplace_back(std::move(Relationship));
 }
 
-void SymbolGraphSerializer::serializeGlobalRecord(const GlobalRecord &Record) {
+void SymbolGraphSerializer::serializeGlobalFunctionRecord(
+    const GlobalFunctionRecord &Record) {
   auto GlobalPathComponentGuard = makePathComponentGuard(Record.Name);
 
   auto Obj = serializeAPIRecord(Record);
   if (!Obj)
     return;
 
-  if (Record.GlobalKind == GVKind::Function)
-    serializeObject(*Obj, "functionSignature",
-                    serializeFunctionSignature(Record.Signature));
+  Symbols.emplace_back(std::move(*Obj));
+}
+
+void SymbolGraphSerializer::serializeGlobalVariableRecord(
+    const GlobalVariableRecord &Record) {
+  auto GlobalPathComponentGuard = makePathComponentGuard(Record.Name);
+
+  auto Obj = serializeAPIRecord(Record);
+  if (!Obj)
+    return;
 
   Symbols.emplace_back(std::move(*Obj));
 }
 
 void SymbolGraphSerializer::serializeEnumRecord(const EnumRecord &Record) {
   auto EnumPathComponentGuard = makePathComponentGuard(Record.Name);
   auto Enum = serializeAPIRecord(Record);
   if (!Enum)
SymbolGraphSerializer::makePathComponentGuard(StringRef Component) {
   return PathComponentGuard(PathComponents, Component);
 }
 
 Object SymbolGraphSerializer::serialize() {
   Object Root;
   serializeObject(Root, "metadata", serializeMetadata());
   serializeObject(Root, "module", serializeModule());
 
-  // Serialize global records in the API set.
-  for (const auto &Global : API.getGlobals())
-    serializeGlobalRecord(*Global.second);
+  // Serialize global variables in the API set.
+  for (const auto &GlobalVar : API.getGlobalVariables())
+    serializeGlobalVariableRecord(*GlobalVar.second);
+
+  for (const auto &GlobalFunction : API.getGlobalFunctions())
+    serializeGlobalFunctionRecord(*GlobalFunction.second);
 
   // Serialize enum records in the API set.
   for (const auto &Enum : API.getEnums())
     serializeEnumRecord(*Enum.second);
 
   // Serialize struct records in the API set.
   for (const auto &Struct : API.getStructs())
     serializeStructRecord(*Struct.second);

clang/test/ExtractAPI/objc_category.m

"symbols": [
           "kind": "identifier",
           "spelling": "InstanceMethod"
         },
         {
           "kind": "text",
           "spelling": ";"
         }
       ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
       "identifier": {
         "interfaceLanguage": "objective-c",
         "precise": "c:objc(cs)Interface(im)InstanceMethod"
       },
       "kind": {
         "displayName": "Instance Method",
         "identifier": "objective-c.method"
       },
"symbols": [
           "kind": "identifier",
           "spelling": "ClassMethod"
         },
         {
           "kind": "text",
           "spelling": ";"
         }
       ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
       "identifier": {
         "interfaceLanguage": "objective-c",
         "precise": "c:objc(cs)Interface(cm)ClassMethod"
       },
       "kind": {
         "displayName": "Type Method",
         "identifier": "objective-c.type.method"
       },

clang/test/ExtractAPI/objc_interface.m

"symbols": [
           "kind": "internalParam",
           "spelling": "Property"
         },
         {
           "kind": "text",
           "spelling": ";"
         }
       ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "text",
+                "spelling": "("
+              },
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:i",
+                "spelling": "unsigned int"
+              },
+              {
+                "kind": "text",
+                "spelling": ") "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "Property"
+              }
+            ],
+            "name": "Property"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "keyword",
+            "spelling": "id"
+          }
+        ]
+      },
       "identifier": {
         "interfaceLanguage": "objective-c",
         "precise": "c:objc(cs)Super(cm)getWithProperty:"
       },
       "kind": {
         "displayName": "Type Method",
         "identifier": "objective-c.type.method"
       },
"symbols": [
           "kind": "internalParam",
           "spelling": "Thing"
         },
         {
           "kind": "text",
           "spelling": ";"
         }
       ],
+      "functionSignature": {
+        "parameters": [
+          {
+            "declarationFragments": [
+              {
+                "kind": "text",
+                "spelling": "("
+              },
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:i",
+                "spelling": "unsigned int"
+              },
+              {
+                "kind": "text",
+                "spelling": ") "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "Property"
+              }
+            ],
+            "name": "Property"
+          },
+          {
+            "declarationFragments": [
+              {
+                "kind": "text",
+                "spelling": "("
+              },
+              {
+                "kind": "typeIdentifier",
+                "preciseIdentifier": "c:i",
+                "spelling": "unsigned int"
+              },
+              {
+                "kind": "text",
+                "spelling": ") "
+              },
+              {
+                "kind": "internalParam",
+                "spelling": "Thing"
+              }
+            ],
+            "name": "Thing"
+          }
+        ],
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:v",
+            "spelling": "void"
+          }
+        ]
+      },
       "identifier": {
         "interfaceLanguage": "objective-c",
         "precise": "c:objc(cs)Super(im)setProperty:andOtherThing:"
       },
       "kind": {
         "displayName": "Instance Method",
         "identifier": "objective-c.method"
       },
"symbols": [
           "kind": "identifier",
           "spelling": "getIvar"
         },
         {
           "kind": "text",
           "spelling": ";"
         }
       ],
+      "functionSignature": {
+        "returns": [
+          {
+            "kind": "typeIdentifier",
+            "preciseIdentifier": "c:C",
+            "spelling": "char"
+          }
+        ]
+      },
       "identifier": {
         "interfaceLanguage": "objective-c",
         "precise": "c:objc(cs)Derived(im)getIvar"
       },
       "kind": {
         "displayName": "Instance Method",
         "identifier": "objective-c.method"
       },