Diff 236449

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

	//===--- IdentifierNamingCheck.h - clang-tidy -------------------- C++ --===//			//===--- IdentifierNamingCheck.h - clang-tidy -------------------- C++ --===//
	//			//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.			// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.			// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception			// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H			#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H
	#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H			#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H

	#include "../ClangTidyCheck.h"			#include "../utils/RenamerClangTidyCheck.h"

	namespace clang {			namespace clang {

	class MacroInfo;			class MacroInfo;

	namespace tidy {			namespace tidy {
	namespace readability {			namespace readability {

	/// Checks for identifiers naming style mismatch.			/// Checks for identifiers naming style mismatch.
	///			///
	/// This check will try to enforce coding guidelines on the identifiers naming.			/// This check will try to enforce coding guidelines on the identifiers naming.
	/// It supports `lower_case`, `UPPER_CASE`, `camelBack` and `CamelCase` casing			/// It supports `lower_case`, `UPPER_CASE`, `camelBack` and `CamelCase` casing
	/// and tries to convert from one to another if a mismatch is detected.			/// and tries to convert from one to another if a mismatch is detected.
	///			///
	/// It also supports a fixed prefix and suffix that will be prepended or			/// It also supports a fixed prefix and suffix that will be prepended or
	/// appended to the identifiers, regardless of the casing.			/// appended to the identifiers, regardless of the casing.
	///			///
	/// Many configuration options are available, in order to be able to create			/// Many configuration options are available, in order to be able to create
	/// different rules for different kind of identifier. In general, the			/// different rules for different kind of identifier. In general, the
	/// rules are falling back to a more generic rule if the specific case is not			/// rules are falling back to a more generic rule if the specific case is not
	/// configured.			/// configured.
	class IdentifierNamingCheck : public ClangTidyCheck {			class IdentifierNamingCheck final : public RenamerClangTidyCheck {
	public:			public:
	IdentifierNamingCheck(StringRef Name, ClangTidyContext *Context);			IdentifierNamingCheck(StringRef Name, ClangTidyContext *Context);
	~IdentifierNamingCheck();			~IdentifierNamingCheck();

	void storeOptions(ClangTidyOptions::OptionMap &Opts) override;			void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
	void registerMatchers(ast_matchers::MatchFinder *Finder) override;
	void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
	void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
	Preprocessor *ModuleExpanderPP) override;
	void onEndOfTranslationUnit() override;

	enum CaseType {			enum CaseType {
	CT_AnyCase = 0,			CT_AnyCase = 0,
	CT_LowerCase,			CT_LowerCase,
	CT_CamelBack,			CT_CamelBack,
	CT_UpperCase,			CT_UpperCase,
	CT_CamelCase,			CT_CamelCase,
	CT_CamelSnakeCase,			CT_CamelSnakeCase,
	CT_CamelSnakeBack			CT_CamelSnakeBack
	};			};

	struct NamingStyle {			struct NamingStyle {
	NamingStyle() = default;			NamingStyle() = default;

	NamingStyle(llvm::Optional<CaseType> Case, const std::string &Prefix,			NamingStyle(llvm::Optional<CaseType> Case, const std::string &Prefix,
	const std::string &Suffix)			const std::string &Suffix)
	: Case(Case), Prefix(Prefix), Suffix(Suffix) {}			: Case(Case), Prefix(Prefix), Suffix(Suffix) {}

	llvm::Optional<CaseType> Case;			llvm::Optional<CaseType> Case;
	std::string Prefix;			std::string Prefix;
	std::string Suffix;			std::string Suffix;
	};			};

	/// This enum will be used in %select of the diagnostic message.
	/// Each value below IgnoreFailureThreshold should have an error message.
	enum class ShouldFixStatus {
	ShouldFix,
	ConflictsWithKeyword, /// The fixup will conflict with a language keyword,
	/// so we can't fix it automatically.
	ConflictsWithMacroDefinition, /// The fixup will conflict with a macro
	/// definition, so we can't fix it
	/// automatically.

	/// Values pass this threshold will be ignored completely
	/// i.e no message, no fixup.
	IgnoreFailureThreshold,

	InsideMacro, /// If the identifier was used or declared within a macro we
	/// won't offer a fixup for safety reasons.
	};

	/// Holds an identifier name check failure, tracking the kind of the
	/// identifier, its possible fixup and the starting locations of all the
	/// identifier usages.
	struct NamingCheckFailure {
	std::string KindName;
	std::string Fixup;

	/// Whether the failure should be fixed or not.
	///
	/// ie: if the identifier was used or declared within a macro we won't offer
	/// a fixup for safety reasons.
	bool ShouldFix() const { return FixStatus == ShouldFixStatus::ShouldFix; }

	bool ShouldNotify() const {
	return FixStatus < ShouldFixStatus::IgnoreFailureThreshold;
	}

	ShouldFixStatus FixStatus = ShouldFixStatus::ShouldFix;

	/// A set of all the identifier usages starting SourceLocation, in
	/// their encoded form.
	llvm::DenseSet<unsigned> RawUsageLocs;

	NamingCheckFailure() = default;
	};

	typedef std::pair<SourceLocation, std::string> NamingCheckId;

	typedef llvm::DenseMap<NamingCheckId, NamingCheckFailure>
	NamingCheckFailureMap;

	/// Check Macros for style violations.
	void checkMacro(SourceManager &sourceMgr, const Token &MacroNameTok,
	const MacroInfo *MI);

	/// Add a usage of a macro if it already has a violation.
	void expandMacro(const Token &MacroNameTok, const MacroInfo *MI);

	private:			private:
				llvm::Optional<FailureInfo>
				GetDeclFailureInfo(const NamedDecl *Decl,
				const SourceManager &SM) const override;
				llvm::Optional<FailureInfo>
				GetMacroFailureInfo(const Token &MacroNameTok,
				const SourceManager &SM) const override;
				DiagInfo GetDiagInfo(const NamingCheckId &ID,
				const NamingCheckFailure &Failure) const override;

	std::vector<llvm::Optional<NamingStyle>> NamingStyles;			std::vector<llvm::Optional<NamingStyle>> NamingStyles;
	bool IgnoreFailedSplit;			bool IgnoreFailedSplit;
	NamingCheckFailureMap NamingCheckFailures;
	};			};

	} // namespace readability			} // namespace readability
	} // namespace tidy			} // namespace tidy
	} // namespace clang			} // namespace clang

	#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H			#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_READABILITY_IDENTIFIERNAMINGCHECK_H

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

Show All 16 Lines
#include "llvm/ADT/DenseMapInfo.h"		#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/Support/Debug.h"		#include "llvm/Support/Debug.h"
#include "llvm/Support/Format.h"		#include "llvm/Support/Format.h"

#define DEBUG_TYPE "clang-tidy"		#define DEBUG_TYPE "clang-tidy"

using namespace clang::ast_matchers;		using namespace clang::ast_matchers;

namespace llvm {
/// Specialisation of DenseMapInfo to allow NamingCheckId objects in DenseMaps
template <>
struct DenseMapInfo<
clang::tidy::readability::IdentifierNamingCheck::NamingCheckId> {
using NamingCheckId =
clang::tidy::readability::IdentifierNamingCheck::NamingCheckId;

static inline NamingCheckId getEmptyKey() {
return NamingCheckId(
clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-1)),
"EMPTY");
}

static inline NamingCheckId getTombstoneKey() {
return NamingCheckId(
clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-2)),
"TOMBSTONE");
}

