You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
667 lines
26 KiB
667 lines
26 KiB
//===-- Serialize.cpp - ClangDoc Serializer ---------------------*- 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "Serialize.h"
|
|
#include "BitcodeWriter.h"
|
|
#include "clang/AST/Comment.h"
|
|
#include "clang/Index/USRGeneration.h"
|
|
#include "llvm/ADT/Hashing.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/Support/SHA1.h"
|
|
|
|
using clang::comments::FullComment;
|
|
|
|
namespace clang {
|
|
namespace doc {
|
|
namespace serialize {
|
|
|
|
SymbolID hashUSR(llvm::StringRef USR) {
|
|
return llvm::SHA1::hash(arrayRefFromStringRef(USR));
|
|
}
|
|
|
|
template <typename T>
|
|
static void
|
|
populateParentNamespaces(llvm::SmallVector<Reference, 4> &Namespaces,
|
|
const T *D, bool &IsAnonymousNamespace);
|
|
|
|
// A function to extract the appropriate relative path for a given info's
|
|
// documentation. The path returned is a composite of the parent namespaces.
|
|
//
|
|
// Example: Given the below, the directory path for class C info will be
|
|
// <root>/A/B
|
|
//
|
|
// namespace A {
|
|
// namespace B {
|
|
//
|
|
// class C {};
|
|
//
|
|
// }
|
|
// }
|
|
llvm::SmallString<128>
|
|
getInfoRelativePath(const llvm::SmallVectorImpl<doc::Reference> &Namespaces) {
|
|
llvm::SmallString<128> Path;
|
|
for (auto R = Namespaces.rbegin(), E = Namespaces.rend(); R != E; ++R)
|
|
llvm::sys::path::append(Path, R->Name);
|
|
return Path;
|
|
}
|
|
|
|
llvm::SmallString<128> getInfoRelativePath(const Decl *D) {
|
|
llvm::SmallVector<Reference, 4> Namespaces;
|
|
// The third arg in populateParentNamespaces is a boolean passed by reference,
|
|
// its value is not relevant in here so it's not used anywhere besides the
|
|
// function call
|
|
bool B = true;
|
|
populateParentNamespaces(Namespaces, D, B);
|
|
return getInfoRelativePath(Namespaces);
|
|
}
|
|
|
|
class ClangDocCommentVisitor
|
|
: public ConstCommentVisitor<ClangDocCommentVisitor> {
|
|
public:
|
|
ClangDocCommentVisitor(CommentInfo &CI) : CurrentCI(CI) {}
|
|
|
|
void parseComment(const comments::Comment *C);
|
|
|
|
void visitTextComment(const TextComment *C);
|
|
void visitInlineCommandComment(const InlineCommandComment *C);
|
|
void visitHTMLStartTagComment(const HTMLStartTagComment *C);
|
|
void visitHTMLEndTagComment(const HTMLEndTagComment *C);
|
|
void visitBlockCommandComment(const BlockCommandComment *C);
|
|
void visitParamCommandComment(const ParamCommandComment *C);
|
|
void visitTParamCommandComment(const TParamCommandComment *C);
|
|
void visitVerbatimBlockComment(const VerbatimBlockComment *C);
|
|
void visitVerbatimBlockLineComment(const VerbatimBlockLineComment *C);
|
|
void visitVerbatimLineComment(const VerbatimLineComment *C);
|
|
|
|
private:
|
|
std::string getCommandName(unsigned CommandID) const;
|
|
bool isWhitespaceOnly(StringRef S) const;
|
|
|
|
CommentInfo &CurrentCI;
|
|
};
|
|
|
|
void ClangDocCommentVisitor::parseComment(const comments::Comment *C) {
|
|
CurrentCI.Kind = C->getCommentKindName();
|
|
ConstCommentVisitor<ClangDocCommentVisitor>::visit(C);
|
|
for (comments::Comment *Child :
|
|
llvm::make_range(C->child_begin(), C->child_end())) {
|
|
CurrentCI.Children.emplace_back(std::make_unique<CommentInfo>());
|
|
ClangDocCommentVisitor Visitor(*CurrentCI.Children.back());
|
|
Visitor.parseComment(Child);
|
|
}
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitTextComment(const TextComment *C) {
|
|
if (!isWhitespaceOnly(C->getText()))
|
|
CurrentCI.Text = C->getText();
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitInlineCommandComment(
|
|
const InlineCommandComment *C) {
|
|
CurrentCI.Name = getCommandName(C->getCommandID());
|
|
for (unsigned I = 0, E = C->getNumArgs(); I != E; ++I)
|
|
CurrentCI.Args.push_back(C->getArgText(I));
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitHTMLStartTagComment(
|
|
const HTMLStartTagComment *C) {
|
|
CurrentCI.Name = C->getTagName();
|
|
CurrentCI.SelfClosing = C->isSelfClosing();
|
|
for (unsigned I = 0, E = C->getNumAttrs(); I < E; ++I) {
|
|
const HTMLStartTagComment::Attribute &Attr = C->getAttr(I);
|
|
CurrentCI.AttrKeys.push_back(Attr.Name);
|
|
CurrentCI.AttrValues.push_back(Attr.Value);
|
|
}
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitHTMLEndTagComment(
|
|
const HTMLEndTagComment *C) {
|
|
CurrentCI.Name = C->getTagName();
|
|
CurrentCI.SelfClosing = true;
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitBlockCommandComment(
|
|
const BlockCommandComment *C) {
|
|
CurrentCI.Name = getCommandName(C->getCommandID());
|
|
for (unsigned I = 0, E = C->getNumArgs(); I < E; ++I)
|
|
CurrentCI.Args.push_back(C->getArgText(I));
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitParamCommandComment(
|
|
const ParamCommandComment *C) {
|
|
CurrentCI.Direction =
|
|
ParamCommandComment::getDirectionAsString(C->getDirection());
|
|
CurrentCI.Explicit = C->isDirectionExplicit();
|
|
if (C->hasParamName())
|
|
CurrentCI.ParamName = C->getParamNameAsWritten();
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitTParamCommandComment(
|
|
const TParamCommandComment *C) {
|
|
if (C->hasParamName())
|
|
CurrentCI.ParamName = C->getParamNameAsWritten();
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitVerbatimBlockComment(
|
|
const VerbatimBlockComment *C) {
|
|
CurrentCI.Name = getCommandName(C->getCommandID());
|
|
CurrentCI.CloseName = C->getCloseName();
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitVerbatimBlockLineComment(
|
|
const VerbatimBlockLineComment *C) {
|
|
if (!isWhitespaceOnly(C->getText()))
|
|
CurrentCI.Text = C->getText();
|
|
}
|
|
|
|
void ClangDocCommentVisitor::visitVerbatimLineComment(
|
|
const VerbatimLineComment *C) {
|
|
if (!isWhitespaceOnly(C->getText()))
|
|
CurrentCI.Text = C->getText();
|
|
}
|
|
|
|
bool ClangDocCommentVisitor::isWhitespaceOnly(llvm::StringRef S) const {
|
|
return std::all_of(S.begin(), S.end(), isspace);
|
|
}
|
|
|
|
std::string ClangDocCommentVisitor::getCommandName(unsigned CommandID) const {
|
|
const CommandInfo *Info = CommandTraits::getBuiltinCommandInfo(CommandID);
|
|
if (Info)
|
|
return Info->Name;
|
|
// TODO: Add parsing for \file command.
|
|
return "<not a builtin command>";
|
|
}
|
|
|
|
// Serializing functions.
|
|
|
|
template <typename T> static std::string serialize(T &I) {
|
|
SmallString<2048> Buffer;
|
|
llvm::BitstreamWriter Stream(Buffer);
|
|
ClangDocBitcodeWriter Writer(Stream);
|
|
Writer.emitBlock(I);
|
|
return Buffer.str().str();
|
|
}
|
|
|
|
std::string serialize(std::unique_ptr<Info> &I) {
|
|
switch (I->IT) {
|
|
case InfoType::IT_namespace:
|
|
return serialize(*static_cast<NamespaceInfo *>(I.get()));
|
|
case InfoType::IT_record:
|
|
return serialize(*static_cast<RecordInfo *>(I.get()));
|
|
case InfoType::IT_enum:
|
|
return serialize(*static_cast<EnumInfo *>(I.get()));
|
|
case InfoType::IT_function:
|
|
return serialize(*static_cast<FunctionInfo *>(I.get()));
|
|
default:
|
|
return "";
|
|
}
|
|
}
|
|
|
|
static void parseFullComment(const FullComment *C, CommentInfo &CI) {
|
|
ClangDocCommentVisitor Visitor(CI);
|
|
Visitor.parseComment(C);
|
|
}
|
|
|
|
static SymbolID getUSRForDecl(const Decl *D) {
|
|
llvm::SmallString<128> USR;
|
|
if (index::generateUSRForDecl(D, USR))
|
|
return SymbolID();
|
|
return hashUSR(USR);
|
|
}
|
|
|
|
static RecordDecl *getDeclForType(const QualType &T) {
|
|
if (const RecordDecl *D = T->getAsRecordDecl())
|
|
return D->getDefinition();
|
|
return nullptr;
|
|
}
|
|
|
|
static bool isPublic(const clang::AccessSpecifier AS,
|
|
const clang::Linkage Link) {
|
|
if (AS == clang::AccessSpecifier::AS_private)
|
|
return false;
|
|
else if ((Link == clang::Linkage::ModuleLinkage) ||
|
|
(Link == clang::Linkage::ExternalLinkage))
|
|
return true;
|
|
return false; // otherwise, linkage is some form of internal linkage
|
|
}
|
|
|
|
static bool shouldSerializeInfo(bool PublicOnly, bool IsInAnonymousNamespace,
|
|
const NamedDecl *D) {
|
|
bool IsAnonymousNamespace = false;
|
|
if (const auto *N = dyn_cast<NamespaceDecl>(D))
|
|
IsAnonymousNamespace = N->isAnonymousNamespace();
|
|
return !PublicOnly ||
|
|
(!IsInAnonymousNamespace && !IsAnonymousNamespace &&
|
|
isPublic(D->getAccessUnsafe(), D->getLinkageInternal()));
|
|
}
|
|
|
|
// There are two uses for this function.
|
|
// 1) Getting the resulting mode of inheritance of a record.
|
|
// Example: class A {}; class B : private A {}; class C : public B {};
|
|
// It's explicit that C is publicly inherited from C and B is privately
|
|
// inherited from A. It's not explicit but C is also privately inherited from
|
|
// A. This is the AS that this function calculates. FirstAS is the
|
|
// inheritance mode of `class C : B` and SecondAS is the inheritance mode of
|
|
// `class B : A`.
|
|
// 2) Getting the inheritance mode of an inherited attribute / method.
|
|
// Example : class A { public: int M; }; class B : private A {};
|
|
// Class B is inherited from class A, which has a public attribute. This
|
|
// attribute is now part of the derived class B but it's not public. This
|
|
// will be private because the inheritance is private. This is the AS that
|
|
// this function calculates. FirstAS is the inheritance mode and SecondAS is
|
|
// the AS of the attribute / method.
|
|
static AccessSpecifier getFinalAccessSpecifier(AccessSpecifier FirstAS,
|
|
AccessSpecifier SecondAS) {
|
|
if (FirstAS == AccessSpecifier::AS_none ||
|
|
SecondAS == AccessSpecifier::AS_none)
|
|
return AccessSpecifier::AS_none;
|
|
if (FirstAS == AccessSpecifier::AS_private ||
|
|
SecondAS == AccessSpecifier::AS_private)
|
|
return AccessSpecifier::AS_private;
|
|
if (FirstAS == AccessSpecifier::AS_protected ||
|
|
SecondAS == AccessSpecifier::AS_protected)
|
|
return AccessSpecifier::AS_protected;
|
|
return AccessSpecifier::AS_public;
|
|
}
|
|
|
|
// The Access parameter is only provided when parsing the field of an inherited
|
|
// record, the access specification of the field depends on the inheritance mode
|
|
static void parseFields(RecordInfo &I, const RecordDecl *D, bool PublicOnly,
|
|
AccessSpecifier Access = AccessSpecifier::AS_public) {
|
|
for (const FieldDecl *F : D->fields()) {
|
|
if (!shouldSerializeInfo(PublicOnly, /*IsInAnonymousNamespace=*/false, F))
|
|
continue;
|
|
if (const auto *T = getDeclForType(F->getTypeSourceInfo()->getType())) {
|
|
// Use getAccessUnsafe so that we just get the default AS_none if it's not
|
|
// valid, as opposed to an assert.
|
|
if (const auto *N = dyn_cast<EnumDecl>(T)) {
|
|
I.Members.emplace_back(
|
|
getUSRForDecl(T), N->getNameAsString(), InfoType::IT_enum,
|
|
getInfoRelativePath(N), F->getNameAsString(),
|
|
getFinalAccessSpecifier(Access, N->getAccessUnsafe()));
|
|
continue;
|
|
} else if (const auto *N = dyn_cast<RecordDecl>(T)) {
|
|
I.Members.emplace_back(
|
|
getUSRForDecl(T), N->getNameAsString(), InfoType::IT_record,
|
|
getInfoRelativePath(N), F->getNameAsString(),
|
|
getFinalAccessSpecifier(Access, N->getAccessUnsafe()));
|
|
continue;
|
|
}
|
|
}
|
|
I.Members.emplace_back(
|
|
F->getTypeSourceInfo()->getType().getAsString(), F->getNameAsString(),
|
|
getFinalAccessSpecifier(Access, F->getAccessUnsafe()));
|
|
}
|
|
}
|
|
|
|
static void parseEnumerators(EnumInfo &I, const EnumDecl *D) {
|
|
for (const EnumConstantDecl *E : D->enumerators())
|
|
I.Members.emplace_back(E->getNameAsString());
|
|
}
|
|
|
|
static void parseParameters(FunctionInfo &I, const FunctionDecl *D) {
|
|
for (const ParmVarDecl *P : D->parameters()) {
|
|
if (const auto *T = getDeclForType(P->getOriginalType())) {
|
|
if (const auto *N = dyn_cast<EnumDecl>(T)) {
|
|
I.Params.emplace_back(getUSRForDecl(N), N->getNameAsString(),
|
|
InfoType::IT_enum, getInfoRelativePath(N),
|
|
P->getNameAsString());
|
|
continue;
|
|
} else if (const auto *N = dyn_cast<RecordDecl>(T)) {
|
|
I.Params.emplace_back(getUSRForDecl(N), N->getNameAsString(),
|
|
InfoType::IT_record, getInfoRelativePath(N),
|
|
P->getNameAsString());
|
|
continue;
|
|
}
|
|
}
|
|
I.Params.emplace_back(P->getOriginalType().getAsString(),
|
|
P->getNameAsString());
|
|
}
|
|
}
|
|
|
|
// TODO: Remove the serialization of Parents and VirtualParents, this
|
|
// information is also extracted in the other definition of parseBases.
|
|
static void parseBases(RecordInfo &I, const CXXRecordDecl *D) {
|
|
// Don't parse bases if this isn't a definition.
|
|
if (!D->isThisDeclarationADefinition())
|
|
return;
|
|
for (const CXXBaseSpecifier &B : D->bases()) {
|
|
if (B.isVirtual())
|
|
continue;
|
|
if (const auto *Ty = B.getType()->getAs<TemplateSpecializationType>()) {
|
|
const TemplateDecl *D = Ty->getTemplateName().getAsTemplateDecl();
|
|
I.Parents.emplace_back(getUSRForDecl(D), B.getType().getAsString(),
|
|
InfoType::IT_record);
|
|
} else if (const RecordDecl *P = getDeclForType(B.getType()))
|
|
I.Parents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
|
|
InfoType::IT_record, getInfoRelativePath(P));
|
|
else
|
|
I.Parents.emplace_back(B.getType().getAsString());
|
|
}
|
|
for (const CXXBaseSpecifier &B : D->vbases()) {
|
|
if (const auto *P = getDeclForType(B.getType()))
|
|
I.VirtualParents.emplace_back(getUSRForDecl(P), P->getNameAsString(),
|
|
InfoType::IT_record,
|
|
getInfoRelativePath(P));
|
|
else
|
|
I.VirtualParents.emplace_back(B.getType().getAsString());
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
static void
|
|
populateParentNamespaces(llvm::SmallVector<Reference, 4> &Namespaces,
|
|
const T *D, bool &IsInAnonymousNamespace) {
|
|
const auto *DC = dyn_cast<DeclContext>(D);
|
|
while ((DC = DC->getParent())) {
|
|
if (const auto *N = dyn_cast<NamespaceDecl>(DC)) {
|
|
std::string Namespace;
|
|
if (N->isAnonymousNamespace()) {
|
|
Namespace = "@nonymous_namespace";
|
|
IsInAnonymousNamespace = true;
|
|
} else
|
|
Namespace = N->getNameAsString();
|
|
Namespaces.emplace_back(getUSRForDecl(N), Namespace,
|
|
InfoType::IT_namespace);
|
|
} else if (const auto *N = dyn_cast<RecordDecl>(DC))
|
|
Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
|
|
InfoType::IT_record);
|
|
else if (const auto *N = dyn_cast<FunctionDecl>(DC))
|
|
Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
|
|
InfoType::IT_function);
|
|
else if (const auto *N = dyn_cast<EnumDecl>(DC))
|
|
Namespaces.emplace_back(getUSRForDecl(N), N->getNameAsString(),
|
|
InfoType::IT_enum);
|
|
}
|
|
// The global namespace should be added to the list of namespaces if the decl
|
|
// corresponds to a Record and if it doesn't have any namespace (because this
|
|
// means it's in the global namespace). Also if its outermost namespace is a
|
|
// record because that record matches the previous condition mentioned.
|
|
if ((Namespaces.empty() && dyn_cast<RecordDecl>(D)) ||
|
|
(!Namespaces.empty() && Namespaces.back().RefType == InfoType::IT_record))
|
|
Namespaces.emplace_back(SymbolID(), "GlobalNamespace",
|
|
InfoType::IT_namespace);
|
|
}
|
|
|
|
template <typename T>
|
|
static void populateInfo(Info &I, const T *D, const FullComment *C,
|
|
bool &IsInAnonymousNamespace) {
|
|
I.USR = getUSRForDecl(D);
|
|
I.Name = D->getNameAsString();
|
|
populateParentNamespaces(I.Namespace, D, IsInAnonymousNamespace);
|
|
if (C) {
|
|
I.Description.emplace_back();
|
|
parseFullComment(C, I.Description.back());
|
|
}
|
|
}
|
|
|
|
template <typename T>
|
|
static void populateSymbolInfo(SymbolInfo &I, const T *D, const FullComment *C,
|
|
int LineNumber, StringRef Filename,
|
|
bool IsFileInRootDir,
|
|
bool &IsInAnonymousNamespace) {
|
|
populateInfo(I, D, C, IsInAnonymousNamespace);
|
|
if (D->isThisDeclarationADefinition())
|
|
I.DefLoc.emplace(LineNumber, Filename, IsFileInRootDir);
|
|
else
|
|
I.Loc.emplace_back(LineNumber, Filename, IsFileInRootDir);
|
|
}
|
|
|
|
static void populateFunctionInfo(FunctionInfo &I, const FunctionDecl *D,
|
|
const FullComment *FC, int LineNumber,
|
|
StringRef Filename, bool IsFileInRootDir,
|
|
bool &IsInAnonymousNamespace) {
|
|
populateSymbolInfo(I, D, FC, LineNumber, Filename, IsFileInRootDir,
|
|
IsInAnonymousNamespace);
|
|
if (const auto *T = getDeclForType(D->getReturnType())) {
|
|
if (dyn_cast<EnumDecl>(T))
|
|
I.ReturnType = TypeInfo(getUSRForDecl(T), T->getNameAsString(),
|
|
InfoType::IT_enum, getInfoRelativePath(T));
|
|
else if (dyn_cast<RecordDecl>(T))
|
|
I.ReturnType = TypeInfo(getUSRForDecl(T), T->getNameAsString(),
|
|
InfoType::IT_record, getInfoRelativePath(T));
|
|
} else {
|
|
I.ReturnType = TypeInfo(D->getReturnType().getAsString());
|
|
}
|
|
parseParameters(I, D);
|
|
}
|
|
|
|
static void
|
|
parseBases(RecordInfo &I, const CXXRecordDecl *D, bool IsFileInRootDir,
|
|
bool PublicOnly, bool IsParent,
|
|
AccessSpecifier ParentAccess = AccessSpecifier::AS_public) {
|
|
// Don't parse bases if this isn't a definition.
|
|
if (!D->isThisDeclarationADefinition())
|
|
return;
|
|
for (const CXXBaseSpecifier &B : D->bases()) {
|
|
if (const RecordType *Ty = B.getType()->getAs<RecordType>()) {
|
|
if (const CXXRecordDecl *Base =
|
|
cast_or_null<CXXRecordDecl>(Ty->getDecl()->getDefinition())) {
|
|
// Initialized without USR and name, this will be set in the following
|
|
// if-else stmt.
|
|
BaseRecordInfo BI(
|
|
{}, "", getInfoRelativePath(Base), B.isVirtual(),
|
|
getFinalAccessSpecifier(ParentAccess, B.getAccessSpecifier()),
|
|
IsParent);
|
|
if (const auto *Ty = B.getType()->getAs<TemplateSpecializationType>()) {
|
|
const TemplateDecl *D = Ty->getTemplateName().getAsTemplateDecl();
|
|
BI.USR = getUSRForDecl(D);
|
|
BI.Name = B.getType().getAsString();
|
|
} else {
|
|
BI.USR = getUSRForDecl(Base);
|
|
BI.Name = Base->getNameAsString();
|
|
}
|
|
parseFields(BI, Base, PublicOnly, BI.Access);
|
|
for (const auto &Decl : Base->decls())
|
|
if (const auto *MD = dyn_cast<CXXMethodDecl>(Decl)) {
|
|
// Don't serialize private methods
|
|
if (MD->getAccessUnsafe() == AccessSpecifier::AS_private ||
|
|
!MD->isUserProvided())
|
|
continue;
|
|
FunctionInfo FI;
|
|
FI.IsMethod = true;
|
|
// The seventh arg in populateFunctionInfo is a boolean passed by
|
|
// reference, its value is not relevant in here so it's not used
|
|
// anywhere besides the function call.
|
|
bool IsInAnonymousNamespace;
|
|
populateFunctionInfo(FI, MD, /*FullComment=*/{}, /*LineNumber=*/{},
|
|
/*FileName=*/{}, IsFileInRootDir,
|
|
IsInAnonymousNamespace);
|
|
FI.Access =
|
|
getFinalAccessSpecifier(BI.Access, MD->getAccessUnsafe());
|
|
BI.ChildFunctions.emplace_back(std::move(FI));
|
|
}
|
|
I.Bases.emplace_back(std::move(BI));
|
|
// Call this function recursively to get the inherited classes of
|
|
// this base; these new bases will also get stored in the original
|
|
// RecordInfo: I.
|
|
parseBases(I, Base, IsFileInRootDir, PublicOnly, false,
|
|
I.Bases.back().Access);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
|
|
emitInfo(const NamespaceDecl *D, const FullComment *FC, int LineNumber,
|
|
llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
|
|
auto I = std::make_unique<NamespaceInfo>();
|
|
bool IsInAnonymousNamespace = false;
|
|
populateInfo(*I, D, FC, IsInAnonymousNamespace);
|
|
if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
|
|
return {};
|
|
|
|
I->Name = D->isAnonymousNamespace()
|
|
? llvm::SmallString<16>("@nonymous_namespace")
|
|
: I->Name;
|
|
I->Path = getInfoRelativePath(I->Namespace);
|
|
if (I->Namespace.empty() && I->USR == SymbolID())
|
|
return {std::unique_ptr<Info>{std::move(I)}, nullptr};
|
|
|
|
auto ParentI = std::make_unique<NamespaceInfo>();
|
|
ParentI->USR = I->Namespace.empty() ? SymbolID() : I->Namespace[0].USR;
|
|
ParentI->ChildNamespaces.emplace_back(I->USR, I->Name, InfoType::IT_namespace,
|
|
getInfoRelativePath(I->Namespace));
|
|
if (I->Namespace.empty())
|
|
ParentI->Path = getInfoRelativePath(ParentI->Namespace);
|
|
return {std::unique_ptr<Info>{std::move(I)},
|
|
std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
|
|
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
|
|
emitInfo(const RecordDecl *D, const FullComment *FC, int LineNumber,
|
|
llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
|
|
auto I = std::make_unique<RecordInfo>();
|
|
bool IsInAnonymousNamespace = false;
|
|
populateSymbolInfo(*I, D, FC, LineNumber, File, IsFileInRootDir,
|
|
IsInAnonymousNamespace);
|
|
if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
|
|
return {};
|
|
|
|
I->TagType = D->getTagKind();
|
|
parseFields(*I, D, PublicOnly);
|
|
if (const auto *C = dyn_cast<CXXRecordDecl>(D)) {
|
|
if (const TypedefNameDecl *TD = C->getTypedefNameForAnonDecl()) {
|
|
I->Name = TD->getNameAsString();
|
|
I->IsTypeDef = true;
|
|
}
|
|
// TODO: remove first call to parseBases, that function should be deleted
|
|
parseBases(*I, C);
|
|
parseBases(*I, C, IsFileInRootDir, PublicOnly, true);
|
|
}
|
|
I->Path = getInfoRelativePath(I->Namespace);
|
|
|
|
switch (I->Namespace[0].RefType) {
|
|
case InfoType::IT_namespace: {
|
|
auto ParentI = std::make_unique<NamespaceInfo>();
|
|
ParentI->USR = I->Namespace[0].USR;
|
|
ParentI->ChildRecords.emplace_back(I->USR, I->Name, InfoType::IT_record,
|
|
getInfoRelativePath(I->Namespace));
|
|
return {std::unique_ptr<Info>{std::move(I)},
|
|
std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
case InfoType::IT_record: {
|
|
auto ParentI = std::make_unique<RecordInfo>();
|
|
ParentI->USR = I->Namespace[0].USR;
|
|
ParentI->ChildRecords.emplace_back(I->USR, I->Name, InfoType::IT_record,
|
|
getInfoRelativePath(I->Namespace));
|
|
return {std::unique_ptr<Info>{std::move(I)},
|
|
std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
default:
|
|
llvm_unreachable("Invalid reference type for parent namespace");
|
|
}
|
|
}
|
|
|
|
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
|
|
emitInfo(const FunctionDecl *D, const FullComment *FC, int LineNumber,
|
|
llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
|
|
FunctionInfo Func;
|
|
bool IsInAnonymousNamespace = false;
|
|
populateFunctionInfo(Func, D, FC, LineNumber, File, IsFileInRootDir,
|
|
IsInAnonymousNamespace);
|
|
Func.Access = clang::AccessSpecifier::AS_none;
|
|
if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
|
|
return {};
|
|
|
|
// Wrap in enclosing scope
|
|
auto ParentI = std::make_unique<NamespaceInfo>();
|
|
if (!Func.Namespace.empty())
|
|
ParentI->USR = Func.Namespace[0].USR;
|
|
else
|
|
ParentI->USR = SymbolID();
|
|
if (Func.Namespace.empty())
|
|
ParentI->Path = getInfoRelativePath(ParentI->Namespace);
|
|
ParentI->ChildFunctions.emplace_back(std::move(Func));
|
|
// Info is wrapped in its parent scope so it's returned in the second position
|
|
return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
|
|
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
|
|
emitInfo(const CXXMethodDecl *D, const FullComment *FC, int LineNumber,
|
|
llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
|
|
FunctionInfo Func;
|
|
bool IsInAnonymousNamespace = false;
|
|
populateFunctionInfo(Func, D, FC, LineNumber, File, IsFileInRootDir,
|
|
IsInAnonymousNamespace);
|
|
if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
|
|
return {};
|
|
|
|
Func.IsMethod = true;
|
|
|
|
const NamedDecl *Parent = nullptr;
|
|
if (const auto *SD =
|
|
dyn_cast<ClassTemplateSpecializationDecl>(D->getParent()))
|
|
Parent = SD->getSpecializedTemplate();
|
|
else
|
|
Parent = D->getParent();
|
|
|
|
SymbolID ParentUSR = getUSRForDecl(Parent);
|
|
Func.Parent =
|
|
Reference{ParentUSR, Parent->getNameAsString(), InfoType::IT_record};
|
|
Func.Access = D->getAccess();
|
|
|
|
// Wrap in enclosing scope
|
|
auto ParentI = std::make_unique<RecordInfo>();
|
|
ParentI->USR = ParentUSR;
|
|
ParentI->ChildFunctions.emplace_back(std::move(Func));
|
|
// Info is wrapped in its parent scope so it's returned in the second position
|
|
return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
|
|
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
|
|
emitInfo(const EnumDecl *D, const FullComment *FC, int LineNumber,
|
|
llvm::StringRef File, bool IsFileInRootDir, bool PublicOnly) {
|
|
EnumInfo Enum;
|
|
bool IsInAnonymousNamespace = false;
|
|
populateSymbolInfo(Enum, D, FC, LineNumber, File, IsFileInRootDir,
|
|
IsInAnonymousNamespace);
|
|
if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
|
|
return {};
|
|
|
|
Enum.Scoped = D->isScoped();
|
|
parseEnumerators(Enum, D);
|
|
|
|
// Put in global namespace
|
|
if (Enum.Namespace.empty()) {
|
|
auto ParentI = std::make_unique<NamespaceInfo>();
|
|
ParentI->USR = SymbolID();
|
|
ParentI->ChildEnums.emplace_back(std::move(Enum));
|
|
ParentI->Path = getInfoRelativePath(ParentI->Namespace);
|
|
// Info is wrapped in its parent scope so it's returned in the second
|
|
// position
|
|
return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
|
|
// Wrap in enclosing scope
|
|
switch (Enum.Namespace[0].RefType) {
|
|
case InfoType::IT_namespace: {
|
|
auto ParentI = std::make_unique<NamespaceInfo>();
|
|
ParentI->USR = Enum.Namespace[0].USR;
|
|
ParentI->ChildEnums.emplace_back(std::move(Enum));
|
|
// Info is wrapped in its parent scope so it's returned in the second
|
|
// position
|
|
return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
case InfoType::IT_record: {
|
|
auto ParentI = std::make_unique<RecordInfo>();
|
|
ParentI->USR = Enum.Namespace[0].USR;
|
|
ParentI->ChildEnums.emplace_back(std::move(Enum));
|
|
// Info is wrapped in its parent scope so it's returned in the second
|
|
// position
|
|
return {nullptr, std::unique_ptr<Info>{std::move(ParentI)}};
|
|
}
|
|
default:
|
|
llvm_unreachable("Invalid reference type for parent namespace");
|
|
}
|
|
}
|
|
|
|
} // namespace serialize
|
|
} // namespace doc
|
|
} // namespace clang
|