[clang-tools-extra] [clang-doc] Fix clang-tidy naming diagnostics (PR #136444)
via cfe-commits
cfe-commits at lists.llvm.org
Sat Apr 19 11:16:52 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-tools-extra
Author: Paul Kirth (ilovepi)
<details>
<summary>Changes</summary>
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.
---
Patch is 24.55 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/136444.diff
3 Files Affected:
- (modified) clang-tools-extra/clang-doc/BitcodeWriter.cpp (+102-97)
- (modified) clang-tools-extra/clang-doc/HTMLGenerator.cpp (+1-3)
- (modified) clang-tools-extra/clang-doc/Serialize.cpp (+41-41)
``````````diff
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();
+ parseFie...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/136444
More information about the cfe-commits
mailing list