static unsigned getHashValue(NamingCheckId Val) {
assert(Val != getEmptyKey() && "Cannot hash the empty key!");
assert(Val != getTombstoneKey() && "Cannot hash the tombstone key!");

std::hash<NamingCheckId::second_type> SecondHash;
return Val.first.getRawEncoding() + SecondHash(Val.second);
}

static bool isEqual(const NamingCheckId &LHS, const NamingCheckId &RHS) {
if (RHS == getEmptyKey())
return LHS == getEmptyKey();
if (RHS == getTombstoneKey())
return LHS == getTombstoneKey();
return LHS == RHS;
}
};
} // namespace llvm

namespace clang {		namespace clang {
namespace tidy {		namespace tidy {
namespace readability {		namespace readability {

// clang-format off		// clang-format off
#define NAMING_KEYS(m) \		#define NAMING_KEYS(m) \
m(Namespace) \		m(Namespace) \
m(InlineNamespace) \		m(InlineNamespace) \
▲ Show 20 Lines • Show All 88 Lines • ▼ Show 20 Lines
private:		private:
Preprocessor *PP;		Preprocessor *PP;
IdentifierNamingCheck *Check;		IdentifierNamingCheck *Check;
};		};
} // namespace		} // namespace

IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,		IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
ClangTidyContext *Context)		ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {		: RenamerClangTidyCheck(Name, Context) {
auto const fromString = [](StringRef Str) {		auto const fromString = [](StringRef Str) {
return llvm::StringSwitch<llvm::Optional<CaseType>>(Str)		return llvm::StringSwitch<llvm::Optional<CaseType>>(Str)
.Case("aNy_CasE", CT_AnyCase)		.Case("aNy_CasE", CT_AnyCase)
.Case("lower_case", CT_LowerCase)		.Case("lower_case", CT_LowerCase)
.Case("UPPER_CASE", CT_UpperCase)		.Case("UPPER_CASE", CT_UpperCase)
.Case("camelBack", CT_CamelBack)		.Case("camelBack", CT_CamelBack)
.Case("CamelCase", CT_CamelCase)		.Case("CamelCase", CT_CamelCase)
.Case("Camel_Snake_Case", CT_CamelSnakeCase)		.Case("Camel_Snake_Case", CT_CamelSnakeCase)
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines	if (NamingStyles[i]) {
Options.store(Opts, (StyleNames[i] + "Suffix").str(),		Options.store(Opts, (StyleNames[i] + "Suffix").str(),
NamingStyles[i]->Suffix);		NamingStyles[i]->Suffix);
}		}
}		}

Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);		Options.store(Opts, "IgnoreFailedSplit", IgnoreFailedSplit);
}		}

void IdentifierNamingCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(namedDecl().bind("decl"), this);
Finder->addMatcher(usingDecl().bind("using"), this);
Finder->addMatcher(declRefExpr().bind("declRef"), this);
Finder->addMatcher(cxxConstructorDecl().bind("classRef"), this);
Finder->addMatcher(cxxDestructorDecl().bind("classRef"), this);
Finder->addMatcher(typeLoc().bind("typeLoc"), this);
Finder->addMatcher(nestedNameSpecifierLoc().bind("nestedNameLoc"), this);
}

void IdentifierNamingCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor PP, Preprocessor ModuleExpanderPP) {
ModuleExpanderPP->addPPCallbacks(
std::make_unique<IdentifierNamingCheckPPCallbacks>(ModuleExpanderPP,
this));
}

static bool matchesStyle(StringRef Name,		static bool matchesStyle(StringRef Name,
IdentifierNamingCheck::NamingStyle Style) {		IdentifierNamingCheck::NamingStyle Style) {
static llvm::Regex Matchers[] = {		static llvm::Regex Matchers[] = {
llvm::Regex("^.*$"),		llvm::Regex("^.*$"),
llvm::Regex("^[a-z][a-z0-9_]*$"),		llvm::Regex("^[a-z][a-z0-9_]*$"),
llvm::Regex("^[a-z][a-zA-Z0-9]*$"),		llvm::Regex("^[a-z][a-zA-Z0-9]*$"),
llvm::Regex("^[A-Z][A-Z0-9_]*$"),		llvm::Regex("^[A-Z][A-Z0-9_]*$"),
llvm::Regex("^[A-Z][a-zA-Z0-9]*$"),		llvm::Regex("^[A-Z][a-zA-Z0-9]*$"),
▲ Show 20 Lines • Show All 401 Lines • ▼ Show 20 Lines	if (NamingStyles[SK_TemplateParameter])
return SK_TemplateParameter;		return SK_TemplateParameter;

return SK_Invalid;		return SK_Invalid;
}		}

return SK_Invalid;		return SK_Invalid;
}		}

static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures,		llvm::Optional<RenamerClangTidyCheck::FailureInfo>
const IdentifierNamingCheck::NamingCheckId &Decl,		IdentifierNamingCheck::GetDeclFailureInfo(const NamedDecl *Decl,
SourceRange Range, SourceManager *SourceMgr = nullptr) {		const SourceManager &SM) const {
// Do nothing if the provided range is invalid.
if (Range.getBegin().isInvalid() \|\| Range.getEnd().isInvalid())
return;

// If we have a source manager, use it to convert to the spelling location for
// performing the fix. This is necessary because macros can map the same
// spelling location to different source locations, and we only want to fix
// the token once, before it is expanded by the macro.
SourceLocation FixLocation = Range.getBegin();
if (SourceMgr)
FixLocation = SourceMgr->getSpellingLoc(FixLocation);
if (FixLocation.isInvalid())
return;

// Try to insert the identifier location in the Usages map, and bail out if it
// is already in there
auto &Failure = Failures[Decl];
if (!Failure.RawUsageLocs.insert(FixLocation.getRawEncoding()).second)
return;

if (!Failure.ShouldFix())
return;

if (!utils::rangeCanBeFixed(Range, SourceMgr))
Failure.FixStatus = IdentifierNamingCheck::ShouldFixStatus::InsideMacro;
}

