From 209a1e8dfdf1c104dd53b50eb196d6bc0dd01659 Mon Sep 17 00:00:00 2001 From: Daniel Grumberg Date: Tue, 2 Apr 2024 15:34:52 +0100 Subject: Revert "[clang][ExtractAPI] Add ability to create multiple symbol graphs (#86676)" This failed the test suite due to missing DiagGroup for a new warning. This reverts commit b31414bf4f9898f7817a9fcf8a91f62ec26f3eaf. --- .../Serialization/SymbolGraphSerializer.cpp | 943 ++++++++++++--------- 1 file changed, 564 insertions(+), 379 deletions(-) (limited to 'clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp') diff --git a/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp b/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp index 57f966c..545860a 100644 --- a/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp +++ b/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp @@ -14,17 +14,13 @@ #include "clang/ExtractAPI/Serialization/SymbolGraphSerializer.h" #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Version.h" -#include "clang/ExtractAPI/API.h" #include "clang/ExtractAPI/DeclarationFragments.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/Path.h" #include "llvm/Support/VersionTuple.h" -#include "llvm/Support/raw_ostream.h" -#include #include #include @@ -37,27 +33,26 @@ namespace { /// Helper function to inject a JSON object \p Obj into another object \p Paren /// at position \p Key. -void serializeObject(Object &Paren, StringRef Key, - std::optional &&Obj) { +void serializeObject(Object &Paren, StringRef Key, std::optional Obj) { if (Obj) Paren[Key] = std::move(*Obj); } +/// Helper function to inject a StringRef \p String into an object \p Paren at +/// position \p Key +void serializeString(Object &Paren, StringRef Key, + std::optional String) { + if (String) + Paren[Key] = std::move(*String); +} + /// Helper function to inject a JSON array \p Array into object \p Paren at /// position \p Key. -void serializeArray(Object &Paren, StringRef Key, - std::optional &&Array) { +void serializeArray(Object &Paren, StringRef Key, std::optional Array) { if (Array) Paren[Key] = std::move(*Array); } -/// Helper function to inject a JSON array composed of the values in \p C into -/// object \p Paren at position \p Key. -template -void serializeArray(Object &Paren, StringRef Key, ContainerTy &&C) { - Paren[Key] = Array(C); -} - /// Serialize a \c VersionTuple \p V with the Symbol Graph semantic version /// format. /// @@ -253,7 +248,6 @@ std::optional serializeDocComment(const DocComment &Comment) { return std::nullopt; Object DocComment; - Array LinesArray; for (const auto &CommentLine : Comment) { Object Line; @@ -262,8 +256,7 @@ std::optional serializeDocComment(const DocComment &Comment) { serializeSourceRange(CommentLine.Begin, CommentLine.End)); LinesArray.emplace_back(std::move(Line)); } - - serializeArray(DocComment, "lines", std::move(LinesArray)); + serializeArray(DocComment, "lines", LinesArray); return DocComment; } @@ -329,14 +322,19 @@ serializeDeclarationFragments(const DeclarationFragments &DF) { /// - \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 serializeNames(const APIRecord *Record) { +Object serializeNames(const APIRecord &Record) { Object Names; - Names["title"] = Record->Name; + if (auto *CategoryRecord = + dyn_cast_or_null(&Record)) + Names["title"] = + (CategoryRecord->Interface.Name + " (" + Record.Name + ")").str(); + else + Names["title"] = Record.Name; serializeArray(Names, "subHeading", - serializeDeclarationFragments(Record->SubHeading)); + serializeDeclarationFragments(Record.SubHeading)); DeclarationFragments NavigatorFragments; - NavigatorFragments.append(Record->Name, + NavigatorFragments.append(Record.Name, DeclarationFragments::FragmentKind::Identifier, /*PreciseIdentifier*/ ""); serializeArray(Names, "navigator", @@ -353,8 +351,7 @@ Object serializeSymbolKind(APIRecord::RecordKind RK, Language Lang) { Object Kind; switch (RK) { case APIRecord::RK_Unknown: - Kind["identifier"] = AddLangPrefix("unknown"); - Kind["displayName"] = "Unknown"; + llvm_unreachable("Records should have an explicit kind"); break; case APIRecord::RK_Namespace: Kind["identifier"] = AddLangPrefix("namespace"); @@ -487,6 +484,10 @@ Object serializeSymbolKind(APIRecord::RecordKind RK, Language Lang) { Kind["identifier"] = AddLangPrefix("class.extension"); Kind["displayName"] = "Class Extension"; break; + case APIRecord::RK_ObjCCategoryModule: + Kind["identifier"] = AddLangPrefix("module.extension"); + Kind["displayName"] = "Module Extension"; + break; case APIRecord::RK_ObjCProtocol: Kind["identifier"] = AddLangPrefix("protocol"); Kind["displayName"] = "Protocol"; @@ -499,8 +500,6 @@ Object serializeSymbolKind(APIRecord::RecordKind RK, Language Lang) { Kind["identifier"] = AddLangPrefix("typealias"); Kind["displayName"] = "Type Alias"; break; - default: - llvm_unreachable("API Record with uninstantiable kind"); } return Kind; @@ -515,18 +514,12 @@ Object serializeSymbolKind(const APIRecord &Record, Language Lang) { return serializeSymbolKind(Record.getKind(), Lang); } -/// 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. template -void serializeFunctionSignatureMixin(Object &Paren, const RecordTy &Record) { +std::optional +serializeFunctionSignatureMixinImpl(const RecordTy &Record, std::true_type) { const auto &FS = Record.Signature; if (FS.empty()) - return; + return std::nullopt; Object Signature; serializeArray(Signature, "returns", @@ -544,14 +537,63 @@ void serializeFunctionSignatureMixin(Object &Paren, const RecordTy &Record) { if (!Parameters.empty()) Signature["parameters"] = std::move(Parameters); - serializeObject(Paren, "functionSignature", std::move(Signature)); + return Signature; } template -void serializeTemplateMixin(Object &Paren, const RecordTy &Record) { +std::optional +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 +void serializeFunctionSignatureMixin(Object &Paren, const RecordTy &Record) { + serializeObject(Paren, "functionSignature", + serializeFunctionSignatureMixinImpl( + Record, has_function_signature())); +} + +template +std::optional serializeAccessMixinImpl(const RecordTy &Record, + std::true_type) { + const auto &AccessControl = Record.Access; + std::string Access; + if (AccessControl.empty()) + return std::nullopt; + Access = AccessControl.getAccess(); + return Access; +} + +template +std::optional serializeAccessMixinImpl(const RecordTy &Record, + std::false_type) { + return std::nullopt; +} + +template +void serializeAccessMixin(Object &Paren, const RecordTy &Record) { + auto accessLevel = serializeAccessMixinImpl(Record, has_access()); + if (!accessLevel.has_value()) + accessLevel = "public"; + serializeString(Paren, "accessLevel", accessLevel); +} + +template +std::optional serializeTemplateMixinImpl(const RecordTy &Record, + std::true_type) { const auto &Template = Record.Templ; if (Template.empty()) - return; + return std::nullopt; Object Generics; Array GenericParameters; @@ -577,66 +619,97 @@ void serializeTemplateMixin(Object &Paren, const RecordTy &Record) { if (!GenericConstraints.empty()) Generics["constraints"] = std::move(GenericConstraints); - serializeObject(Paren, "swiftGenerics", Generics); + return Generics; } -Array generateParentContexts(const SmallVectorImpl &Parents, - Language Lang) { - Array ParentContexts; - - for (const auto &Parent : Parents) { - Object Elem; - Elem["usr"] = Parent.USR; - Elem["name"] = Parent.Name; - if (Parent.Record) - Elem["kind"] = - serializeSymbolKind(Parent.Record->getKind(), Lang)["identifier"]; - else - Elem["kind"] = - serializeSymbolKind(APIRecord::RK_Unknown, Lang)["identifier"]; - ParentContexts.emplace_back(std::move(Elem)); - } +template +std::optional serializeTemplateMixinImpl(const RecordTy &Record, + std::false_type) { + return std::nullopt; +} - return ParentContexts; +template +void serializeTemplateMixin(Object &Paren, const RecordTy &Record) { + serializeObject(Paren, "swiftGenerics", + serializeTemplateMixinImpl(Record, has_template())); } -/// Walk the records parent information in reverse to generate a hierarchy -/// suitable for serialization. -SmallVector -generateHierarchyFromRecord(const APIRecord *Record) { - SmallVector ReverseHierarchy; - for (const auto *Current = Record; Current != nullptr; - Current = Current->Parent.Record) - ReverseHierarchy.emplace_back(Current); - - return SmallVector( - std::make_move_iterator(ReverseHierarchy.rbegin()), - std::make_move_iterator(ReverseHierarchy.rend())); -} - -SymbolReference getHierarchyReference(const APIRecord *Record, - const APISet &API) { - // If the parent is a category extended from internal module then we need to - // pretend this belongs to the associated interface. - if (auto *CategoryRecord = dyn_cast_or_null(Record)) { - return CategoryRecord->Interface; - // FIXME: TODO generate path components correctly for categories extending - // an external module. +struct PathComponent { + StringRef USR; + StringRef Name; + APIRecord::RecordKind Kind; + + PathComponent(StringRef USR, StringRef Name, APIRecord::RecordKind Kind) + : USR(USR), Name(Name), Kind(Kind) {} +}; + +template +bool generatePathComponents( + const RecordTy &Record, const APISet &API, + function_ref ComponentTransformer) { + SmallVector ReverseComponenents; + ReverseComponenents.emplace_back(Record.USR, Record.Name, Record.getKind()); + const auto *CurrentParent = &Record.ParentInformation; + bool FailedToFindParent = false; + while (CurrentParent && !CurrentParent->empty()) { + PathComponent CurrentParentComponent(CurrentParent->ParentUSR, + CurrentParent->ParentName, + CurrentParent->ParentKind); + + auto *ParentRecord = CurrentParent->ParentRecord; + // Slow path if we don't have a direct reference to the ParentRecord + if (!ParentRecord) + ParentRecord = API.findRecordForUSR(CurrentParent->ParentUSR); + + // If the parent is a category extended from internal module then we need to + // pretend this belongs to the associated interface. + if (auto *CategoryRecord = + dyn_cast_or_null(ParentRecord)) { + if (!CategoryRecord->IsFromExternalModule) { + ParentRecord = API.findRecordForUSR(CategoryRecord->Interface.USR); + CurrentParentComponent = PathComponent(CategoryRecord->Interface.USR, + CategoryRecord->Interface.Name, + APIRecord::RK_ObjCInterface); + } + } + + // The parent record doesn't exist which means the symbol shouldn't be + // treated as part of the current product. + if (!ParentRecord) { + FailedToFindParent = true; + break; + } + + ReverseComponenents.push_back(std::move(CurrentParentComponent)); + CurrentParent = &ParentRecord->ParentInformation; } - return SymbolReference(Record); -} + for (const auto &PC : reverse(ReverseComponenents)) + ComponentTransformer(PC); -} // namespace + return FailedToFindParent; +} -Object *ExtendedModule::addSymbol(Object &&Symbol) { - Symbols.emplace_back(std::move(Symbol)); - return Symbols.back().getAsObject(); +Object serializeParentContext(const PathComponent &PC, Language Lang) { + Object ParentContextElem; + ParentContextElem["usr"] = PC.USR; + ParentContextElem["name"] = PC.Name; + ParentContextElem["kind"] = serializeSymbolKind(PC.Kind, Lang)["identifier"]; + return ParentContextElem; } -void ExtendedModule::addRelationship(Object &&Relationship) { - Relationships.emplace_back(std::move(Relationship)); +template +Array generateParentContexts(const RecordTy &Record, const APISet &API, + Language Lang) { + Array ParentContexts; + generatePathComponents( + Record, API, [Lang, &ParentContexts](const PathComponent &PC) { + ParentContexts.push_back(serializeParentContext(PC, Lang)); + }); + + return ParentContexts; } +} // namespace /// Defines the format version emitted by SymbolGraphSerializer. const VersionTuple SymbolGraphSerializer::FormatVersion{0, 5, 3}; @@ -649,44 +722,84 @@ Object SymbolGraphSerializer::serializeMetadata() const { return Metadata; } -Object -SymbolGraphSerializer::serializeModuleObject(StringRef ModuleName) const { +Object SymbolGraphSerializer::serializeModule() const { Object Module; - Module["name"] = ModuleName; + // The user is expected to always pass `--product-name=` on the command line + // to populate this field. + Module["name"] = API.ProductName; serializeObject(Module, "platform", serializePlatform(API.getTarget())); return Module; } -bool SymbolGraphSerializer::shouldSkip(const APIRecord *Record) const { - if (!Record) +bool SymbolGraphSerializer::shouldSkip(const APIRecord &Record) const { + // Skip explicitly ignored symbols. + if (IgnoresList.shouldIgnore(Record.Name)) return true; // Skip unconditionally unavailable symbols - if (Record->Availability.isUnconditionallyUnavailable()) + if (Record.Availability.isUnconditionallyUnavailable()) return true; // Filter out symbols prefixed with an underscored as they are understood to // be symbols clients should not use. - if (Record->Name.starts_with("_")) - return true; - - // Skip explicitly ignored symbols. - if (IgnoresList.shouldIgnore(Record->Name)) + if (Record.Name.starts_with("_")) return true; return false; } -ExtendedModule &SymbolGraphSerializer::getModuleForCurrentSymbol() { - if (!ForceEmitToMainModule && ModuleForCurrentSymbol) - return *ModuleForCurrentSymbol; +template +std::optional +SymbolGraphSerializer::serializeAPIRecord(const RecordTy &Record) const { + if (shouldSkip(Record)) + return std::nullopt; + + 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)); + serializeArray(Obj, "availability", + serializeAvailability(Record.Availability)); + serializeObject(Obj, "docComment", serializeDocComment(Record.Comment)); + serializeArray(Obj, "declarationFragments", + serializeDeclarationFragments(Record.Declaration)); + SmallVector 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 {}; + + serializeArray(Obj, "pathComponents", Array(PathComponentsNames)); - return MainModule; + serializeFunctionSignatureMixin(Obj, Record); + serializeAccessMixin(Obj, Record); + serializeTemplateMixin(Obj, Record); + + return Obj; } -Array SymbolGraphSerializer::serializePathComponents( - const APIRecord *Record) const { - return Array(map_range(Hierarchy, [](auto Elt) { return Elt.Name; })); +template +void SymbolGraphSerializer::serializeMembers( + const APIRecord &Record, + const SmallVector> &Members) { + // Members should not be serialized if we aren't recursing. + if (!ShouldRecurse) + return; + for (const auto &Member : Members) { + auto MemberRecord = serializeAPIRecord(*Member); + if (!MemberRecord) + continue; + + Symbols.emplace_back(std::move(*MemberRecord)); + serializeRelationship(RelationshipKind::MemberOf, *Member, Record); + } } StringRef SymbolGraphSerializer::getRelationshipString(RelationshipKind Kind) { @@ -703,33 +816,6 @@ StringRef SymbolGraphSerializer::getRelationshipString(RelationshipKind Kind) { llvm_unreachable("Unhandled relationship kind"); } -void SymbolGraphSerializer::serializeRelationship(RelationshipKind Kind, - const SymbolReference &Source, - const SymbolReference &Target, - ExtendedModule &Into) { - Object Relationship; - SmallString<64> TestRelLabel; - if (EmitSymbolLabelsForTesting) { - llvm::raw_svector_ostream OS(TestRelLabel); - OS << SymbolGraphSerializer::getRelationshipString(Kind) << " $ " - << Source.USR << " $ "; - if (Target.USR.empty()) - OS << Target.Name; - else - OS << Target.USR; - Relationship["!testRelLabel"] = TestRelLabel; - } - Relationship["source"] = Source.USR; - Relationship["target"] = Target.USR; - Relationship["targetFallback"] = Target.Name; - Relationship["kind"] = SymbolGraphSerializer::getRelationshipString(Kind); - - if (ForceEmitToMainModule) - MainModule.addRelationship(std::move(Relationship)); - else - Into.addRelationship(std::move(Relationship)); -} - StringRef SymbolGraphSerializer::getConstraintString(ConstraintKind Kind) { switch (Kind) { case ConstraintKind::Conformance: @@ -740,324 +826,430 @@ StringRef SymbolGraphSerializer::getConstraintString(ConstraintKind Kind) { llvm_unreachable("Unhandled constraint kind"); } -void SymbolGraphSerializer::serializeAPIRecord(const APIRecord *Record) { - Object Obj; - - // If we need symbol labels for testing emit the USR as the value and the key - // starts with '!'' to ensure it ends up at the top of the object. - if (EmitSymbolLabelsForTesting) - Obj["!testLabel"] = Record->USR; +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); - 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->Availability)); - serializeObject(Obj, "docComment", serializeDocComment(Record->Comment)); - serializeArray(Obj, "declarationFragments", - serializeDeclarationFragments(Record->Declaration)); + Relationships.emplace_back(std::move(Relationship)); +} - Obj["pathComponents"] = serializePathComponents(Record); - Obj["accessLevel"] = Record->Access.getAccess(); +void SymbolGraphSerializer::visitNamespaceRecord( + const NamespaceRecord &Record) { + auto Namespace = serializeAPIRecord(Record); + if (!Namespace) + return; + Symbols.emplace_back(std::move(*Namespace)); + if (!Record.ParentInformation.empty()) + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); +} - ExtendedModule &Module = getModuleForCurrentSymbol(); - // If the hierarchy has at least one parent and child. - if (Hierarchy.size() >= 2) - serializeRelationship(MemberOf, Hierarchy.back(), - Hierarchy[Hierarchy.size() - 2], Module); +void SymbolGraphSerializer::visitGlobalFunctionRecord( + const GlobalFunctionRecord &Record) { + auto Obj = serializeAPIRecord(Record); + if (!Obj) + return; - CurrentSymbol = Module.addSymbol(std::move(Obj)); + Symbols.emplace_back(std::move(*Obj)); } -bool SymbolGraphSerializer::traverseAPIRecord(const APIRecord *Record) { - if (!Record) - return true; - if (shouldSkip(Record)) - return true; - Hierarchy.push_back(getHierarchyReference(Record, API)); - // Defer traversal mechanics to APISetVisitor base implementation - auto RetVal = Base::traverseAPIRecord(Record); - Hierarchy.pop_back(); - return RetVal; +void SymbolGraphSerializer::visitGlobalVariableRecord( + const GlobalVariableRecord &Record) { + auto Obj = serializeAPIRecord(Record); + if (!Obj) + return; + + Symbols.emplace_back(std::move(*Obj)); } -bool SymbolGraphSerializer::visitAPIRecord(const APIRecord *Record) { - serializeAPIRecord(Record); - return true; +void SymbolGraphSerializer::visitEnumRecord(const EnumRecord &Record) { + auto Enum = serializeAPIRecord(Record); + if (!Enum) + return; + + Symbols.emplace_back(std::move(*Enum)); + serializeMembers(Record, Record.Constants); } -bool SymbolGraphSerializer::visitGlobalFunctionRecord( - const GlobalFunctionRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitRecordRecord(const RecordRecord &Record) { + auto SerializedRecord = serializeAPIRecord(Record); + if (!SerializedRecord) + return; - serializeFunctionSignatureMixin(*CurrentSymbol, *Record); - return true; + Symbols.emplace_back(std::move(*SerializedRecord)); + serializeMembers(Record, Record.Fields); } -bool SymbolGraphSerializer::visitCXXClassRecord(const CXXClassRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitStaticFieldRecord( + const StaticFieldRecord &Record) { + auto StaticField = serializeAPIRecord(Record); + if (!StaticField) + return; + Symbols.emplace_back(std::move(*StaticField)); + serializeRelationship(RelationshipKind::MemberOf, Record, Record.Context); +} - for (const auto &Base : Record->Bases) - serializeRelationship(RelationshipKind::InheritsFrom, Record, Base, - getModuleForCurrentSymbol()); - return true; +void SymbolGraphSerializer::visitCXXClassRecord(const CXXClassRecord &Record) { + auto Class = serializeAPIRecord(Record); + if (!Class) + return; + + Symbols.emplace_back(std::move(*Class)); + for (const auto &Base : Record.Bases) + serializeRelationship(RelationshipKind::InheritsFrom, Record, Base); + if (!Record.ParentInformation.empty()) + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer::visitClassTemplateRecord( - const ClassTemplateRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitClassTemplateRecord( + const ClassTemplateRecord &Record) { + auto Class = serializeAPIRecord(Record); + if (!Class) + return; - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; + Symbols.emplace_back(std::move(*Class)); + for (const auto &Base : Record.Bases) + serializeRelationship(RelationshipKind::InheritsFrom, Record, Base); + if (!Record.ParentInformation.empty()) + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer::visitClassTemplatePartialSpecializationRecord( - const ClassTemplatePartialSpecializationRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitClassTemplateSpecializationRecord( + const ClassTemplateSpecializationRecord &Record) { + auto Class = serializeAPIRecord(Record); + if (!Class) + return; - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; + Symbols.emplace_back(std::move(*Class)); + + for (const auto &Base : Record.Bases) + serializeRelationship(RelationshipKind::InheritsFrom, Record, Base); + if (!Record.ParentInformation.empty()) + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer::visitCXXMethodRecord( - const CXXMethodRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitClassTemplatePartialSpecializationRecord( + const ClassTemplatePartialSpecializationRecord &Record) { + auto Class = serializeAPIRecord(Record); + if (!Class) + return; + + Symbols.emplace_back(std::move(*Class)); - serializeFunctionSignatureMixin(*CurrentSymbol, *Record); - return true; + for (const auto &Base : Record.Bases) + serializeRelationship(RelationshipKind::InheritsFrom, Record, Base); + if (!Record.ParentInformation.empty()) + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer::visitCXXMethodTemplateRecord( - const CXXMethodTemplateRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitCXXInstanceMethodRecord( + const CXXInstanceMethodRecord &Record) { + auto InstanceMethod = serializeAPIRecord(Record); + if (!InstanceMethod) + return; - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; + Symbols.emplace_back(std::move(*InstanceMethod)); + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer::visitCXXFieldTemplateRecord( - const CXXFieldTemplateRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitCXXStaticMethodRecord( + const CXXStaticMethodRecord &Record) { + auto StaticMethod = serializeAPIRecord(Record); + if (!StaticMethod) + return; - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; + Symbols.emplace_back(std::move(*StaticMethod)); + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer::visitConceptRecord(const ConceptRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitMethodTemplateRecord( + const CXXMethodTemplateRecord &Record) { + if (!ShouldRecurse) + // Ignore child symbols + return; + auto MethodTemplate = serializeAPIRecord(Record); + if (!MethodTemplate) + return; + Symbols.emplace_back(std::move(*MethodTemplate)); + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); +} - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; +void SymbolGraphSerializer::visitMethodTemplateSpecializationRecord( + const CXXMethodTemplateSpecializationRecord &Record) { + if (!ShouldRecurse) + // Ignore child symbols + return; + auto MethodTemplateSpecialization = serializeAPIRecord(Record); + if (!MethodTemplateSpecialization) + return; + Symbols.emplace_back(std::move(*MethodTemplateSpecialization)); + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer::visitGlobalVariableTemplateRecord( - const GlobalVariableTemplateRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitCXXFieldRecord(const CXXFieldRecord &Record) { + if (!ShouldRecurse) + return; + auto CXXField = serializeAPIRecord(Record); + if (!CXXField) + return; + Symbols.emplace_back(std::move(*CXXField)); + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); +} - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; +void SymbolGraphSerializer::visitCXXFieldTemplateRecord( + const CXXFieldTemplateRecord &Record) { + if (!ShouldRecurse) + // Ignore child symbols + return; + auto CXXFieldTemplate = serializeAPIRecord(Record); + if (!CXXFieldTemplate) + return; + Symbols.emplace_back(std::move(*CXXFieldTemplate)); + serializeRelationship(RelationshipKind::MemberOf, Record, + Record.ParentInformation.ParentRecord); } -bool SymbolGraphSerializer:: - visitGlobalVariableTemplatePartialSpecializationRecord( - const GlobalVariableTemplatePartialSpecializationRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitConceptRecord(const ConceptRecord &Record) { + auto Concept = serializeAPIRecord(Record); + if (!Concept) + return; - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; + Symbols.emplace_back(std::move(*Concept)); } -bool SymbolGraphSerializer::visitGlobalFunctionTemplateRecord( - const GlobalFunctionTemplateRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitGlobalVariableTemplateRecord( + const GlobalVariableTemplateRecord &Record) { + auto GlobalVariableTemplate = serializeAPIRecord(Record); + if (!GlobalVariableTemplate) + return; + Symbols.emplace_back(std::move(*GlobalVariableTemplate)); +} - serializeTemplateMixin(*CurrentSymbol, *Record); - return true; +void SymbolGraphSerializer::visitGlobalVariableTemplateSpecializationRecord( + const GlobalVariableTemplateSpecializationRecord &Record) { + auto GlobalVariableTemplateSpecialization = serializeAPIRecord(Record); + if (!GlobalVariableTemplateSpecialization) + return; + Symbols.emplace_back(std::move(*GlobalVariableTemplateSpecialization)); } -bool SymbolGraphSerializer::visitObjCContainerRecord( - const ObjCContainerRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer:: + visitGlobalVariableTemplatePartialSpecializationRecord( + const GlobalVariableTemplatePartialSpecializationRecord &Record) { + auto GlobalVariableTemplatePartialSpecialization = serializeAPIRecord(Record); + if (!GlobalVariableTemplatePartialSpecialization) + return; + Symbols.emplace_back(std::move(*GlobalVariableTemplatePartialSpecialization)); +} - for (const auto &Protocol : Record->Protocols) - serializeRelationship(ConformsTo, Record, Protocol, - getModuleForCurrentSymbol()); +void SymbolGraphSerializer::visitGlobalFunctionTemplateRecord( + const GlobalFunctionTemplateRecord &Record) { + auto GlobalFunctionTemplate = serializeAPIRecord(Record); + if (!GlobalFunctionTemplate) + return; + Symbols.emplace_back(std::move(*GlobalFunctionTemplate)); +} - return true; +void SymbolGraphSerializer::visitGlobalFunctionTemplateSpecializationRecord( + const GlobalFunctionTemplateSpecializationRecord &Record) { + auto GlobalFunctionTemplateSpecialization = serializeAPIRecord(Record); + if (!GlobalFunctionTemplateSpecialization) + return; + Symbols.emplace_back(std::move(*GlobalFunctionTemplateSpecialization)); } -bool SymbolGraphSerializer::visitObjCInterfaceRecord( - const ObjCInterfaceRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitObjCContainerRecord( + const ObjCContainerRecord &Record) { + auto ObjCContainer = serializeAPIRecord(Record); + if (!ObjCContainer) + return; - if (!Record->SuperClass.empty()) - serializeRelationship(InheritsFrom, Record, Record->SuperClass, - getModuleForCurrentSymbol()); - return true; + Symbols.emplace_back(std::move(*ObjCContainer)); + + serializeMembers(Record, Record.Ivars); + serializeMembers(Record, Record.Methods); + serializeMembers(Record, Record.Properties); + + for (const auto &Protocol : Record.Protocols) + // Record that Record conforms to Protocol. + serializeRelationship(RelationshipKind::ConformsTo, Record, Protocol); + + if (auto *ObjCInterface = dyn_cast(&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. + 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) { + 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) + serializeRelationship(RelationshipKind::ConformsTo, Record, Protocol); + } + } } -bool SymbolGraphSerializer::traverseObjCCategoryRecord( - const ObjCCategoryRecord *Record) { - auto *CurrentModule = ModuleForCurrentSymbol; - if (Record->isExtendingExternalModule()) - ModuleForCurrentSymbol = &ExtendedModules[Record->Interface.Source]; +void SymbolGraphSerializer::visitObjCCategoryRecord( + const ObjCCategoryRecord &Record) { + if (!Record.IsFromExternalModule) + return; - if (!walkUpFromObjCCategoryRecord(Record)) - return false; + // Check if the current Category' parent has been visited before, if so skip. + if (!visitedCategories.contains(Record.Interface.Name)) { + visitedCategories.insert(Record.Interface.Name); + Object Obj; + serializeObject(Obj, "identifier", + serializeIdentifier(Record, API.getLanguage())); + serializeObject(Obj, "kind", + serializeSymbolKind(APIRecord::RK_ObjCCategoryModule, + API.getLanguage())); + Obj["accessLevel"] = "public"; + Symbols.emplace_back(std::move(Obj)); + } - bool RetVal = traverseRecordContext(Record); - ModuleForCurrentSymbol = CurrentModule; - return RetVal; -} + Object Relationship; + Relationship["source"] = Record.USR; + Relationship["target"] = Record.Interface.USR; + Relationship["targetFallback"] = Record.Interface.Name; + Relationship["kind"] = getRelationshipString(RelationshipKind::ExtensionTo); + Relationships.emplace_back(std::move(Relationship)); -bool SymbolGraphSerializer::walkUpFromObjCCategoryRecord( - const ObjCCategoryRecord *Record) { - return visitObjCCategoryRecord(Record); -} + auto ObjCCategory = serializeAPIRecord(Record); + + if (!ObjCCategory) + return; -bool SymbolGraphSerializer::visitObjCCategoryRecord( - const ObjCCategoryRecord *Record) { - // If we need to create a record for the category in the future do so here, - // otherwise everything is set up to pretend that the category is in fact the - // interface it extends. - for (const auto &Protocol : Record->Protocols) - serializeRelationship(ConformsTo, Record->Interface, Protocol, - getModuleForCurrentSymbol()); + Symbols.emplace_back(std::move(*ObjCCategory)); + serializeMembers(Record, Record.Methods); + serializeMembers(Record, Record.Properties); - return true; + // Surface the protocols of the category to the interface. + for (const auto &Protocol : Record.Protocols) + serializeRelationship(RelationshipKind::ConformsTo, Record, Protocol); } -bool SymbolGraphSerializer::visitObjCMethodRecord( - const ObjCMethodRecord *Record) { - if (!CurrentSymbol) - return true; +void SymbolGraphSerializer::visitMacroDefinitionRecord( + const MacroDefinitionRecord &Record) { + auto Macro = serializeAPIRecord(Record); - serializeFunctionSignatureMixin(*CurrentSymbol, *Record); - return true; -} + if (!Macro) + return; -bool SymbolGraphSerializer::visitObjCInstanceVariableRecord( - const ObjCInstanceVariableRecord *Record) { - // FIXME: serialize ivar access control here. - return true; + Symbols.emplace_back(std::move(*Macro)); } -bool SymbolGraphSerializer::walkUpFromTypedefRecord( - const TypedefRecord *Record) { - // Short-circuit walking up the class hierarchy and handle creating typedef - // symbol objects manually as there are additional symbol dropping rules to - // respect. - return visitTypedefRecord(Record); +void SymbolGraphSerializer::serializeSingleRecord(const APIRecord *Record) { + switch (Record->getKind()) { + case APIRecord::RK_Unknown: + llvm_unreachable("Records should have a known kind!"); + case APIRecord::RK_GlobalFunction: + visitGlobalFunctionRecord(*cast(Record)); + break; + case APIRecord::RK_GlobalVariable: + visitGlobalVariableRecord(*cast(Record)); + break; + case APIRecord::RK_Enum: + visitEnumRecord(*cast(Record)); + break; + case APIRecord::RK_Struct: + LLVM_FALLTHROUGH; + case APIRecord::RK_Union: + visitRecordRecord(*cast(Record)); + break; + case APIRecord::RK_StaticField: + visitStaticFieldRecord(*cast(Record)); + break; + case APIRecord::RK_CXXClass: + visitCXXClassRecord(*cast(Record)); + break; + case APIRecord::RK_ObjCInterface: + visitObjCContainerRecord(*cast(Record)); + break; + case APIRecord::RK_ObjCProtocol: + visitObjCContainerRecord(*cast(Record)); + break; + case APIRecord::RK_ObjCCategory: + visitObjCCategoryRecord(*cast(Record)); + break; + case APIRecord::RK_MacroDefinition: + visitMacroDefinitionRecord(*cast(Record)); + break; + case APIRecord::RK_Typedef: + visitTypedefRecord(*cast(Record)); + break; + default: + if (auto Obj = serializeAPIRecord(*Record)) { + Symbols.emplace_back(std::move(*Obj)); + auto &ParentInformation = Record->ParentInformation; + if (!ParentInformation.empty()) + serializeRelationship(RelationshipKind::MemberOf, *Record, + *ParentInformation.ParentRecord); + } + break; + } } -bool SymbolGraphSerializer::visitTypedefRecord(const TypedefRecord *Record) { +void SymbolGraphSerializer::visitTypedefRecord(const TypedefRecord &Record) { // Typedefs of anonymous types have their entries unified with the underlying // type. - bool ShouldDrop = Record->UnderlyingType.Name.empty(); + 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); + ShouldDrop |= (Record.UnderlyingType.Name == Record.Name); if (ShouldDrop) - return true; + return; - // Create the symbol record if the other symbol droppping rules permit it. - serializeAPIRecord(Record); - if (!CurrentSymbol) - return true; + auto Typedef = serializeAPIRecord(Record); + if (!Typedef) + return; - (*CurrentSymbol)["type"] = Record->UnderlyingType.USR; + (*Typedef)["type"] = Record.UnderlyingType.USR; - return true; + Symbols.emplace_back(std::move(*Typedef)); } -void SymbolGraphSerializer::serializeSingleRecord(const APIRecord *Record) { - switch (Record->getKind()) { - // dispatch to the relevant walkUpFromMethod -#define CONCRETE_RECORD(CLASS, BASE, KIND) \ - case APIRecord::KIND: { \ - walkUpFrom##CLASS(static_cast(Record)); \ - break; \ - } -#include "clang/ExtractAPI/APIRecords.inc" - // otherwise fallback on the only behavior we can implement safely. - case APIRecord::RK_Unknown: - visitAPIRecord(Record); - break; - default: - llvm_unreachable("API Record with uninstantiable kind"); - } +Object SymbolGraphSerializer::serialize() { + traverseAPISet(); + return serializeCurrentGraph(); } -Object SymbolGraphSerializer::serializeGraph(StringRef ModuleName, - ExtendedModule &&EM) { +Object SymbolGraphSerializer::serializeCurrentGraph() { Object Root; serializeObject(Root, "metadata", serializeMetadata()); - serializeObject(Root, "module", serializeModuleObject(ModuleName)); + serializeObject(Root, "module", serializeModule()); - Root["symbols"] = std::move(EM.Symbols); - Root["relationships"] = std::move(EM.Relationships); + Root["symbols"] = std::move(Symbols); + Root["relationships"] = std::move(Relationships); return Root; } -void SymbolGraphSerializer::serializeGraphToStream( - raw_ostream &OS, SymbolGraphSerializerOption Options, StringRef ModuleName, - ExtendedModule &&EM) { - Object Root = serializeGraph(ModuleName, std::move(EM)); +void SymbolGraphSerializer::serialize(raw_ostream &os) { + Object root = serialize(); if (Options.Compact) - OS << formatv("{0}", Value(std::move(Root))) << "\n"; + os << formatv("{0}", Value(std::move(root))) << "\n"; else - OS << formatv("{0:2}", Value(std::move(Root))) << "\n"; -} - -void SymbolGraphSerializer::serializeMainSymbolGraph( - raw_ostream &OS, const APISet &API, const APIIgnoresList &IgnoresList, - SymbolGraphSerializerOption Options) { - SymbolGraphSerializer Serializer(API, IgnoresList, - Options.EmitSymbolLabelsForTesting); - Serializer.traverseAPISet(); - Serializer.serializeGraphToStream(OS, Options, API.ProductName, - std::move(Serializer.MainModule)); - // FIXME: TODO handle extended modules here -} - -void SymbolGraphSerializer::serializeWithExtensionGraphs( - raw_ostream &MainOutput, const APISet &API, - const APIIgnoresList &IgnoresList, - llvm::function_ref(Twine BaseName)> - CreateOutputStream, - SymbolGraphSerializerOption Options) { - SymbolGraphSerializer Serializer(API, IgnoresList, - Options.EmitSymbolLabelsForTesting); - Serializer.traverseAPISet(); - - Serializer.serializeGraphToStream(MainOutput, Options, API.ProductName, - std::move(Serializer.MainModule)); - - for (auto &ExtensionSGF : Serializer.ExtendedModules) { - if (auto ExtensionOS = - CreateOutputStream(ExtensionSGF.getKey() + "@" + API.ProductName)) - Serializer.serializeGraphToStream(*ExtensionOS, Options, - ExtensionSGF.getKey(), - std::move(ExtensionSGF.getValue())); - } + os << formatv("{0:2}", Value(std::move(root))) << "\n"; } std::optional @@ -1070,20 +1262,14 @@ SymbolGraphSerializer::serializeSingleSymbolSGF(StringRef USR, Object Root; APIIgnoresList EmptyIgnores; SymbolGraphSerializer Serializer(API, EmptyIgnores, - /*EmitSymbolLabelsForTesting*/ false, - /*ForceEmitToMainModule*/ true); - - // Set up serializer parent chain - Serializer.Hierarchy = generateHierarchyFromRecord(Record); - + /*Options.Compact*/ {true}, + /*ShouldRecurse*/ false); Serializer.serializeSingleRecord(Record); - serializeObject(Root, "symbolGraph", - Serializer.serializeGraph(API.ProductName, - std::move(Serializer.MainModule))); + serializeObject(Root, "symbolGraph", Serializer.serializeCurrentGraph()); Language Lang = API.getLanguage(); serializeArray(Root, "parentContexts", - generateParentContexts(Serializer.Hierarchy, Lang)); + generateParentContexts(*Record, API, Lang)); Array RelatedSymbols; @@ -1101,15 +1287,14 @@ SymbolGraphSerializer::serializeSingleSymbolSGF(StringRef USR, Object RelatedSymbol; RelatedSymbol["usr"] = RelatedRecord->USR; RelatedSymbol["declarationLanguage"] = getLanguageName(Lang); - RelatedSymbol["accessLevel"] = RelatedRecord->Access.getAccess(); + // 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; serializeArray(RelatedSymbol, "parentContexts", - generateParentContexts( - generateHierarchyFromRecord(RelatedRecord), Lang)); - + generateParentContexts(*RelatedRecord, API, Lang)); RelatedSymbols.push_back(std::move(RelatedSymbol)); } -- cgit v1.1