This is an archive of the discontinued LLVM Phabricator instance.

@alexfh This change is based on the behavior of AST Matchers being changed to ignore invisible/implicit AST nodes by default. As the default was not changed in the end, this patch would need to be updated to add traverse(TK_IgnoreUnlessSpelledInSource) wrapping around the matchers.

Before I update the patch to add that, do you have any feedback?

In D80499#2352339, @steveire wrote:

@alexfh This change is based on the behavior of AST Matchers being changed to ignore invisible/implicit AST nodes by default. As the default was not changed in the end, this patch would need to be updated to add traverse(TK_IgnoreUnlessSpelledInSource) wrapping around the matchers.

Before I update the patch to add that, do you have any feedback?

If the default is not being changed, clear improvement will be noticeable only where multiple ignore.* matchers are being replaced with a traverse(TK_IgnoreUnlessSpelledInSource). However, in many cases the behavior of the checks will change (and I'm not sure we have good enough test coverage especially where implicit conversions and similar are present). I believe, we're going to hit a number of corner cases and uncover a ton of bugs with this change. (Not that it would be different, if the default was changed to ignore implicit stuff ;)

You should be ready for back and forth with this change, if users hit widespread issues not caught by tests. Maybe splitting it into separate pieces and involving check authors where practical may be reasonable.

! In D80499#2353187, @alexfh wrote:
You should be ready for back and forth with this change, if users hit widespread issues not caught by tests. Maybe splitting it into separate pieces and involving check authors where practical may be reasonable.

Ok, I'll do that when https://reviews.llvm.org/D80961 and https://reviews.llvm.org/D82278 are merged.

In D80499#2362028, @steveire wrote:

! In D80499#2353187, @alexfh wrote:
You should be ready for back and forth with this change, if users hit widespread issues not caught by tests. Maybe splitting it into separate pieces and involving check authors where practical may be reasonable.

Ok, I'll do that when https://reviews.llvm.org/D80961 and https://reviews.llvm.org/D82278 are merged.

@alexfh This is done in D91302 and D91303. Could you review?

Revision Contents

Path

Size

clang-tools-extra/

clang-tidy/

abseil/

DurationAdditionCheck.cpp

4 lines

DurationConversionCastCheck.cpp

4 lines

DurationFactoryScaleCheck.cpp

23 lines

DurationRewriter.cpp

4 lines

DurationUnnecessaryConversionCheck.cpp

20 lines

StringFindStartswithCheck.cpp

6 lines

bugprone/

MisplacedPointerArithmeticInAllocCheck.cpp

3 lines

MoveForwardingReferenceCheck.cpp

3 lines

NotNullTerminatedResultCheck.cpp

79 lines

SizeofContainerCheck.cpp

12 lines

SizeofExpressionCheck.cpp

146 lines

StringConstructorCheck.cpp

32 lines

StringIntegerAssignmentCheck.cpp

22 lines

StringLiteralWithEmbeddedNulCheck.cpp

3 lines

SuspiciousEnumUsageCheck.cpp

20 lines

SuspiciousMissingCommaCheck.cpp

5 lines

TerminatingContinueCheck.cpp

6 lines

UnusedReturnValueCheck.cpp

4 lines

cppcoreguidelines/

ProBoundsConstantArrayIndexCheck.cpp

6 lines

ProBoundsPointerArithmeticCheck.cpp

10 lines

google/

ExplicitMakePairCheck.cpp

7 lines

hicpp/

MultiwayPathsCoveredCheck.cpp

11 lines

SignedBitwiseCheck.cpp

7 lines

misc/

StaticAssertCheck.cpp

40 lines

UnconventionalAssignOperatorCheck.cpp

18 lines

UniqueptrResetReleaseCheck.cpp

4 lines

modernize/

UseDefaultMemberInitCheck.cpp

10 lines

UseUncaughtExceptionsCheck.cpp

4 lines

performance/

FasterStringFindCheck.cpp

3 lines

InefficientStringConcatenationCheck.cpp

17 lines

InefficientVectorOperationCheck.cpp

6 lines

readability/

ContainerSizeEmptyCheck.cpp

15 lines

ElseAfterReturnCheck.cpp

3 lines

RedundantSmartptrGetCheck.cpp

16 lines

SimplifyBooleanExprCheck.cpp

3 lines

SimplifySubscriptExprCheck.cpp

4 lines

UniqueptrDeleteReleaseCheck.cpp

10 lines

Diff 265951

clang-tools-extra/clang-tidy/abseil/DurationAdditionCheck.cpp

	Show All 15 Lines

	namespace clang {			namespace clang {
	namespace tidy {			namespace tidy {
	namespace abseil {			namespace abseil {

	void DurationAdditionCheck::registerMatchers(MatchFinder *Finder) {			void DurationAdditionCheck::registerMatchers(MatchFinder *Finder) {
	Finder->addMatcher(			Finder->addMatcher(
	binaryOperator(hasOperatorName("+"),			binaryOperator(hasOperatorName("+"),
	hasEitherOperand(expr(ignoringParenImpCasts(			hasEitherOperand(
	callExpr(callee(functionDecl(TimeConversionFunction())			callExpr(callee(functionDecl(TimeConversionFunction())
	.bind("function_decl")))			.bind("function_decl")))
	.bind("call")))))			.bind("call")))
	.bind("binop"),			.bind("binop"),
	this);			this);
	}			}

	void DurationAdditionCheck::check(const MatchFinder::MatchResult &Result) {			void DurationAdditionCheck::check(const MatchFinder::MatchResult &Result) {
	const BinaryOperator *Binop =			const BinaryOperator *Binop =
	Result.Nodes.getNodeAs<clang::BinaryOperator>("binop");			Result.Nodes.getNodeAs<clang::BinaryOperator>("binop");
	const CallExpr *Call = Result.Nodes.getNodeAs<clang::CallExpr>("call");			const CallExpr *Call = Result.Nodes.getNodeAs<clang::CallExpr>("call");
	Show All 38 Lines

clang-tools-extra/clang-tidy/abseil/DurationConversionCastCheck.cpp

	Show All 13 Lines

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

	namespace clang {			namespace clang {
	namespace tidy {			namespace tidy {
	namespace abseil {			namespace abseil {

	void DurationConversionCastCheck::registerMatchers(MatchFinder *Finder) {			void DurationConversionCastCheck::registerMatchers(MatchFinder *Finder) {
	auto CallMatcher = ignoringImpCasts(callExpr(			auto CallMatcher = callExpr(
	callee(functionDecl(DurationConversionFunction()).bind("func_decl")),			callee(functionDecl(DurationConversionFunction()).bind("func_decl")),
	hasArgument(0, expr().bind("arg"))));			hasArgument(0, expr().bind("arg")));

	Finder->addMatcher(			Finder->addMatcher(
	expr(anyOf(			expr(anyOf(
	cxxStaticCastExpr(hasSourceExpression(CallMatcher)).bind("cast_expr"),			cxxStaticCastExpr(hasSourceExpression(CallMatcher)).bind("cast_expr"),
	cStyleCastExpr(hasSourceExpression(CallMatcher)).bind("cast_expr"),			cStyleCastExpr(hasSourceExpression(CallMatcher)).bind("cast_expr"),
	cxxFunctionalCastExpr(hasSourceExpression(CallMatcher))			cxxFunctionalCastExpr(hasSourceExpression(CallMatcher))
	.bind("cast_expr"))),			.bind("cast_expr"))),
	this);			this);
	▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp

	Show First 20 Lines • Show All 110 Lines • ▼ Show 20 Lines
	}			}

	void DurationFactoryScaleCheck::registerMatchers(MatchFinder *Finder) {			void DurationFactoryScaleCheck::registerMatchers(MatchFinder *Finder) {
	Finder->addMatcher(			Finder->addMatcher(
	callExpr(			callExpr(
	callee(functionDecl(DurationFactoryFunction()).bind("call_decl")),			callee(functionDecl(DurationFactoryFunction()).bind("call_decl")),
	hasArgument(			hasArgument(
	0,			0,
	ignoringImpCasts(anyOf(			anyOf(cxxFunctionalCastExpr(
	cxxFunctionalCastExpr(
	hasDestinationType(			hasDestinationType(
	anyOf(isInteger(), realFloatingPointType())),			anyOf(isInteger(), realFloatingPointType())),
	hasSourceExpression(initListExpr())),			hasSourceExpression(initListExpr())),
	integerLiteral(equals(0)), floatLiteral(equals(0.0)),			integerLiteral(equals(0)), floatLiteral(equals(0.0)),
	binaryOperator(hasOperatorName("*"),			binaryOperator(hasOperatorName("*"),
	hasEitherOperand(ignoringImpCasts(			hasEitherOperand(
	anyOf(integerLiteral(), floatLiteral()))))			anyOf(integerLiteral(), floatLiteral())))
	.bind("mult_binop"),			.bind("mult_binop"),
	binaryOperator(hasOperatorName("/"), hasRHS(floatLiteral()))			binaryOperator(hasOperatorName("/"), hasRHS(floatLiteral()))
	.bind("div_binop")))))			.bind("div_binop"))))
	.bind("call"),			.bind("call"),
	this);			this);
	}			}

	void DurationFactoryScaleCheck::check(const MatchFinder::MatchResult &Result) {			void DurationFactoryScaleCheck::check(const MatchFinder::MatchResult &Result) {
	const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");			const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");

	// Don't try to replace things inside of macro definitions.			// Don't try to replace things inside of macro definitions.
	▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/abseil/DurationRewriter.cpp

	Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines

	/// Returns `true` if `Node` is a value which evaluates to a literal `0`.			/// Returns `true` if `Node` is a value which evaluates to a literal `0`.
	bool IsLiteralZero(const MatchFinder::MatchResult &Result, const Expr &Node) {			bool IsLiteralZero(const MatchFinder::MatchResult &Result, const Expr &Node) {
	auto ZeroMatcher =			auto ZeroMatcher =
	anyOf(integerLiteral(equals(0)), floatLiteral(equals(0.0)));			anyOf(integerLiteral(equals(0)), floatLiteral(equals(0.0)));

	// Check to see if we're using a zero directly.			// Check to see if we're using a zero directly.
	if (selectFirst<const clang::Expr>(			if (selectFirst<const clang::Expr>(
	"val", match(expr(ignoringImpCasts(ZeroMatcher)).bind("val"), Node,			"val", match(expr(ZeroMatcher).bind("val"), Node, *Result.Context)) !=
	*Result.Context)) != nullptr)			nullptr)
	return true;			return true;

	// Now check to see if we're using a functional cast with a scalar			// Now check to see if we're using a functional cast with a scalar
	// initializer expression, e.g. `int{0}`.			// initializer expression, e.g. `int{0}`.
	if (selectFirst<const clang::Expr>(			if (selectFirst<const clang::Expr>(
	"val", match(cxxFunctionalCastExpr(			"val", match(cxxFunctionalCastExpr(
	hasDestinationType(			hasDestinationType(
	anyOf(isInteger(), realFloatingPointType())),			anyOf(isInteger(), realFloatingPointType())),
	▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/abseil/DurationUnnecessaryConversionCheck.cpp

Show All 24 Lines	for (const auto &Scale : {"Hours", "Minutes", "Seconds", "Milliseconds",
std::string DurationFactory = (llvm::Twine("::absl::") + Scale).str();		std::string DurationFactory = (llvm::Twine("::absl::") + Scale).str();
std::string FloatConversion =		std::string FloatConversion =
(llvm::Twine("::absl::ToDouble") + Scale).str();		(llvm::Twine("::absl::ToDouble") + Scale).str();
std::string IntegerConversion =		std::string IntegerConversion =
(llvm::Twine("::absl::ToInt64") + Scale).str();		(llvm::Twine("::absl::ToInt64") + Scale).str();

// Matcher which matches the current scale's factory with a `1` argument,		// Matcher which matches the current scale's factory with a `1` argument,
// e.g. `absl::Seconds(1)`.		// e.g. `absl::Seconds(1)`.
auto factory_matcher = ignoringElidableConstructorCall(		auto factory_matcher =
callExpr(callee(functionDecl(hasName(DurationFactory))),		callExpr(callee(functionDecl(hasName(DurationFactory))),
hasArgument(0, ignoringImpCasts(integerLiteral(equals(1))))));		hasArgument(0, integerLiteral(equals(1))));

// Matcher which matches either inverse function and binds its argument,		// Matcher which matches either inverse function and binds its argument,
// e.g. `absl::ToDoubleSeconds(dur)`.		// e.g. `absl::ToDoubleSeconds(dur)`.
auto inverse_function_matcher = callExpr(		auto inverse_function_matcher = callExpr(
callee(functionDecl(hasAnyName(FloatConversion, IntegerConversion))),		callee(functionDecl(hasAnyName(FloatConversion, IntegerConversion))),
hasArgument(0, expr().bind("arg")));		hasArgument(0, expr().bind("arg")));

// Matcher which matches a duration divided by the factory_matcher above,		// Matcher which matches a duration divided by the factory_matcher above,
// e.g. `dur / absl::Seconds(1)`.		// e.g. `dur / absl::Seconds(1)`.
auto division_operator_matcher = cxxOperatorCallExpr(		auto division_operator_matcher = cxxOperatorCallExpr(
hasOverloadedOperatorName("/"), hasArgument(0, expr().bind("arg")),		hasOverloadedOperatorName("/"), hasArgument(0, expr().bind("arg")),
hasArgument(1, factory_matcher));		hasArgument(1, factory_matcher));

// Matcher which matches a duration argument to `FDivDuration`,		// Matcher which matches a duration argument to `FDivDuration`,
// e.g. `absl::FDivDuration(dur, absl::Seconds(1))`		// e.g. `absl::FDivDuration(dur, absl::Seconds(1))`
auto fdiv_matcher = callExpr(		auto fdiv_matcher = callExpr(
callee(functionDecl(hasName("::absl::FDivDuration"))),		callee(functionDecl(hasName("::absl::FDivDuration"))),
hasArgument(0, expr().bind("arg")), hasArgument(1, factory_matcher));		hasArgument(0, expr().bind("arg")), hasArgument(1, factory_matcher));

// Matcher which matches a duration argument being scaled,		// Matcher which matches a duration argument being scaled,
// e.g. `absl::ToDoubleSeconds(dur) * 2`		// e.g. `absl::ToDoubleSeconds(dur) * 2`
auto scalar_matcher = ignoringImpCasts(		auto scalar_matcher =
binaryOperator(hasOperatorName("*"),		binaryOperator(
hasEitherOperand(expr(ignoringParenImpCasts(		hasOperatorName("*"),
callExpr(callee(functionDecl(hasAnyName(		hasEitherOperand(callExpr(callee(functionDecl(hasAnyName(
FloatConversion, IntegerConversion))),		FloatConversion, IntegerConversion))),
hasArgument(0, expr().bind("arg")))		hasArgument(0, expr().bind("arg")))
.bind("inner_call")))))		.bind("inner_call")))
.bind("binop"));		.bind("binop");

Finder->addMatcher(		Finder->addMatcher(
callExpr(callee(functionDecl(hasName(DurationFactory))),		callExpr(callee(functionDecl(hasName(DurationFactory))),
hasArgument(0, anyOf(inverse_function_matcher,		hasArgument(0, anyOf(inverse_function_matcher,
division_operator_matcher, fdiv_matcher,		division_operator_matcher, fdiv_matcher,
scalar_matcher)))		scalar_matcher)))
.bind("call"),		.bind("call"),
this);		this);
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines	auto StringFind = cxxMemberCallExpr(
on(hasType(StringType)),		on(hasType(StringType)),
// ... with some search expression ...		// ... with some search expression ...
hasArgument(0, expr().bind("needle")),		hasArgument(0, expr().bind("needle")),
// ... and either "0" as second argument or the default argument (also 0).		// ... and either "0" as second argument or the default argument (also 0).
anyOf(hasArgument(1, ZeroLiteral), hasArgument(1, cxxDefaultArgExpr())));		anyOf(hasArgument(1, ZeroLiteral), hasArgument(1, cxxDefaultArgExpr())));

Finder->addMatcher(		Finder->addMatcher(
// Match [=!]= with a zero on one side and a string.find on the other.		// Match [=!]= with a zero on one side and a string.find on the other.
binaryOperator(		binaryOperator(hasAnyOperatorName("==", "!="),
hasAnyOperatorName("==", "!="),		hasOperands(ZeroLiteral, StringFind.bind("findexpr")))
hasOperands(ignoringParenImpCasts(ZeroLiteral),
ignoringParenImpCasts(StringFind.bind("findexpr"))))
.bind("expr"),		.bind("expr"),
this);		this);
}		}

void StringFindStartswithCheck::check(const MatchFinder::MatchResult &Result) {		void StringFindStartswithCheck::check(const MatchFinder::MatchResult &Result) {
const ASTContext &Context = *Result.Context;		const ASTContext &Context = *Result.Context;
const SourceManager &Source = Context.getSourceManager();		const SourceManager &Source = Context.getSourceManager();

▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/MisplacedPointerArithmeticInAllocCheck.cpp

Show All 19 Lines	void MisplacedPointerArithmeticInAllocCheck::registerMatchers(
MatchFinder *Finder) {		MatchFinder *Finder) {
const auto AllocFunc = functionDecl(		const auto AllocFunc = functionDecl(
anyOf(hasName("::malloc"), hasName("std::malloc"), hasName("::alloca"),		anyOf(hasName("::malloc"), hasName("std::malloc"), hasName("::alloca"),
hasName("::calloc"), hasName("std::calloc"), hasName("::realloc"),		hasName("::calloc"), hasName("std::calloc"), hasName("::realloc"),
hasName("std::realloc")));		hasName("std::realloc")));

const auto AllocFuncPtr =		const auto AllocFuncPtr =
varDecl(hasType(isConstQualified()),		varDecl(hasType(isConstQualified()),
hasInitializer(ignoringParenImpCasts(		hasInitializer(declRefExpr(hasDeclaration(AllocFunc))));
declRefExpr(hasDeclaration(AllocFunc)))));

const auto AdditiveOperator = binaryOperator(hasAnyOperatorName("+", "-"));		const auto AdditiveOperator = binaryOperator(hasAnyOperatorName("+", "-"));

const auto IntExpr = expr(hasType(isInteger()));		const auto IntExpr = expr(hasType(isInteger()));

const auto AllocCall = callExpr(callee(decl(anyOf(AllocFunc, AllocFuncPtr))));		const auto AllocCall = callExpr(callee(decl(anyOf(AllocFunc, AllocFuncPtr))));

Finder->addMatcher(		Finder->addMatcher(
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/MoveForwardingReferenceCheck.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines	auto ForwardingReferenceParmMatcher =
.bind("parm-var");		.bind("parm-var");

Finder->addMatcher(		Finder->addMatcher(
callExpr(callee(unresolvedLookupExpr(		callExpr(callee(unresolvedLookupExpr(
hasAnyDeclaration(namedDecl(		hasAnyDeclaration(namedDecl(
hasUnderlyingDecl(hasName("::std::move")))))		hasUnderlyingDecl(hasName("::std::move")))))
.bind("lookup")),		.bind("lookup")),
argumentCountIs(1),		argumentCountIs(1),
hasArgument(0, ignoringParenImpCasts(declRefExpr(		hasArgument(0, declRefExpr(to(ForwardingReferenceParmMatcher))))
to(ForwardingReferenceParmMatcher)))))
.bind("call-move"),		.bind("call-move"),
this);		this);
}		}

void MoveForwardingReferenceCheck::check(		void MoveForwardingReferenceCheck::check(
const MatchFinder::MatchResult &Result) {		const MatchFinder::MatchResult &Result) {
const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");		const auto *CallMove = Result.Nodes.getNodeAs<CallExpr>("call-move");
const auto *UnresolvedLookup =		const auto *UnresolvedLookup =
Show All 34 Lines

clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp

Show First 20 Lines • Show All 514 Lines • ▼ Show 20 Lines
AST_MATCHER_P(Expr, hasDefinition, ast_matchers::internal::Matcher<Expr>,		AST_MATCHER_P(Expr, hasDefinition, ast_matchers::internal::Matcher<Expr>,
InnerMatcher) {		InnerMatcher) {
const Expr *SimpleNode = &Node;		const Expr *SimpleNode = &Node;
SimpleNode = SimpleNode->IgnoreParenImpCasts();		SimpleNode = SimpleNode->IgnoreParenImpCasts();

if (InnerMatcher.matches(*SimpleNode, Finder, Builder))		if (InnerMatcher.matches(*SimpleNode, Finder, Builder))
return true;		return true;

auto DREHasInit = ignoringImpCasts(		auto DREHasInit = declRefExpr(to(varDecl(hasInitializer(InnerMatcher))));
declRefExpr(to(varDecl(hasInitializer(ignoringImpCasts(InnerMatcher))))));

if (DREHasInit.matches(*SimpleNode, Finder, Builder))		if (DREHasInit.matches(*SimpleNode, Finder, Builder))
return true;		return true;

const char *const VarDeclName = "variable-declaration";		const char *const VarDeclName = "variable-declaration";
auto DREHasDefinition = ignoringImpCasts(declRefExpr(		auto DREHasDefinition = declRefExpr(
allOf(to(varDecl().bind(VarDeclName)),		allOf(to(varDecl().bind(VarDeclName)),
hasAncestor(compoundStmt(hasDescendant(binaryOperator(		hasAncestor(compoundStmt(hasDescendant(binaryOperator(
hasLHS(declRefExpr(to(varDecl(equalsBoundNode(VarDeclName))))),		hasLHS(declRefExpr(to(varDecl(equalsBoundNode(VarDeclName))))),
hasRHS(ignoringImpCasts(InnerMatcher)))))))));		hasRHS(InnerMatcher)))))));

if (DREHasDefinition.matches(*SimpleNode, Finder, Builder))		if (DREHasDefinition.matches(*SimpleNode, Finder, Builder))
return true;		return true;

return false;		return false;
}		}
} // namespace		} // namespace

void NotNullTerminatedResultCheck::registerMatchers(MatchFinder *Finder) {		void NotNullTerminatedResultCheck::registerMatchers(MatchFinder *Finder) {
auto IncOp =		auto IncOp =
binaryOperator(hasOperatorName("+"),		binaryOperator(hasOperatorName("+"), hasEitherOperand(integerLiteral()));
hasEitherOperand(ignoringParenImpCasts(integerLiteral())));

auto DecOp =		auto DecOp =
binaryOperator(hasOperatorName("-"),		binaryOperator(hasOperatorName("-"), hasEitherOperand(integerLiteral()));
hasEitherOperand(ignoringParenImpCasts(integerLiteral())));

auto HasIncOp = anyOf(ignoringImpCasts(IncOp), hasDescendant(IncOp));		auto HasIncOp = anyOf(IncOp, hasDescendant(IncOp));
auto HasDecOp = anyOf(ignoringImpCasts(DecOp), hasDescendant(DecOp));		auto HasDecOp = anyOf(DecOp, hasDescendant(DecOp));

auto Container = ignoringImpCasts(cxxMemberCallExpr(hasDescendant(declRefExpr(		auto Container = cxxMemberCallExpr(hasDescendant(declRefExpr(
hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(recordDecl(		hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(recordDecl(
hasAnyName("::std::vector", "::std::list", "::std::deque"))))))))));		hasAnyName("::std::vector", "::std::list", "::std::deque")))))))));

auto StringTy = type(hasUnqualifiedDesugaredType(recordType(		auto StringTy = type(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));		hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));

auto AnyOfStringTy =		auto AnyOfStringTy =
anyOf(hasType(StringTy), hasType(qualType(pointsTo(StringTy))));		anyOf(hasType(StringTy), hasType(qualType(pointsTo(StringTy))));

auto CharTyArray = hasType(qualType(hasCanonicalType(		auto CharTyArray = hasType(qualType(hasCanonicalType(
Show All 18 Lines	auto SizeOrLength =
cxxMemberCallExpr(		cxxMemberCallExpr(
allOf(on(expr(AnyOfStringTy).bind("Foo")),		allOf(on(expr(AnyOfStringTy).bind("Foo")),
has(memberExpr(member(hasAnyName("size", "length"))))))		has(memberExpr(member(hasAnyName("size", "length"))))))
.bind(WrongLengthExprName);		.bind(WrongLengthExprName);

// - Example: char src[] = "foo"; sizeof(src);		// - Example: char src[] = "foo"; sizeof(src);
auto SizeOfCharExpr = unaryExprOrTypeTraitExpr(has(expr(AnyOfCharTy)));		auto SizeOfCharExpr = unaryExprOrTypeTraitExpr(has(expr(AnyOfCharTy)));

auto WrongLength =		auto WrongLength = anyOf(Strlen, SizeOrLength, hasDescendant(Strlen),
ignoringImpCasts(anyOf(Strlen, SizeOrLength, hasDescendant(Strlen),		hasDescendant(SizeOrLength));
hasDescendant(SizeOrLength)));

// - Example: length = strlen(src);		// - Example: length = strlen(src);
auto DREWithoutInc =		auto DREWithoutInc = declRefExpr(to(varDecl(hasInitializer(WrongLength))));
ignoringImpCasts(declRefExpr(to(varDecl(hasInitializer(WrongLength)))));

auto AnyOfCallOrDREWithoutInc = anyOf(DREWithoutInc, WrongLength);		auto AnyOfCallOrDREWithoutInc = anyOf(DREWithoutInc, WrongLength);

// - Example: int getLength(const char *str) { return strlen(str); }		// - Example: int getLength(const char *str) { return strlen(str); }
auto CallExprReturnWithoutInc = ignoringImpCasts(callExpr(callee(functionDecl(		auto CallExprReturnWithoutInc = callExpr(callee(functionDecl(
hasBody(has(returnStmt(hasReturnValue(AnyOfCallOrDREWithoutInc))))))));		hasBody(has(returnStmt(hasReturnValue(AnyOfCallOrDREWithoutInc)))))));

// - Example: int length = getLength(src);		// - Example: int length = getLength(src);
auto DREHasReturnWithoutInc = ignoringImpCasts(		auto DREHasReturnWithoutInc =
declRefExpr(to(varDecl(hasInitializer(CallExprReturnWithoutInc)))));		declRefExpr(to(varDecl(hasInitializer(CallExprReturnWithoutInc))));

auto AnyOfWrongLengthInit =		auto AnyOfWrongLengthInit =
anyOf(WrongLength, AnyOfCallOrDREWithoutInc, CallExprReturnWithoutInc,		anyOf(WrongLength, AnyOfCallOrDREWithoutInc, CallExprReturnWithoutInc,
DREHasReturnWithoutInc);		DREHasReturnWithoutInc);

//===--------------------------------------------------------------------===//		//===--------------------------------------------------------------------===//
// The following five cases match the 'destination' array length's		// The following five cases match the 'destination' array length's
// expression which is used in 'memcpy()' and 'memmove()' matchers.		// expression which is used in 'memcpy()' and 'memmove()' matchers.
//===--------------------------------------------------------------------===//		//===--------------------------------------------------------------------===//

// Note: Sometimes the size of char is explicitly written out.		// Note: Sometimes the size of char is explicitly written out.
auto SizeExpr = anyOf(SizeOfCharExpr, integerLiteral(equals(1)));		auto SizeExpr = anyOf(SizeOfCharExpr, integerLiteral(equals(1)));

auto MallocLengthExpr = allOf(		auto MallocLengthExpr = allOf(
callee(functionDecl(		callee(functionDecl(
hasAnyName("::alloca", "::calloc", "malloc", "realloc"))),		hasAnyName("::alloca", "::calloc", "malloc", "realloc"))),
hasAnyArgument(allOf(unless(SizeExpr), expr().bind(DestMallocExprName))));		hasAnyArgument(allOf(unless(SizeExpr), expr().bind(DestMallocExprName))));

// - Example: (char *)malloc(length);		// - Example: (char *)malloc(length);
auto DestMalloc = anyOf(callExpr(MallocLengthExpr),		auto DestMalloc = anyOf(callExpr(MallocLengthExpr),
hasDescendant(callExpr(MallocLengthExpr)));		hasDescendant(callExpr(MallocLengthExpr)));

// - Example: new char[length];		// - Example: new char[length];
auto DestCXXNewExpr = ignoringImpCasts(		auto DestCXXNewExpr =
cxxNewExpr(hasArraySize(expr().bind(DestMallocExprName))));		cxxNewExpr(hasArraySize(expr().bind(DestMallocExprName)));

auto AnyOfDestInit = anyOf(DestMalloc, DestCXXNewExpr);		auto AnyOfDestInit = anyOf(DestMalloc, DestCXXNewExpr);

// - Example: char dest[13]; or char dest[length];		// - Example: char dest[13]; or char dest[length];
auto DestArrayTyDecl = declRefExpr(		auto DestArrayTyDecl = declRefExpr(
to(anyOf(varDecl(CharTyArray).bind(DestVarDeclName),		to(anyOf(varDecl(CharTyArray).bind(DestVarDeclName),
varDecl(hasInitializer(AnyOfDestInit)).bind(DestVarDeclName))));		varDecl(hasInitializer(AnyOfDestInit)).bind(DestVarDeclName))));

// - Example: foo[bar[baz]].qux; (or just ParmVarDecl)		// - Example: foo[bar[baz]].qux; (or just ParmVarDecl)
auto DestUnknownDecl =		auto DestUnknownDecl =
declRefExpr(allOf(to(varDecl(AnyOfCharTy).bind(DestVarDeclName)),		declRefExpr(allOf(to(varDecl(AnyOfCharTy).bind(DestVarDeclName)),
expr().bind(UnknownDestName)))		expr().bind(UnknownDestName)))
.bind(DestExprName);		.bind(DestExprName);

auto AnyOfDestDecl = ignoringImpCasts(		auto AnyOfDestDecl =
anyOf(allOf(hasDefinition(anyOf(AnyOfDestInit, DestArrayTyDecl,		anyOf(allOf(hasDefinition(anyOf(AnyOfDestInit, DestArrayTyDecl,
hasDescendant(DestArrayTyDecl))),		hasDescendant(DestArrayTyDecl))),
expr().bind(DestExprName)),		expr().bind(DestExprName)),
anyOf(DestUnknownDecl, hasDescendant(DestUnknownDecl))));		anyOf(DestUnknownDecl, hasDescendant(DestUnknownDecl)));

auto NullTerminatorExpr = binaryOperator(		auto NullTerminatorExpr = binaryOperator(
hasLHS(anyOf(hasDescendant(declRefExpr(to(varDecl(		hasLHS(anyOf(hasDescendant(declRefExpr(to(varDecl(
equalsBoundNode(std::string(DestVarDeclName)))))),		equalsBoundNode(std::string(DestVarDeclName)))))),
hasDescendant(declRefExpr(		hasDescendant(declRefExpr(
equalsBoundNode(std::string(DestExprName)))))),		equalsBoundNode(std::string(DestExprName)))))),
hasRHS(ignoringImpCasts(		hasRHS(anyOf(characterLiteral(equals(0U)), integerLiteral(equals(0)))));
anyOf(characterLiteral(equals(0U)), integerLiteral(equals(0))))));

auto SrcDecl = declRefExpr(		auto SrcDecl = declRefExpr(
allOf(to(decl().bind(SrcVarDeclName)),		allOf(to(decl().bind(SrcVarDeclName)),
anyOf(hasAncestor(cxxMemberCallExpr().bind(SrcExprName)),		anyOf(hasAncestor(cxxMemberCallExpr().bind(SrcExprName)),
expr().bind(SrcExprName))));		expr().bind(SrcExprName))));

auto AnyOfSrcDecl =		auto AnyOfSrcDecl = anyOf(stringLiteral().bind(SrcExprName),
ignoringImpCasts(anyOf(stringLiteral().bind(SrcExprName),
hasDescendant(stringLiteral().bind(SrcExprName)),		hasDescendant(stringLiteral().bind(SrcExprName)),
SrcDecl, hasDescendant(SrcDecl)));		SrcDecl, hasDescendant(SrcDecl));

//===--------------------------------------------------------------------===//		//===--------------------------------------------------------------------===//
// Match the problematic function calls.		// Match the problematic function calls.
//===--------------------------------------------------------------------===//		//===--------------------------------------------------------------------===//

struct CallContext {		struct CallContext {
CallContext(StringRef Name, Optional<unsigned> DestinationPos,		CallContext(StringRef Name, Optional<unsigned> DestinationPos,
Optional<unsigned> SourcePos, unsigned LengthPos,		Optional<unsigned> SourcePos, unsigned LengthPos,
Show All 18 Lines	void NotNullTerminatedResultCheck::registerMatchers(MatchFinder *Finder) {

auto MatchSource = [=](CallContext CC) {		auto MatchSource = [=](CallContext CC) {
return hasArgument(*CC.SourcePos, AnyOfSrcDecl);		return hasArgument(*CC.SourcePos, AnyOfSrcDecl);
};		};

auto MatchGivenLength = [=](CallContext CC) {		auto MatchGivenLength = [=](CallContext CC) {
return hasArgument(		return hasArgument(
CC.LengthPos,		CC.LengthPos,
allOf(		allOf(anyOf(integerLiteral().bind(WrongLengthExprName),
anyOf(
ignoringImpCasts(integerLiteral().bind(WrongLengthExprName)),
allOf(unless(hasDefinition(SizeOfCharExpr)),		allOf(unless(hasDefinition(SizeOfCharExpr)),
allOf(CC.WithIncrease		allOf(CC.WithIncrease
? ignoringImpCasts(hasDefinition(HasIncOp))		? hasDefinition(HasIncOp)
: ignoringImpCasts(allOf(		: allOf(unless(hasDefinition(HasIncOp)),
unless(hasDefinition(HasIncOp)),		anyOf(hasDefinition(
anyOf(hasDefinition(binaryOperator().bind(		binaryOperator().bind(
UnknownLengthName)),		UnknownLengthName)),
hasDefinition(anything())))),		hasDefinition(anything()))),
AnyOfWrongLengthInit))),		AnyOfWrongLengthInit))),
expr().bind(LengthExprName)));		expr().bind(LengthExprName)));
};		};

auto MatchCall = [=](CallContext CC) {		auto MatchCall = [=](CallContext CC) {
std::string CharHandlerFuncName = "::" + CC.Name.str();		std::string CharHandlerFuncName = "::" + CC.Name.str();

// Try to match with 'wchar_t' based function calls.		// Try to match with 'wchar_t' based function calls.
std::string WcharHandlerFuncName =		std::string WcharHandlerFuncName =
"::" + (CC.Name.startswith("mem") ? "w" + CC.Name.str()		"::" + (CC.Name.startswith("mem") ? "w" + CC.Name.str()
▲ Show 20 Lines • Show All 283 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/SizeofContainerCheck.cpp

	Show All 13 Lines

	namespace clang {			namespace clang {
	namespace tidy {			namespace tidy {
	namespace bugprone {			namespace bugprone {

	void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {			void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {
	Finder->addMatcher(			Finder->addMatcher(
	expr(unless(isInTemplateInstantiation()),			expr(unless(isInTemplateInstantiation()),
	expr(sizeOfExpr(has(ignoringParenImpCasts(			expr(sizeOfExpr(has(
	expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(			expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
	matchesName("^(::std::\|::string)"),			matchesName("^(::std::\|::string)"),
	unless(matchesName("^::std::(bitset\|array)$")),			unless(matchesName("^::std::(bitset\|array)$")),
	hasMethod(cxxMethodDecl(hasName("size"), isPublic(),			hasMethod(cxxMethodDecl(hasName("size"), isPublic(),
	isConst())))))))))))			isConst()))))))))))
	.bind("sizeof"),			.bind("sizeof"),
	// Ignore ARRAYSIZE(<array of containers>) pattern.			// Ignore ARRAYSIZE(<array of containers>) pattern.
	unless(hasAncestor(binaryOperator(			unless(
	hasAnyOperatorName("/", "%"),			hasAncestor(binaryOperator(hasAnyOperatorName("/", "%"),
	hasLHS(ignoringParenCasts(sizeOfExpr(expr()))),			hasLHS(sizeOfExpr(expr())),
	hasRHS(ignoringParenCasts(equalsBoundNode("sizeof"))))))),			hasRHS(equalsBoundNode("sizeof")))))),
	this);			this);
	}			}

	void SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) {			void SizeofContainerCheck::check(const MatchFinder::MatchResult &Result) {
	const auto *SizeOf =			const auto *SizeOf =
	Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof");			Result.Nodes.getNodeAs<UnaryExprOrTypeTraitExpr>("sizeof");

	auto Diag =			auto Diag =
	diag(SizeOf->getBeginLoc(), "sizeof() doesn't return the size of the "			diag(SizeOf->getBeginLoc(), "sizeof() doesn't return the size of the "
	"container; did you mean .size()?");			"container; did you mean .size()?");
	}			}

	} // namespace bugprone			} // namespace bugprone
	} // namespace tidy			} // namespace tidy
	} // namespace clang			} // namespace clang

clang-tools-extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines	void SizeofExpressionCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "WarnOnSizeOfIntegerExpression",		Options.store(Opts, "WarnOnSizeOfIntegerExpression",
WarnOnSizeOfIntegerExpression);		WarnOnSizeOfIntegerExpression);
Options.store(Opts, "WarnOnSizeOfThis", WarnOnSizeOfThis);		Options.store(Opts, "WarnOnSizeOfThis", WarnOnSizeOfThis);
Options.store(Opts, "WarnOnSizeOfCompareToConstant",		Options.store(Opts, "WarnOnSizeOfCompareToConstant",
WarnOnSizeOfCompareToConstant);		WarnOnSizeOfCompareToConstant);
}		}

void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {		void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
const auto IntegerExpr = ignoringParenImpCasts(integerLiteral());		const auto ConstantExpr = expr(anyOf(
const auto ConstantExpr = expr(ignoringParenImpCasts(		integerLiteral(), unaryOperator(hasUnaryOperand(integerLiteral())),
anyOf(integerLiteral(), unaryOperator(hasUnaryOperand(IntegerExpr)),		binaryOperator(hasLHS(integerLiteral()), hasRHS(integerLiteral()))));
binaryOperator(hasLHS(IntegerExpr), hasRHS(IntegerExpr)))));		const auto IntegerCallExpr =
const auto IntegerCallExpr = expr(ignoringParenImpCasts(
callExpr(anyOf(hasType(isInteger()), hasType(enumType())),		callExpr(anyOf(hasType(isInteger()), hasType(enumType())),
unless(isInTemplateInstantiation()))));		unless(isInTemplateInstantiation()));
const auto SizeOfExpr = expr(anyOf(		const auto SizeOfExpr = expr(anyOf(
sizeOfExpr(		sizeOfExpr(
has(hasUnqualifiedDesugaredType(type().bind("sizeof-arg-type")))),		has(hasUnqualifiedDesugaredType(type().bind("sizeof-arg-type")))),
sizeOfExpr(has(expr(hasType(		sizeOfExpr(has(expr(hasType(
hasUnqualifiedDesugaredType(type().bind("sizeof-arg-type"))))))));		hasUnqualifiedDesugaredType(type().bind("sizeof-arg-type"))))))));
const auto SizeOfZero = expr(		const auto SizeOfZero = expr(sizeOfExpr(has(integerLiteral(equals(0)))));
sizeOfExpr(has(ignoringParenImpCasts(expr(integerLiteral(equals(0)))))));

// Detect expression like: sizeof(ARRAYLEN);		// Detect expression like: sizeof(ARRAYLEN);
// Note: The expression 'sizeof(sizeof(0))' is a portable trick used to know		// Note: The expression 'sizeof(sizeof(0))' is a portable trick used to know
// the sizeof size_t.		// the sizeof size_t.
if (WarnOnSizeOfConstant) {		if (WarnOnSizeOfConstant) {
Finder->addMatcher(		Finder->addMatcher(expr(sizeOfExpr(has(ConstantExpr)), unless(SizeOfZero))
expr(sizeOfExpr(has(ignoringParenImpCasts(ConstantExpr))),
unless(SizeOfZero))
.bind("sizeof-constant"),		.bind("sizeof-constant"),
this);		this);
}		}

// Detect sizeof(f())		// Detect sizeof(f())
if (WarnOnSizeOfIntegerExpression) {		if (WarnOnSizeOfIntegerExpression) {
Finder->addMatcher(		Finder->addMatcher(
expr(sizeOfExpr(ignoringParenImpCasts(has(IntegerCallExpr))))		sizeOfExpr(has(IntegerCallExpr)).bind("sizeof-integer-call"), this);
.bind("sizeof-integer-call"),
this);
}		}

// Detect expression like: sizeof(this);		// Detect expression like: sizeof(this);
if (WarnOnSizeOfThis) {		if (WarnOnSizeOfThis) {
Finder->addMatcher(		Finder->addMatcher(sizeOfExpr(has(cxxThisExpr())).bind("sizeof-this"),
expr(sizeOfExpr(has(ignoringParenImpCasts(expr(cxxThisExpr())))))
.bind("sizeof-this"),
this);		this);
}		}

// Detect sizeof(kPtr) where kPtr is 'const char* kPtr = "abc"';		// Detect sizeof(kPtr) where kPtr is 'const char* kPtr = "abc"';
const auto CharPtrType = pointerType(pointee(isAnyCharacter()));		const auto CharPtrType = pointerType(pointee(isAnyCharacter()));
const auto ConstStrLiteralDecl =		const auto ConstStrLiteralDecl =
varDecl(isDefinition(), hasType(qualType(hasCanonicalType(CharPtrType))),		varDecl(isDefinition(), hasType(qualType(hasCanonicalType(CharPtrType))),
hasInitializer(ignoringParenImpCasts(stringLiteral())));		hasInitializer(stringLiteral()));
Finder->addMatcher(expr(sizeOfExpr(has(ignoringParenImpCasts(expr(		Finder->addMatcher(
hasType(qualType(hasCanonicalType(CharPtrType))),		expr(sizeOfExpr(
ignoringParenImpCasts(declRefExpr(		has(expr(hasType(qualType(hasCanonicalType(CharPtrType))),
hasDeclaration(ConstStrLiteralDecl))))))))		declRefExpr(hasDeclaration(ConstStrLiteralDecl))))))
.bind("sizeof-charp"),		.bind("sizeof-charp"),
this);		this);

// Detect sizeof(ptr) where ptr points to an aggregate (i.e. sizeof(&S)).		// Detect sizeof(ptr) where ptr points to an aggregate (i.e. sizeof(&S)).
const auto ArrayExpr = expr(ignoringParenImpCasts(		const auto ArrayExpr = expr(hasType(qualType(hasCanonicalType(arrayType()))));
expr(hasType(qualType(hasCanonicalType(arrayType()))))));
const auto ArrayCastExpr = expr(anyOf(		const auto ArrayCastExpr = expr(anyOf(
unaryOperator(hasUnaryOperand(ArrayExpr), unless(hasOperatorName("*"))),		unaryOperator(hasUnaryOperand(ArrayExpr), unless(hasOperatorName("*"))),
binaryOperator(hasEitherOperand(ArrayExpr)),		binaryOperator(hasEitherOperand(ArrayExpr)),
castExpr(hasSourceExpression(ArrayExpr))));		castExpr(hasSourceExpression(ArrayExpr))));
const auto PointerToArrayExpr = expr(ignoringParenImpCasts(expr(		const auto PointerToArrayExpr = expr(
hasType(qualType(hasCanonicalType(pointerType(pointee(arrayType()))))))));		hasType(qualType(hasCanonicalType(pointerType(pointee(arrayType()))))));

const auto StructAddrOfExpr =		const auto StructAddrOfExpr = unaryOperator(
unaryOperator(hasOperatorName("&"),		hasOperatorName("&"),
hasUnaryOperand(ignoringParenImpCasts(expr(		hasUnaryOperand(hasType(qualType(hasCanonicalType(recordType())))));
hasType(qualType(hasCanonicalType(recordType())))))));
const auto PointerToStructType = type(hasUnqualifiedDesugaredType(		const auto PointerToStructType = type(hasUnqualifiedDesugaredType(
pointerType(pointee(recordType()))));		pointerType(pointee(recordType()))));
const auto PointerToStructExpr = expr(ignoringParenImpCasts(expr(		const auto PointerToStructExpr =
hasType(qualType(hasCanonicalType(PointerToStructType))),		expr(hasType(qualType(hasCanonicalType(PointerToStructType))),
unless(cxxThisExpr()))));		unless(cxxThisExpr()));

Finder->addMatcher(		Finder->addMatcher(expr(anyOf(sizeOfExpr(has(expr(anyOf(
expr(anyOf(sizeOfExpr(has(expr(ignoringParenImpCasts(		ArrayCastExpr, PointerToArrayExpr,
anyOf(ArrayCastExpr, PointerToArrayExpr, StructAddrOfExpr,		StructAddrOfExpr, PointerToStructExpr)))),
PointerToStructExpr))))),
sizeOfExpr(has(PointerToStructType))))		sizeOfExpr(has(PointerToStructType))))
.bind("sizeof-pointer-to-aggregate"),		.bind("sizeof-pointer-to-aggregate"),
this);		this);

// Detect expression like: sizeof(epxr) <= k for a suspicious constant 'k'.		// Detect expression like: sizeof(epxr) <= k for a suspicious constant 'k'.
if (WarnOnSizeOfCompareToConstant) {		if (WarnOnSizeOfCompareToConstant) {
Finder->addMatcher(		Finder->addMatcher(
binaryOperator(matchers::isRelationalOperator(),		binaryOperator(
hasOperands(ignoringParenImpCasts(SizeOfExpr),		matchers::isRelationalOperator(),
ignoringParenImpCasts(anyOf(		hasOperands(SizeOfExpr,
integerLiteral(equals(0)),		anyOf(integerLiteral(equals(0)),
integerLiteral(isBiggerThan(0x80000))))))		integerLiteral(isBiggerThan(0x80000)))))
.bind("sizeof-compare-constant"),		.bind("sizeof-compare-constant"),
this);		this);
}		}

// Detect expression like: sizeof(expr, expr); most likely an error.		// Detect expression like: sizeof(expr, expr); most likely an error.
Finder->addMatcher(expr(sizeOfExpr(has(expr(ignoringParenImpCasts(		Finder->addMatcher(sizeOfExpr(has(binaryOperator(hasOperatorName(","))))
binaryOperator(hasOperatorName(",")))))))
.bind("sizeof-comma-expr"),		.bind("sizeof-comma-expr"),
this);		this);

// Detect sizeof(...) /sizeof(...));		// Detect sizeof(...) /sizeof(...));
const auto ElemType =		const auto ElemType =
arrayType(hasElementType(recordType().bind("elem-type")));		arrayType(hasElementType(recordType().bind("elem-type")));
const auto ElemPtrType = pointerType(pointee(type().bind("elem-ptr-type")));		const auto ElemPtrType = pointerType(pointee(type().bind("elem-ptr-type")));
const auto NumType = qualType(hasCanonicalType(		const auto NumType = qualType(hasCanonicalType(
type(anyOf(ElemType, ElemPtrType, type())).bind("num-type")));		type(anyOf(ElemType, ElemPtrType, type())).bind("num-type")));
const auto DenomType = qualType(hasCanonicalType(type().bind("denom-type")));		const auto DenomType = qualType(hasCanonicalType(type().bind("denom-type")));

Finder->addMatcher(		Finder->addMatcher(
binaryOperator(hasOperatorName("/"),		binaryOperator(
hasLHS(expr(ignoringParenImpCasts(		hasOperatorName("/"),
anyOf(sizeOfExpr(has(NumType)),		hasLHS(expr(anyOf(sizeOfExpr(has(NumType)),
sizeOfExpr(has(expr(hasType(NumType)))))))),		sizeOfExpr(has(expr(hasType(NumType))))))),
hasRHS(expr(ignoringParenImpCasts(		hasRHS(expr(anyOf(sizeOfExpr(has(DenomType)),
anyOf(sizeOfExpr(has(DenomType)),		sizeOfExpr(has(expr(hasType(DenomType))))))))
sizeOfExpr(has(expr(hasType(DenomType)))))))))
.bind("sizeof-divide-expr"),		.bind("sizeof-divide-expr"),
this);		this);

// Detect expression like: sizeof(...) * sizeof(...)); most likely an error.		// Detect expression like: sizeof(...) * sizeof(...)); most likely an error.
Finder->addMatcher(binaryOperator(hasOperatorName("*"),		Finder->addMatcher(binaryOperator(hasOperatorName("*"), hasLHS(SizeOfExpr),
hasLHS(ignoringParenImpCasts(SizeOfExpr)),		hasRHS(SizeOfExpr))
hasRHS(ignoringParenImpCasts(SizeOfExpr)))
.bind("sizeof-multiply-sizeof"),		.bind("sizeof-multiply-sizeof"),
this);		this);

Finder->addMatcher(		Finder->addMatcher(
binaryOperator(hasOperatorName("*"),		binaryOperator(
hasOperands(ignoringParenImpCasts(SizeOfExpr),
ignoringParenImpCasts(binaryOperator(
hasOperatorName("*"),		hasOperatorName("*"),
hasEitherOperand(		hasOperands(SizeOfExpr, binaryOperator(hasOperatorName("*"),
ignoringParenImpCasts(SizeOfExpr))))))		hasEitherOperand(SizeOfExpr))))
.bind("sizeof-multiply-sizeof"),		.bind("sizeof-multiply-sizeof"),
this);		this);

// Detect strange double-sizeof expression like: sizeof(sizeof(...));		// Detect strange double-sizeof expression like: sizeof(sizeof(...));
// Note: The expression 'sizeof(sizeof(0))' is accepted.		// Note: The expression 'sizeof(sizeof(0))' is accepted.
Finder->addMatcher(		Finder->addMatcher(sizeOfExpr(has(hasSizeOfDescendant(
expr(sizeOfExpr(has(ignoringParenImpCasts(expr(		8, expr(SizeOfExpr, unless(SizeOfZero)))))
hasSizeOfDescendant(8, expr(SizeOfExpr, unless(SizeOfZero))))))))
.bind("sizeof-sizeof-expr"),		.bind("sizeof-sizeof-expr"),
this);		this);

// Detect sizeof in pointer arithmetic like: N * sizeof(S) == P1 - P2 or		// Detect sizeof in pointer arithmetic like: N * sizeof(S) == P1 - P2 or
// (P1 - P2) / sizeof(S) where P1 and P2 are pointers to type S.		// (P1 - P2) / sizeof(S) where P1 and P2 are pointers to type S.
const auto PtrDiffExpr = binaryOperator(		const auto PtrDiffExpr = binaryOperator(
hasOperatorName("-"),		hasOperatorName("-"),
hasLHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(		hasLHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
hasUnqualifiedDesugaredType(type().bind("left-ptr-type")))))))),		hasUnqualifiedDesugaredType(type().bind("left-ptr-type")))))))),
hasRHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(		hasRHS(expr(hasType(hasUnqualifiedDesugaredType(pointerType(pointee(
hasUnqualifiedDesugaredType(type().bind("right-ptr-type")))))))));		hasUnqualifiedDesugaredType(type().bind("right-ptr-type")))))))));

Finder->addMatcher(		Finder->addMatcher(
binaryOperator(		binaryOperator(
hasAnyOperatorName("==", "!=", "<", "<=", ">", ">=", "+", "-"),		hasAnyOperatorName("==", "!=", "<", "<=", ">", ">=", "+", "-"),
hasOperands(expr(anyOf(ignoringParenImpCasts(SizeOfExpr),		hasOperands(
ignoringParenImpCasts(binaryOperator(		anyOf(SizeOfExpr, binaryOperator(hasOperatorName("*"),
hasOperatorName("*"),		hasEitherOperand(SizeOfExpr))),
hasEitherOperand(		PtrDiffExpr))
ignoringParenImpCasts(SizeOfExpr)))))),
ignoringParenImpCasts(PtrDiffExpr)))
.bind("sizeof-in-ptr-arithmetic-mul"),		.bind("sizeof-in-ptr-arithmetic-mul"),
this);		this);

Finder->addMatcher(binaryOperator(hasOperatorName("/"),		Finder->addMatcher(binaryOperator(hasOperatorName("/"), hasLHS(PtrDiffExpr),
hasLHS(ignoringParenImpCasts(PtrDiffExpr)),		hasRHS(SizeOfExpr))
hasRHS(ignoringParenImpCasts(SizeOfExpr)))
.bind("sizeof-in-ptr-arithmetic-div"),		.bind("sizeof-in-ptr-arithmetic-div"),
this);		this);
}		}

void SizeofExpressionCheck::check(const MatchFinder::MatchResult &Result) {		void SizeofExpressionCheck::check(const MatchFinder::MatchResult &Result) {
const ASTContext &Ctx = *Result.Context;		const ASTContext &Ctx = *Result.Context;

if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {		if (const auto *E = Result.Nodes.getNodeAs<Expr>("sizeof-constant")) {
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/StringConstructorCheck.cpp

Show All 29 Lines	: ClangTidyCheck(Name, Context),
LargeLengthThreshold(Options.get("LargeLengthThreshold", 0x800000)) {}		LargeLengthThreshold(Options.get("LargeLengthThreshold", 0x800000)) {}

void StringConstructorCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {		void StringConstructorCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "WarnOnLargeLength", WarnOnLargeLength);		Options.store(Opts, "WarnOnLargeLength", WarnOnLargeLength);
Options.store(Opts, "LargeLengthThreshold", LargeLengthThreshold);		Options.store(Opts, "LargeLengthThreshold", LargeLengthThreshold);
}		}

void StringConstructorCheck::registerMatchers(MatchFinder *Finder) {		void StringConstructorCheck::registerMatchers(MatchFinder *Finder) {
const auto ZeroExpr = expr(ignoringParenImpCasts(integerLiteral(equals(0))));		const auto ZeroExpr = integerLiteral(equals(0));
const auto CharExpr = expr(ignoringParenImpCasts(characterLiteral()));		const auto NegativeExpr = unaryOperator(
const auto NegativeExpr = expr(ignoringParenImpCasts(		hasOperatorName("-"), hasUnaryOperand(integerLiteral(unless(equals(0)))));
unaryOperator(hasOperatorName("-"),		const auto LargeLengthExpr =
hasUnaryOperand(integerLiteral(unless(equals(0)))))));		integerLiteral(isBiggerThan(LargeLengthThreshold));
const auto LargeLengthExpr = expr(ignoringParenImpCasts(
integerLiteral(isBiggerThan(LargeLengthThreshold))));
const auto CharPtrType = type(anyOf(pointerType(), arrayType()));		const auto CharPtrType = type(anyOf(pointerType(), arrayType()));

// Match a string-literal; even through a declaration with initializer.		// Match a string-literal; even through a declaration with initializer.
const auto BoundStringLiteral = stringLiteral().bind("str");		const auto BoundStringLiteral = stringLiteral().bind("str");
const auto ConstStrLiteralDecl = varDecl(		const auto ConstStrLiteralDecl =
isDefinition(), hasType(constantArrayType()), hasType(isConstQualified()),		varDecl(isDefinition(), hasType(constantArrayType()),
hasInitializer(ignoringParenImpCasts(BoundStringLiteral)));		hasType(isConstQualified()), hasInitializer(BoundStringLiteral));
const auto ConstPtrStrLiteralDecl = varDecl(		const auto ConstPtrStrLiteralDecl = varDecl(
isDefinition(),		isDefinition(),
hasType(pointerType(pointee(isAnyCharacter(), isConstQualified()))),		hasType(pointerType(pointee(isAnyCharacter(), isConstQualified()))),
hasInitializer(ignoringParenImpCasts(BoundStringLiteral)));		hasInitializer(BoundStringLiteral));
const auto ConstStrLiteral = expr(ignoringParenImpCasts(anyOf(		const auto ConstStrLiteral =
BoundStringLiteral, declRefExpr(hasDeclaration(anyOf(		expr(anyOf(BoundStringLiteral,
ConstPtrStrLiteralDecl, ConstStrLiteralDecl))))));		declRefExpr(hasDeclaration(
		anyOf(ConstPtrStrLiteralDecl, ConstStrLiteralDecl)))));

// Check the fill constructor. Fills the string with n consecutive copies of		// Check the fill constructor. Fills the string with n consecutive copies of
// character c. [i.e string(size_t n, char c);].		// character c. [i.e string(size_t n, char c);].
Finder->addMatcher(		Finder->addMatcher(
cxxConstructExpr(		cxxConstructExpr(
hasDeclaration(cxxMethodDecl(hasName("basic_string"))),		hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
hasArgument(0, hasType(qualType(isInteger()))),		hasArgument(0, hasType(qualType(isInteger()))),
hasArgument(1, hasType(qualType(isInteger()))),		hasArgument(1, hasType(qualType(isInteger()))),
anyOf(		anyOf(
// Detect the expression: string('x', 40);		// Detect the expression: string('x', 40);
hasArgument(0, CharExpr.bind("swapped-parameter")),		hasArgument(0, characterLiteral().bind("swapped-parameter")),
// Detect the expression: string(0, ...);		// Detect the expression: string(0, ...);
hasArgument(0, ZeroExpr.bind("empty-string")),		hasArgument(0, ZeroExpr.bind("empty-string")),
// Detect the expression: string(-4, ...);		// Detect the expression: string(-4, ...);
hasArgument(0, NegativeExpr.bind("negative-length")),		hasArgument(0, NegativeExpr.bind("negative-length")),
// Detect the expression: string(0x1234567, ...);		// Detect the expression: string(0x1234567, ...);
hasArgument(0, LargeLengthExpr.bind("large-length"))))		hasArgument(0, LargeLengthExpr.bind("large-length"))))
.bind("constructor"),		.bind("constructor"),
this);		this);
Show All 9 Lines	Finder->addMatcher(
// Detect the expression: string("...", 0);		// Detect the expression: string("...", 0);
hasArgument(1, ZeroExpr.bind("empty-string")),		hasArgument(1, ZeroExpr.bind("empty-string")),
// Detect the expression: string("...", -4);		// Detect the expression: string("...", -4);
hasArgument(1, NegativeExpr.bind("negative-length")),		hasArgument(1, NegativeExpr.bind("negative-length")),
// Detect the expression: string("lit", 0x1234567);		// Detect the expression: string("lit", 0x1234567);
hasArgument(1, LargeLengthExpr.bind("large-length")),		hasArgument(1, LargeLengthExpr.bind("large-length")),
// Detect the expression: string("lit", 5)		// Detect the expression: string("lit", 5)
allOf(hasArgument(0, ConstStrLiteral.bind("literal-with-length")),		allOf(hasArgument(0, ConstStrLiteral.bind("literal-with-length")),
hasArgument(1, ignoringParenImpCasts(		hasArgument(1, integerLiteral().bind("int")))))
integerLiteral().bind("int"))))))
.bind("constructor"),		.bind("constructor"),
this);		this);

// Check the literal string constructor with char pointer.		// Check the literal string constructor with char pointer.
// [i.e. string (const char* s);]		// [i.e. string (const char* s);]
Finder->addMatcher(		Finder->addMatcher(
traverse(TK_AsIs,		traverse(TK_AsIs,
cxxConstructExpr(hasDeclaration(cxxMethodDecl(hasName("basic_string"))),		cxxConstructExpr(hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/StringIntegerAssignmentCheck.cpp

Show All 20 Lines	void StringIntegerAssignmentCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(		Finder->addMatcher(
cxxOperatorCallExpr(		cxxOperatorCallExpr(
hasAnyOverloadedOperatorName("=", "+="),		hasAnyOverloadedOperatorName("=", "+="),
callee(cxxMethodDecl(ofClass(classTemplateSpecializationDecl(		callee(cxxMethodDecl(ofClass(classTemplateSpecializationDecl(
hasName("::std::basic_string"),		hasName("::std::basic_string"),
hasTemplateArgument(0, refersToType(hasCanonicalType(		hasTemplateArgument(0, refersToType(hasCanonicalType(
qualType().bind("type")))))))),		qualType().bind("type")))))))),
hasArgument(		hasArgument(
1,		1, expr(hasType(isInteger()), unless(hasType(isAnyCharacter())),
ignoringImpCasts(
expr(hasType(isInteger()), unless(hasType(isAnyCharacter())),
// Ignore calls to tolower/toupper (see PR27723).		// Ignore calls to tolower/toupper (see PR27723).
unless(callExpr(callee(functionDecl(		unless(callExpr(callee(functionDecl(
hasAnyName("tolower", "std::tolower", "toupper",		hasAnyName("tolower", "std::tolower", "toupper",
"std::toupper"))))),		"std::toupper"))))),
// Do not warn if assigning e.g. `CodePoint` to		// Do not warn if assigning e.g. `CodePoint` to
// `basic_string<CodePoint>`		// `basic_string<CodePoint>`
unless(hasType(qualType(		unless(hasType(
hasCanonicalType(equalsBoundNode("type"))))))		qualType(hasCanonicalType(equalsBoundNode("type"))))))
.bind("expr"))),		.bind("expr")),
unless(isInTemplateInstantiation())),		unless(isInTemplateInstantiation())),
this);		this);
}		}

class CharExpressionDetector {		class CharExpressionDetector {
public:		public:
CharExpressionDetector(QualType CharType, const ASTContext &Ctx)		CharExpressionDetector(QualType CharType, const ASTContext &Ctx)
: CharType(CharType), Ctx(Ctx) {}		: CharType(CharType), Ctx(Ctx) {}
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/StringLiteralWithEmbeddedNulCheck.cpp

Show All 28 Lines	void StringLiteralWithEmbeddedNulCheck::registerMatchers(MatchFinder *Finder) {
// Match a string that contains embedded NUL character. Extra-checks are		// Match a string that contains embedded NUL character. Extra-checks are
// applied in \|check\| to find incorrectly escaped characters.		// applied in \|check\| to find incorrectly escaped characters.
Finder->addMatcher(stringLiteral(containsNul()).bind("strlit"), this);		Finder->addMatcher(stringLiteral(containsNul()).bind("strlit"), this);

// The remaining checks only apply to C++.		// The remaining checks only apply to C++.
if (!getLangOpts().CPlusPlus)		if (!getLangOpts().CPlusPlus)
return;		return;

const auto StrLitWithNul =		const auto StrLitWithNul = stringLiteral(containsNul()).bind("truncated");
ignoringParenImpCasts(stringLiteral(containsNul()).bind("truncated"));

// Match string constructor.		// Match string constructor.
const auto StringConstructorExpr = expr(anyOf(		const auto StringConstructorExpr = expr(anyOf(
cxxConstructExpr(argumentCountIs(1),		cxxConstructExpr(argumentCountIs(1),
hasDeclaration(cxxMethodDecl(hasName("basic_string")))),		hasDeclaration(cxxMethodDecl(hasName("basic_string")))),
// If present, the second argument is the alloc object which must not		// If present, the second argument is the alloc object which must not
// be present explicitly.		// be present explicitly.
cxxConstructExpr(argumentCountIs(2),		cxxConstructExpr(argumentCountIs(2),
Show All 38 Lines

clang-tools-extra/clang-tidy/bugprone/SuspiciousEnumUsageCheck.cpp

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines	: ClangTidyCheck(Name, Context),
StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}		StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}

void SuspiciousEnumUsageCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {		void SuspiciousEnumUsageCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "StrictMode", StrictMode);		Options.store(Opts, "StrictMode", StrictMode);
}		}

void SuspiciousEnumUsageCheck::registerMatchers(MatchFinder *Finder) {		void SuspiciousEnumUsageCheck::registerMatchers(MatchFinder *Finder) {
const auto enumExpr = [](StringRef RefName, StringRef DeclName) {		const auto enumExpr = [](StringRef RefName, StringRef DeclName) {
return expr(ignoringImpCasts(expr().bind(RefName)),		return expr(expr().bind(RefName), hasType(enumDecl().bind(DeclName)));
ignoringImpCasts(hasType(enumDecl().bind(DeclName))));
};		};

Finder->addMatcher(		Finder->addMatcher(
binaryOperator(hasOperatorName("\|"), hasLHS(enumExpr("", "enumDecl")),		binaryOperator(
		hasOperatorName("\|"), hasLHS(enumExpr("", "enumDecl")),
hasRHS(expr(enumExpr("", "otherEnumDecl"),		hasRHS(expr(enumExpr("", "otherEnumDecl"),
ignoringImpCasts(hasType(enumDecl(		hasType(enumDecl(unless(equalsBoundNode("enumDecl")))))))
unless(equalsBoundNode("enumDecl"))))))))
.bind("diffEnumOp"),		.bind("diffEnumOp"),
this);		this);

Finder->addMatcher(		Finder->addMatcher(
binaryOperator(hasAnyOperatorName("+", "\|"),		binaryOperator(
hasLHS(enumExpr("lhsExpr", "enumDecl")),		hasAnyOperatorName("+", "\|"), hasLHS(enumExpr("lhsExpr", "enumDecl")),
hasRHS(expr(enumExpr("rhsExpr", ""),		hasRHS(expr(enumExpr("rhsExpr", ""),
ignoringImpCasts(hasType(		hasType(enumDecl(equalsBoundNode("enumDecl")))))),
enumDecl(equalsBoundNode("enumDecl"))))))),
this);		this);

Finder->addMatcher(		Finder->addMatcher(
binaryOperator(		binaryOperator(
hasAnyOperatorName("+", "\|"),		hasAnyOperatorName("+", "\|"),
hasOperands(expr(hasType(isInteger()), unless(enumExpr("", ""))),		hasOperands(expr(hasType(isInteger()), unless(enumExpr("", ""))),
enumExpr("enumExpr", "enumDecl"))),		enumExpr("enumExpr", "enumDecl"))),
this);		this);
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines	void SuspiciousMissingCommaCheck::storeOptions(
Options.store(Opts, "RatioThreshold", std::to_string(RatioThreshold));		Options.store(Opts, "RatioThreshold", std::to_string(RatioThreshold));
Options.store(Opts, "MaxConcatenatedTokens", MaxConcatenatedTokens);		Options.store(Opts, "MaxConcatenatedTokens", MaxConcatenatedTokens);
}		}

void SuspiciousMissingCommaCheck::registerMatchers(MatchFinder *Finder) {		void SuspiciousMissingCommaCheck::registerMatchers(MatchFinder *Finder) {
const auto ConcatenatedStringLiteral =		const auto ConcatenatedStringLiteral =
stringLiteral(isConcatenatedLiteral(MaxConcatenatedTokens)).bind("str");		stringLiteral(isConcatenatedLiteral(MaxConcatenatedTokens)).bind("str");

const auto StringsInitializerList =		const auto StringsInitializerList = initListExpr(
initListExpr(hasType(constantArrayType()),		hasType(constantArrayType()), has(ConcatenatedStringLiteral));
has(ignoringParenImpCasts(expr(ConcatenatedStringLiteral))));

Finder->addMatcher(StringsInitializerList.bind("list"), this);		Finder->addMatcher(StringsInitializerList.bind("list"), this);
}		}

void SuspiciousMissingCommaCheck::check(		void SuspiciousMissingCommaCheck::check(
const MatchFinder::MatchResult &Result) {		const MatchFinder::MatchResult &Result) {
const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list");		const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list");
const auto *ConcatenatedLiteral =		const auto *ConcatenatedLiteral =
Show All 30 Lines

clang-tools-extra/clang-tidy/bugprone/TerminatingContinueCheck.cpp

	Show All 14 Lines
	using namespace clang::ast_matchers;			using namespace clang::ast_matchers;

	namespace clang {			namespace clang {
	namespace tidy {			namespace tidy {
	namespace bugprone {			namespace bugprone {

	void TerminatingContinueCheck::registerMatchers(MatchFinder *Finder) {			void TerminatingContinueCheck::registerMatchers(MatchFinder *Finder) {
	const auto doWithFalse =			const auto doWithFalse =
	doStmt(hasCondition(ignoringImpCasts(			doStmt(hasCondition(anyOf(cxxBoolLiteral(equals(false)),
	anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)),			integerLiteral(equals(0)),
	cxxNullPtrLiteralExpr(), gnuNullExpr()))),			cxxNullPtrLiteralExpr(), gnuNullExpr())),
	equalsBoundNode("closestLoop"));			equalsBoundNode("closestLoop"));

	Finder->addMatcher(			Finder->addMatcher(
	continueStmt(hasAncestor(stmt(anyOf(forStmt(), whileStmt(),			continueStmt(hasAncestor(stmt(anyOf(forStmt(), whileStmt(),
	cxxForRangeStmt(), doStmt()))			cxxForRangeStmt(), doStmt()))
	.bind("closestLoop")),			.bind("closestLoop")),
	hasAncestor(doWithFalse))			hasAncestor(doWithFalse))
	.bind("continue"),			.bind("continue"),
	Show All 15 Lines

clang-tools-extra/clang-tidy/bugprone/UnusedReturnValueCheck.cpp

Show First 20 Lines • Show All 128 Lines • ▼ Show 20 Lines	: ClangTidyCheck(Name, Context),
"::ttyname")) {}		"::ttyname")) {}

void UnusedReturnValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {		void UnusedReturnValueCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "CheckedFunctions", CheckedFunctions);		Options.store(Opts, "CheckedFunctions", CheckedFunctions);
}		}

void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {		void UnusedReturnValueCheck::registerMatchers(MatchFinder *Finder) {
auto FunVec = utils::options::parseStringList(CheckedFunctions);		auto FunVec = utils::options::parseStringList(CheckedFunctions);
auto MatchedCallExpr = expr(ignoringImplicit(ignoringParenImpCasts(		auto MatchedCallExpr =
callExpr(callee(functionDecl(		callExpr(callee(functionDecl(
// Don't match void overloads of checked functions.		// Don't match void overloads of checked functions.
unless(returns(voidType())),		unless(returns(voidType())),
isInstantiatedFrom(hasAnyName(		isInstantiatedFrom(hasAnyName(
std::vector<StringRef>(FunVec.begin(), FunVec.end()))))))		std::vector<StringRef>(FunVec.begin(), FunVec.end()))))))
.bind("match"))));		.bind("match");

auto UnusedInCompoundStmt =		auto UnusedInCompoundStmt =
compoundStmt(forEach(MatchedCallExpr),		compoundStmt(forEach(MatchedCallExpr),
// The checker can't currently differentiate between the		// The checker can't currently differentiate between the
// return statement and other statements inside GNU statement		// return statement and other statements inside GNU statement
// expressions, so disable the checker inside them to avoid		// expressions, so disable the checker inside them to avoid
// false positives.		// false positives.
unless(hasParent(stmtExpr())));		unless(hasParent(stmtExpr())));
Show All 31 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp

Show All 36 Lines	Inserter = std::make_unique<utils::IncludeInserter>(SM, getLangOpts(),
IncludeStyle);		IncludeStyle);
PP->addPPCallbacks(Inserter->CreatePPCallbacks());		PP->addPPCallbacks(Inserter->CreatePPCallbacks());
}		}

void ProBoundsConstantArrayIndexCheck::registerMatchers(MatchFinder *Finder) {		void ProBoundsConstantArrayIndexCheck::registerMatchers(MatchFinder *Finder) {
// Note: if a struct contains an array member, the compiler-generated		// Note: if a struct contains an array member, the compiler-generated
// constructor has an arraySubscriptExpr.		// constructor has an arraySubscriptExpr.
Finder->addMatcher(		Finder->addMatcher(
arraySubscriptExpr(		arraySubscriptExpr(hasBase(hasType(constantArrayType().bind("type"))),
hasBase(ignoringImpCasts(hasType(constantArrayType().bind("type")))),		hasIndex(expr().bind("index")),
hasIndex(expr().bind("index")), unless(hasAncestor(isImplicit())))		unless(hasAncestor(isImplicit())))
.bind("expr"),		.bind("expr"),
this);		this);

Finder->addMatcher(		Finder->addMatcher(
cxxOperatorCallExpr(		cxxOperatorCallExpr(
hasOverloadedOperatorName("[]"),		hasOverloadedOperatorName("[]"),
hasArgument(		hasArgument(
0, hasType(cxxRecordDecl(hasName("::std::array")).bind("type"))),		0, hasType(cxxRecordDecl(hasName("::std::array")).bind("type"))),
▲ Show 20 Lines • Show All 77 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp

Show All 20 Lines	if (!getLangOpts().CPlusPlus)
return;		return;

const auto AllPointerTypes = anyOf(		const auto AllPointerTypes = anyOf(
hasType(pointerType()), hasType(autoType(hasDeducedType(pointerType()))),		hasType(pointerType()), hasType(autoType(hasDeducedType(pointerType()))),
hasType(decltypeType(hasUnderlyingType(pointerType()))));		hasType(decltypeType(hasUnderlyingType(pointerType()))));

// Flag all operators +, -, +=, -=, ++, -- that result in a pointer		// Flag all operators +, -, +=, -=, ++, -- that result in a pointer
Finder->addMatcher(		Finder->addMatcher(
binaryOperator(		binaryOperator(hasAnyOperatorName("+", "-", "+=", "-="), AllPointerTypes,
hasAnyOperatorName("+", "-", "+=", "-="), AllPointerTypes,		unless(hasLHS(declRefExpr(to(isImplicit())))))
unless(hasLHS(ignoringImpCasts(declRefExpr(to(isImplicit()))))))
.bind("expr"),		.bind("expr"),
this);		this);

Finder->addMatcher(		Finder->addMatcher(
unaryOperator(hasAnyOperatorName("++", "--"), hasType(pointerType()))		unaryOperator(hasAnyOperatorName("++", "--"), hasType(pointerType()))
.bind("expr"),		.bind("expr"),
this);		this);

// Array subscript on a pointer (not an array) is also pointer arithmetic		// Array subscript on a pointer (not an array) is also pointer arithmetic
Finder->addMatcher(		Finder->addMatcher(
arraySubscriptExpr(		arraySubscriptExpr(
hasBase(ignoringImpCasts(		hasBase(anyOf(AllPointerTypes,
anyOf(AllPointerTypes,		hasType(decayedType(hasDecayedType(pointerType()))))))
hasType(decayedType(hasDecayedType(pointerType())))))))
.bind("expr"),		.bind("expr"),
this);		this);
}		}

void ProBoundsPointerArithmeticCheck::check(		void ProBoundsPointerArithmeticCheck::check(
const MatchFinder::MatchResult &Result) {		const MatchFinder::MatchResult &Result) {
const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");		const auto *MatchedExpr = Result.Nodes.getNodeAs<Expr>("expr");

diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic");		diag(MatchedExpr->getExprLoc(), "do not use pointer arithmetic");
}		}

} // namespace cppcoreguidelines		} // namespace cppcoreguidelines
} // namespace tidy		} // namespace tidy
} // namespace clang		} // namespace clang

clang-tools-extra/clang-tidy/google/ExplicitMakePairCheck.cpp

	Show All 24 Lines
	namespace build {			namespace build {

	void ExplicitMakePairCheck::registerMatchers(			void ExplicitMakePairCheck::registerMatchers(
	ast_matchers::MatchFinder *Finder) {			ast_matchers::MatchFinder *Finder) {
	// Look for std::make_pair with explicit template args. Ignore calls in			// Look for std::make_pair with explicit template args. Ignore calls in
	// templates.			// templates.
	Finder->addMatcher(			Finder->addMatcher(
	callExpr(unless(isInTemplateInstantiation()),			callExpr(unless(isInTemplateInstantiation()),
	callee(expr(ignoringParenImpCasts(			callee(declRefExpr(hasExplicitTemplateArgs(),
	declRefExpr(hasExplicitTemplateArgs(),
	to(functionDecl(hasName("::std::make_pair"))))			to(functionDecl(hasName("::std::make_pair"))))
	.bind("declref")))))			.bind("declref")))
	.bind("call"),			.bind("call"),
	this);			this);
	}			}

	void ExplicitMakePairCheck::check(const MatchFinder::MatchResult &Result) {			void ExplicitMakePairCheck::check(const MatchFinder::MatchResult &Result) {
	const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");			const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
	const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declref");			const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declref");

	Show All 28 Lines

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

Show All 23 Lines

void MultiwayPathsCoveredCheck::registerMatchers(MatchFinder *Finder) {		void MultiwayPathsCoveredCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(		Finder->addMatcher(
switchStmt(		switchStmt(
hasCondition(expr(		hasCondition(expr(
// Match on switch statements that have either a bit-field or		// Match on switch statements that have either a bit-field or
// an integer condition. The ordering in 'anyOf()' is		// an integer condition. The ordering in 'anyOf()' is
// important because the last condition is the most general.		// important because the last condition is the most general.
anyOf(ignoringImpCasts(memberExpr(hasDeclaration(		anyOf(memberExpr(hasDeclaration(
fieldDecl(isBitField()).bind("bitfield")))),		fieldDecl(isBitField()).bind("bitfield"))),
ignoringImpCasts(declRefExpr().bind("non-enum-condition"))),		declRefExpr().bind("non-enum-condition")),
// 'unless()' must be the last match here and must be bound,		// 'unless()' must be the last match here and must be bound,
// otherwise the matcher does not work correctly, because it		// otherwise the matcher does not work correctly, because it
// will not explicitly ignore enum conditions.		// will not explicitly ignore enum conditions.
unless(ignoringImpCasts(		unless(declRefExpr(hasType(enumType())).bind("enum-condition")))))
declRefExpr(hasType(enumType())).bind("enum-condition"))))))
.bind("switch"),		.bind("switch"),
this);		this);

// This option is noisy, therefore matching is configurable.		// This option is noisy, therefore matching is configurable.
if (WarnOnMissingElse) {		if (WarnOnMissingElse) {
Finder->addMatcher(ifStmt(hasParent(ifStmt()), unless(hasElse(anything())))		Finder->addMatcher(ifStmt(hasParent(ifStmt()), unless(hasElse(anything())))
.bind("else-if"),		.bind("else-if"),
this);		this);
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines	void MultiwayPathsCoveredCheck::check(const MatchFinder::MatchResult &Result) {
// Checks all 'switch' statements that do not define a default label.		// Checks all 'switch' statements that do not define a default label.
// Here the heavy lifting happens.		// Here the heavy lifting happens.
if (!SwitchHasDefault && SwitchCaseCount > 0) {		if (!SwitchHasDefault && SwitchCaseCount > 0) {
handleSwitchWithoutDefault(Switch, SwitchCaseCount, Result);		handleSwitchWithoutDefault(Switch, SwitchCaseCount, Result);
return;		return;
}		}
// Warns for degenerated 'switch' statements that neither define a case nor		// Warns for degenerated 'switch' statements that neither define a case nor
// a default label.		// a default label.
// FIXME: Evaluate, if emitting a fix-it to simplify that statement is		// FIXME: Evaluate, if emitting a fix-it to simplify that statement is
// reasonable.		// reasonable.
if (!SwitchHasDefault && SwitchCaseCount == 0) {		if (!SwitchHasDefault && SwitchCaseCount == 0) {
diag(Switch->getBeginLoc(),		diag(Switch->getBeginLoc(),
"switch statement without labels has no effect");		"switch statement without labels has no effect");
return;		return;
}		}
llvm_unreachable("matched a case, that was not explicitly handled");		llvm_unreachable("matched a case, that was not explicitly handled");
}		}
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/hicpp/SignedBitwiseCheck.cpp

	Show All 25 Lines
	void SignedBitwiseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {			void SignedBitwiseCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
	Options.store(Opts, "IgnorePositiveIntegerLiterals",			Options.store(Opts, "IgnorePositiveIntegerLiterals",
	IgnorePositiveIntegerLiterals);			IgnorePositiveIntegerLiterals);
	}			}

	void SignedBitwiseCheck::registerMatchers(MatchFinder *Finder) {			void SignedBitwiseCheck::registerMatchers(MatchFinder *Finder) {
	const auto SignedIntegerOperand =			const auto SignedIntegerOperand =
	(IgnorePositiveIntegerLiterals			(IgnorePositiveIntegerLiterals
	? expr(ignoringImpCasts(hasType(isSignedInteger())),			? expr(hasType(isSignedInteger()), unless(integerLiteral()))
	unless(integerLiteral()))			: expr(hasType(isSignedInteger())))
	: expr(ignoringImpCasts(hasType(isSignedInteger()))))
	.bind("signed-operand");			.bind("signed-operand");

	// The standard [bitmask.types] allows some integral types to be implemented			// The standard [bitmask.types] allows some integral types to be implemented
	// as signed types. Exclude these types from diagnosing for bitwise or(\|) and			// as signed types. Exclude these types from diagnosing for bitwise or(\|) and
	// bitwise and(&). Shifting and complementing such values is still not			// bitwise and(&). Shifting and complementing such values is still not
	// allowed.			// allowed.
	const auto BitmaskType = namedDecl(			const auto BitmaskType = namedDecl(
	hasAnyName("::std::locale::category", "::std::ctype_base::mask",			hasAnyName("::std::locale::category", "::std::ctype_base::mask",
	"::std::ios_base::fmtflags", "::std::ios_base::iostate",			"::std::ios_base::fmtflags", "::std::ios_base::iostate",
	"::std::ios_base::openmode"));			"::std::ios_base::openmode"));
	const auto IsStdBitmask = ignoringImpCasts(declRefExpr(hasType(BitmaskType)));			const auto IsStdBitmask = declRefExpr(hasType(BitmaskType));

	// Match binary bitwise operations on signed integer arguments.			// Match binary bitwise operations on signed integer arguments.
	Finder->addMatcher(			Finder->addMatcher(
	binaryOperator(hasAnyOperatorName("^", "\|", "&", "^=", "\|=", "&="),			binaryOperator(hasAnyOperatorName("^", "\|", "&", "^=", "\|=", "&="),

	unless(allOf(hasLHS(IsStdBitmask), hasRHS(IsStdBitmask))),			unless(allOf(hasLHS(IsStdBitmask), hasRHS(IsStdBitmask))),

	hasEitherOperand(SignedIntegerOperand),			hasEitherOperand(SignedIntegerOperand),
	▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp

	Show All 21 Lines
	namespace clang {			namespace clang {
	namespace tidy {			namespace tidy {
	namespace misc {			namespace misc {

	StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context)			StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context)
	: ClangTidyCheck(Name, Context) {}			: ClangTidyCheck(Name, Context) {}

	void StaticAssertCheck::registerMatchers(MatchFinder *Finder) {			void StaticAssertCheck::registerMatchers(MatchFinder *Finder) {
	auto NegatedString = unaryOperator(			auto NegatedString =
	hasOperatorName("!"), hasUnaryOperand(ignoringImpCasts(stringLiteral())));			unaryOperator(hasOperatorName("!"), hasUnaryOperand(stringLiteral()));
	auto IsAlwaysFalse =			auto IsAlwaysFalse =
	expr(anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)),			expr(anyOf(cxxBoolLiteral(equals(false)), integerLiteral(equals(0)),
	cxxNullPtrLiteralExpr(), gnuNullExpr(), NegatedString))			cxxNullPtrLiteralExpr(), gnuNullExpr(), NegatedString))
	.bind("isAlwaysFalse");			.bind("isAlwaysFalse");
	auto IsAlwaysFalseWithCast = ignoringParenImpCasts(anyOf(			auto IsAlwaysFalseWithCast =
	IsAlwaysFalse, cStyleCastExpr(has(ignoringParenImpCasts(IsAlwaysFalse)))			anyOf(IsAlwaysFalse, cStyleCastExpr(has(IsAlwaysFalse)).bind("castExpr"));
	.bind("castExpr")));			auto AssertExprRoot =
	auto AssertExprRoot = anyOf(			anyOf(binaryOperator(
	binaryOperator(
	hasAnyOperatorName("&&", "=="),			hasAnyOperatorName("&&", "=="),
	hasEitherOperand(ignoringImpCasts(stringLiteral().bind("assertMSG"))),			hasEitherOperand(stringLiteral().bind("assertMSG")),
	anyOf(binaryOperator(hasEitherOperand(IsAlwaysFalseWithCast)),			anyOf(binaryOperator(hasEitherOperand(IsAlwaysFalseWithCast)),
	anything()))			anything()))
	.bind("assertExprRoot"),			.bind("assertExprRoot"),
	IsAlwaysFalse);			IsAlwaysFalse);
	auto NonConstexprFunctionCall =			auto NonConstexprFunctionCall =
	callExpr(hasDeclaration(functionDecl(unless(isConstexpr()))));			callExpr(hasDeclaration(functionDecl(unless(isConstexpr()))));
	auto AssertCondition =			auto AssertCondition =
	expr(			expr(anyOf(anyOf(AssertExprRoot,
	anyOf(expr(ignoringParenCasts(anyOf(			unaryOperator(hasUnaryOperand(AssertExprRoot))),
	AssertExprRoot, unaryOperator(hasUnaryOperand(
	ignoringParenCasts(AssertExprRoot)))))),
	anything()),			anything()),
	unless(findAll(NonConstexprFunctionCall)))			unless(findAll(NonConstexprFunctionCall)))
	.bind("condition");			.bind("condition");
	auto Condition =			auto Condition =
	anyOf(ignoringParenImpCasts(callExpr(			anyOf(callExpr(hasDeclaration(functionDecl(hasName("__builtin_expect"))),
	hasDeclaration(functionDecl(hasName("__builtin_expect"))),			hasArgument(0, AssertCondition)),
	hasArgument(0, AssertCondition))),
	AssertCondition);			AssertCondition);

	Finder->addMatcher(conditionalOperator(hasCondition(Condition),			Finder->addMatcher(conditionalOperator(hasCondition(Condition),
	unless(isInTemplateInstantiation()))			unless(isInTemplateInstantiation()))
	.bind("condStmt"),			.bind("condStmt"),
	this);			this);

	Finder->addMatcher(			Finder->addMatcher(
	▲ Show 20 Lines • Show All 103 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines	Finder->addMatcher(
hasParameter(0, parmVarDecl(hasType(BadSelf))))		hasParameter(0, parmVarDecl(hasType(BadSelf))))
.bind("ArgumentType"),		.bind("ArgumentType"),
this);		this);

Finder->addMatcher(		Finder->addMatcher(
cxxMethodDecl(IsSelfAssign, anyOf(isConst(), isVirtual())).bind("cv"),		cxxMethodDecl(IsSelfAssign, anyOf(isConst(), isVirtual())).bind("cv"),
this);		this);

const auto IsBadReturnStatement = returnStmt(unless(has(ignoringParenImpCasts(		const auto IsBadReturnStatement = returnStmt(unless(has(stmt(anyOf(
anyOf(unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())),		unaryOperator(hasOperatorName("*"), hasUnaryOperand(cxxThisExpr())),
cxxOperatorCallExpr(argumentCountIs(1),		cxxOperatorCallExpr(argumentCountIs(1), callee(unresolvedLookupExpr()),
callee(unresolvedLookupExpr()),
hasArgument(0, cxxThisExpr())),		hasArgument(0, cxxThisExpr())),
cxxOperatorCallExpr(		cxxOperatorCallExpr(
hasOverloadedOperatorName("="),		hasOverloadedOperatorName("="),
hasArgument(		hasArgument(0, unaryOperator(hasOperatorName("*"),
0, unaryOperator(hasOperatorName("*"),
hasUnaryOperand(cxxThisExpr())))))))));		hasUnaryOperand(cxxThisExpr())))))))));
const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);		const auto IsGoodAssign = cxxMethodDecl(IsAssign, HasGoodReturnType);

Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))		Finder->addMatcher(returnStmt(IsBadReturnStatement, forFunction(IsGoodAssign))
.bind("returnStmt"),		.bind("returnStmt"),
this);		this);
}		}

void UnconventionalAssignOperatorCheck::check(		void UnconventionalAssignOperatorCheck::check(
Show All 25 Lines

clang-tools-extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

	Show All 18 Lines
	void UniqueptrResetReleaseCheck::registerMatchers(MatchFinder *Finder) {			void UniqueptrResetReleaseCheck::registerMatchers(MatchFinder *Finder) {
	Finder->addMatcher(			Finder->addMatcher(
	cxxMemberCallExpr(			cxxMemberCallExpr(
	on(expr().bind("left")), callee(memberExpr().bind("reset_member")),			on(expr().bind("left")), callee(memberExpr().bind("reset_member")),
	callee(			callee(
	cxxMethodDecl(hasName("reset"),			cxxMethodDecl(hasName("reset"),
	ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),			ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),
	decl().bind("left_class"))))),			decl().bind("left_class"))))),
	has(ignoringParenImpCasts(cxxMemberCallExpr(			has(cxxMemberCallExpr(
	on(expr().bind("right")),			on(expr().bind("right")),
	callee(memberExpr().bind("release_member")),			callee(memberExpr().bind("release_member")),
	callee(cxxMethodDecl(			callee(cxxMethodDecl(
	hasName("release"),			hasName("release"),
	ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),			ofClass(cxxRecordDecl(hasName("::std::unique_ptr"),
	decl().bind("right_class")))))))))			decl().bind("right_class"))))))))
	.bind("reset_call"),			.bind("reset_call"),
	this);			this);
	}			}

	namespace {			namespace {
	const Type *getDeleterForUniquePtr(const MatchFinder::MatchResult &Result,			const Type *getDeleterForUniquePtr(const MatchFinder::MatchResult &Result,
	StringRef ID) {			StringRef ID) {
	const auto *Class =			const auto *Class =
	▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

Show First 20 Lines • Show All 201 Lines • ▼ Show 20 Lines	auto InitBase =
hasUnaryOperand(integerLiteral())),		hasUnaryOperand(integerLiteral())),
floatLiteral(),		floatLiteral(),
unaryOperator(hasAnyOperatorName("+", "-"),		unaryOperator(hasAnyOperatorName("+", "-"),
hasUnaryOperand(floatLiteral())),		hasUnaryOperand(floatLiteral())),
cxxBoolLiteral(), cxxNullPtrLiteralExpr(), implicitValueInitExpr(),		cxxBoolLiteral(), cxxNullPtrLiteralExpr(), implicitValueInitExpr(),
declRefExpr(to(enumConstantDecl())));		declRefExpr(to(enumConstantDecl())));

auto Init =		auto Init =
anyOf(initListExpr(anyOf(		anyOf(initListExpr(anyOf(allOf(initCountIs(1), hasInit(0, InitBase)),
allOf(initCountIs(1), hasInit(0, ignoringImplicit(InitBase))),
initCountIs(0))),		initCountIs(0))),
InitBase);		InitBase);

Finder->addMatcher(		Finder->addMatcher(
cxxConstructorDecl(		cxxConstructorDecl(
isDefaultConstructor(), unless(isInstantiated()),		isDefaultConstructor(), unless(isInstantiated()),
forEachConstructorInitializer(		forEachConstructorInitializer(
cxxCtorInitializer(		cxxCtorInitializer(
forField(unless(anyOf(getLangOpts().CPlusPlus20		forField(unless(anyOf(getLangOpts().CPlusPlus20
? unless(anything())		? unless(anything())
: isBitField(),		: isBitField(),
hasInClassInitializer(anything()),		hasInClassInitializer(anything()),
hasParent(recordDecl(isUnion()))))),		hasParent(recordDecl(isUnion()))))),
isWritten(), withInitializer(ignoringImplicit(Init)))		isWritten(), withInitializer(Init))
.bind("default"))),		.bind("default"))),
this);		this);

Finder->addMatcher(		Finder->addMatcher(
cxxConstructorDecl(		cxxConstructorDecl(
unless(ast_matchers::isTemplateInstantiation()),		unless(ast_matchers::isTemplateInstantiation()),
forEachConstructorInitializer(		forEachConstructorInitializer(
cxxCtorInitializer(forField(hasInClassInitializer(anything())),		cxxCtorInitializer(forField(hasInClassInitializer(anything())),
isWritten(),		isWritten(), withInitializer(Init))
withInitializer(ignoringImplicit(Init)))
.bind("existing"))),		.bind("existing"))),
this);		this);
}		}

void UseDefaultMemberInitCheck::check(const MatchFinder::MatchResult &Result) {		void UseDefaultMemberInitCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Default =		if (const auto *Default =
Result.Nodes.getNodeAs<CXXCtorInitializer>("default"))		Result.Nodes.getNodeAs<CXXCtorInitializer>("default"))
checkDefaultInit(Result, Default);		checkDefaultInit(Result, Default);
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp

Show All 25 Lines	Finder->addMatcher(
this);		this);

// DeclRefExpr: warning, no fix-it.		// DeclRefExpr: warning, no fix-it.
Finder->addMatcher(		Finder->addMatcher(
declRefExpr(to(functionDecl(hasName(MatchText))), unless(callExpr()))		declRefExpr(to(functionDecl(hasName(MatchText))), unless(callExpr()))
.bind("decl_ref_expr"),		.bind("decl_ref_expr"),
this);		this);

auto DirectCallToUncaughtException = callee(expr(ignoringImpCasts(		auto DirectCallToUncaughtException =
declRefExpr(hasDeclaration(functionDecl(hasName(MatchText)))))));		callee(declRefExpr(hasDeclaration(functionDecl(hasName(MatchText)))));

// CallExpr: warning, fix-it.		// CallExpr: warning, fix-it.
Finder->addMatcher(callExpr(DirectCallToUncaughtException,		Finder->addMatcher(callExpr(DirectCallToUncaughtException,
unless(hasAncestor(initListExpr())))		unless(hasAncestor(initListExpr())))
.bind("call_expr"),		.bind("call_expr"),
this);		this);
// CallExpr in initialisation list: warning, fix-it with avoiding narrowing		// CallExpr in initialisation list: warning, fix-it with avoiding narrowing
// conversions.		// conversions.
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines	void FasterStringFindCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "StringLikeClasses",		Options.store(Opts, "StringLikeClasses",
utils::options::serializeStringList(StringLikeClasses));		utils::options::serializeStringList(StringLikeClasses));
}		}

void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {		void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)		if (!getLangOpts().CPlusPlus)
return;		return;

const auto SingleChar =		const auto SingleChar = stringLiteral(hasSize(1)).bind("literal");
expr(ignoringParenCasts(stringLiteral(hasSize(1)).bind("literal")));
const auto StringFindFunctions =		const auto StringFindFunctions =
hasAnyName("find", "rfind", "find_first_of", "find_first_not_of",		hasAnyName("find", "rfind", "find_first_of", "find_first_not_of",
"find_last_of", "find_last_not_of");		"find_last_of", "find_last_not_of");

Finder->addMatcher(		Finder->addMatcher(
cxxMemberCallExpr(		cxxMemberCallExpr(
callee(functionDecl(StringFindFunctions).bind("func")),		callee(functionDecl(StringFindFunctions).bind("func")),
anyOf(argumentCountIs(1), argumentCountIs(2)),		anyOf(argumentCountIs(1), argumentCountIs(2)),
Show All 30 Lines

clang-tools-extra/clang-tidy/performance/InefficientStringConcatenationCheck.cpp

Show All 26 Lines	: ClangTidyCheck(Name, Context),
StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}		StrictMode(Options.getLocalOrGlobal("StrictMode", false)) {}

void InefficientStringConcatenationCheck::registerMatchers(		void InefficientStringConcatenationCheck::registerMatchers(
MatchFinder *Finder) {		MatchFinder *Finder) {
const auto BasicStringType =		const auto BasicStringType =
hasType(qualType(hasUnqualifiedDesugaredType(recordType(		hasType(qualType(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasName("::std::basic_string")))))));		hasDeclaration(cxxRecordDecl(hasName("::std::basic_string")))))));

const auto BasicStringPlusOperator = cxxOperatorCallExpr(		const auto BasicStringPlusOperator =
hasOverloadedOperatorName("+"),		cxxOperatorCallExpr(hasOverloadedOperatorName("+"),
hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))));		hasAnyArgument(declRefExpr(BasicStringType)));

const auto PlusOperator =		const auto PlusOperator =
cxxOperatorCallExpr(		cxxOperatorCallExpr(hasOverloadedOperatorName("+"),
hasOverloadedOperatorName("+"),		hasAnyArgument(declRefExpr(BasicStringType)),
hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))),
hasDescendant(BasicStringPlusOperator))		hasDescendant(BasicStringPlusOperator))
.bind("plusOperator");		.bind("plusOperator");

const auto AssignOperator = cxxOperatorCallExpr(		const auto AssignOperator = cxxOperatorCallExpr(
hasOverloadedOperatorName("="),		hasOverloadedOperatorName("="),
hasArgument(0, declRefExpr(BasicStringType,		hasArgument(0, declRefExpr(BasicStringType,
hasDeclaration(decl().bind("lhsStrT")))		hasDeclaration(decl().bind("lhsStrT")))
.bind("lhsStr")),		.bind("lhsStr")),
hasArgument(1, stmt(hasDescendant(declRefExpr(		hasArgument(1, hasDescendant(declRefExpr(
hasDeclaration(decl(equalsBoundNode("lhsStrT"))))))),		hasDeclaration(decl(equalsBoundNode("lhsStrT")))))),
hasDescendant(BasicStringPlusOperator));		hasDescendant(BasicStringPlusOperator));

if (StrictMode) {		if (StrictMode) {
Finder->addMatcher(cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator)),		Finder->addMatcher(cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator)),
this);		this);
} else {		} else {
Finder->addMatcher(		Finder->addMatcher(
cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator),		cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator),
Show All 24 Lines

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines	const auto TargetVarDefStmt =
declStmt(hasSingleDecl(equalsBoundNode(std::string(VarDeclName))))		declStmt(hasSingleDecl(equalsBoundNode(std::string(VarDeclName))))
.bind(VarDeclStmtName);		.bind(VarDeclStmtName);

const auto AppendCallExpr =		const auto AppendCallExpr =
cxxMemberCallExpr(		cxxMemberCallExpr(
callee(AppendMethodDecl), on(hasType(TargetRecordDecl)),		callee(AppendMethodDecl), on(hasType(TargetRecordDecl)),
onImplicitObjectArgument(declRefExpr(to(TargetVarDecl))))		onImplicitObjectArgument(declRefExpr(to(TargetVarDecl))))
.bind(AppendCallName);		.bind(AppendCallName);
const auto AppendCall = expr(ignoringImplicit(AppendCallExpr));		const auto AppendCall = AppendCallExpr;
const auto LoopVarInit =		const auto LoopVarInit =
declStmt(hasSingleDecl(varDecl(hasInitializer(integerLiteral(equals(0))))		declStmt(hasSingleDecl(varDecl(hasInitializer(integerLiteral(equals(0))))
.bind(LoopInitVarName)));		.bind(LoopInitVarName)));
const auto RefersToLoopVar = ignoringParenImpCasts(		const auto RefersToLoopVar =
declRefExpr(to(varDecl(equalsBoundNode(LoopInitVarName)))));		declRefExpr(to(varDecl(equalsBoundNode(LoopInitVarName))));

// Matchers for the loop whose body has only 1 push_back/emplace_back calling		// Matchers for the loop whose body has only 1 push_back/emplace_back calling
// statement.		// statement.
const auto HasInterestingLoopBody = hasBody(		const auto HasInterestingLoopBody = hasBody(
anyOf(compoundStmt(statementCountIs(1), has(AppendCall)), AppendCall));		anyOf(compoundStmt(statementCountIs(1), has(AppendCall)), AppendCall));
const auto InInterestingCompoundStmt =		const auto InInterestingCompoundStmt =
hasParent(compoundStmt(has(TargetVarDefStmt)).bind(LoopParentName));		hasParent(compoundStmt(has(TargetVarDefStmt)).bind(LoopParentName));

▲ Show 20 Lines • Show All 154 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines	Finder->addMatcher(
.bind("SizeCallExpr"),		.bind("SizeCallExpr"),
this);		this);

// Empty constructor matcher.		// Empty constructor matcher.
const auto DefaultConstructor = cxxConstructExpr(		const auto DefaultConstructor = cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(isDefaultConstructor())));		hasDeclaration(cxxConstructorDecl(isDefaultConstructor())));
// Comparison to empty string or empty constructor.		// Comparison to empty string or empty constructor.
const auto WrongComparend = anyOf(		const auto WrongComparend = anyOf(
ignoringImpCasts(stringLiteral(hasSize(0))),		stringLiteral(hasSize(0)), cxxBindTemporaryExpr(has(DefaultConstructor)),
ignoringImpCasts(cxxBindTemporaryExpr(has(DefaultConstructor))),		DefaultConstructor,
ignoringImplicit(DefaultConstructor),		cxxConstructExpr(hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
cxxConstructExpr(		has(DefaultConstructor)),
hasDeclaration(cxxConstructorDecl(isCopyConstructor())),		cxxConstructExpr(hasDeclaration(cxxConstructorDecl(isMoveConstructor())),
has(expr(ignoringImpCasts(DefaultConstructor)))),		has(DefaultConstructor)));
cxxConstructExpr(
hasDeclaration(cxxConstructorDecl(isMoveConstructor())),
has(expr(ignoringImpCasts(DefaultConstructor)))));
// Match the object being compared.		// Match the object being compared.
const auto STLArg =		const auto STLArg =
anyOf(unaryOperator(		anyOf(unaryOperator(
hasOperatorName("*"),		hasOperatorName("*"),
hasUnaryOperand(		hasUnaryOperand(
expr(hasType(pointsTo(ValidContainer))).bind("Pointee"))),		expr(hasType(pointsTo(ValidContainer))).bind("Pointee"))),
expr(hasType(ValidContainer)).bind("STLObject"));		expr(hasType(ValidContainer)).bind("STLObject"));
Finder->addMatcher(		Finder->addMatcher(
▲ Show 20 Lines • Show All 140 Lines • Show Last 20 Lines

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

	Show First 20 Lines • Show All 140 Lines • ▼ Show 20 Lines

	void ElseAfterReturnCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {			void ElseAfterReturnCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
	Options.store(Opts, WarnOnUnfixableStr, WarnOnUnfixable);			Options.store(Opts, WarnOnUnfixableStr, WarnOnUnfixable);
	}			}

	void ElseAfterReturnCheck::registerMatchers(MatchFinder *Finder) {			void ElseAfterReturnCheck::registerMatchers(MatchFinder *Finder) {
	const auto InterruptsControlFlow =			const auto InterruptsControlFlow =
	stmt(anyOf(returnStmt().bind(ReturnStr), continueStmt().bind(ContinueStr),			stmt(anyOf(returnStmt().bind(ReturnStr), continueStmt().bind(ContinueStr),
	breakStmt().bind(BreakStr),			breakStmt().bind(BreakStr), cxxThrowExpr().bind(ThrowStr)));
	expr(ignoringImplicit(cxxThrowExpr().bind(ThrowStr)))));
	Finder->addMatcher(			Finder->addMatcher(
	compoundStmt(			compoundStmt(
	forEach(ifStmt(unless(isConstexpr()),			forEach(ifStmt(unless(isConstexpr()),
	hasThen(stmt(			hasThen(stmt(
	anyOf(InterruptsControlFlow,			anyOf(InterruptsControlFlow,
	compoundStmt(has(InterruptsControlFlow))))),			compoundStmt(has(InterruptsControlFlow))))),
	hasElse(stmt().bind("else")))			hasElse(stmt().bind("else")))
	.bind("if")))			.bind("if")))
	▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	const auto QuacksLikeASmartptr = recordDecl(
returns(qualType(pointsTo(type().bind("op->Type")))))),		returns(qualType(pointsTo(type().bind("op->Type")))))),
has(cxxMethodDecl(hasName("operator*"), returns(qualType(references(		has(cxxMethodDecl(hasName("operator*"), returns(qualType(references(
type().bind("op*Type")))))));		type().bind("op*Type")))))));

// Make sure we are not missing the known standard types.		// Make sure we are not missing the known standard types.
const auto Smartptr = anyOf(knownSmartptr(), QuacksLikeASmartptr);		const auto Smartptr = anyOf(knownSmartptr(), QuacksLikeASmartptr);

// Catch 'ptr.get()->Foo()'		// Catch 'ptr.get()->Foo()'
Finder->addMatcher(		Finder->addMatcher(memberExpr(expr().bind("memberExpr"), isArrow(),
memberExpr(expr().bind("memberExpr"), isArrow(),		hasObjectExpression(callToGet(Smartptr))),
hasObjectExpression(ignoringImpCasts(callToGet(Smartptr)))),
Callback);		Callback);

// Catch 'ptr.get()' or 'ptr->get()'		// Catch 'ptr.get()' or 'ptr->get()'
Finder->addMatcher(		Finder->addMatcher(
unaryOperator(hasOperatorName("*"), hasUnaryOperand(callToGet(Smartptr))),		unaryOperator(hasOperatorName("*"), hasUnaryOperand(callToGet(Smartptr))),
Callback);		Callback);

// Catch '!ptr.get()'		// Catch '!ptr.get()'
const auto CallToGetAsBool = ignoringParenImpCasts(callToGet(		const auto CallToGetAsBool = callToGet(
recordDecl(Smartptr, has(cxxConversionDecl(returns(booleanType()))))));		recordDecl(Smartptr, has(cxxConversionDecl(returns(booleanType())))));
Finder->addMatcher(		Finder->addMatcher(
unaryOperator(hasOperatorName("!"), hasUnaryOperand(CallToGetAsBool)),		unaryOperator(hasOperatorName("!"), hasUnaryOperand(CallToGetAsBool)),
Callback);		Callback);

// Catch 'if(ptr.get())'		// Catch 'if(ptr.get())'
Finder->addMatcher(ifStmt(hasCondition(CallToGetAsBool)), Callback);		Finder->addMatcher(ifStmt(hasCondition(CallToGetAsBool)), Callback);

// Catch 'ptr.get() ? X : Y'		// Catch 'ptr.get() ? X : Y'
Finder->addMatcher(conditionalOperator(hasCondition(CallToGetAsBool)),		Finder->addMatcher(conditionalOperator(hasCondition(CallToGetAsBool)),
Callback);		Callback);
}		}

void registerMatchersForGetEquals(MatchFinder *Finder,		void registerMatchersForGetEquals(MatchFinder *Finder,
MatchFinder::MatchCallback *Callback) {		MatchFinder::MatchCallback *Callback) {
// This one is harder to do with duck typing.		// This one is harder to do with duck typing.
// The operator==/!= that we are looking for might be member or non-member,		// The operator==/!= that we are looking for might be member or non-member,
// might be on global namespace or found by ADL, might be a template, etc.		// might be on global namespace or found by ADL, might be a template, etc.
// For now, lets keep it to the known standard types.		// For now, lets keep it to the known standard types.

// Matches against nullptr.		// Matches against nullptr.
Finder->addMatcher(		Finder->addMatcher(
binaryOperator(hasAnyOperatorName("==", "!="),		binaryOperator(hasAnyOperatorName("==", "!="),
hasOperands(ignoringImpCasts(anyOf(		hasOperands(anyOf(cxxNullPtrLiteralExpr(), gnuNullExpr(),
cxxNullPtrLiteralExpr(), gnuNullExpr(),		integerLiteral(equals(0))),
integerLiteral(equals(0)))),
callToGet(knownSmartptr()))),		callToGet(knownSmartptr()))),
Callback);		Callback);

// FIXME: Match and fix if (l.get() == r.get()).		// FIXME: Match and fix if (l.get() == r.get()).
}		}

} // namespace		} // namespace

▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

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

	Show First 20 Lines • Show All 483 Lines • ▼ Show 20 Lines

	void SimplifyBooleanExprCheck::matchCompoundIfReturnsBool(MatchFinder *Finder,			void SimplifyBooleanExprCheck::matchCompoundIfReturnsBool(MatchFinder *Finder,
	bool Value,			bool Value,
	StringRef Id) {			StringRef Id) {
	Finder->addMatcher(			Finder->addMatcher(
	compoundStmt(			compoundStmt(
	hasAnySubstatement(			hasAnySubstatement(
	ifStmt(hasThen(returnsBool(Value)), unless(hasElse(stmt())))),			ifStmt(hasThen(returnsBool(Value)), unless(hasElse(stmt())))),
	hasAnySubstatement(returnStmt(has(ignoringParenImpCasts(			hasAnySubstatement(returnStmt(has(cxxBoolLiteral(equals(!Value))))
	cxxBoolLiteral(equals(!Value)))))
	.bind(CompoundReturnId)))			.bind(CompoundReturnId)))
	.bind(Id),			.bind(Id),
	this);			this);
	}			}

	void SimplifyBooleanExprCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {			void SimplifyBooleanExprCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
	Options.store(Opts, "ChainedConditionalReturn", ChainedConditionalReturn);			Options.store(Opts, "ChainedConditionalReturn", ChainedConditionalReturn);
	Options.store(Opts, "ChainedConditionalAssignment",			Options.store(Opts, "ChainedConditionalAssignment",
	▲ Show 20 Lines • Show All 170 Lines • Show Last 20 Lines

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

	Show All 26 Lines
	}			}

	void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {			void SimplifySubscriptExprCheck::registerMatchers(MatchFinder *Finder) {
	const auto TypesMatcher = hasUnqualifiedDesugaredType(			const auto TypesMatcher = hasUnqualifiedDesugaredType(
	recordType(hasDeclaration(cxxRecordDecl(hasAnyName(			recordType(hasDeclaration(cxxRecordDecl(hasAnyName(
	llvm::SmallVector<StringRef, 8>(Types.begin(), Types.end()))))));			llvm::SmallVector<StringRef, 8>(Types.begin(), Types.end()))))));

	Finder->addMatcher(			Finder->addMatcher(
	arraySubscriptExpr(hasBase(ignoringParenImpCasts(			arraySubscriptExpr(hasBase(
	cxxMemberCallExpr(			cxxMemberCallExpr(
	has(memberExpr().bind("member")),			has(memberExpr().bind("member")),
	on(hasType(qualType(			on(hasType(qualType(
	unless(anyOf(substTemplateTypeParmType(),			unless(anyOf(substTemplateTypeParmType(),
	hasDescendant(substTemplateTypeParmType()))),			hasDescendant(substTemplateTypeParmType()))),
	anyOf(TypesMatcher, pointerType(pointee(TypesMatcher)))))),			anyOf(TypesMatcher, pointerType(pointee(TypesMatcher)))))),
	callee(namedDecl(hasName("data"))))			callee(namedDecl(hasName("data"))))
	.bind("call")))),			.bind("call"))),
	this);			this);
	}			}

	void SimplifySubscriptExprCheck::check(const MatchFinder::MatchResult &Result) {			void SimplifySubscriptExprCheck::check(const MatchFinder::MatchResult &Result) {
	const auto *Call = Result.Nodes.getNodeAs<CXXMemberCallExpr>("call");			const auto *Call = Result.Nodes.getNodeAs<CXXMemberCallExpr>("call");
	if (Result.Context->getSourceManager().isMacroBodyExpansion(			if (Result.Context->getSourceManager().isMacroBodyExpansion(
	Call->getExprLoc()))			Call->getExprLoc()))
	return;			return;
	Show All 21 Lines

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

Show All 21 Lines	auto IsSusbstituted = qualType(anyOf(
substTemplateTypeParmType(), hasDescendant(substTemplateTypeParmType())));		substTemplateTypeParmType(), hasDescendant(substTemplateTypeParmType())));

auto UniquePtrWithDefaultDelete = classTemplateSpecializationDecl(		auto UniquePtrWithDefaultDelete = classTemplateSpecializationDecl(
hasName("std::unique_ptr"),		hasName("std::unique_ptr"),
hasTemplateArgument(1, refersToType(qualType(hasDeclaration(cxxRecordDecl(		hasTemplateArgument(1, refersToType(qualType(hasDeclaration(cxxRecordDecl(
hasName("std::default_delete")))))));		hasName("std::default_delete")))))));

Finder->addMatcher(		Finder->addMatcher(
cxxDeleteExpr(has(ignoringParenImpCasts(cxxMemberCallExpr(		cxxDeleteExpr(
on(expr(hasType(UniquePtrWithDefaultDelete),		has(cxxMemberCallExpr(on(expr(hasType(UniquePtrWithDefaultDelete),
unless(hasType(IsSusbstituted)))		unless(hasType(IsSusbstituted)))
.bind("uptr")),		.bind("uptr")),
callee(cxxMethodDecl(hasName("release")))))))		callee(cxxMethodDecl(hasName("release"))))))
.bind("delete"),		.bind("delete"),
this);		this);
}		}

void UniqueptrDeleteReleaseCheck::check(		void UniqueptrDeleteReleaseCheck::check(
const MatchFinder::MatchResult &Result) {		const MatchFinder::MatchResult &Result) {
const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr");		const auto *PtrExpr = Result.Nodes.getNodeAs<Expr>("uptr");
const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete");		const auto *DeleteExpr = Result.Nodes.getNodeAs<Expr>("delete");
Show All 26 Lines

This is an archive of the discontinued LLVM Phabricator instance.

Remove obsolete ignore*() matcher usesAcceptedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 265951

clang-tools-extra/clang-tidy/abseil/DurationAdditionCheck.cpp

clang-tools-extra/clang-tidy/abseil/DurationConversionCastCheck.cpp

clang-tools-extra/clang-tidy/abseil/DurationFactoryScaleCheck.cpp

clang-tools-extra/clang-tidy/abseil/DurationRewriter.cpp

clang-tools-extra/clang-tidy/abseil/DurationUnnecessaryConversionCheck.cpp

clang-tools-extra/clang-tidy/abseil/StringFindStartswithCheck.cpp

clang-tools-extra/clang-tidy/bugprone/MisplacedPointerArithmeticInAllocCheck.cpp

clang-tools-extra/clang-tidy/bugprone/MoveForwardingReferenceCheck.cpp

clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp

clang-tools-extra/clang-tidy/bugprone/SizeofContainerCheck.cpp

clang-tools-extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp

clang-tools-extra/clang-tidy/bugprone/StringConstructorCheck.cpp

clang-tools-extra/clang-tidy/bugprone/StringIntegerAssignmentCheck.cpp

clang-tools-extra/clang-tidy/bugprone/StringLiteralWithEmbeddedNulCheck.cpp

clang-tools-extra/clang-tidy/bugprone/SuspiciousEnumUsageCheck.cpp

clang-tools-extra/clang-tidy/bugprone/SuspiciousMissingCommaCheck.cpp

clang-tools-extra/clang-tidy/bugprone/TerminatingContinueCheck.cpp

clang-tools-extra/clang-tidy/bugprone/UnusedReturnValueCheck.cpp

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsConstantArrayIndexCheck.cpp

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp

clang-tools-extra/clang-tidy/google/ExplicitMakePairCheck.cpp

clang-tools-extra/clang-tidy/hicpp/MultiwayPathsCoveredCheck.cpp

clang-tools-extra/clang-tidy/hicpp/SignedBitwiseCheck.cpp

clang-tools-extra/clang-tidy/misc/StaticAssertCheck.cpp

clang-tools-extra/clang-tidy/misc/UnconventionalAssignOperatorCheck.cpp

clang-tools-extra/clang-tidy/misc/UniqueptrResetReleaseCheck.cpp

clang-tools-extra/clang-tidy/modernize/UseDefaultMemberInitCheck.cpp

clang-tools-extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.cpp

clang-tools-extra/clang-tidy/performance/InefficientStringConcatenationCheck.cpp

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp

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

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

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

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

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

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

Remove obsolete ignore*() matcher uses
AcceptedPublic