/// Convenience method when the usage to be added is a NamedDecl
static void addUsage(IdentifierNamingCheck::NamingCheckFailureMap &Failures,
const NamedDecl *Decl, SourceRange Range,
SourceManager *SourceMgr = nullptr) {
return addUsage(Failures,
IdentifierNamingCheck::NamingCheckId(Decl->getLocation(),
Decl->getNameAsString()),
Range, SourceMgr);
}

void IdentifierNamingCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Decl =
Result.Nodes.getNodeAs<CXXConstructorDecl>("classRef")) {
if (Decl->isImplicit())
return;

addUsage(NamingCheckFailures, Decl->getParent(),
Decl->getNameInfo().getSourceRange());

for (const auto *Init : Decl->inits()) {
if (!Init->isWritten() \|\| Init->isInClassMemberInitializer())
continue;
if (const auto *FD = Init->getAnyMember())
addUsage(NamingCheckFailures, FD,
SourceRange(Init->getMemberLocation()));
// Note: delegating constructors and base class initializers are handled
// via the "typeLoc" matcher.
}
return;
}

if (const auto *Decl =
Result.Nodes.getNodeAs<CXXDestructorDecl>("classRef")) {
if (Decl->isImplicit())
return;

SourceRange Range = Decl->getNameInfo().getSourceRange();
if (Range.getBegin().isInvalid())
return;
// The first token that will be found is the ~ (or the equivalent trigraph),
// we want instead to replace the next token, that will be the identifier.
Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());

addUsage(NamingCheckFailures, Decl->getParent(), Range);
return;
}

if (const auto *Loc = Result.Nodes.getNodeAs<TypeLoc>("typeLoc")) {
NamedDecl *Decl = nullptr;
if (const auto &Ref = Loc->getAs<TagTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<InjectedClassNameTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<UnresolvedUsingTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<TemplateTypeParmTypeLoc>()) {
Decl = Ref.getDecl();
}

if (Decl) {
addUsage(NamingCheckFailures, Decl, Loc->getSourceRange());
return;
}

if (const auto &Ref = Loc->getAs<TemplateSpecializationTypeLoc>()) {
const auto *Decl =
Ref.getTypePtr()->getTemplateName().getAsTemplateDecl();

SourceRange Range(Ref.getTemplateNameLoc(), Ref.getTemplateNameLoc());
if (const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
if (const auto *TemplDecl = ClassDecl->getTemplatedDecl())
addUsage(NamingCheckFailures, TemplDecl, Range);
return;
}
}

if (const auto &Ref =
Loc->getAs<DependentTemplateSpecializationTypeLoc>()) {
if (const auto *Decl = Ref.getTypePtr()->getAsTagDecl())
addUsage(NamingCheckFailures, Decl, Loc->getSourceRange());
return;
}
}

if (const auto *Loc =
Result.Nodes.getNodeAs<NestedNameSpecifierLoc>("nestedNameLoc")) {
if (NestedNameSpecifier *Spec = Loc->getNestedNameSpecifier()) {
if (NamespaceDecl *Decl = Spec->getAsNamespace()) {
addUsage(NamingCheckFailures, Decl, Loc->getLocalSourceRange());
return;
}
}
}

if (const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>("using")) {
for (const auto *Shadow : Decl->shadows()) {
addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
Decl->getNameInfo().getSourceRange());
}
return;
}

if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
SourceRange Range = DeclRef->getNameInfo().getSourceRange();
addUsage(NamingCheckFailures, DeclRef->getDecl(), Range,
Result.SourceManager);
return;
}

if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
if (!Decl->getIdentifier() \|\| Decl->getName().empty() \|\| Decl->isImplicit())
return;

// Fix type aliases in value declarations
if (const auto *Value = Result.Nodes.getNodeAs<ValueDecl>("decl")) {
if (const auto *TypePtr = Value->getType().getTypePtrOrNull()) {
if (const auto *Typedef = TypePtr->getAs<TypedefType>()) {
addUsage(NamingCheckFailures, Typedef->getDecl(),
Value->getSourceRange());
}
}
}

// Fix type aliases in function declarations
if (const auto *Value = Result.Nodes.getNodeAs<FunctionDecl>("decl")) {
if (const auto *Typedef =
Value->getReturnType().getTypePtr()->getAs<TypedefType>()) {
addUsage(NamingCheckFailures, Typedef->getDecl(),
Value->getSourceRange());
}
for (unsigned i = 0; i < Value->getNumParams(); ++i) {
if (const auto *Typedef = Value->parameters()[i]
->getType()
.getTypePtr()
->getAs<TypedefType>()) {
addUsage(NamingCheckFailures, Typedef->getDecl(),
Value->getSourceRange());
}
}
}

// Ignore ClassTemplateSpecializationDecl which are creating duplicate
// replacements with CXXRecordDecl
if (isa<ClassTemplateSpecializationDecl>(Decl))
return;

StyleKind SK = findStyleKind(Decl, NamingStyles);		StyleKind SK = findStyleKind(Decl, NamingStyles);
if (SK == SK_Invalid)		if (SK == SK_Invalid)
return;		return None;

if (!NamingStyles[SK])		if (!NamingStyles[SK])
return;		return None;

const NamingStyle &Style = *NamingStyles[SK];		const NamingStyle &Style = *NamingStyles[SK];
StringRef Name = Decl->getName();		StringRef Name = Decl->getName();
if (matchesStyle(Name, Style))		if (matchesStyle(Name, Style))
return;		return None;

std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);		std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);
std::replace(KindName.begin(), KindName.end(), '_', ' ');		std::replace(KindName.begin(), KindName.end(), '_', ' ');

