From bcb0f95fc596b336c18b864db593d2a2ce896a85 Mon Sep 17 00:00:00 2001 From: xyb Date: Sun, 1 Sep 2019 16:48:23 -0700 Subject: [PATCH] Add bugprone-argument-comment option: IgnoreSingleArgument. When true, the check will ignore the single argument. Sometimes, it's not necessary to add comment to single argument. For example: std::string name("Yubo Xie"); pScreen->SetWidth(1920); pScreen->SetHeight(1080); This option can ignore such single argument in bugprone-argument-comment check. --- .../bugprone/ArgumentCommentCheck.cpp | 5 +- .../bugprone/ArgumentCommentCheck.h | 1 + .../checks/bugprone-argument-comment.rst | 3 + ...rgument-comment-ignore-single-argument.cpp | 97 +++++++++++++++++++ 4 files changed, 105 insertions(+), 1 deletion(-) create mode 100644 clang-tools-extra/test/clang-tidy/bugprone-argument-comment-ignore-single-argument.cpp diff --git a/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp b/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp index 5d6c7c9a4ca3c0..f1c3022052f365 100644 --- a/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp +++ b/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.cpp @@ -24,6 +24,8 @@ ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name, ClangTidyContext *Context) : ClangTidyCheck(Name, Context), StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0), + IgnoreSingleArgument( + Options.getLocalOrGlobal("IgnoreSingleArgument", 0) != 0), CommentBoolLiterals(Options.getLocalOrGlobal("CommentBoolLiterals", 0) != 0), CommentIntegerLiterals( @@ -41,6 +43,7 @@ ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name, void ArgumentCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { Options.store(Opts, "StrictMode", StrictMode); + Options.store(Opts, "IgnoreSingleArgument", IgnoreSingleArgument); Options.store(Opts, "CommentBoolLiterals", CommentBoolLiterals); Options.store(Opts, "CommentIntegerLiterals", CommentIntegerLiterals); Options.store(Opts, "CommentFloatLiterals", CommentFloatLiterals); @@ -252,7 +255,7 @@ void ArgumentCommentCheck::checkCallArgs(ASTContext *Ctx, Callee = Callee->getFirstDecl(); unsigned NumArgs = std::min(Args.size(), Callee->getNumParams()); - if (NumArgs == 0) + if ((NumArgs == 0) || (IgnoreSingleArgument && NumArgs == 1)) return; auto MakeFileCharRange = [Ctx](SourceLocation Begin, SourceLocation End) { diff --git a/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.h b/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.h index 216d92c5d8155e..0c66ffbdb3554c 100644 --- a/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.h +++ b/clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.h @@ -41,6 +41,7 @@ class ArgumentCommentCheck : public ClangTidyCheck { private: const unsigned StrictMode : 1; + const unsigned IgnoreSingleArgument : 1; const unsigned CommentBoolLiterals : 1; const unsigned CommentIntegerLiterals : 1; const unsigned CommentFloatLiterals : 1; diff --git a/clang-tools-extra/docs/clang-tidy/checks/bugprone-argument-comment.rst b/clang-tools-extra/docs/clang-tidy/checks/bugprone-argument-comment.rst index afc12186c99d7b..82579020049606 100644 --- a/clang-tools-extra/docs/clang-tidy/checks/bugprone-argument-comment.rst +++ b/clang-tools-extra/docs/clang-tidy/checks/bugprone-argument-comment.rst @@ -28,6 +28,9 @@ Options underscores and case when comparing names -- otherwise they are taken into account. +.. option:: IgnoreSingleArgument + When true, the check will ignore the single argument. + .. option:: CommentBoolLiterals When true, the check will add argument comments in the format diff --git a/clang-tools-extra/test/clang-tidy/bugprone-argument-comment-ignore-single-argument.cpp b/clang-tools-extra/test/clang-tidy/bugprone-argument-comment-ignore-single-argument.cpp new file mode 100644 index 00000000000000..9c6e7ef64c12a7 --- /dev/null +++ b/clang-tools-extra/test/clang-tidy/bugprone-argument-comment-ignore-single-argument.cpp @@ -0,0 +1,97 @@ +// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \ +// RUN: -config="{CheckOptions: [{key: IgnoreSingleArgument, value: 1}, {key: CommentBoolLiterals, value: 1},{key: CommentIntegerLiterals, value: 1}, {key: CommentFloatLiterals, value: 1}, {key: CommentUserDefinedLiterals, value: 1}, {key: CommentStringLiterals, value: 1}, {key: CommentNullPtrs, value: 1}, {key: CommentCharacterLiterals, value: 1}]}" -- + +struct A { + void foo(bool abc); + void foo(bool abc, bool cde); + void foo(const char *, bool abc); + void foo(int iabc); + void foo(float fabc); + void foo(double dabc); + void foo(const char *strabc); + void fooW(const wchar_t *wstrabc); + void fooPtr(A *ptrabc); + void foo(char chabc); +}; + +#define FOO 1 + +void g(int a); +void h(double b); +void i(const char *c); + +double operator"" _km(long double); + +void test() { + A a; + + a.foo(true); + + a.foo(false); + + a.foo(true, false); + // CHECK-MESSAGES: [[@LINE-1]]:9: warning: argument comment missing for literal argument 'abc' [bugprone-argument-comment] + // CHECK-MESSAGES: [[@LINE-2]]:15: warning: argument comment missing for literal argument 'cde' [bugprone-argument-comment] + // CHECK-FIXES: a.foo(/*abc=*/true, /*cde=*/false); + + a.foo(false, true); + // CHECK-MESSAGES: [[@LINE-1]]:9: warning: argument comment missing for literal argument 'abc' [bugprone-argument-comment] + // CHECK-MESSAGES: [[@LINE-2]]:16: warning: argument comment missing for literal argument 'cde' [bugprone-argument-comment] + // CHECK-FIXES: a.foo(/*abc=*/false, /*cde=*/true); + + a.foo(/*abc=*/false, true); + // CHECK-MESSAGES: [[@LINE-1]]:24: warning: argument comment missing for literal argument 'cde' [bugprone-argument-comment] + // CHECK-FIXES: a.foo(/*abc=*/false, /*cde=*/true); + + a.foo(false, /*cde=*/true); + // CHECK-MESSAGES: [[@LINE-1]]:9: warning: argument comment missing for literal argument 'abc' [bugprone-argument-comment] + // CHECK-FIXES: a.foo(/*abc=*/false, /*cde=*/true); + + bool val1 = true; + bool val2 = false; + a.foo(val1, val2); + + a.foo("", true); + // CHECK-MESSAGES: [[@LINE-1]]:13: warning: argument comment missing for literal argument 'abc' [bugprone-argument-comment] + // CHECK-FIXES: a.foo("", /*abc=*/true); + + a.foo(0); + + a.foo(1.0f); + + a.foo(1.0); + + int val3 = 10; + a.foo(val3); + + float val4 = 10.0; + a.foo(val4); + + double val5 = 10.0; + a.foo(val5); + + a.foo("Hello World"); + + a.fooW(L"Hello World"); + + a.fooPtr(nullptr); + + a.foo(402.0_km); + + a.foo('A'); + + g(FOO); + + h(1.0f); + + i(__FILE__); + + g((1)); +} + +void f(bool _with_underscores_); +void ignores_underscores() { + f(false); + + f(true); +}