https://github.com/ilovepi created
https://github.com/llvm/llvm-project/pull/136444
In quite a few places we were not following the project naming
conventions. This patch applies clang-tidy fixes, and updates
some additional names to follow more typical project wide patterns.
>From 437a8def36b7c5609a1aed371d1150ecbb64c333 Mon Sep 17 00:00:00 2001
From: Paul Kirth <paulki...@google.com>
Date: Sat, 19 Apr 2025 11:06:26 -0700
Subject: [PATCH] [clang-doc] Fix clang-tidy naming diagnostics
In quite a few places we were not following the project naming
conventions. This patch applies clang-tidy fixes, and updates
some additional names to follow more typical project wide patterns.
---
clang-tools-extra/clang-doc/BitcodeWriter.cpp | 199 +++++++++---------
clang-tools-extra/clang-doc/HTMLGenerator.cpp | 4 +-
clang-tools-extra/clang-doc/Serialize.cpp | 82 ++++----
3 files changed, 144 insertions(+), 141 deletions(-)
diff --git a/clang-tools-extra/clang-doc/BitcodeWriter.cpp
b/clang-tools-extra/clang-doc/BitcodeWriter.cpp
index 621af4e51e443..6545629f1c739 100644
--- a/clang-tools-extra/clang-doc/BitcodeWriter.cpp
+++ b/clang-tools-extra/clang-doc/BitcodeWriter.cpp
@@ -30,49 +30,50 @@ struct RecordIdToIndexFunctor {
using AbbrevDsc = void (*)(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev);
-static void AbbrevGen(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev,
- const std::initializer_list<llvm::BitCodeAbbrevOp> Ops) {
+static void
+generateAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev,
+ const std::initializer_list<llvm::BitCodeAbbrevOp> Ops) {
for (const auto &Op : Ops)
Abbrev->Add(Op);
}
-static void BoolAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
- AbbrevGen(Abbrev,
- {// 0. Boolean
- llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
- BitCodeConstants::BoolSize)});
+static void genBoolAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
+ generateAbbrev(Abbrev,
+ {// 0. Boolean
+ llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
+ BitCodeConstants::BoolSize)});
}
-static void IntAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
- AbbrevGen(Abbrev,
- {// 0. Fixed-size integer
- llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
- BitCodeConstants::IntSize)});
+static void genIntAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
+ generateAbbrev(Abbrev,
+ {// 0. Fixed-size integer
+ llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
+ BitCodeConstants::IntSize)});
}
-static void SymbolIDAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
- AbbrevGen(Abbrev,
- {// 0. Fixed-size integer (length of the sha1'd USR)
- llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
- BitCodeConstants::USRLengthSize),
- // 1. Fixed-size array of Char6 (USR)
- llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array),
- llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
- BitCodeConstants::USRBitLengthSize)});
+static void genSymbolIdAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
+ generateAbbrev(Abbrev,
+ {// 0. Fixed-size integer (length of the sha1'd USR)
+ llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
+ BitCodeConstants::USRLengthSize),
+ // 1. Fixed-size array of Char6 (USR)
+ llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Array),
+ llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
+ BitCodeConstants::USRBitLengthSize)});
}
-static void StringAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
- AbbrevGen(Abbrev,
- {// 0. Fixed-size integer (length of the following string)
- llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
- BitCodeConstants::StringLengthSize),
- // 1. The string blob
- llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
+static void genStringAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
+ generateAbbrev(Abbrev,
+ {// 0. Fixed-size integer (length of the following string)
+ llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
+ BitCodeConstants::StringLengthSize),
+ // 1. The string blob
+ llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Blob)});
}
// Assumes that the file will not have more than 65535 lines.
-static void LocationAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
- AbbrevGen(
+static void genLocationAbbrev(std::shared_ptr<llvm::BitCodeAbbrev> &Abbrev) {
+ generateAbbrev(
Abbrev,
{// 0. Fixed-size integer (line number)
llvm::BitCodeAbbrevOp(llvm::BitCodeAbbrevOp::Fixed,
@@ -140,67 +141,68 @@ static const llvm::IndexedMap<RecordIdDsc,
RecordIdToIndexFunctor>
// There is no init-list constructor for the IndexedMap, so have to
// improvise
static const std::vector<std::pair<RecordId, RecordIdDsc>> Inits = {
- {VERSION, {"Version", &IntAbbrev}},
- {COMMENT_KIND, {"Kind", &StringAbbrev}},
- {COMMENT_TEXT, {"Text", &StringAbbrev}},
- {COMMENT_NAME, {"Name", &StringAbbrev}},
- {COMMENT_DIRECTION, {"Direction", &StringAbbrev}},
- {COMMENT_PARAMNAME, {"ParamName", &StringAbbrev}},
- {COMMENT_CLOSENAME, {"CloseName", &StringAbbrev}},
- {COMMENT_SELFCLOSING, {"SelfClosing", &BoolAbbrev}},
- {COMMENT_EXPLICIT, {"Explicit", &BoolAbbrev}},
- {COMMENT_ATTRKEY, {"AttrKey", &StringAbbrev}},
- {COMMENT_ATTRVAL, {"AttrVal", &StringAbbrev}},
- {COMMENT_ARG, {"Arg", &StringAbbrev}},
- {FIELD_TYPE_NAME, {"Name", &StringAbbrev}},
- {FIELD_DEFAULT_VALUE, {"DefaultValue", &StringAbbrev}},
- {MEMBER_TYPE_NAME, {"Name", &StringAbbrev}},
- {MEMBER_TYPE_ACCESS, {"Access", &IntAbbrev}},
- {MEMBER_TYPE_IS_STATIC, {"IsStatic", &BoolAbbrev}},
- {NAMESPACE_USR, {"USR", &SymbolIDAbbrev}},
- {NAMESPACE_NAME, {"Name", &StringAbbrev}},
- {NAMESPACE_PATH, {"Path", &StringAbbrev}},
- {ENUM_USR, {"USR", &SymbolIDAbbrev}},
- {ENUM_NAME, {"Name", &StringAbbrev}},
- {ENUM_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
- {ENUM_LOCATION, {"Location", &LocationAbbrev}},
- {ENUM_SCOPED, {"Scoped", &BoolAbbrev}},
- {ENUM_VALUE_NAME, {"Name", &StringAbbrev}},
- {ENUM_VALUE_VALUE, {"Value", &StringAbbrev}},
- {ENUM_VALUE_EXPR, {"Expr", &StringAbbrev}},
- {RECORD_USR, {"USR", &SymbolIDAbbrev}},
- {RECORD_NAME, {"Name", &StringAbbrev}},
- {RECORD_PATH, {"Path", &StringAbbrev}},
- {RECORD_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
- {RECORD_LOCATION, {"Location", &LocationAbbrev}},
- {RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
- {RECORD_IS_TYPE_DEF, {"IsTypeDef", &BoolAbbrev}},
- {BASE_RECORD_USR, {"USR", &SymbolIDAbbrev}},
- {BASE_RECORD_NAME, {"Name", &StringAbbrev}},
- {BASE_RECORD_PATH, {"Path", &StringAbbrev}},
- {BASE_RECORD_TAG_TYPE, {"TagType", &IntAbbrev}},
- {BASE_RECORD_IS_VIRTUAL, {"IsVirtual", &BoolAbbrev}},
- {BASE_RECORD_ACCESS, {"Access", &IntAbbrev}},
- {BASE_RECORD_IS_PARENT, {"IsParent", &BoolAbbrev}},
- {FUNCTION_USR, {"USR", &SymbolIDAbbrev}},
- {FUNCTION_NAME, {"Name", &StringAbbrev}},
- {FUNCTION_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
- {FUNCTION_LOCATION, {"Location", &LocationAbbrev}},
- {FUNCTION_ACCESS, {"Access", &IntAbbrev}},
- {FUNCTION_IS_METHOD, {"IsMethod", &BoolAbbrev}},
- {FUNCTION_IS_STATIC, {"IsStatic", &BoolAbbrev}},
- {REFERENCE_USR, {"USR", &SymbolIDAbbrev}},
- {REFERENCE_NAME, {"Name", &StringAbbrev}},
- {REFERENCE_QUAL_NAME, {"QualName", &StringAbbrev}},
- {REFERENCE_TYPE, {"RefType", &IntAbbrev}},
- {REFERENCE_PATH, {"Path", &StringAbbrev}},
- {REFERENCE_FIELD, {"Field", &IntAbbrev}},
- {TEMPLATE_PARAM_CONTENTS, {"Contents", &StringAbbrev}},
- {TEMPLATE_SPECIALIZATION_OF, {"SpecializationOf", &SymbolIDAbbrev}},
- {TYPEDEF_USR, {"USR", &SymbolIDAbbrev}},
- {TYPEDEF_NAME, {"Name", &StringAbbrev}},
- {TYPEDEF_DEFLOCATION, {"DefLocation", &LocationAbbrev}},
- {TYPEDEF_IS_USING, {"IsUsing", &BoolAbbrev}}};
+ {VERSION, {"Version", &genIntAbbrev}},
+ {COMMENT_KIND, {"Kind", &genStringAbbrev}},
+ {COMMENT_TEXT, {"Text", &genStringAbbrev}},
+ {COMMENT_NAME, {"Name", &genStringAbbrev}},
+ {COMMENT_DIRECTION, {"Direction", &genStringAbbrev}},
+ {COMMENT_PARAMNAME, {"ParamName", &genStringAbbrev}},
+ {COMMENT_CLOSENAME, {"CloseName", &genStringAbbrev}},
+ {COMMENT_SELFCLOSING, {"SelfClosing", &genBoolAbbrev}},
+ {COMMENT_EXPLICIT, {"Explicit", &genBoolAbbrev}},
+ {COMMENT_ATTRKEY, {"AttrKey", &genStringAbbrev}},
+ {COMMENT_ATTRVAL, {"AttrVal", &genStringAbbrev}},
+ {COMMENT_ARG, {"Arg", &genStringAbbrev}},
+ {FIELD_TYPE_NAME, {"Name", &genStringAbbrev}},
+ {FIELD_DEFAULT_VALUE, {"DefaultValue", &genStringAbbrev}},
+ {MEMBER_TYPE_NAME, {"Name", &genStringAbbrev}},
+ {MEMBER_TYPE_ACCESS, {"Access", &genIntAbbrev}},
+ {MEMBER_TYPE_IS_STATIC, {"IsStatic", &genBoolAbbrev}},
+ {NAMESPACE_USR, {"USR", &genSymbolIdAbbrev}},
+ {NAMESPACE_NAME, {"Name", &genStringAbbrev}},
+ {NAMESPACE_PATH, {"Path", &genStringAbbrev}},
+ {ENUM_USR, {"USR", &genSymbolIdAbbrev}},
+ {ENUM_NAME, {"Name", &genStringAbbrev}},
+ {ENUM_DEFLOCATION, {"DefLocation", &genLocationAbbrev}},
+ {ENUM_LOCATION, {"Location", &genLocationAbbrev}},
+ {ENUM_SCOPED, {"Scoped", &genBoolAbbrev}},
+ {ENUM_VALUE_NAME, {"Name", &genStringAbbrev}},
+ {ENUM_VALUE_VALUE, {"Value", &genStringAbbrev}},
+ {ENUM_VALUE_EXPR, {"Expr", &genStringAbbrev}},
+ {RECORD_USR, {"USR", &genSymbolIdAbbrev}},
+ {RECORD_NAME, {"Name", &genStringAbbrev}},
+ {RECORD_PATH, {"Path", &genStringAbbrev}},
+ {RECORD_DEFLOCATION, {"DefLocation", &genLocationAbbrev}},
+ {RECORD_LOCATION, {"Location", &genLocationAbbrev}},
+ {RECORD_TAG_TYPE, {"TagType", &genIntAbbrev}},
+ {RECORD_IS_TYPE_DEF, {"IsTypeDef", &genBoolAbbrev}},
+ {BASE_RECORD_USR, {"USR", &genSymbolIdAbbrev}},
+ {BASE_RECORD_NAME, {"Name", &genStringAbbrev}},
+ {BASE_RECORD_PATH, {"Path", &genStringAbbrev}},
+ {BASE_RECORD_TAG_TYPE, {"TagType", &genIntAbbrev}},
+ {BASE_RECORD_IS_VIRTUAL, {"IsVirtual", &genBoolAbbrev}},
+ {BASE_RECORD_ACCESS, {"Access", &genIntAbbrev}},
+ {BASE_RECORD_IS_PARENT, {"IsParent", &genBoolAbbrev}},
+ {FUNCTION_USR, {"USR", &genSymbolIdAbbrev}},
+ {FUNCTION_NAME, {"Name", &genStringAbbrev}},
+ {FUNCTION_DEFLOCATION, {"DefLocation", &genLocationAbbrev}},
+ {FUNCTION_LOCATION, {"Location", &genLocationAbbrev}},
+ {FUNCTION_ACCESS, {"Access", &genIntAbbrev}},
+ {FUNCTION_IS_METHOD, {"IsMethod", &genBoolAbbrev}},
+ {FUNCTION_IS_STATIC, {"IsStatic", &genBoolAbbrev}},
+ {REFERENCE_USR, {"USR", &genSymbolIdAbbrev}},
+ {REFERENCE_NAME, {"Name", &genStringAbbrev}},
+ {REFERENCE_QUAL_NAME, {"QualName", &genStringAbbrev}},
+ {REFERENCE_TYPE, {"RefType", &genIntAbbrev}},
+ {REFERENCE_PATH, {"Path", &genStringAbbrev}},
+ {REFERENCE_FIELD, {"Field", &genIntAbbrev}},
+ {TEMPLATE_PARAM_CONTENTS, {"Contents", &genStringAbbrev}},
+ {TEMPLATE_SPECIALIZATION_OF,
+ {"SpecializationOf", &genSymbolIdAbbrev}},
+ {TYPEDEF_USR, {"USR", &genSymbolIdAbbrev}},
+ {TYPEDEF_NAME, {"Name", &genStringAbbrev}},
+ {TYPEDEF_DEFLOCATION, {"DefLocation", &genLocationAbbrev}},
+ {TYPEDEF_IS_USING, {"IsUsing", &genBoolAbbrev}}};
assert(Inits.size() == RecordIdCount);
for (const auto &Init : Inits) {
RecordIdNameMap[Init.first] = Init.second;
@@ -327,7 +329,7 @@ void ClangDocBitcodeWriter::emitAbbrev(RecordId ID, BlockId
Block) {
void ClangDocBitcodeWriter::emitRecord(const SymbolID &Sym, RecordId ID) {
assert(RecordIdNameMap[ID] && "Unknown RecordId.");
- assert(RecordIdNameMap[ID].Abbrev == &SymbolIDAbbrev &&
+ assert(RecordIdNameMap[ID].Abbrev == &genSymbolIdAbbrev &&
"Abbrev type mismatch.");
if (!prepRecordData(ID, Sym != EmptySID))
return;
@@ -339,7 +341,7 @@ void ClangDocBitcodeWriter::emitRecord(const SymbolID &Sym,
RecordId ID) {
void ClangDocBitcodeWriter::emitRecord(llvm::StringRef Str, RecordId ID) {
assert(RecordIdNameMap[ID] && "Unknown RecordId.");
- assert(RecordIdNameMap[ID].Abbrev == &StringAbbrev &&
+ assert(RecordIdNameMap[ID].Abbrev == &genStringAbbrev &&
"Abbrev type mismatch.");
if (!prepRecordData(ID, !Str.empty()))
return;
@@ -350,7 +352,7 @@ void ClangDocBitcodeWriter::emitRecord(llvm::StringRef Str,
RecordId ID) {
void ClangDocBitcodeWriter::emitRecord(const Location &Loc, RecordId ID) {
assert(RecordIdNameMap[ID] && "Unknown RecordId.");
- assert(RecordIdNameMap[ID].Abbrev == &LocationAbbrev &&
+ assert(RecordIdNameMap[ID].Abbrev == &genLocationAbbrev &&
"Abbrev type mismatch.");
if (!prepRecordData(ID, true))
return;
@@ -364,7 +366,8 @@ void ClangDocBitcodeWriter::emitRecord(const Location &Loc,
RecordId ID) {
void ClangDocBitcodeWriter::emitRecord(bool Val, RecordId ID) {
assert(RecordIdNameMap[ID] && "Unknown RecordId.");
- assert(RecordIdNameMap[ID].Abbrev == &BoolAbbrev && "Abbrev type mismatch.");
+ assert(RecordIdNameMap[ID].Abbrev == &genBoolAbbrev &&
+ "Abbrev type mismatch.");
if (!prepRecordData(ID, Val))
return;
Record.push_back(Val);
@@ -373,7 +376,8 @@ void ClangDocBitcodeWriter::emitRecord(bool Val, RecordId
ID) {
void ClangDocBitcodeWriter::emitRecord(int Val, RecordId ID) {
assert(RecordIdNameMap[ID] && "Unknown RecordId.");
- assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
+ assert(RecordIdNameMap[ID].Abbrev == &genIntAbbrev &&
+ "Abbrev type mismatch.");
if (!prepRecordData(ID, Val))
return;
// FIXME: Assert that the integer is of the appropriate size.
@@ -383,7 +387,8 @@ void ClangDocBitcodeWriter::emitRecord(int Val, RecordId
ID) {
void ClangDocBitcodeWriter::emitRecord(unsigned Val, RecordId ID) {
assert(RecordIdNameMap[ID] && "Unknown RecordId.");
- assert(RecordIdNameMap[ID].Abbrev == &IntAbbrev && "Abbrev type mismatch.");
+ assert(RecordIdNameMap[ID].Abbrev == &genIntAbbrev &&
+ "Abbrev type mismatch.");
if (!prepRecordData(ID, Val))
return;
assert(Val < (1U << BitCodeConstants::IntSize));
diff --git a/clang-tools-extra/clang-doc/HTMLGenerator.cpp
b/clang-tools-extra/clang-doc/HTMLGenerator.cpp
index ef6e61d34e1bf..6d061b33a67c1 100644
--- a/clang-tools-extra/clang-doc/HTMLGenerator.cpp
+++ b/clang-tools-extra/clang-doc/HTMLGenerator.cpp
@@ -105,12 +105,10 @@ struct TagNode : public HTMLNode {
void render(llvm::raw_ostream &OS, int IndentationLevel) override;
};
-constexpr const char *kDoctypeDecl = "<!DOCTYPE html>";
-
struct HTMLFile {
std::vector<std::unique_ptr<HTMLNode>> Children; // List of child nodes
void render(llvm::raw_ostream &OS) {
- OS << kDoctypeDecl << "\n";
+ OS << "<!DOCTYPE html>\n";
for (const auto &C : Children) {
C->render(OS, 0);
OS << "\n";
diff --git a/clang-tools-extra/clang-doc/Serialize.cpp
b/clang-tools-extra/clang-doc/Serialize.cpp
index 1dcccf3c3c2ab..687a7e3e31207 100644
--- a/clang-tools-extra/clang-doc/Serialize.cpp
+++ b/clang-tools-extra/clang-doc/Serialize.cpp
@@ -320,7 +320,7 @@ static void InsertChild(ScopeChildren &Scope, TypedefInfo
Info) {
// parameter. Since each variant is used once, it's not worth having a more
// elaborate system to automatically deduce this information.
template <typename ChildType>
-static std::unique_ptr<Info> MakeAndInsertIntoParent(ChildType Child) {
+static std::unique_ptr<Info> makeAndInsertIntoParent(ChildType Child) {
if (Child.Namespace.empty()) {
// Insert into unnamed parent namespace.
auto ParentNS = std::make_unique<NamespaceInfo>();
@@ -498,7 +498,7 @@ populateParentNamespaces(llvm::SmallVector<Reference, 4>
&Namespaces,
}
static void
-PopulateTemplateParameters(std::optional<TemplateInfo> &TemplateInfo,
+populateTemplateParameters(std::optional<TemplateInfo> &TemplateInfo,
const clang::Decl *D) {
if (const TemplateParameterList *ParamList =
D->getDescribedTemplateParams()) {
@@ -512,8 +512,8 @@ PopulateTemplateParameters(std::optional<TemplateInfo>
&TemplateInfo,
}
}
-static TemplateParamInfo TemplateArgumentToInfo(const clang::Decl *D,
- const TemplateArgument &Arg) {
+static TemplateParamInfo convertTemplateArgToInfo(const clang::Decl *D,
+ const TemplateArgument &Arg)
{
// The TemplateArgument's pretty printing handles all the normal cases
// well enough for our requirements.
std::string Str;
@@ -556,7 +556,7 @@ static void populateFunctionInfo(FunctionInfo &I, const
FunctionDecl *D,
I.ReturnType = getTypeInfoForType(D->getReturnType(), LO);
parseParameters(I, D);
- PopulateTemplateParameters(I.Template, D);
+ populateTemplateParameters(I.Template, D);
// Handle function template specializations.
if (const FunctionTemplateSpecializationInfo *FTSI =
@@ -571,7 +571,7 @@ static void populateFunctionInfo(FunctionInfo &I, const
FunctionDecl *D,
// Template parameters to the specialization.
if (FTSI->TemplateArguments) {
for (const TemplateArgument &Arg : FTSI->TemplateArguments->asArray()) {
- Specialization.Params.push_back(TemplateArgumentToInfo(D, Arg));
+ Specialization.Params.push_back(convertTemplateArgToInfo(D, Arg));
}
}
}
@@ -588,9 +588,9 @@ static void populateMemberTypeInfo(MemberTypeInfo &I, const
Decl *D) {
return;
Comment->setAttached();
- if (comments::FullComment *fc = Comment->parse(Context, nullptr, D)) {
+ if (comments::FullComment *Fc = Comment->parse(Context, nullptr, D)) {
I.Description.emplace_back();
- parseFullComment(fc, I.Description.back());
+ parseFullComment(Fc, I.Description.back());
}
}
@@ -665,55 +665,55 @@ parseBases(RecordInfo &I, const CXXRecordDecl *D, bool
IsFileInRootDir,
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>();
+ auto NSI = std::make_unique<NamespaceInfo>();
bool IsInAnonymousNamespace = false;
- populateInfo(*I, D, FC, IsInAnonymousNamespace);
+ populateInfo(*NSI, 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};
+ NSI->Name = D->isAnonymousNamespace()
+ ? llvm::SmallString<16>("@nonymous_namespace")
+ : NSI->Name;
+ NSI->Path = getInfoRelativePath(NSI->Namespace);
+ if (NSI->Namespace.empty() && NSI->USR == SymbolID())
+ return {std::unique_ptr<Info>{std::move(NSI)}, nullptr};
// Namespaces are inserted into the parent by reference, so we need to return
// both the parent and the record itself.
- return {std::move(I), MakeAndInsertIntoParent<const NamespaceInfo &>(*I)};
+ return {std::move(NSI), makeAndInsertIntoParent<const NamespaceInfo
&>(*NSI)};
}
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>();
+ auto RI = std::make_unique<RecordInfo>();
bool IsInAnonymousNamespace = false;
- populateSymbolInfo(*I, D, FC, LineNumber, File, IsFileInRootDir,
+ populateSymbolInfo(*RI, D, FC, LineNumber, File, IsFileInRootDir,
IsInAnonymousNamespace);
if (!shouldSerializeInfo(PublicOnly, IsInAnonymousNamespace, D))
return {};
- I->TagType = D->getTagKind();
- parseFields(*I, D, PublicOnly);
+ RI->TagType = D->getTagKind();
+ parseFields(*RI, D, PublicOnly);
if (const auto *C = dyn_cast<CXXRecordDecl>(D)) {
if (const TypedefNameDecl *TD = C->getTypedefNameForAnonDecl()) {
- I->Name = TD->getNameAsString();
- I->IsTypeDef = true;
+ RI->Name = TD->getNameAsString();
+ RI->IsTypeDef = true;
}
// TODO: remove first call to parseBases, that function should be deleted
- parseBases(*I, C);
- parseBases(*I, C, IsFileInRootDir, PublicOnly, true);
+ parseBases(*RI, C);
+ parseBases(*RI, C, IsFileInRootDir, PublicOnly, true);
}
- I->Path = getInfoRelativePath(I->Namespace);
+ RI->Path = getInfoRelativePath(RI->Namespace);
- PopulateTemplateParameters(I->Template, D);
+ populateTemplateParameters(RI->Template, D);
// Full and partial specializations.
if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
- if (!I->Template)
- I->Template.emplace();
- I->Template->Specialization.emplace();
- auto &Specialization = *I->Template->Specialization;
+ if (!RI->Template)
+ RI->Template.emplace();
+ RI->Template->Specialization.emplace();
+ auto &Specialization = *RI->Template->Specialization;
// What this is a specialization of.
auto SpecOf = CTSD->getSpecializedTemplateOrPartial();
@@ -732,22 +732,22 @@ emitInfo(const RecordDecl *D, const FullComment *FC, int
LineNumber,
dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
if (const ASTTemplateArgumentListInfo *AsWritten =
CTPSD->getTemplateArgsAsWritten()) {
- for (unsigned i = 0; i < AsWritten->getNumTemplateArgs(); i++) {
+ for (unsigned Idx = 0; Idx < AsWritten->getNumTemplateArgs(); Idx++) {
Specialization.Params.emplace_back(
- getSourceCode(D, (*AsWritten)[i].getSourceRange()));
+ getSourceCode(D, (*AsWritten)[Idx].getSourceRange()));
}
}
} else {
for (const TemplateArgument &Arg : CTSD->getTemplateArgs().asArray()) {
- Specialization.Params.push_back(TemplateArgumentToInfo(D, Arg));
+ Specialization.Params.push_back(convertTemplateArgToInfo(D, Arg));
}
}
}
// Records are inserted into the parent by reference, so we need to return
// both the parent and the record itself.
- auto Parent = MakeAndInsertIntoParent<const RecordInfo &>(*I);
- return {std::move(I), std::move(Parent)};
+ auto Parent = makeAndInsertIntoParent<const RecordInfo &>(*RI);
+ return {std::move(RI), std::move(Parent)};
}
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
@@ -762,7 +762,7 @@ emitInfo(const FunctionDecl *D, const FullComment *FC, int
LineNumber,
return {};
// Info is wrapped in its parent scope so is returned in the second position.
- return {nullptr, MakeAndInsertIntoParent<FunctionInfo &&>(std::move(Func))};
+ return {nullptr, makeAndInsertIntoParent<FunctionInfo &&>(std::move(Func))};
}
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
@@ -792,7 +792,7 @@ emitInfo(const CXXMethodDecl *D, const FullComment *FC, int
LineNumber,
Func.Access = D->getAccess();
// Info is wrapped in its parent scope so is returned in the second position.
- return {nullptr, MakeAndInsertIntoParent<FunctionInfo &&>(std::move(Func))};
+ return {nullptr, makeAndInsertIntoParent<FunctionInfo &&>(std::move(Func))};
}
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
@@ -817,7 +817,7 @@ emitInfo(const TypedefDecl *D, const FullComment *FC, int
LineNumber,
Info.IsUsing = false;
// Info is wrapped in its parent scope so is returned in the second position.
- return {nullptr, MakeAndInsertIntoParent<TypedefInfo &&>(std::move(Info))};
+ return {nullptr, makeAndInsertIntoParent<TypedefInfo &&>(std::move(Info))};
}
// A type alias is a C++ "using" declaration for a type. It gets mapped to a
@@ -838,7 +838,7 @@ emitInfo(const TypeAliasDecl *D, const FullComment *FC, int
LineNumber,
Info.IsUsing = true;
// Info is wrapped in its parent scope so is returned in the second position.
- return {nullptr, MakeAndInsertIntoParent<TypedefInfo &&>(std::move(Info))};
+ return {nullptr, makeAndInsertIntoParent<TypedefInfo &&>(std::move(Info))};
}
std::pair<std::unique_ptr<Info>, std::unique_ptr<Info>>
@@ -859,7 +859,7 @@ emitInfo(const EnumDecl *D, const FullComment *FC, int
LineNumber,
parseEnumerators(Enum, D);
// Info is wrapped in its parent scope so is returned in the second position.
- return {nullptr, MakeAndInsertIntoParent<EnumInfo &&>(std::move(Enum))};
+ return {nullptr, makeAndInsertIntoParent<EnumInfo &&>(std::move(Enum))};
}
} // namespace serialize
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