std::string Fixup = fixupWithStyle(Name, Style);		std::string Fixup = fixupWithStyle(Name, Style);
if (StringRef(Fixup).equals(Name)) {		if (StringRef(Fixup).equals(Name)) {
if (!IgnoreFailedSplit) {		if (!IgnoreFailedSplit) {
LLVM_DEBUG(llvm::dbgs()		LLVM_DEBUG(llvm::dbgs()
<< Decl->getBeginLoc().printToString(*Result.SourceManager)		<< Decl->getBeginLoc().printToString(SM)
<< llvm::format(": unable to split words for %s '%s'\n",		<< llvm::format(": unable to split words for %s '%s'\n",
KindName.c_str(), Name.str().c_str()));		KindName.c_str(), Name.str().c_str()));
}		}
} else {		return None;
NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
Decl->getLocation(), Decl->getNameAsString())];
SourceRange Range =
DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
.getSourceRange();

const IdentifierTable &Idents = Decl->getASTContext().Idents;
auto CheckNewIdentifier = Idents.find(Fixup);
if (CheckNewIdentifier != Idents.end()) {
const IdentifierInfo *Ident = CheckNewIdentifier->second;
if (Ident->isKeyword(getLangOpts()))
Failure.FixStatus = ShouldFixStatus::ConflictsWithKeyword;
else if (Ident->hasMacroDefinition())
Failure.FixStatus = ShouldFixStatus::ConflictsWithMacroDefinition;
}

Failure.Fixup = std::move(Fixup);
Failure.KindName = std::move(KindName);
addUsage(NamingCheckFailures, Decl, Range);
}
}		}
		return FailureInfo{std::move(KindName), std::move(Fixup)};
}		}

void IdentifierNamingCheck::checkMacro(SourceManager &SourceMgr,		llvm::Optional<RenamerClangTidyCheck::FailureInfo>
const Token &MacroNameTok,		IdentifierNamingCheck::GetMacroFailureInfo(const Token &MacroNameTok,
const MacroInfo *MI) {		const SourceManager &SM) const {
if (!NamingStyles[SK_MacroDefinition])		if (!NamingStyles[SK_MacroDefinition])
return;		return None;

StringRef Name = MacroNameTok.getIdentifierInfo()->getName();		StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
const NamingStyle &Style = *NamingStyles[SK_MacroDefinition];		const NamingStyle &Style = *NamingStyles[SK_MacroDefinition];
if (matchesStyle(Name, Style))		if (matchesStyle(Name, Style))
return;		return None;

std::string KindName =		std::string KindName =
fixupWithCase(StyleNames[SK_MacroDefinition], CT_LowerCase);		fixupWithCase(StyleNames[SK_MacroDefinition], CT_LowerCase);
std::replace(KindName.begin(), KindName.end(), '_', ' ');		std::replace(KindName.begin(), KindName.end(), '_', ' ');

std::string Fixup = fixupWithStyle(Name, Style);		std::string Fixup = fixupWithStyle(Name, Style);
if (StringRef(Fixup).equals(Name)) {		if (StringRef(Fixup).equals(Name)) {
if (!IgnoreFailedSplit) {		if (!IgnoreFailedSplit) {
LLVM_DEBUG(llvm::dbgs()		LLVM_DEBUG(llvm::dbgs()
<< MacroNameTok.getLocation().printToString(SourceMgr)		<< MacroNameTok.getLocation().printToString(SM)
<< llvm::format(": unable to split words for %s '%s'\n",		<< llvm::format(": unable to split words for %s '%s'\n",
KindName.c_str(), Name.str().c_str()));		KindName.c_str(), Name.str().c_str()));
}		}
} else {		return None;
NamingCheckId ID(MI->getDefinitionLoc(), Name);
NamingCheckFailure &Failure = NamingCheckFailures[ID];
SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());

Failure.Fixup = std::move(Fixup);
Failure.KindName = std::move(KindName);
addUsage(NamingCheckFailures, ID, Range);
}		}
		return FailureInfo{std::move(KindName), std::move(Fixup)};
}		}

void IdentifierNamingCheck::expandMacro(const Token &MacroNameTok,		RenamerClangTidyCheck::DiagInfo
const MacroInfo *MI) {		IdentifierNamingCheck::GetDiagInfo(const NamingCheckId &ID,
StringRef Name = MacroNameTok.getIdentifierInfo()->getName();		const NamingCheckFailure &Failure) const {
NamingCheckId ID(MI->getDefinitionLoc(), Name);		return DiagInfo{"invalid case style for %0 '%1'",
		[&](DiagnosticBuilder &diag) {
auto Failure = NamingCheckFailures.find(ID);		diag << Failure.Info.KindName << ID.second;
if (Failure == NamingCheckFailures.end())		}};
return;

SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
addUsage(NamingCheckFailures, ID, Range);
}

void IdentifierNamingCheck::onEndOfTranslationUnit() {
for (const auto &Pair : NamingCheckFailures) {
const NamingCheckId &Decl = Pair.first;
const NamingCheckFailure &Failure = Pair.second;

if (Failure.KindName.empty())
continue;

if (Failure.ShouldNotify()) {
auto Diag =
diag(Decl.first,
"invalid case style for %0 '%1'%select{\|" // Case 0 is empty on
// purpose, because we
// intent to provide a
// fix
"; cannot be fixed because '%3' would conflict with a keyword\|"
"; cannot be fixed because '%3' would conflict with a macro "
"definition}2")
<< Failure.KindName << Decl.second
<< static_cast<int>(Failure.FixStatus) << Failure.Fixup;

if (Failure.ShouldFix()) {
for (const auto &Loc : Failure.RawUsageLocs) {
// We assume that the identifier name is made of one token only. This
// is always the case as we ignore usages in macros that could build
// identifier names by combining multiple tokens.
//
// For destructors, we already take care of it by remembering the
// location of the start of the identifier and not the start of the
// tilde.
//
// Other multi-token identifiers, such as operators are not checked at
// all.
Diag << FixItHint::CreateReplacement(
SourceRange(SourceLocation::getFromRawEncoding(Loc)),
Failure.Fixup);
}
}
}
}
}		}

} // namespace readability		} // namespace readability
} // namespace tidy		} // namespace tidy
} // namespace clang		} // namespace clang

