This is an archive of the discontinued LLVM Phabricator instance.

Differential D101721

[clang-tidy][NFC] Update tests and Default options to use boolean value
ClosedPublic

Authored by njames93 on May 2 2021, 5:25 AM.

Details

Reviewers
aaron.ballman
Commits
rGe1c729c56829: [clang-tidy][NFC] Update tests and Default options to use boolean value
Summary

Change instances where options which are boolean are assigned the value 1|0 to use true|false instead.

Diff Detail

Event Timeline

njames93 created this revision.May 2 2021, 5:25 AM
Herald added subscribers: kbarton, xazax.hun, nemanjai. · View Herald TranscriptMay 2 2021, 5:25 AM
njames93 requested review of this revision.May 2 2021, 5:25 AM
Herald added a project: Restricted Project. · View Herald TranscriptMay 2 2021, 5:25 AM
Herald added subscribers: cfe-commits, aheejin. · View Herald Transcript
Harbormaster completed remote builds in B102171: Diff 342235.May 2 2021, 6:14 AM
aaron.ballman accepted this revision.May 3 2021, 4:17 AM

LGTM! One thing I'd like to be sure of though -- do we still have at least one test that's showing you can use false/0 and true/1/nonzero interchangeably? If not, we should probably have one that shows which "alternate forms" are accepted.

This revision is now accepted and ready to land.May 3 2021, 4:17 AM
njames93 added a comment.May 3 2021, 4:48 AM
In D101721#2733125, @aaron.ballman wrote:

LGTM! One thing I'd like to be sure of though -- do we still have at least one test that's showing you can use false/0 and true/1/nonzero interchangeably? If not, we should probably have one that shows which "alternate forms" are accepted.

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp::CheckOptionsValidation::ValidIntOptions contains a test which supports 0 and 1.
However in a few years once we can be confident most users are using clang-tidy-11 or newer, it may be wise to drop support for 0 and 1 in order to be inline with yaml completely.

aaron.ballman added a comment.May 3 2021, 4:53 AM
In D101721#2733169, @njames93 wrote:
In D101721#2733125, @aaron.ballman wrote:

LGTM! One thing I'd like to be sure of though -- do we still have at least one test that's showing you can use false/0 and true/1/nonzero interchangeably? If not, we should probably have one that shows which "alternate forms" are accepted.

clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp::CheckOptionsValidation::ValidIntOptions contains a test which supports 0 and 1.

Awesome, thank you for verifying!

However in a few years once we can be confident most users are using clang-tidy-11 or newer, it may be wise to drop support for 0 and 1 in order to be inline with yaml completely.

I think if we want to go that route (which seems sensible to me), we should start warning on using anything but true/false as being deprecated. WDYT?

njames93 added a comment.May 3 2021, 5:40 AM
In D101721#2733173, @aaron.ballman wrote:
In D101721#2733169, @njames93 wrote:

However in a few years once we can be confident most users are using clang-tidy-11 or newer, it may be wise to drop support for 0 and 1 in order to be inline with yaml completely.

I think if we want to go that route (which seems sensible to me), we should start warning on using anything but true/false as being deprecated. WDYT?

That's sort of the plan, however we shouldn't make that change right away as there's no point in issuing warnings at this time. As configurations are checked in there is likely to be people still using 10 and previous, which don't support the new spelling. This means the config can't be updated and users with newer clang-tidy versions will get a warning they can't silence.

aaron.ballman added a comment.May 3 2021, 5:51 AM
In D101721#2733260, @njames93 wrote:
In D101721#2733173, @aaron.ballman wrote:
In D101721#2733169, @njames93 wrote:

However in a few years once we can be confident most users are using clang-tidy-11 or newer, it may be wise to drop support for 0 and 1 in order to be inline with yaml completely.

I think if we want to go that route (which seems sensible to me), we should start warning on using anything but true/false as being deprecated. WDYT?

That's sort of the plan, however we shouldn't make that change right away as there's no point in issuing warnings at this time. As configurations are checked in there is likely to be people still using 10 and previous, which don't support the new spelling. This means the config can't be updated and users with newer clang-tidy versions will get a warning they can't silence.

That makes sense to me. Should we file a bug to suggest adding the deprecation warning in Clang 14(?) and planned removal in Clang 16(?) so that we don't lose track of this? (I have no firm opinion about which versions we decide to start deprecating and remove so long as they're not disruptive.)

njames93 added a comment.May 3 2021, 10:58 AM
In D101721#2733279, @aaron.ballman wrote:

That makes sense to me. Should we file a bug to suggest adding the deprecation warning in Clang 14(?) and planned removal in Clang 16(?) so that we don't lose track of this? (I have no firm opinion about which versions we decide to start deprecating and remove so long as they're not disruptive.)

I was thinking later tbh. clang-tidy 11 is where the spelling support was adopted and, more importantly, emitting a warning when a present key could not be parsed. Giving 3 years from there puts a deprecation notice in Clang17 (Assuming we stick to the same semiannual release cycle).

Closed by commit rGe1c729c56829: [clang-tidy][NFC] Update tests and Default options to use boolean value (authored by njames93). · Explain WhyMay 4 2021, 10:18 AM
This revision was automatically updated to reflect the committed changes.
njames93 added a commit: rGe1c729c56829: [clang-tidy][NFC] Update tests and Default options to use boolean value.

Revision Contents

PathSize
clang-tools-extra/
clang-tidy/
cert/
4 lines
cppcoreguidelines/
4 lines
llvm/
6 lines
test/
clang-tidy/
checkers/
16 lines
14 lines
2 lines
2 lines
4 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
8 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
4 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
infrastructure/
Inputs/
config-files/
4/
2 lines
44/
4 lines
2 lines

Diff 342793

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

Show First 20 Lines • Show All 119 Lines • ▼ Show 20 Lines void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<bugprone::SignedCharMisuseCheck>( CheckFactories.registerCheck<bugprone::SignedCharMisuseCheck>(
"cert-str34-c"); "cert-str34-c");
} }
ClangTidyOptions getModuleOptions() override { ClangTidyOptions getModuleOptions() override {
ClangTidyOptions Options; ClangTidyOptions Options;
ClangTidyOptions::OptionMap &Opts = Options.CheckOptions; ClangTidyOptions::OptionMap &Opts = Options.CheckOptions;
Opts["cert-dcl16-c.NewSuffixes"] = "L;LL;LU;LLU"; Opts["cert-dcl16-c.NewSuffixes"] = "L;LL;LU;LLU";
Opts["cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField"] = "0"; Opts["cert-oop54-cpp.WarnOnlyIfThisHasSuspiciousField"] = "false";
Opts["cert-str34-c.DiagnoseSignedUnsignedCharComparisons"] = "0"; Opts["cert-str34-c.DiagnoseSignedUnsignedCharComparisons"] = "false";
return Options; return Options;
} }
}; };
} // namespace cert } // namespace cert
// Register the MiscTidyModule using this statically initialized variable. // Register the MiscTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<cert::CERTModule> static ClangTidyModuleRegistry::Add<cert::CERTModule>
Show All 9 Lines

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

Show First 20 Lines • Show All 95 Lines • ▼ Show 20 Lines CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
"cppcoreguidelines-c-copy-assignment-signature"); "cppcoreguidelines-c-copy-assignment-signature");
} }
ClangTidyOptions getModuleOptions() override { ClangTidyOptions getModuleOptions() override {
ClangTidyOptions Options; ClangTidyOptions Options;
ClangTidyOptions::OptionMap &Opts = Options.CheckOptions; ClangTidyOptions::OptionMap &Opts = Options.CheckOptions;
Opts["cppcoreguidelines-non-private-member-variables-in-classes." Opts["cppcoreguidelines-non-private-member-variables-in-classes."
"IgnoreClassesWithAllMemberVariablesBeingPublic"] = "1"; "IgnoreClassesWithAllMemberVariablesBeingPublic"] = "true";
Opts["cppcoreguidelines-explicit-virtual-functions." Opts["cppcoreguidelines-explicit-virtual-functions."
"IgnoreDestructors"] = "1"; "IgnoreDestructors"] = "true";
return Options; return Options;
} }
}; };
// Register the LLVMTidyModule using this statically initialized variable. // Register the LLVMTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<CppCoreGuidelinesModule> static ClangTidyModuleRegistry::Add<CppCoreGuidelinesModule>
X("cppcoreguidelines-module", "Adds checks for the C++ Core Guidelines."); X("cppcoreguidelines-module", "Adds checks for the C++ Core Guidelines.");
Show All 9 Lines

clang-tools-extra/clang-tidy/llvm/LLVMTidyModule.cpp

Show All 36 Lines CheckFactories.registerCheck<PreferRegisterOverUnsignedCheck>(
"llvm-prefer-register-over-unsigned"); "llvm-prefer-register-over-unsigned");
CheckFactories.registerCheck<readability::QualifiedAutoCheck>( CheckFactories.registerCheck<readability::QualifiedAutoCheck>(
"llvm-qualified-auto"); "llvm-qualified-auto");
CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local"); CheckFactories.registerCheck<TwineLocalCheck>("llvm-twine-local");
} }
ClangTidyOptions getModuleOptions() override { ClangTidyOptions getModuleOptions() override {
ClangTidyOptions Options; ClangTidyOptions Options;
Options.CheckOptions["llvm-qualified-auto.AddConstToQualified"] = "0"; Options.CheckOptions["llvm-qualified-auto.AddConstToQualified"] = "false";
Options.CheckOptions["llvm-else-after-return.WarnOnUnfixable"] = "0"; Options.CheckOptions["llvm-else-after-return.WarnOnUnfixable"] = "false";
Options.CheckOptions["llvm-else-after-return.WarnOnConditionVariables"] = Options.CheckOptions["llvm-else-after-return.WarnOnConditionVariables"] =
"0"; "false";
return Options; return Options;
} }
}; };
// Register the LLVMTidyModule using this statically initialized variable. // Register the LLVMTidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module", static ClangTidyModuleRegistry::Add<LLVMModule> X("llvm-module",
"Adds LLVM lint checks."); "Adds LLVM lint checks.");
} // namespace llvm_check } // namespace llvm_check
// This anchor is used to force the linker to link in the generated object file // This anchor is used to force the linker to link in the generated object file
// and thus register the LLVMModule. // and thus register the LLVMModule.
volatile int LLVMModuleAnchorSource = 0; volatile int LLVMModuleAnchorSource = 0;
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tools-extra/test/clang-tidy/checkers/bugprone-argument-comment-ignore-single-argument.cpp

// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \ // RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: [ \
// RUN: {key: bugprone-argument-comment.IgnoreSingleArgument, value: 1}, \ // RUN: {key: bugprone-argument-comment.IgnoreSingleArgument, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentBoolLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentBoolLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentIntegerLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentIntegerLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentFloatLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentFloatLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentUserDefinedLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentUserDefinedLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentStringLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentStringLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentNullPtrs, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentNullPtrs, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentCharacterLiterals, value: 1}]}" -- // RUN: {key: bugprone-argument-comment.CommentCharacterLiterals, value: true}]}" --
struct A { struct A {
void foo(bool abc); void foo(bool abc);
void foo(bool abc, bool cde); void foo(bool abc, bool cde);
void foo(const char *, bool abc); void foo(const char *, bool abc);
void foo(int iabc); void foo(int iabc);
void foo(float fabc); void foo(float fabc);
void foo(double dabc); void foo(double dabc);
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-argument-comment-literals.cpp

// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \ // RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: [ \
// RUN: {key: bugprone-argument-comment.CommentBoolLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentBoolLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentIntegerLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentIntegerLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentFloatLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentFloatLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentUserDefinedLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentUserDefinedLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentStringLiterals, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentStringLiterals, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentNullPtrs, value: 1}, \ // RUN: {key: bugprone-argument-comment.CommentNullPtrs, value: true}, \
// RUN: {key: bugprone-argument-comment.CommentCharacterLiterals, value: 1}]}" -- // RUN: {key: bugprone-argument-comment.CommentCharacterLiterals, value: true}]}" --
struct A { struct A {
void foo(bool abc); void foo(bool abc);
void foo(bool abc, bool cde); void foo(bool abc, bool cde);
void foo(const char *, bool abc); void foo(const char *, bool abc);
void foo(int iabc); void foo(int iabc);
void foo(float fabc); void foo(float fabc);
void foo(double dabc); void foo(double dabc);
▲ Show 20 Lines • Show All 168 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-argument-comment-strict.cpp

// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \ // RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \
// RUN: -config="{CheckOptions: [{key: StrictMode, value: 1}]}" -- // RUN: -config="{CheckOptions: [{key: StrictMode, value: true}]}" --
void f(int _with_underscores_); void f(int _with_underscores_);
void g(int x_); void g(int x_);
void ignores_underscores() { void ignores_underscores() {
f(/*With_Underscores=*/0); f(/*With_Underscores=*/0);
// CHECK-NOTES: [[@LINE-1]]:5: warning: argument name 'With_Underscores' in comment does not match parameter name '_with_underscores_' // CHECK-NOTES: [[@LINE-1]]:5: warning: argument name 'With_Underscores' in comment does not match parameter name '_with_underscores_'
// CHECK-NOTES: [[@LINE-5]]:12: note: '_with_underscores_' declared here // CHECK-NOTES: [[@LINE-5]]:12: note: '_with_underscores_' declared here
// CHECK-FIXES: f(/*_with_underscores_=*/0); // CHECK-FIXES: f(/*_with_underscores_=*/0);
Show All 14 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-assert-side-effect.cpp

// RUN: %check_clang_tidy %s bugprone-assert-side-effect %t -- -config="{CheckOptions: [{key: bugprone-assert-side-effect.CheckFunctionCalls, value: 1}, {key: bugprone-assert-side-effect.AssertMacros, value: 'assert,assert2,my_assert,convoluted_assert,msvc_assert'}]}" -- -fexceptions // RUN: %check_clang_tidy %s bugprone-assert-side-effect %t -- -config="{CheckOptions: [{key: bugprone-assert-side-effect.CheckFunctionCalls, value: true}, {key: bugprone-assert-side-effect.AssertMacros, value: 'assert,assert2,my_assert,convoluted_assert,msvc_assert'}]}" -- -fexceptions
//===--- assert definition block ------------------------------------------===// //===--- assert definition block ------------------------------------------===//
int abort() { return 0; } int abort() { return 0; }
#ifdef NDEBUG #ifdef NDEBUG
#define assert(x) 1 #define assert(x) 1
#else #else
#define assert(x) \ #define assert(x) \
▲ Show 20 Lines • Show All 105 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-implicit-widening-of-multiplication-result-array-subscript-expression.cpp

// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++ // RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++
// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: 0} \ // RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c // RUN: ]}' -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: 0} \ // RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c++ // RUN: ]}' -- -target x86_64-unknown-unknown -x c++
char *t0(char *base, int a, int b) { char *t0(char *base, int a, int b) {
return &base[a * b]; return &base[a * b];
// CHECK-NOTES-ALL: :[[@LINE-1]]:11: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t' // CHECK-NOTES-ALL: :[[@LINE-1]]:11: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t'
// CHECK-NOTES-ALL: :[[@LINE-2]]:16: note: make conversion explicit to silence this warning // CHECK-NOTES-ALL: :[[@LINE-2]]:16: note: make conversion explicit to silence this warning
// CHECK-NOTES-C: (ptrdiff_t)( ) // CHECK-NOTES-C: (ptrdiff_t)( )
// CHECK-NOTES-CXX: static_cast<ptrdiff_t>( ) // CHECK-NOTES-CXX: static_cast<ptrdiff_t>( )
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-implicit-widening-of-multiplication-result-int.cpp

// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++ // RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++
// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: 0} \ // RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c // RUN: ]}' -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: 0} \ // RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c++ // RUN: ]}' -- -target x86_64-unknown-unknown -x c++
long t0(int a, int b) { long t0(int a, int b) {
return a * b; return a * b;
// CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: performing an implicit widening conversion to type 'long' of a multiplication performed in type 'int' // CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: performing an implicit widening conversion to type 'long' of a multiplication performed in type 'int'
// CHECK-NOTES-ALL: :[[@LINE-2]]:10: note: make conversion explicit to silence this warning // CHECK-NOTES-ALL: :[[@LINE-2]]:10: note: make conversion explicit to silence this warning
// CHECK-NOTES-C: (long)( ) // CHECK-NOTES-C: (long)( )
// CHECK-NOTES-CXX: static_cast<long>( ) // CHECK-NOTES-CXX: static_cast<long>( )
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-implicit-widening-of-multiplication-result-pointer-offset.cpp

// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++ // RUN: %check_clang_tidy -check-suffixes=ALL,CXX %s bugprone-implicit-widening-of-multiplication-result %t -- -- -target x86_64-unknown-unknown -x c++
// RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C -std=c99 %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: 0} \ // RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c // RUN: ]}' -- -target x86_64-unknown-unknown -x c
// RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \ // RUN: %check_clang_tidy -check-suffixes=ALL,C %s bugprone-implicit-widening-of-multiplication-result %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: 0} \ // RUN: {key: bugprone-implicit-widening-of-multiplication-result.UseCXXStaticCastsInCppSources, value: false} \
// RUN: ]}' -- -target x86_64-unknown-unknown -x c++ // RUN: ]}' -- -target x86_64-unknown-unknown -x c++
char *t0(char *base, int a, int b) { char *t0(char *base, int a, int b) {
return base + a * b; return base + a * b;
// CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t' // CHECK-NOTES-ALL: :[[@LINE-1]]:10: warning: result of multiplication in type 'int' is used as a pointer offset after an implicit widening conversion to type 'ptrdiff_t'
// CHECK-NOTES-ALL: :[[@LINE-2]]:17: note: make conversion explicit to silence this warning // CHECK-NOTES-ALL: :[[@LINE-2]]:17: note: make conversion explicit to silence this warning
// CHECK-NOTES-C: (ptrdiff_t)( ) // CHECK-NOTES-C: (ptrdiff_t)( )
// CHECK-NOTES-CXX: static_cast<ptrdiff_t>( ) // CHECK-NOTES-CXX: static_cast<ptrdiff_t>( )
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-misplaced-widening-cast-explicit-only.cpp

// RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: [{key: bugprone-misplaced-widening-cast.CheckImplicitCasts, value: 0}]}" -- // RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: [{key: bugprone-misplaced-widening-cast.CheckImplicitCasts, value: false}]}" --
void func(long arg) {} void func(long arg) {}
void assign(int a, int b) { void assign(int a, int b) {
long l; long l;
l = a * b; l = a * b;
l = (long)(a * b); l = (long)(a * b);
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-misplaced-widening-cast-implicit-enabled.cpp

// RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: [{key: bugprone-misplaced-widening-cast.CheckImplicitCasts, value: 1}]}" -- // RUN: %check_clang_tidy %s bugprone-misplaced-widening-cast %t -- -config="{CheckOptions: [{key: bugprone-misplaced-widening-cast.CheckImplicitCasts, value: true}]}" --
void func(long arg) {} void func(long arg) {}
void assign(int a, int b) { void assign(int a, int b) {
long l; long l;
l = a * b; l = a * b;
// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: either cast from 'int' to 'long' is ineffective, or there is loss of precision before the conversion [bugprone-misplaced-widening-cast] // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: either cast from 'int' to 'long' is ineffective, or there is loss of precision before the conversion [bugprone-misplaced-widening-cast]
▲ Show 20 Lines • Show All 92 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-not-null-terminated-result-memcpy-before-safe.c

// RUN: %check_clang_tidy %s bugprone-not-null-terminated-result %t -- \ // RUN: %check_clang_tidy %s bugprone-not-null-terminated-result %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: bugprone-not-null-terminated-result.WantToUseSafeFunctions, \ // RUN: [{key: bugprone-not-null-terminated-result.WantToUseSafeFunctions, \
// RUN: value: 1}]}" \ // RUN: value: true}]}" \
// RUN: -- -std=c11 -I %S/Inputs/bugprone-not-null-terminated-result // RUN: -- -std=c11 -I %S/Inputs/bugprone-not-null-terminated-result
#include "not-null-terminated-result-c.h" #include "not-null-terminated-result-c.h"
// The following is not defined therefore the safe functions are unavailable. // The following is not defined therefore the safe functions are unavailable.
// #define __STDC_LIB_EXT1__ 1 // #define __STDC_LIB_EXT1__ 1
#define __STDC_WANT_LIB_EXT1__ 1 #define __STDC_WANT_LIB_EXT1__ 1
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-reserved-identifier-invert.cpp

// RUN: %check_clang_tidy %s bugprone-reserved-identifier %t -- \ // RUN: %check_clang_tidy %s bugprone-reserved-identifier %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: bugprone-reserved-identifier.Invert, value: 1}, \ // RUN: {key: bugprone-reserved-identifier.Invert, value: true}, \
// RUN: {key: bugprone-reserved-identifier.AllowedIdentifiers, value: std;reference_wrapper;ref;cref;type;get}, \ // RUN: {key: bugprone-reserved-identifier.AllowedIdentifiers, value: std;reference_wrapper;ref;cref;type;get}, \
// RUN: ]}' -- \ // RUN: ]}' -- \
// RUN: -I%S/Inputs/bugprone-reserved-identifier \ // RUN: -I%S/Inputs/bugprone-reserved-identifier \
// RUN: -isystem %S/Inputs/bugprone-reserved-identifier/system // RUN: -isystem %S/Inputs/bugprone-reserved-identifier/system
namespace std { namespace std {
void __f() {} void __f() {}
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-sizeof-expression.cpp

// RUN: %check_clang_tidy %s bugprone-sizeof-expression %t -- -config="{CheckOptions: [{key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression, value: 1}]}" -- // RUN: %check_clang_tidy %s bugprone-sizeof-expression %t -- -config="{CheckOptions: [{key: bugprone-sizeof-expression.WarnOnSizeOfIntegerExpression, value: true}]}" --
class C { class C {
int size() { return sizeof(this); } int size() { return sizeof(this); }
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(this)' // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: suspicious usage of 'sizeof(this)'
}; };
#define LEN 8 #define LEN 8
▲ Show 20 Lines • Show All 311 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-suspicious-enum-usage-strict.cpp

// RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: [{key: bugprone-suspicious-enum-usage.StrictMode, value: 1}]}" -- // RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: [{key: bugprone-suspicious-enum-usage.StrictMode, value: true}]}" --
enum A { enum A {
A = 1, A = 1,
B = 2, B = 2,
C = 4, C = 4,
D = 8, D = 8,
E = 16, E = 16,
F = 32, F = 32,
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-suspicious-enum-usage.cpp

// RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: [{key: bugprone-suspicious-enum-usage.StrictMode, value: 0}]}" -- // RUN: %check_clang_tidy %s bugprone-suspicious-enum-usage %t -- -config="{CheckOptions: [{key: bugprone-suspicious-enum-usage.StrictMode, value: false}]}" --
enum Empty { enum Empty {
}; };
enum A { enum A {
A = 1, A = 1,
B = 2, B = 2,
C = 4, C = 4,
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-suspicious-string-compare.c

// RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \ // RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: 1}, \ // RUN: [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: true}, \
// RUN: {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: 1}]}' \ // RUN: {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: true}]}' \
// RUN: -- -std=c99 // RUN: -- -std=c99
static const char A[] = "abc"; static const char A[] = "abc";
int strcmp(const char *, const char *); int strcmp(const char *, const char *);
int test_warning_patterns() { int test_warning_patterns() {
if (strcmp(A, "a")) if (strcmp(A, "a"))
▲ Show 20 Lines • Show All 67 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-suspicious-string-compare.cpp

// RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \ // RUN: %check_clang_tidy %s bugprone-suspicious-string-compare %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: 1}, \ // RUN: [{key: bugprone-suspicious-string-compare.WarnOnImplicitComparison, value: true}, \
// RUN: {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: 1}]}' \ // RUN: {key: bugprone-suspicious-string-compare.WarnOnLogicalNotComparison, value: true}]}' \
// RUN: -- // RUN: --
typedef __SIZE_TYPE__ size; typedef __SIZE_TYPE__ size;
struct locale_t { struct locale_t {
void* dummy; void* dummy;
} locale; } locale;
▲ Show 20 Lines • Show All 325 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/bugprone-unhandled-self-assignment-warn-only-if-this-has-suspicious-field.cpp

// RUN: %check_clang_tidy %s bugprone-unhandled-self-assignment %t -- \ // RUN: %check_clang_tidy %s bugprone-unhandled-self-assignment %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField, \ // RUN: [{key: bugprone-unhandled-self-assignment.WarnOnlyIfThisHasSuspiciousField, \
// RUN: value: 0}]}" // RUN: value: false}]}"
// Classes with pointer field are still caught. // Classes with pointer field are still caught.
class PtrField { class PtrField {
public: public:
PtrField &operator=(const PtrField &object) { PtrField &operator=(const PtrField &object) {
// CHECK-MESSAGES: [[@LINE-1]]:13: warning: operator=() does not handle self-assignment properly [bugprone-unhandled-self-assignment] // CHECK-MESSAGES: [[@LINE-1]]:13: warning: operator=() does not handle self-assignment properly [bugprone-unhandled-self-assignment]
return *this; return *this;
} }
Show All 29 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-macro-usage-caps-only.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-macro-usage %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: cppcoreguidelines-macro-usage.CheckCapsOnly, value: 1}]}' -- // RUN: [{key: cppcoreguidelines-macro-usage.CheckCapsOnly, value: true}]}' --
#ifndef INCLUDE_GUARD #ifndef INCLUDE_GUARD
#define INCLUDE_GUARD #define INCLUDE_GUARD
#define problematic_constant 0 #define problematic_constant 0
// CHECK-MESSAGES: [[@LINE-1]]:9: warning: macro definition does not define the macro name 'problematic_constant' using all uppercase characters // CHECK-MESSAGES: [[@LINE-1]]:9: warning: macro definition does not define the macro name 'problematic_constant' using all uppercase characters
#define problematic_function(x, y) ((a) > (b) ? (a) : (b)) #define problematic_function(x, y) ((a) > (b) ? (a) : (b))
Show All 13 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-macro-usage-command-line-macros.cpp

// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -- -D_ZZZ_IM_A_MACRO // RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -- -D_ZZZ_IM_A_MACRO
// RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: 1}]}' -- -D_ZZZ_IM_A_MACRO // RUN: %check_clang_tidy -check-suffixes=NORMAL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: true}]}' -- -D_ZZZ_IM_A_MACRO
// RUN: %check_clang_tidy -check-suffixes=NORMAL,CL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: 0}]}' -- -D_ZZZ_IM_A_MACRO // RUN: %check_clang_tidy -check-suffixes=NORMAL,CL %s cppcoreguidelines-macro-usage %t -- -config='{CheckOptions: [{key: cppcoreguidelines-macro-usage.IgnoreCommandLineMacros, value: false}]}' -- -D_ZZZ_IM_A_MACRO
// CHECK-MESSAGES-CL: warning: macro '_ZZZ_IM_A_MACRO' used to declare a constant; consider using a 'constexpr' constant // CHECK-MESSAGES-CL: warning: macro '_ZZZ_IM_A_MACRO' used to declare a constant; consider using a 'constexpr' constant
#define PROBLEMATIC_CONSTANT 0 #define PROBLEMATIC_CONSTANT 0
// CHECK-MESSAGES-NORMAL: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant // CHECK-MESSAGES-NORMAL: [[@LINE-1]]:9: warning: macro 'PROBLEMATIC_CONSTANT' used to declare a constant; consider using a 'constexpr' constant

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-narrowing-conversions-pedanticmode-option.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: [ \
// RUN: {key: "cppcoreguidelines-narrowing-conversions.PedanticMode", value: 1} \ // RUN: {key: "cppcoreguidelines-narrowing-conversions.PedanticMode", value: true} \
// RUN: ]}" \ // RUN: ]}" \
// RUN: -- -target x86_64-unknown-linux -fsigned-char // RUN: -- -target x86_64-unknown-linux -fsigned-char
namespace floats { namespace floats {
void triggers_wrong_constant_type_warning(double d) { void triggers_wrong_constant_type_warning(double d) {
int i = 0.0; int i = 0.0;
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: constant value should be of type of type 'int' instead of 'double' [cppcoreguidelines-narrowing-conversions] // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: constant value should be of type of type 'int' instead of 'double' [cppcoreguidelines-narrowing-conversions]
Show All 12 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-narrowing-conversions.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \ // RUN: %check_clang_tidy %s cppcoreguidelines-narrowing-conversions %t \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: [ \
// RUN: {key: "cppcoreguidelines-narrowing-conversions.WarnOnFloatingPointNarrowingConversion", value: 0}, \ // RUN: {key: "cppcoreguidelines-narrowing-conversions.WarnOnFloatingPointNarrowingConversion", value: false}, \
// RUN: ]}" \ // RUN: ]}" \
// RUN: -- -target x86_64-unknown-linux -fsigned-char // RUN: -- -target x86_64-unknown-linux -fsigned-char
float ceil(float); float ceil(float);
namespace std { namespace std {
double ceil(double); double ceil(double);
long double floor(long double); long double floor(long double);
} // namespace std } // namespace std
▲ Show 20 Lines • Show All 348 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-prefer-member-initializer-modernize-use-default-member-init-assignment.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-prefer-member-initializer,modernize-use-default-member-init %t -- \ // RUN: %check_clang_tidy %s cppcoreguidelines-prefer-member-initializer,modernize-use-default-member-init %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: 1}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: true}]}"
class Simple1 { class Simple1 {
int n; int n;
// CHECK-FIXES: int n = 0; // CHECK-FIXES: int n = 0;
double x; double x;
// CHECK-FIXES: double x = 0.0; // CHECK-FIXES: double x = 0.0;
public: public:
Show All 21 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-pro-type-member-init-use-assignment.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -config="{CheckOptions: [{key: "cppcoreguidelines-pro-type-member-init.UseAssignment", value: 1}]}" -- -fsigned-char // RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init %t -- -config="{CheckOptions: [{key: "cppcoreguidelines-pro-type-member-init.UseAssignment", value: true}]}" -- -fsigned-char
struct T { struct T {
int i; int i;
}; };
struct S { struct S {
bool b; bool b;
// CHECK-FIXES: bool b = false; // CHECK-FIXES: bool b = false;
Show All 31 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-special-member-functions-allow-missing-move-when-copy-is-deleted.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: [{key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted, value: 1}]}" -- // RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: [{key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctionsWhenCopyIsDeleted, value: true}]}" --
class DefinesEverything { class DefinesEverything {
DefinesEverything(const DefinesEverything &); DefinesEverything(const DefinesEverything &);
DefinesEverything(DefinesEverything &&); DefinesEverything(DefinesEverything &&);
DefinesEverything &operator=(const DefinesEverything &); DefinesEverything &operator=(const DefinesEverything &);
DefinesEverything &operator=(DefinesEverything &&); DefinesEverything &operator=(DefinesEverything &&);
~DefinesEverything(); ~DefinesEverything();
}; };
Show All 40 Lines

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-special-member-functions-relaxed.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: [{key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions, value: 1}, {key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor, value: 1}]}" -- // RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -config="{CheckOptions: [{key: cppcoreguidelines-special-member-functions.AllowMissingMoveFunctions, value: true}, {key: cppcoreguidelines-special-member-functions.AllowSoleDefaultDtor, value: true}]}" --
class DefinesDestructor { class DefinesDestructor {
~DefinesDestructor(); ~DefinesDestructor();
}; };
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesDestructor' defines a non-default destructor but does not define a copy constructor or a copy assignment operator [cppcoreguidelines-special-member-functions] // CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesDestructor' defines a non-default destructor but does not define a copy constructor or a copy assignment operator [cppcoreguidelines-special-member-functions]
class DefinesDefaultedDestructor { class DefinesDefaultedDestructor {
~DefinesDefaultedDestructor() = default; ~DefinesDefaultedDestructor() = default;
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/hicpp-multiway-paths-covered-else.cpp

// RUN: %check_clang_tidy %s hicpp-multiway-paths-covered %t \ // RUN: %check_clang_tidy %s hicpp-multiway-paths-covered %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: hicpp-multiway-paths-covered.WarnOnMissingElse, value: 1}]}'\ // RUN: [{key: hicpp-multiway-paths-covered.WarnOnMissingElse, value: true}]}'\
// RUN: -- // RUN: --
enum OS { Mac, enum OS { Mac,
Windows, Windows,
Linux }; Linux };
void problematic_if(int i, enum OS os) { void problematic_if(int i, enum OS os) {
if (i > 0) { if (i > 0) {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/hicpp-signed-bitwise-integer-literals.cpp

// RUN: %check_clang_tidy %s hicpp-signed-bitwise %t -- \ // RUN: %check_clang_tidy %s hicpp-signed-bitwise %t -- \
// RUN: -config="{CheckOptions: [{key: hicpp-signed-bitwise.IgnorePositiveIntegerLiterals, value: 1 }]}" \ // RUN: -config="{CheckOptions: [{key: hicpp-signed-bitwise.IgnorePositiveIntegerLiterals, value: true }]}" \
// RUN: -- -std=c++11 // RUN: -- -std=c++11
void examples() { void examples() {
unsigned UValue = 40u; unsigned UValue = 40u;
unsigned URes; unsigned URes;
URes = UValue & 1u; //Ok URes = UValue & 1u; //Ok
URes = UValue & -1; URes = UValue & -1;
Show All 23 Lines

clang-tools-extra/test/clang-tidy/checkers/misc-non-private-member-variables-in-classes.cpp

// RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t // RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t
// RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: 0}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: 0}]}' -- // RUN: %check_clang_tidy -check-suffixes=PUBLIC,NONPRIVATE,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: false}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: false}]}' --
// RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: 0}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: 1}]}' -- // RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: false}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: true}]}' --
// RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s cppcoreguidelines-non-private-member-variables-in-classes %t -- -- // RUN: %check_clang_tidy -check-suffixes=PUBLIC,PROTECTED %s cppcoreguidelines-non-private-member-variables-in-classes %t -- --
// RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: 1}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: 0}]}' -- // RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: true}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: false}]}' --
// RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: 1}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: 1}]}' -- // RUN: %check_clang_tidy -check-suffixes=PROTECTED %s misc-non-private-member-variables-in-classes %t -- -config='{CheckOptions: [{key: misc-non-private-member-variables-in-classes.IgnorePublicMemberVariables, value: true}, {key: misc-non-private-member-variables-in-classes.IgnoreClassesWithAllMemberVariablesBeingPublic, value: true}]}' --
//----------------------------------------------------------------------------// //----------------------------------------------------------------------------//
// Only data, do not warn // Only data, do not warn
struct S0 { struct S0 {
int S0_v0; int S0_v0;
▲ Show 20 Lines • Show All 383 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/misc-unused-parameters-strict.cpp

// RUN: %check_clang_tidy %s misc-unused-parameters %t -- \ // RUN: %check_clang_tidy %s misc-unused-parameters %t -- \
// RUN: -config="{CheckOptions: [{key: StrictMode, value: 1}]}" -- // RUN: -config="{CheckOptions: [{key: StrictMode, value: true}]}" --
// Warn on empty function bodies in StrictMode. // Warn on empty function bodies in StrictMode.
namespace strict_mode { namespace strict_mode {
void f(int foo) {} void f(int foo) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'foo' is unused [misc-unused-parameters] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: parameter 'foo' is unused [misc-unused-parameters]
// CHECK-FIXES: {{^}}void f(int /*foo*/) {}{{$}} // CHECK-FIXES: {{^}}void f(int /*foo*/) {}{{$}}
class E { class E {
int i; int i;
Show All 15 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-avoid-bind-permissive-parameter-list.cpp

// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-avoid-bind %t -- \ // RUN: %check_clang_tidy -std=c++14-or-later %s modernize-avoid-bind %t -- \
// RUN: -config="{CheckOptions: [ \ // RUN: -config="{CheckOptions: [ \
// RUN: {key: modernize-avoid-bind.PermissiveParameterList, value: 1}]}" -- // RUN: {key: modernize-avoid-bind.PermissiveParameterList, value: true}]}" --
namespace std { namespace std {
inline namespace impl { inline namespace impl {
template <class Fp, class... Arguments> template <class Fp, class... Arguments>
class bind_rt {}; class bind_rt {};
template <class Fp, class... Arguments> template <class Fp, class... Arguments>
bind_rt<Fp, Arguments...> bind(Fp &&, Arguments &&...); bind_rt<Fp, Arguments...> bind(Fp &&, Arguments &&...);
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-make-unique-macros.cpp

// RUN: %check_clang_tidy -std=c++14-or-later %s modernize-make-unique %t -- \ // RUN: %check_clang_tidy -std=c++14-or-later %s modernize-make-unique %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-make-unique.IgnoreMacros, value: 0}]}" \ // RUN: -config="{CheckOptions: [{key: modernize-make-unique.IgnoreMacros, value: false}]}" \
// RUN: -- -I %S/Inputs/modernize-smart-ptr // RUN: -- -I %S/Inputs/modernize-smart-ptr
#include "unique_ptr.h" #include "unique_ptr.h"
class Foo {}; class Foo {};
class Bar {}; class Bar {};
#define DEFINE(...) __VA_ARGS__ #define DEFINE(...) __VA_ARGS__
// CHECK-FIXES: {{^}}#define DEFINE(...) __VA_ARGS__{{$}} // CHECK-FIXES: {{^}}#define DEFINE(...) __VA_ARGS__{{$}}
Show All 18 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-raw-string-literal-delimiter.cpp

// RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config='{CheckOptions: [{key: "modernize-raw-string-literal.DelimiterStem", value: "str"}, {key: modernize-raw-string-literal.ReplaceShorterLiterals, value: 1}]}' // RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config='{CheckOptions: [{key: "modernize-raw-string-literal.DelimiterStem", value: "str"}, {key: modernize-raw-string-literal.ReplaceShorterLiterals, value: true}]}'
char const *const ContainsSentinel{"who\\ops)\""}; char const *const ContainsSentinel{"who\\ops)\""};
// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: {{.*}} can be written as a raw string literal // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: {{.*}} can be written as a raw string literal
// CHECK-FIXES: {{^}}char const *const ContainsSentinel{R"str(who\ops)")str"};{{$}} // CHECK-FIXES: {{^}}char const *const ContainsSentinel{R"str(who\ops)")str"};{{$}}
//char const *const ContainsDelim{"whoops)\")lit\""}; //char const *const ContainsDelim{"whoops)\")lit\""};
// CHECK-XMESSAGES: :[[@LINE-1]]:33: warning: {{.*}} can be written as a raw string literal // CHECK-XMESSAGES: :[[@LINE-1]]:33: warning: {{.*}} can be written as a raw string literal
// CHECK-XFIXES: {{^}}char const *const ContainsDelim{R"lit1(whoops)")lit")lit1"};{{$}} // CHECK-XFIXES: {{^}}char const *const ContainsDelim{R"lit1(whoops)")lit")lit1"};{{$}}

clang-tools-extra/test/clang-tidy/checkers/modernize-raw-string-literal.cpp

// RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config="{CheckOptions: [{key: modernize-raw-string-literal.ReplaceShorterLiterals, value: 1}]}" // RUN: %check_clang_tidy %s modernize-raw-string-literal %t -- -config="{CheckOptions: [{key: modernize-raw-string-literal.ReplaceShorterLiterals, value: true}]}"
char const *const BackSlash("goink\\frob"); char const *const BackSlash("goink\\frob");
// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: escaped string literal can be written as a raw string literal [modernize-raw-string-literal] // CHECK-MESSAGES: :[[@LINE-1]]:29: warning: escaped string literal can be written as a raw string literal [modernize-raw-string-literal]
// CHECK-FIXES: {{^}}char const *const BackSlash(R"(goink\frob)");{{$}} // CHECK-FIXES: {{^}}char const *const BackSlash(R"(goink\frob)");{{$}}
char const *const PlainLiteral("plain literal"); char const *const PlainLiteral("plain literal");
// Non-printable ASCII characters. // Non-printable ASCII characters.
▲ Show 20 Lines • Show All 122 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-auto-cast-remove-stars.cpp

// RUN: %check_clang_tidy %s modernize-use-auto %t -- \ // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: '1'} , {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \ // RUN: -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 'true'} , {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" \
// RUN: -- -frtti // RUN: -- -frtti
struct A { struct A {
virtual ~A() {} virtual ~A() {}
}; };
struct B : public A {}; struct B : public A {};
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-auto-min-type-name-length.cpp

// RUN: %check_clang_tidy -check-suffix=0-0 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 0}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=0-0 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: false}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti
// RUN: %check_clang_tidy -check-suffix=0-8 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 0}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=0-8 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: false}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti
// RUN: %check_clang_tidy -check-suffix=1-0 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 1}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=1-0 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: true}, {key: modernize-use-auto.MinTypeNameLength, value: 0}]}" -- -frtti
// RUN: %check_clang_tidy -check-suffix=1-8 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 1}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti // RUN: %check_clang_tidy -check-suffix=1-8 %s modernize-use-auto %t -- -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: true}, {key: modernize-use-auto.MinTypeNameLength, value: 8}]}" -- -frtti
template <class T> extern T foo(); template <class T> extern T foo();
template <class T> struct P { explicit P(T t) : t_(t) {} T t_;}; template <class T> struct P { explicit P(T t) : t_(t) {} T t_;};
template <class T> P<T> *foo_ptr(); template <class T> P<T> *foo_ptr();
template <class T> P<T> &foo_ref(); template <class T> P<T> &foo_ref();
int bar() { int bar() {
{ {
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-auto-new-remove-stars.cpp

// RUN: %check_clang_tidy %s modernize-use-auto %t -- \ // RUN: %check_clang_tidy %s modernize-use-auto %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: '1'}, {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-auto.RemoveStars, value: 'true'}, {key: modernize-use-auto.MinTypeNameLength, value: '0'}]}"
class MyType {}; class MyType {};
class MyDerivedType : public MyType {}; class MyDerivedType : public MyType {};
// FIXME: the replacement sometimes results in two consecutive spaces after // FIXME: the replacement sometimes results in two consecutive spaces after
// the word 'auto' (due to the presence of spaces at both sides of '*'). // the word 'auto' (due to the presence of spaces at both sides of '*').
void auto_new() { void auto_new() {
▲ Show 20 Lines • Show All 95 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-bool-literals-ignore-macros.cpp

// RUN: %check_clang_tidy %s modernize-use-bool-literals %t -- \ // RUN: %check_clang_tidy %s modernize-use-bool-literals %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: modernize-use-bool-literals.IgnoreMacros, \ // RUN: [{key: modernize-use-bool-literals.IgnoreMacros, \
// RUN: value: 1}]}" // RUN: value: true}]}"
bool IntToTrue = 1; bool IntToTrue = 1;
// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals] // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals]
// CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}} // CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}}
bool IntToFalse(0); bool IntToFalse(0);
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}} // CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}}
▲ Show 20 Lines • Show All 135 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-bool-literals.cpp

// RUN: %check_clang_tidy %s modernize-use-bool-literals %t -- \ // RUN: %check_clang_tidy %s modernize-use-bool-literals %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: modernize-use-bool-literals.IgnoreMacros, \ // RUN: [{key: modernize-use-bool-literals.IgnoreMacros, \
// RUN: value: 0}]}" // RUN: value: false}]}"
bool IntToTrue = 1; bool IntToTrue = 1;
// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals] // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals]
// CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}} // CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}}
bool IntToFalse(0); bool IntToFalse(0);
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}} // CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}}
▲ Show 20 Lines • Show All 139 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-default-member-init-assignment.cpp

// RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \ // RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: 1}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.UseAssignment, value: true}]}"
struct S { struct S {
}; };
struct PositiveValueChar { struct PositiveValueChar {
PositiveValueChar() : c0(), c1()/*, c2(), c3()*/ {} PositiveValueChar() : c0(), c1()/*, c2(), c3()*/ {}
// CHECK-FIXES: PositiveValueChar() {} // CHECK-FIXES: PositiveValueChar() {}
const char c0; const char c0;
▲ Show 20 Lines • Show All 182 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-default-member-init-macros.cpp

// RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \ // RUN: %check_clang_tidy %s modernize-use-default-member-init %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.IgnoreMacros, value: 0}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-default-member-init.IgnoreMacros, value: false}]}"
#define MACRO() \ #define MACRO() \
struct S { \ struct S { \
void *P; \ void *P; \
S() : P(nullptr) {} \ S() : P(nullptr) {} \
}; };
MACRO(); MACRO();
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use default member initializer for 'P' // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use default member initializer for 'P'
struct S2 { struct S2 {
void *P; void *P;
// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use default member initializer for 'P' // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: use default member initializer for 'P'
S2() : P(nullptr) {} S2() : P(nullptr) {}
}; };

clang-tools-extra/test/clang-tidy/checkers/modernize-use-emplace-ignore-implicit-constructors.cpp

// RUN: %check_clang_tidy %s modernize-use-emplace %t -- \ // RUN: %check_clang_tidy %s modernize-use-emplace %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: modernize-use-emplace.IgnoreImplicitConstructors, \ // RUN: [{key: modernize-use-emplace.IgnoreImplicitConstructors, \
// RUN: value: 1}] \ // RUN: value: true}] \
// RUN: }" // RUN: }"
namespace std { namespace std {
template <typename> template <typename>
class initializer_list class initializer_list
{ {
public: public:
initializer_list() noexcept {} initializer_list() noexcept {}
▲ Show 20 Lines • Show All 111 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-equals-default-copy.cpp

// RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \ // RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: 0}]}" \ // RUN: -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: false}]}" \
// RUN: -- -fno-delayed-template-parsing -fexceptions // RUN: -- -fno-delayed-template-parsing -fexceptions
// Out of line definition. // Out of line definition.
struct OL { struct OL {
OL(const OL &); OL(const OL &);
OL &operator=(const OL &); OL &operator=(const OL &);
int Field; int Field;
}; };
▲ Show 20 Lines • Show All 497 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-equals-default-macros.cpp

// RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \ // RUN: %check_clang_tidy %s modernize-use-equals-default %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: 0}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-equals-default.IgnoreMacros, value: false}]}"
#define STRUCT_WITH_DEFAULT(_base, _type) \ #define STRUCT_WITH_DEFAULT(_base, _type) \
struct _type { \ struct _type { \
_type() {} \ _type() {} \
_base value; \ _base value; \
}; };
STRUCT_WITH_DEFAULT(unsigned char, InMacro) STRUCT_WITH_DEFAULT(unsigned char, InMacro)
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial default constructor // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use '= default' to define a trivial default constructor
// CHECK-MESSAGES: :[[@LINE-6]]:13: note: // CHECK-MESSAGES: :[[@LINE-6]]:13: note:

clang-tools-extra/test/clang-tidy/checkers/modernize-use-equals-delete-macros.cpp

// RUN: %check_clang_tidy %s modernize-use-equals-delete %t -- \ // RUN: %check_clang_tidy %s modernize-use-equals-delete %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-equals-delete.IgnoreMacros, value: 0}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-equals-delete.IgnoreMacros, value: false}]}"
#define MACRO(type) void operator=(type const &) #define MACRO(type) void operator=(type const &)
class C { class C {
private: private:
MACRO(C); MACRO(C);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= delete' to prohibit calling of a special member function // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: use '= delete' to prohibit calling of a special member function
}; };

clang-tools-extra/test/clang-tidy/checkers/modernize-use-noexcept-opt.cpp

// RUN: %check_clang_tidy -std=c++11,c++14 %s modernize-use-noexcept %t -- \ // RUN: %check_clang_tidy -std=c++11,c++14 %s modernize-use-noexcept %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-noexcept.UseNoexceptFalse, value: 0}]}" \ // RUN: -config="{CheckOptions: [{key: modernize-use-noexcept.UseNoexceptFalse, value: false}]}" \
// RUN: -- -fexceptions // RUN: -- -fexceptions
// This test is not run in C++17 or later because dynamic exception // This test is not run in C++17 or later because dynamic exception
// specifications were removed in C++17. // specifications were removed in C++17.
using size_t = __SIZE_TYPE__; using size_t = __SIZE_TYPE__;
class A {}; class A {};
class B {}; class B {};
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-override-allow-override-and-final.cpp

// RUN: %check_clang_tidy %s modernize-use-override %t -- \ // RUN: %check_clang_tidy %s modernize-use-override %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-override.AllowOverrideAndFinal, value: 1}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-override.AllowOverrideAndFinal, value: true}]}"
struct Base { struct Base {
virtual ~Base(); virtual ~Base();
virtual void a(); virtual void a();
virtual void b(); virtual void b();
virtual void c(); virtual void c();
virtual void d(); virtual void d();
virtual void e(); virtual void e();
Show All 30 Lines

clang-tools-extra/test/clang-tidy/checkers/modernize-use-override-no-destructors.cpp

// RUN: %check_clang_tidy %s modernize-use-override %t -- \ // RUN: %check_clang_tidy %s modernize-use-override %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-override.IgnoreDestructors, value: 1}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-override.IgnoreDestructors, value: true}]}"
struct Base { struct Base {
virtual ~Base(); virtual ~Base();
virtual void f(); virtual void f();
}; };
struct Simple : public Base { struct Simple : public Base {
virtual ~Simple(); virtual ~Simple();
// CHECK-MESSAGES-NOT: warning: // CHECK-MESSAGES-NOT: warning:
virtual void f(); virtual void f();
// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: prefer using
// CHECK-FIXES: {{^}} void f() override; // CHECK-FIXES: {{^}} void f() override;
}; };

clang-tools-extra/test/clang-tidy/checkers/modernize-use-using-macros.cpp

// RUN: %check_clang_tidy %s modernize-use-using %t -- \ // RUN: %check_clang_tidy %s modernize-use-using %t -- \
// RUN: -config="{CheckOptions: [{key: modernize-use-using.IgnoreMacros, value: 0}]}" // RUN: -config="{CheckOptions: [{key: modernize-use-using.IgnoreMacros, value: false}]}"
#define CODE typedef int INT #define CODE typedef int INT
CODE; CODE;
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use 'using' instead of 'typedef' // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: use 'using' instead of 'typedef'
// CHECK-FIXES: #define CODE typedef int INT // CHECK-FIXES: #define CODE typedef int INT
// CHECK-FIXES: CODE; // CHECK-FIXES: CODE;
Show All 12 Lines

clang-tools-extra/test/clang-tidy/checkers/performance-for-range-copy-warn-on-all-auto-copies.cpp

// RUN: %check_clang_tidy %s performance-for-range-copy %t -- \ // RUN: %check_clang_tidy %s performance-for-range-copy %t -- \
// RUN: -config="{CheckOptions: [{key: "performance-for-range-copy.WarnOnAllAutoCopies", value: 1}]}" // RUN: -config="{CheckOptions: [{key: "performance-for-range-copy.WarnOnAllAutoCopies", value: true}]}"
template <typename T> template <typename T>
struct Iterator { struct Iterator {
void operator++() {} void operator++() {}
const T& operator*() { const T& operator*() {
static T* TT = new T(); static T* TT = new T();
return *TT; return *TT;
} }
Show All 30 Lines

clang-tools-extra/test/clang-tidy/checkers/performance-inefficient-vector-operation.cpp

// RUN: %check_clang_tidy %s performance-inefficient-vector-operation %t -- \ // RUN: %check_clang_tidy %s performance-inefficient-vector-operation %t -- \
// RUN: -format-style=llvm \ // RUN: -format-style=llvm \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: performance-inefficient-vector-operation.EnableProto, value: 1}]}' // RUN: [{key: performance-inefficient-vector-operation.EnableProto, value: true}]}'
namespace std { namespace std {
typedef int size_t; typedef int size_t;
template<class E> class initializer_list { template<class E> class initializer_list {
public: public:
using value_type = E; using value_type = E;
▲ Show 20 Lines • Show All 349 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/performance-move-const-arg-trivially-copyable.cpp

// RUN: %check_clang_tidy %s performance-move-const-arg %t \ // RUN: %check_clang_tidy %s performance-move-const-arg %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: performance-move-const-arg.CheckTriviallyCopyableMove, value: 0}]}' // RUN: [{key: performance-move-const-arg.CheckTriviallyCopyableMove, value: false}]}'
namespace std { namespace std {
template <typename> struct remove_reference; template <typename> struct remove_reference;
template <typename _Tp> struct remove_reference { typedef _Tp type; }; template <typename _Tp> struct remove_reference { typedef _Tp type; };
template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; }; template <typename _Tp> struct remove_reference<_Tp &> { typedef _Tp type; };
template <typename _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; }; template <typename _Tp> struct remove_reference<_Tp &&> { typedef _Tp type; };
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/performance-move-constructor-init.cpp

// RUN: %check_clang_tidy %s performance-move-constructor-init,modernize-pass-by-value %t -- \ // RUN: %check_clang_tidy %s performance-move-constructor-init,modernize-pass-by-value %t -- \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: modernize-pass-by-value.ValuesOnly, value: 1}]}' \ // RUN: [{key: modernize-pass-by-value.ValuesOnly, value: true}]}' \
// RUN: -- -isystem %S/Inputs/Headers // RUN: -- -isystem %S/Inputs/Headers
#include <s.h> #include <s.h>
// CHECK-FIXES: #include <utility> // CHECK-FIXES: #include <utility>
template <class T> struct remove_reference {typedef T type;}; template <class T> struct remove_reference {typedef T type;};
template <class T> struct remove_reference<T&> {typedef T type;}; template <class T> struct remove_reference<T&> {typedef T type;};
▲ Show 20 Lines • Show All 145 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/portability-simd-intrinsics-ppc.cpp

// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \ // RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: portability-simd-intrinsics.Suggest, value: 1} \ // RUN: {key: portability-simd-intrinsics.Suggest, value: true} \
// RUN: ]}' -- -target ppc64le -maltivec // RUN: ]}' -- -target ppc64le -maltivec
// RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \ // RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: portability-simd-intrinsics.Suggest, value: 1} \ // RUN: {key: portability-simd-intrinsics.Suggest, value: true} \
// RUN: ]}' -- -target ppc64le -maltivec // RUN: ]}' -- -target ppc64le -maltivec
vector int vec_add(vector int, vector int); vector int vec_add(vector int, vector int);
void PPC() { void PPC() {
vector int i0, i1; vector int i0, i1;
vec_add(i0, i1); vec_add(i0, i1);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'vec_add' can be replaced by operator+ on std::experimental::simd objects [portability-simd-intrinsics] // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: 'vec_add' can be replaced by operator+ on std::experimental::simd objects [portability-simd-intrinsics]
// CHECK-MESSAGES-CXX20: :[[@LINE-2]]:3: warning: 'vec_add' can be replaced by operator+ on std::simd objects [portability-simd-intrinsics] // CHECK-MESSAGES-CXX20: :[[@LINE-2]]:3: warning: 'vec_add' can be replaced by operator+ on std::simd objects [portability-simd-intrinsics]
} }

clang-tools-extra/test/clang-tidy/checkers/portability-simd-intrinsics-x86.cpp

// RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \ // RUN: %check_clang_tidy -std=c++11,c++14,c++17 %s portability-simd-intrinsics %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: portability-simd-intrinsics.Suggest, value: 1} \ // RUN: {key: portability-simd-intrinsics.Suggest, value: true} \
// RUN: ]}' -- -target x86_64 // RUN: ]}' -- -target x86_64
// RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \ // RUN: %check_clang_tidy -std=c++20-or-later %s portability-simd-intrinsics -check-suffix=CXX20 %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: portability-simd-intrinsics.Suggest, value: 1} \ // RUN: {key: portability-simd-intrinsics.Suggest, value: true} \
// RUN: ]}' -- -target x86_64 // RUN: ]}' -- -target x86_64
typedef long long __m128i __attribute__((vector_size(16))); typedef long long __m128i __attribute__((vector_size(16)));
typedef double __m256 __attribute__((vector_size(32))); typedef double __m256 __attribute__((vector_size(32)));
__m128i _mm_add_epi32(__m128i, __m128i); __m128i _mm_add_epi32(__m128i, __m128i);
__m256 _mm256_load_pd(double const *); __m256 _mm256_load_pd(double const *);
void _mm256_store_pd(double *, __m256); void _mm256_store_pd(double *, __m256);
Show All 15 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-else-after-return-no-warn.cpp

// RUN: %check_clang_tidy %s readability-else-after-return %t -- \ // RUN: %check_clang_tidy %s readability-else-after-return %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: readability-else-after-return.WarnOnUnfixable, value: 0}, \ // RUN: {key: readability-else-after-return.WarnOnUnfixable, value: false}, \
// RUN: ]}' // RUN: ]}'
int h(int); int h(int);
int lifeTimeExtensionTests(int a) { int lifeTimeExtensionTests(int a) {
if (a > 0) { if (a > 0) {
return a; return a;
} else { } else {
Show All 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-main-like.cpp

// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ // RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \
// RUN: {key: readability-identifier-naming.IgnoreMainLikeFunctions, value: 1} \ // RUN: {key: readability-identifier-naming.IgnoreMainLikeFunctions, value: true} \
// RUN: ]}' // RUN: ]}'
int mainLike(int argc, char **argv); int mainLike(int argc, char **argv);
int mainLike(int argc, char **argv, const char **env); int mainLike(int argc, char **argv, const char **env);
int mainLike(int argc, const char **argv); int mainLike(int argc, const char **argv);
int mainLike(int argc, const char **argv, const char **env); int mainLike(int argc, const char **argv, const char **env);
int mainLike(int argc, char *argv[]); int mainLike(int argc, char *argv[]);
int mainLike(int argc, const char *argv[]); int mainLike(int argc, const char *argv[]);
▲ Show 20 Lines • Show All 76 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming-member-decl-usage.cpp

// RUN: %check_clang_tidy %s readability-identifier-naming %t -- \ // RUN: %check_clang_tidy %s readability-identifier-naming %t -- \
// RUN: -config='{CheckOptions: [ \ // RUN: -config='{CheckOptions: [ \
// RUN: {key: readability-identifier-naming.MemberCase, value: CamelCase}, \ // RUN: {key: readability-identifier-naming.MemberCase, value: CamelCase}, \
// RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \ // RUN: {key: readability-identifier-naming.ParameterCase, value: CamelCase}, \
// RUN: {key: readability-identifier-naming.MethodCase, value: camelBack}, \ // RUN: {key: readability-identifier-naming.MethodCase, value: camelBack}, \
// RUN: {key: readability-identifier-naming.AggressiveDependentMemberLookup, value: 1} \ // RUN: {key: readability-identifier-naming.AggressiveDependentMemberLookup, value: true} \
// RUN: ]}' -- -fno-delayed-template-parsing // RUN: ]}' -- -fno-delayed-template-parsing
int set_up(int); int set_up(int);
int clear(int); int clear(int);
class Foo { class Foo {
public: public:
const int bar_baz; // comment-0 const int bar_baz; // comment-0
▲ Show 20 Lines • Show All 204 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-identifier-naming.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines
// RUN: {key: readability-identifier-naming.UsingCase, value: lower_case}, \ // RUN: {key: readability-identifier-naming.UsingCase, value: lower_case}, \
// RUN: {key: readability-identifier-naming.ValueTemplateParameterCase, value: camelBack}, \ // RUN: {key: readability-identifier-naming.ValueTemplateParameterCase, value: camelBack}, \
// RUN: {key: readability-identifier-naming.VariableCase, value: lower_case}, \ // RUN: {key: readability-identifier-naming.VariableCase, value: lower_case}, \
// RUN: {key: readability-identifier-naming.VirtualMethodCase, value: Camel_Snake_Case}, \ // RUN: {key: readability-identifier-naming.VirtualMethodCase, value: Camel_Snake_Case}, \
// RUN: {key: readability-identifier-naming.VirtualMethodPrefix, value: 'v_'}, \ // RUN: {key: readability-identifier-naming.VirtualMethodPrefix, value: 'v_'}, \
// RUN: {key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE}, \ // RUN: {key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE}, \
// RUN: {key: readability-identifier-naming.TypeAliasCase, value: camel_Snake_Back}, \ // RUN: {key: readability-identifier-naming.TypeAliasCase, value: camel_Snake_Back}, \
// RUN: {key: readability-identifier-naming.TypeAliasSuffix, value: '_t'}, \ // RUN: {key: readability-identifier-naming.TypeAliasSuffix, value: '_t'}, \
// RUN: {key: readability-identifier-naming.IgnoreFailedSplit, value: 0}, \ // RUN: {key: readability-identifier-naming.IgnoreFailedSplit, value: false}, \
// RUN: {key: readability-identifier-naming.GlobalPointerCase, value: CamelCase}, \ // RUN: {key: readability-identifier-naming.GlobalPointerCase, value: CamelCase}, \
// RUN: {key: readability-identifier-naming.GlobalPointerSuffix, value: '_Ptr'}, \ // RUN: {key: readability-identifier-naming.GlobalPointerSuffix, value: '_Ptr'}, \
// RUN: {key: readability-identifier-naming.GlobalConstantPointerCase, value: UPPER_CASE}, \ // RUN: {key: readability-identifier-naming.GlobalConstantPointerCase, value: UPPER_CASE}, \
// RUN: {key: readability-identifier-naming.GlobalConstantPointerSuffix, value: '_Ptr'}, \ // RUN: {key: readability-identifier-naming.GlobalConstantPointerSuffix, value: '_Ptr'}, \
// RUN: {key: readability-identifier-naming.PointerParameterCase, value: lower_case}, \ // RUN: {key: readability-identifier-naming.PointerParameterCase, value: lower_case}, \
// RUN: {key: readability-identifier-naming.PointerParameterPrefix, value: 'p_'}, \ // RUN: {key: readability-identifier-naming.PointerParameterPrefix, value: 'p_'}, \
// RUN: {key: readability-identifier-naming.ConstantPointerParameterCase, value: CamelCase}, \ // RUN: {key: readability-identifier-naming.ConstantPointerParameterCase, value: CamelCase}, \
// RUN: {key: readability-identifier-naming.ConstantPointerParameterPrefix, value: 'cp_'}, \ // RUN: {key: readability-identifier-naming.ConstantPointerParameterPrefix, value: 'cp_'}, \
▲ Show 20 Lines • Show All 556 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-implicit-bool-conversion-allow-in-conditions.cpp

// RUN: %check_clang_tidy %s readability-implicit-bool-conversion %t \ // RUN: %check_clang_tidy %s readability-implicit-bool-conversion %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-implicit-bool-conversion.AllowIntegerConditions, value: 1}, \ // RUN: [{key: readability-implicit-bool-conversion.AllowIntegerConditions, value: true}, \
// RUN: {key: readability-implicit-bool-conversion.AllowPointerConditions, value: 1}]}' // RUN: {key: readability-implicit-bool-conversion.AllowPointerConditions, value: true}]}'
template<typename T> template<typename T>
void functionTaking(T); void functionTaking(T);
int functionReturningInt(); int functionReturningInt();
int* functionReturningPointer(); int* functionReturningPointer();
struct Struct { struct Struct {
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-inconsistent-declaration-parameter-name-macros.cpp

// RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \ // RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \
// RUN: -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.IgnoreMacros, value: 0}]}" // RUN: -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.IgnoreMacros, value: false}]}"
#define MACRO() \ #define MACRO() \
void f(int x) void f(int x)
struct S1 { struct S1 {
MACRO(); MACRO();
// CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'S1::f' has a definition with different parameter names // CHECK-NOTES: :[[@LINE-1]]:3: warning: function 'S1::f' has a definition with different parameter names
// CHECK-NOTES: :[[@LINE-5]]:8: note: expanded from macro 'MACRO' // CHECK-NOTES: :[[@LINE-5]]:8: note: expanded from macro 'MACRO'
Show All 36 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-inconsistent-declaration-parameter-name-strict.cpp

// RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \ // RUN: %check_clang_tidy %s readability-inconsistent-declaration-parameter-name %t -- \
// RUN: -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.Strict, value: 1}]}" // RUN: -config="{CheckOptions: [{key: readability-inconsistent-declaration-parameter-name.Strict, value: true}]}"
void inconsistentFunction(int a, int b, int c); void inconsistentFunction(int a, int b, int c);
// CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'inconsistentFunction' has 1 other declaration with different parameter names // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: function 'inconsistentFunction' has 1 other declaration with different parameter names
void inconsistentFunction(int prefixA, int b, int cSuffix); void inconsistentFunction(int prefixA, int b, int cSuffix);
// CHECK-MESSAGES: :[[@LINE-1]]:6: note: the 1st inconsistent declaration seen here // CHECK-MESSAGES: :[[@LINE-1]]:6: note: the 1st inconsistent declaration seen here
// CHECK-MESSAGES: :[[@LINE-2]]:6: note: differing parameters are named here: ('prefixA', 'cSuffix'), in the other declaration: ('a', 'c') // CHECK-MESSAGES: :[[@LINE-2]]:6: note: differing parameters are named here: ('prefixA', 'cSuffix'), in the other declaration: ('a', 'c')
void inconsistentFunction(int a, int b, int c); void inconsistentFunction(int a, int b, int c);
void inconsistentFunction(int /*c*/, int /*c*/, int /*c*/); void inconsistentFunction(int /*c*/, int /*c*/, int /*c*/);

clang-tools-extra/test/clang-tidy/checkers/readability-magic-numbers.cpp

// RUN: %check_clang_tidy %s readability-magic-numbers %t \ // RUN: %check_clang_tidy %s readability-magic-numbers %t \
// RUN: -config='{CheckOptions: \ // RUN: -config='{CheckOptions: \
// RUN: [{key: readability-magic-numbers.IgnoredIntegerValues, value: "0;1;2;10;100;"}, \ // RUN: [{key: readability-magic-numbers.IgnoredIntegerValues, value: "0;1;2;10;100;"}, \
// RUN: {key: readability-magic-numbers.IgnoredFloatingPointValues, value: "3.14;2.71828;9.81;10000.0;101.0;0x1.2p3"}, \ // RUN: {key: readability-magic-numbers.IgnoredFloatingPointValues, value: "3.14;2.71828;9.81;10000.0;101.0;0x1.2p3"}, \
// RUN: {key: readability-magic-numbers.IgnoreBitFieldsWidths, value: 0}, \ // RUN: {key: readability-magic-numbers.IgnoreBitFieldsWidths, value: false}, \
// RUN: {key: readability-magic-numbers.IgnorePowersOf2IntegerValues, value: 1}]}' \ // RUN: {key: readability-magic-numbers.IgnorePowersOf2IntegerValues, value: true}]}' \
// RUN: -- // RUN: --
template <typename T, int V> template <typename T, int V>
struct ValueBucket { struct ValueBucket {
T value[V]; T value[V];
}; };
int BadGlobalInt = 5; int BadGlobalInt = 5;
▲ Show 20 Lines • Show All 214 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-redundant-access-specifiers-check-first-declaration.cpp

// RUN: %check_clang_tidy %s readability-redundant-access-specifiers %t -- \ // RUN: %check_clang_tidy %s readability-redundant-access-specifiers %t -- \
// RUN: -config="{CheckOptions: [{key: readability-redundant-access-specifiers.CheckFirstDeclaration, value: 1}]}" -- // RUN: -config="{CheckOptions: [{key: readability-redundant-access-specifiers.CheckFirstDeclaration, value: true}]}" --
class FooPublic { class FooPublic {
private: // comment-0 private: // comment-0
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the implicit access specifier [readability-redundant-access-specifiers] // CHECK-MESSAGES: :[[@LINE-1]]:1: warning: redundant access specifier has the same accessibility as the implicit access specifier [readability-redundant-access-specifiers]
// CHECK-FIXES: {{^}}// comment-0{{$}} // CHECK-FIXES: {{^}}// comment-0{{$}}
int a; int a;
}; };
Show All 33 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-redundant-declaration-ignore-macros.cpp

// RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \ // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-declaration.IgnoreMacros, \ // RUN: [{key: readability-redundant-declaration.IgnoreMacros, \
// RUN: value: 1}]}" // RUN: value: true}]}"
extern int Xyz; extern int Xyz;
extern int Xyz; // Xyz extern int Xyz; // Xyz
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration]
// CHECK-FIXES: {{^}}// Xyz{{$}} // CHECK-FIXES: {{^}}// Xyz{{$}}
namespace macros { namespace macros {
#define DECLARE(x) extern int x #define DECLARE(x) extern int x
Show All 9 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-redundant-declaration.cpp

// RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \ // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-declaration.IgnoreMacros, \ // RUN: [{key: readability-redundant-declaration.IgnoreMacros, \
// RUN: value: 0}]}" // RUN: value: false}]}"
// //
// With -fms-compatibility and -DEXTERNINLINE, the extern inline shouldn't // With -fms-compatibility and -DEXTERNINLINE, the extern inline shouldn't
// produce additional diagnostics, so same check suffix as before: // produce additional diagnostics, so same check suffix as before:
// RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \ // RUN: %check_clang_tidy %s readability-redundant-declaration %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-declaration.IgnoreMacros, \ // RUN: [{key: readability-redundant-declaration.IgnoreMacros, \
// RUN: value: 0}]}" -- -fms-compatibility -DEXTERNINLINE // RUN: value: false}]}" -- -fms-compatibility -DEXTERNINLINE
// //
// With -fno-ms-compatibility, DEXTERNINLINE causes additional output. // With -fno-ms-compatibility, DEXTERNINLINE causes additional output.
// (The leading ',' means "default checks in addition to NOMSCOMPAT checks.) // (The leading ',' means "default checks in addition to NOMSCOMPAT checks.)
// RUN: %check_clang_tidy -check-suffix=,NOMSCOMPAT \ // RUN: %check_clang_tidy -check-suffix=,NOMSCOMPAT \
// RUN: %s readability-redundant-declaration %t -- \ // RUN: %s readability-redundant-declaration %t -- \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-declaration.IgnoreMacros, \ // RUN: [{key: readability-redundant-declaration.IgnoreMacros, \
// RUN: value: 0}]}" -- -fno-ms-compatibility -DEXTERNINLINE // RUN: value: false}]}" -- -fno-ms-compatibility -DEXTERNINLINE
extern int Xyz; extern int Xyz;
extern int Xyz; // Xyz extern int Xyz; // Xyz
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration] // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: redundant 'Xyz' declaration [readability-redundant-declaration]
// CHECK-FIXES: {{^}}// Xyz{{$}} // CHECK-FIXES: {{^}}// Xyz{{$}}
int Xyz = 123; int Xyz = 123;
extern int A; extern int A;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-redundant-member-init.cpp

// RUN: %check_clang_tidy %s readability-redundant-member-init %t \ // RUN: %check_clang_tidy %s readability-redundant-member-init %t \
// RUN: -config="{CheckOptions: \ // RUN: -config="{CheckOptions: \
// RUN: [{key: readability-redundant-member-init.IgnoreBaseInCopyConstructors, \ // RUN: [{key: readability-redundant-member-init.IgnoreBaseInCopyConstructors, \
// RUN: value: 1}] \ // RUN: value: true}] \
// RUN: }" // RUN: }"
struct S { struct S {
S() = default; S() = default;
S(int i) : i(i) {} S(int i) : i(i) {}
int i = 1; int i = 1;
}; };
▲ Show 20 Lines • Show All 240 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-redundant-smartptr-get-macros.cpp

// RUN: %check_clang_tidy %s readability-redundant-smartptr-get %t -- \ // RUN: %check_clang_tidy %s readability-redundant-smartptr-get %t -- \
// RUN: -config="{CheckOptions: [{key: readability-redundant-smartptr-get.IgnoreMacros, value: 0}]}" // RUN: -config="{CheckOptions: [{key: readability-redundant-smartptr-get.IgnoreMacros, value: false}]}"
namespace std { namespace std {
template <typename T> template <typename T>
struct shared_ptr { struct shared_ptr {
T &operator*() const; T &operator*() const;
T *operator->() const; T *operator->() const;
T *get() const; T *get() const;
Show All 13 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-simplify-bool-expr-chained-conditional-assignment.cpp

// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: 1}]}" -- // RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalAssignment", value: true}]}" --
void chained_conditional_compound_assignment(int i) { void chained_conditional_compound_assignment(int i) {
bool b; bool b;
if (i < 0) { if (i < 0) {
b = true; b = true;
} else if (i < 10) { } else if (i < 10) {
b = false; b = false;
} else if (i > 20) { } else if (i > 20) {
Show All 25 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-simplify-bool-expr-chained-conditional-return.cpp

// RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: 1}]}" -- // RUN: %check_clang_tidy %s readability-simplify-boolean-expr %t -- -config="{CheckOptions: [{key: "readability-simplify-boolean-expr.ChainedConditionalReturn", value: true}]}" --
bool chained_conditional_compound_return(int i) { bool chained_conditional_compound_return(int i) {
if (i < 0) { if (i < 0) {
return true; return true;
} else if (i < 10) { } else if (i < 10) {
return false; return false;
} else if (i > 20) { } else if (i > 20) {
return true; return true;
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

clang-tools-extra/test/clang-tidy/checkers/readability-uppercase-literal-suffix-integer-macro.cpp

// RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- \ // RUN: %check_clang_tidy %s readability-uppercase-literal-suffix %t -- \
// RUN: -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.IgnoreMacros, value: 0}]}" \ // RUN: -config="{CheckOptions: [{key: readability-uppercase-literal-suffix.IgnoreMacros, value: false}]}" \
// RUN: -- -I %S // RUN: -- -I %S
void macros() { void macros() {
#define INMACRO(X) 1.f #define INMACRO(X) 1.f
static constexpr auto m1 = INMACRO(); static constexpr auto m1 = INMACRO();
// CHECK-NOTES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase // CHECK-NOTES: :[[@LINE-1]]:30: warning: floating point literal has suffix 'f', which is not uppercase
// CHECK-NOTES: :[[@LINE-3]]:20: note: expanded from macro 'INMACRO' // CHECK-NOTES: :[[@LINE-3]]:20: note: expanded from macro 'INMACRO'
// CHECK-FIXES: #define INMACRO(X) 1.f // CHECK-FIXES: #define INMACRO(X) 1.f
Show All 17 Lines

clang-tools-extra/test/clang-tidy/infrastructure/Inputs/config-files/4/.clang-tidy

Checks: '-*,modernize-loop-convert,modernize-use-using' Checks: '-*,modernize-loop-convert,modernize-use-using'
CheckOptions: CheckOptions:
- key: modernize-loop-convert.MaxCopySize - key: modernize-loop-convert.MaxCopySize
value: '10' value: '10'
- key: modernize-loop-convert.MinConfidence - key: modernize-loop-convert.MinConfidence
value: reasonable value: reasonable
- key: modernize-use-using.IgnoreMacros - key: modernize-use-using.IgnoreMacros
value: 1 value: true

clang-tools-extra/test/clang-tidy/infrastructure/Inputs/config-files/4/44/.clang-tidy

InheritParentConfig: true InheritParentConfig: true
Checks: 'llvm-qualified-auto' Checks: 'llvm-qualified-auto'
CheckOptions: CheckOptions:
- key: modernize-loop-convert.MaxCopySize - key: modernize-loop-convert.MaxCopySize
value: '20' value: '20'
- key: llvm-qualified-auto.AddConstToQualified - key: llvm-qualified-auto.AddConstToQualified
value: '1' value: 'true'
- key: IgnoreMacros - key: IgnoreMacros
value: '0' value: 'false'

clang-tools-extra/test/clang-tidy/infrastructure/duplicate-conflicted-fixes-of-alias-checkers.cpp

// RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init,hicpp-member-init,modernize-use-emplace,hicpp-use-emplace %t -- \ // RUN: %check_clang_tidy %s cppcoreguidelines-pro-type-member-init,hicpp-member-init,modernize-use-emplace,hicpp-use-emplace %t -- \
//// RUN: -config='{CheckOptions: [ \ //// RUN: -config='{CheckOptions: [ \
//// RUN: {key: cppcoreguidelines-pro-type-member-init.UseAssignment, value: 1}, \ //// RUN: {key: cppcoreguidelines-pro-type-member-init.UseAssignment, value: true}, \
//// RUN: ]}' //// RUN: ]}'
class Foo { class Foo {
public: public:
Foo() : _num1(0) Foo() : _num1(0)
// CHECK-MESSAGES: warning: constructor does not initialize these fields: _num2 [cppcoreguidelines-pro-type-member-init,hicpp-member-init] // CHECK-MESSAGES: warning: constructor does not initialize these fields: _num2 [cppcoreguidelines-pro-type-member-init,hicpp-member-init]
// CHECK-MESSAGES: note: cannot apply fix-it because an alias checker has suggested a different fix-it; please remove one of the checkers ('cppcoreguidelines-pro-type-member-init', 'hicpp-member-init') or ensure they are both configured the same // CHECK-MESSAGES: note: cannot apply fix-it because an alias checker has suggested a different fix-it; please remove one of the checkers ('cppcoreguidelines-pro-type-member-init', 'hicpp-member-init') or ensure they are both configured the same
{ {
Show All 12 Lines