clang-tools-extra/clang-tidy/utils/CMakeLists.txt

	set(LLVM_LINK_COMPONENTS support)			set(LLVM_LINK_COMPONENTS support)

	add_clang_library(clangTidyUtils			add_clang_library(clangTidyUtils
	ASTUtils.cpp			ASTUtils.cpp
	DeclRefExprUtils.cpp			DeclRefExprUtils.cpp
	ExceptionAnalyzer.cpp			ExceptionAnalyzer.cpp
	ExprSequence.cpp			ExprSequence.cpp
	FixItHintUtils.cpp			FixItHintUtils.cpp
	HeaderFileExtensionsUtils.cpp			HeaderFileExtensionsUtils.cpp
	HeaderGuard.cpp			HeaderGuard.cpp
	IncludeInserter.cpp			IncludeInserter.cpp
	IncludeSorter.cpp			IncludeSorter.cpp
	LexerUtils.cpp			LexerUtils.cpp
	NamespaceAliaser.cpp			NamespaceAliaser.cpp
	OptionsUtils.cpp			OptionsUtils.cpp
				RenamerClangTidyCheck.cpp
	TransformerClangTidyCheck.cpp			TransformerClangTidyCheck.cpp
	TypeTraits.cpp			TypeTraits.cpp
	UsingInserter.cpp			UsingInserter.cpp

	LINK_LIBS			LINK_LIBS
	clangAST			clangAST
	clangASTMatchers			clangASTMatchers
	clangBasic			clangBasic
	clangLex			clangLex
	clangSema			clangSema
	clangTidy			clangTidy
	clangTransformer			clangTransformer
	)			)

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.h

This file was added.

				//===--- RenamderClangTidyCheck.h - clang-tidy ------------------- 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
				//
				//===----------------------------------------------------------------------===//

				#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_RENAMERCLANGTIDYCHECK_H
				#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_RENAMERCLANGTIDYCHECK_H

				#include "../ClangTidyCheck.h"
				#include "llvm/ADT/DenseMap.h"
				#include "llvm/ADT/DenseSet.h"
				#include "llvm/ADT/Optional.h"
				#include <string>
				#include <utility>

				namespace clang {

				class MacroInfo;

				namespace tidy {

				/// Base class for clang-tidy checks that want to flag declarations and/or
				/// macros for renaming based on customizable criteria.
				class RenamerClangTidyCheck : public ClangTidyCheck {
				public:
				RenamerClangTidyCheck(StringRef CheckName, ClangTidyContext *Context);
				~RenamerClangTidyCheck();
				njames93Unsubmitted Done Reply Inline Actions Should this be protected as this class should never be instantiated directly. Also the definition could be moved inline as its just a delegating constructor njames93: Should this be protected as this class should never be instantiated directly. Also the…
				logan-5AuthorUnsubmitted Done Reply Inline Actions The constructor (and destructor) can't be inline, since they need to be able to see the specialization of `DenseMapInfo<NamingCheckId>` in the cpp. I could change it to `protected` to clean up the interface -- though it won't strictly change anything, since the class already has pure virtual functions so it's not instantiable. logan-5: The constructor (and destructor) can't be inline, since they need to be able to see the…
				logan-5AuthorUnsubmitted Done Reply Inline Actions Searched the LLVM codebase for other abstract base classes with explicitly defined constructors (e.g. `MakeSmartPtrCheck` in clang-tidy), and their constructors seem to be public. I think I'll keep this one public too for consistency. logan-5: Searched the LLVM codebase for other abstract base classes with explicitly defined constructors…

				/// Derived classes should not implement any matching logic themselves; this
				/// class will do the matching and call the derived class'
				/// GetDeclFailureInfo() and GetMacroFailureInfo() for determining whether a
				/// given identifier passes or fails the check.
				void registerMatchers(ast_matchers::MatchFinder *Finder) override final;
				void
				check(const ast_matchers::MatchFinder::MatchResult &Result) override final;
				void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
				Preprocessor *ModuleExpanderPP) override final;
				void onEndOfTranslationUnit() override final;

				/// This enum will be used in %select of the diagnostic message.
				/// Each value below IgnoreFailureThreshold should have an error message.
				enum class ShouldFixStatus {
				ShouldFix,
				ConflictsWithKeyword, /// The fixup will conflict with a language keyword,
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions It'll be reasonable to place all comments consistently: before definition or after. Eugene.Zelenko: It'll be reasonable to place all comments consistently: before definition or after.
				/// so we can't fix it automatically.
				ConflictsWithMacroDefinition, /// The fixup will conflict with a macro
				/// definition, so we can't fix it
				/// automatically.

				/// Values pass this threshold will be ignored completely
				/// i.e no message, no fixup.
				IgnoreFailureThreshold,

				InsideMacro, /// If the identifier was used or declared within a macro we
				/// won't offer a fixup for safety reasons.
				};

				/// Information describing a failed check
				struct FailureInfo {
				std::string KindName; // Tag or misc info to be used as derived classes need
				std::string Fixup; // The name that will be proposed as a fix-it hint
				};

				/// Holds an identifier name check failure, tracking the kind of the
				/// identifier, its possible fixup and the starting locations of all the
				/// identifier usages.
				struct NamingCheckFailure {
				FailureInfo Info;

				/// Whether the failure should be fixed or not.
				///
				/// e.g.: if the identifier was used or declared within a macro we won't
				/// offer a fixup for safety reasons.
				bool ShouldFix() const {
				return FixStatus == ShouldFixStatus::ShouldFix && !Info.Fixup.empty();
				}

				bool ShouldNotify() const {
				return FixStatus < ShouldFixStatus::IgnoreFailureThreshold;
				}

				ShouldFixStatus FixStatus = ShouldFixStatus::ShouldFix;

				/// A set of all the identifier usages starting SourceLocation, in
				/// their encoded form.
				llvm::DenseSet<unsigned> RawUsageLocs;

				NamingCheckFailure() = default;
				};

				typedef std::pair<SourceLocation, std::string> NamingCheckId;
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Please use using. Same below. See modernize-use-using. Eugene.Zelenko: Please use using. Same below. See modernize-use-using.

				typedef llvm::DenseMap<NamingCheckId, NamingCheckFailure>
				NamingCheckFailureMap;

				/// Check Macros for style violations.
				void checkMacro(SourceManager &sourceMgr, const Token &MacroNameTok,
				const MacroInfo *MI);

				/// Add a usage of a macro if it already has a violation.
				void expandMacro(const Token &MacroNameTok, const MacroInfo *MI);

				protected:
				/// Overridden by derived classes, returns information about if and how a Decl
				/// failed the check. A 'None' result means the Decl did not fail the check.
				virtual llvm::Optional<FailureInfo>
				GetDeclFailureInfo(const NamedDecl *Decl, const SourceManager &SM) const = 0;

				/// Overridden by derived classes, returns information about if and how a
				/// macro failed the check. A 'None' result means the macro did not fail the
				/// check.
				virtual llvm::Optional<FailureInfo>
				GetMacroFailureInfo(const Token &MacroNameTok,
				const SourceManager &SM) const = 0;

				/// Represents customized diagnostic text and how arguments should be applied.
				/// Example usage:
				///
				/// return DiagInfo{"my %1 very %2 special %3 text",
				/// [=](DiagnosticBuilder &diag) {
				/// diag << arg1 << arg2 << arg3;
				/// }};
				struct DiagInfo {
				std::string Text;
				llvm::unique_function<void(DiagnosticBuilder &)> ApplyArgs;
				};

				/// Overridden by derived classes, returns a description of the diagnostic
				/// that should be emitted for the given failure. The base class will then
				/// further customize the diagnostic by adding info about whether the fix-it
				/// can be automatically applied or not.
				virtual DiagInfo GetDiagInfo(const NamingCheckId &ID,
				const NamingCheckFailure &Failure) const = 0;

				private:
				NamingCheckFailureMap NamingCheckFailures;
				};

				} // namespace tidy
				} // namespace clang

				#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_RENAMERCLANGTIDYCHECK_H

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

This file was added.

				//===--- RenamerClangTidyCheck.cpp - clang-tidy ---------------------------===//
				//
				// 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 "RenamerClangTidyCheck.h"
				#include "ASTUtils.h"
				#include "clang/AST/CXXInheritance.h"
				#include "clang/ASTMatchers/ASTMatchFinder.h"
				#include "clang/Frontend/CompilerInstance.h"
				#include "clang/Lex/PPCallbacks.h"
				#include "clang/Lex/Preprocessor.h"
				#include "llvm/ADT/DenseMapInfo.h"
				#include "llvm/Support/Debug.h"
				#include "llvm/Support/Format.h"

				#define DEBUG_TYPE "clang-tidy"

				using namespace clang::ast_matchers;

				namespace llvm {

				/// Specialisation of DenseMapInfo to allow NamingCheckId objects in DenseMaps
				template <>
				struct DenseMapInfo<clang::tidy::RenamerClangTidyCheck::NamingCheckId> {
				using NamingCheckId = clang::tidy::RenamerClangTidyCheck::NamingCheckId;

				static inline NamingCheckId getEmptyKey() {
				return NamingCheckId(
				clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-1)),
				"EMPTY");
				}

				static inline NamingCheckId getTombstoneKey() {
				return NamingCheckId(
				clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-2)),
				"TOMBSTONE");
				}

				static unsigned getHashValue(NamingCheckId Val) {
				assert(Val != getEmptyKey() && "Cannot hash the empty key!");
				assert(Val != getTombstoneKey() && "Cannot hash the tombstone key!");

				std::hash<NamingCheckId::second_type> SecondHash;
				return Val.first.getRawEncoding() + SecondHash(Val.second);
				}

				static bool isEqual(const NamingCheckId &LHS, const NamingCheckId &RHS) {
				if (RHS == getEmptyKey())
				return LHS == getEmptyKey();
				if (RHS == getTombstoneKey())
				return LHS == getTombstoneKey();
				return LHS == RHS;
				}
				};

				} // namespace llvm

				namespace clang {
				namespace tidy {

				namespace {

				/// Callback supplies macros to RenamerClangTidyCheck::checkMacro
				class RenamerClangTidyCheckPPCallbacks : public PPCallbacks {
				public:
				RenamerClangTidyCheckPPCallbacks(Preprocessor *PP,
				RenamerClangTidyCheck *Check)
				: PP(PP), Check(Check) {}

				/// MacroDefined calls checkMacro for macros in the main file
				void MacroDefined(const Token &MacroNameTok,
				const MacroDirective *MD) override {
				Check->checkMacro(PP->getSourceManager(), MacroNameTok, MD->getMacroInfo());
				}

				/// MacroExpands calls expandMacro for macros in the main file
				void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
				SourceRange /Range/,
				const MacroArgs * /Args/) override {
				Check->expandMacro(MacroNameTok, MD.getMacroInfo());
				}

				private:
				Preprocessor *PP;
				RenamerClangTidyCheck *Check;
				};

				} // namespace

				RenamerClangTidyCheck::RenamerClangTidyCheck(StringRef CheckName,
				ClangTidyContext *Context)
				: ClangTidyCheck(CheckName, Context) {}
				RenamerClangTidyCheck::~RenamerClangTidyCheck() = default;

				void RenamerClangTidyCheck::registerMatchers(MatchFinder *Finder) {
				Finder->addMatcher(namedDecl().bind("decl"), this);
				Finder->addMatcher(usingDecl().bind("using"), this);
				Finder->addMatcher(declRefExpr().bind("declRef"), this);
				Finder->addMatcher(cxxConstructorDecl().bind("classRef"), this);
				Finder->addMatcher(cxxDestructorDecl().bind("classRef"), this);
				Finder->addMatcher(typeLoc().bind("typeLoc"), this);
				Finder->addMatcher(nestedNameSpecifierLoc().bind("nestedNameLoc"), this);
				}

				void RenamerClangTidyCheck::registerPPCallbacks(
				const SourceManager &SM, Preprocessor PP, Preprocessor ModuleExpanderPP) {
				ModuleExpanderPP->addPPCallbacks(
				std::make_unique<RenamerClangTidyCheckPPCallbacks>(ModuleExpanderPP,
				this));
				}

				static void addUsage(RenamerClangTidyCheck::NamingCheckFailureMap &Failures,
				const RenamerClangTidyCheck::NamingCheckId &Decl,
				SourceRange Range, SourceManager *SourceMgr = nullptr) {
				// Do nothing if the provided range is invalid.
				if (Range.getBegin().isInvalid() \|\| Range.getEnd().isInvalid())
				return;

				// If we have a source manager, use it to convert to the spelling location for
				// performing the fix. This is necessary because macros can map the same
				// spelling location to different source locations, and we only want to fix
				// the token once, before it is expanded by the macro.
				SourceLocation FixLocation = Range.getBegin();
				if (SourceMgr)
				FixLocation = SourceMgr->getSpellingLoc(FixLocation);
				if (FixLocation.isInvalid())
				return;

				// Try to insert the identifier location in the Usages map, and bail out if it
				// is already in there
				RenamerClangTidyCheck::NamingCheckFailure &Failure = Failures[Decl];
				if (!Failure.RawUsageLocs.insert(FixLocation.getRawEncoding()).second)
				return;

				if (!Failure.ShouldFix())
				return;

				if (!utils::rangeCanBeFixed(Range, SourceMgr))
				Failure.FixStatus = RenamerClangTidyCheck::ShouldFixStatus::InsideMacro;
				}

				/// Convenience method when the usage to be added is a NamedDecl
				static void addUsage(RenamerClangTidyCheck::NamingCheckFailureMap &Failures,
				const NamedDecl *Decl, SourceRange Range,
				SourceManager *SourceMgr = nullptr) {
				return addUsage(Failures,
				RenamerClangTidyCheck::NamingCheckId(Decl->getLocation(),
				Decl->getNameAsString()),
				Range, SourceMgr);
				}

				void RenamerClangTidyCheck::check(const MatchFinder::MatchResult &Result) {
				if (const auto *Decl =
				Result.Nodes.getNodeAs<CXXConstructorDecl>("classRef")) {
				if (Decl->isImplicit())
				return;

				addUsage(NamingCheckFailures, Decl->getParent(),
				Decl->getNameInfo().getSourceRange());

				for (const auto *Init : Decl->inits()) {
				if (!Init->isWritten() \|\| Init->isInClassMemberInitializer())
				continue;
				if (const FieldDecl *FD = Init->getAnyMember())
				addUsage(NamingCheckFailures, FD,
				SourceRange(Init->getMemberLocation()));
				// Note: delegating constructors and base class initializers are handled
				// via the "typeLoc" matcher.
				}
				return;
				}

				if (const auto *Decl =
				Result.Nodes.getNodeAs<CXXDestructorDecl>("classRef")) {
				if (Decl->isImplicit())
				return;

				SourceRange Range = Decl->getNameInfo().getSourceRange();
				if (Range.getBegin().isInvalid())
				return;
				// The first token that will be found is the ~ (or the equivalent trigraph),
				// we want instead to replace the next token, that will be the identifier.
				Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());

				addUsage(NamingCheckFailures, Decl->getParent(), Range);
				return;
				}

				if (const auto *Loc = Result.Nodes.getNodeAs<TypeLoc>("typeLoc")) {
				NamedDecl *Decl = nullptr;
				if (const auto &Ref = Loc->getAs<TagTypeLoc>()) {
				Decl = Ref.getDecl();
				} else if (const auto &Ref = Loc->getAs<InjectedClassNameTypeLoc>()) {
				Decl = Ref.getDecl();
				} else if (const auto &Ref = Loc->getAs<UnresolvedUsingTypeLoc>()) {
				Decl = Ref.getDecl();
				} else if (const auto &Ref = Loc->getAs<TemplateTypeParmTypeLoc>()) {
				Decl = Ref.getDecl();
				} // further TypeLocs handled below

				JonasTothUnsubmitted Done Reply Inline Actions What about the else? If it is unreachable it should have a `llvm_unreachable("Reason");`, if not, i think a little fallthrough comment wouldn't hurt. JonasToth: What about the else? If it is unreachable it should have a `llvm_unreachable("Reason");`, if…
				if (Decl) {
				addUsage(NamingCheckFailures, Decl, Loc->getSourceRange());
				return;
				}

				if (const auto &Ref = Loc->getAs<TemplateSpecializationTypeLoc>()) {
				const TemplateDecl *Decl =
				Ref.getTypePtr()->getTemplateName().getAsTemplateDecl();

				SourceRange Range(Ref.getTemplateNameLoc(), Ref.getTemplateNameLoc());
				if (const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
				if (const NamedDecl *TemplDecl = ClassDecl->getTemplatedDecl())
				addUsage(NamingCheckFailures, TemplDecl, Range);
				return;
				}
				}

				if (const auto &Ref =
				Loc->getAs<DependentTemplateSpecializationTypeLoc>()) {
				if (const TagDecl *Decl = Ref.getTypePtr()->getAsTagDecl())
				addUsage(NamingCheckFailures, Decl, Loc->getSourceRange());
				return;
				}
				}

				if (const auto *Loc =
				Result.Nodes.getNodeAs<NestedNameSpecifierLoc>("nestedNameLoc")) {
				if (const NestedNameSpecifier *Spec = Loc->getNestedNameSpecifier()) {
				if (const NamespaceDecl *Decl = Spec->getAsNamespace()) {
				addUsage(NamingCheckFailures, Decl, Loc->getLocalSourceRange());
				return;
				}
				}
				}

				if (const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>("using")) {
				for (const auto *Shadow : Decl->shadows()) {
				addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
				Decl->getNameInfo().getSourceRange());
				}
				return;
				}

				if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
				SourceRange Range = DeclRef->getNameInfo().getSourceRange();
				addUsage(NamingCheckFailures, DeclRef->getDecl(), Range,
				Result.SourceManager);
				return;
				}

				if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
				if (!Decl->getIdentifier() \|\| Decl->getName().empty() \|\| Decl->isImplicit())
				return;

				// Fix type aliases in value declarations.
				if (const auto *Value = Result.Nodes.getNodeAs<ValueDecl>("decl")) {
				JonasTothUnsubmitted Done Reply Inline Actions Please add punctuation here and in the comments below. JonasToth: Please add punctuation here and in the comments below.
				if (const Type *TypePtr = Value->getType().getTypePtrOrNull()) {
				if (const auto *Typedef = TypePtr->getAs<TypedefType>()) {
				addUsage(NamingCheckFailures, Typedef->getDecl(),
				Value->getSourceRange());
				}
				}
				}

				// Fix type aliases in function declarations.
				if (const auto *Value = Result.Nodes.getNodeAs<FunctionDecl>("decl")) {
				if (const auto *Typedef =
				Value->getReturnType().getTypePtr()->getAs<TypedefType>()) {
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Please elide braces. Eugene.Zelenko: Please elide braces.
				logan-5AuthorUnsubmitted Done Reply Inline Actions Would you mind pointing me toward a resource for these formatting nits? I don't see anything about requiring omitting braces for single-statement if()s in the official LLVM coding standards (and I happen to think the braces actually help readability here). If this stuff is explicitly documented somewhere and painstakingly enforced like this, I'd rather get it right the first time. logan-5: Would you mind pointing me toward a resource for these formatting nits? I don't see anything…
				aaron.ballmanUnsubmitted Done Reply Inline Actions I looked through the coding standard and it does not suggest this, which I am really surprised to see (I feel like the standard used to say it at some point, but it likely got removed and I did not notice). This is a common pattern that's used all over the code base (likely from fairly consistent review guidance over the years), and so it's best to be consistent with the style used locally, but that's a pretty weak argument for new code. aaron.ballman: I looked through the coding standard and it does not suggest this, which I am really surprised…
				JonasTothUnsubmitted Not Done Reply Inline Actions Did it maybe get dropped? Wasn't there are overhaul a few weeks ago? But I am surprised as well, as this was at one point explicitly stated. JonasToth: Did it maybe get dropped? Wasn't there are overhaul a few weeks ago? But I am surprised as well…
				aaron.ballmanUnsubmitted Not Done Reply Inline Actions I went as far back as the 4.0 coding standards and it wasn't listed in there, but I'm with you on remembering this being explicitly stated somewhere. aaron.ballman: I went as far back as the 4.0 coding standards and it wasn't listed in there, but I'm with you…
				addUsage(NamingCheckFailures, Typedef->getDecl(),
				Value->getSourceRange());
				}
				for (unsigned i = 0; i < Value->getNumParams(); ++i) {
				if (const TypedefType *Typedef = Value->parameters()[i]
				->getType()
				.getTypePtr()
				->getAs<TypedefType>()) {
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Please elide braces. Eugene.Zelenko: Please elide braces.
				addUsage(NamingCheckFailures, Typedef->getDecl(),
				Value->getSourceRange());
				}
				}
				}

				// Ignore ClassTemplateSpecializationDecl which are creating duplicate
				// replacements with CXXRecordDecl.
				if (isa<ClassTemplateSpecializationDecl>(Decl))
				return;

				Optional<FailureInfo> MaybeFailure =
				GetDeclFailureInfo(Decl, *Result.SourceManager);
				if (!MaybeFailure)
				return;
				FailureInfo &Info = *MaybeFailure;
				NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
				Decl->getLocation(), Decl->getNameAsString())];
				SourceRange Range =
				DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
				.getSourceRange();

				const IdentifierTable &Idents = Decl->getASTContext().Idents;
				auto CheckNewIdentifier = Idents.find(Info.Fixup);
				if (CheckNewIdentifier != Idents.end()) {
				const IdentifierInfo *Ident = CheckNewIdentifier->second;
				if (Ident->isKeyword(getLangOpts()))
				Failure.FixStatus = ShouldFixStatus::ConflictsWithKeyword;
				else if (Ident->hasMacroDefinition())
				Failure.FixStatus = ShouldFixStatus::ConflictsWithMacroDefinition;
				}

				Failure.Info = std::move(Info);
				addUsage(NamingCheckFailures, Decl, Range);
				}
				}

				void RenamerClangTidyCheck::checkMacro(SourceManager &SourceMgr,
				const Token &MacroNameTok,
				const MacroInfo *MI) {
				Optional<FailureInfo> MaybeFailure =
				GetMacroFailureInfo(MacroNameTok, SourceMgr);
				if (!MaybeFailure)
				return;
				FailureInfo &Info = *MaybeFailure;
				StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
				NamingCheckId ID(MI->getDefinitionLoc(), Name);
				NamingCheckFailure &Failure = NamingCheckFailures[ID];
				SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());

				Failure.Info = std::move(Info);
				addUsage(NamingCheckFailures, ID, Range);
				}

				void RenamerClangTidyCheck::expandMacro(const Token &MacroNameTok,
				const MacroInfo *MI) {
				StringRef Name = MacroNameTok.getIdentifierInfo()->getName();
				NamingCheckId ID(MI->getDefinitionLoc(), Name);

				auto Failure = NamingCheckFailures.find(ID);
				if (Failure == NamingCheckFailures.end())
				return;

				SourceRange Range(MacroNameTok.getLocation(), MacroNameTok.getEndLoc());
				addUsage(NamingCheckFailures, ID, Range);
				}

				static std::string
				getDiagnosticSuffix(const RenamerClangTidyCheck::ShouldFixStatus FixStatus,
				const std::string &Fixup) {
				if (Fixup.empty())
				return "; cannot be fixed automatically";
				Eugene.ZelenkoUnsubmitted Done Reply Inline Actions Please elide braces. Same below. Eugene.Zelenko: Please elide braces. Same below.
				if (FixStatus == RenamerClangTidyCheck::ShouldFixStatus::ShouldFix)
				return {};
				if (FixStatus >=
				RenamerClangTidyCheck::ShouldFixStatus::IgnoreFailureThreshold)
				return {};
				if (FixStatus == RenamerClangTidyCheck::ShouldFixStatus::ConflictsWithKeyword)
				return "; cannot be fixed because '" + Fixup +
				"' would conflict with a keyword";
				if (FixStatus ==
				RenamerClangTidyCheck::ShouldFixStatus::ConflictsWithMacroDefinition)
				return "; cannot be fixed because '" + Fixup +
				"' would conflict with a macro definition";

				llvm_unreachable("invalid ShouldFixStatus");
				}

				void RenamerClangTidyCheck::onEndOfTranslationUnit() {
				for (const auto &Pair : NamingCheckFailures) {
				const NamingCheckId &Decl = Pair.first;
				const NamingCheckFailure &Failure = Pair.second;

				if (Failure.Info.KindName.empty())
				continue;

				if (Failure.ShouldNotify()) {
				auto DiagInfo = GetDiagInfo(Decl, Failure);
				auto Diag = diag(Decl.first,
				DiagInfo.Text + getDiagnosticSuffix(Failure.FixStatus,
				Failure.Info.Fixup));
				DiagInfo.ApplyArgs(Diag);

				if (Failure.ShouldFix()) {
				for (const auto &Loc : Failure.RawUsageLocs) {
				// We assume that the identifier name is made of one token only. This
				// is always the case as we ignore usages in macros that could build
				// identifier names by combining multiple tokens.
				//
				// For destructors, we already take care of it by remembering the
				// location of the start of the identifier and not the start of the
				// tilde.
				//
				// Other multi-token identifiers, such as operators are not checked at
				// all.
				Diag << FixItHint::CreateReplacement(
				SourceRange(SourceLocation::getFromRawEncoding(Loc)),
				Failure.Info.Fixup);
				}
				}
				}
				}
				}

				} // namespace tidy
				} // namespace clang

This is an archive of the discontinued LLVM Phabricator instance.

[clang-tidy] Factor out renaming logic from readability-identifier-naming
ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 236449

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

clang-tools-extra/clang-tidy/utils/CMakeLists.txt

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.h

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

This is an archive of the discontinued LLVM Phabricator instance.

[clang-tidy] Factor out renaming logic from readability-identifier-namingClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 236449

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

clang-tools-extra/clang-tidy/utils/CMakeLists.txt

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.h

clang-tools-extra/clang-tidy/utils/RenamerClangTidyCheck.cpp

[clang-tidy] Factor out renaming logic from readability-identifier-naming
ClosedPublic