Add an option "IgnoreStdFunctionArguments" to bugprone-argument-comment.

Standard library function has different prototypes between different
compilers. For example, memset() in gcc, the prototype might be:

	void* memset(void* dest, int ch, size_t count);

So if we run clang-tidy, it might add comment to the argument like this:

	memset(buffer, /*ch=*/0, count);

But in vc, the prototype might be:

	void* memset(void* _Dst, int _Val, size_t _Size);

So if we run clang-tidy, it might add comment to the argument like this:

	memset(buffer, /*_Val*/0, count);

That means the same code might pass build under one compiler but fail
under another compiler.

This change tries to fix this issue. It adds an option
"IgnoreStdFunctionArguments". If it is true, clang-tidy will try its
best to recongize the standard function, and ignore the argument comment
check on such function declared in system library.

Author: xieyubo

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

@@ -25,6 +25,7 @@ ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name,
     : ClangTidyCheck(Name, Context),
       StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0),
       IgnoreSingleArgument(Options.get("IgnoreSingleArgument", 0) != 0),
+      IgnoreStdFunctionArguments(Options.get("IgnoreStdFunctionArguments", 0) != 0),
       CommentBoolLiterals(Options.get("CommentBoolLiterals", 0) != 0),
       CommentIntegerLiterals(Options.get("CommentIntegerLiterals", 0) != 0),
       CommentFloatLiterals(Options.get("CommentFloatLiterals", 0) != 0),
@@ -38,6 +39,7 @@ ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name,
 void ArgumentCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "StrictMode", StrictMode);
   Options.store(Opts, "IgnoreSingleArgument", IgnoreSingleArgument);
+  Options.store(Opts, "IgnoreStdFunctionArguments", IgnoreStdFunctionArguments);
   Options.store(Opts, "CommentBoolLiterals", CommentBoolLiterals);
   Options.store(Opts, "CommentIntegerLiterals", CommentIntegerLiterals);
   Options.store(Opts, "CommentFloatLiterals", CommentFloatLiterals);
@@ -254,6 +256,52 @@ void ArgumentCommentCheck::checkCallArgs(ASTContext *Ctx,
   if ((NumArgs == 0) || (IgnoreSingleArgument && NumArgs == 1))
     return;
 
+  if (IgnoreStdFunctionArguments) {
+    const SourceManager& SourceMgr = Ctx->getSourceManager();
+    const FileID FileId = SourceMgr.getFileID(Callee->getLocation());
+    const unsigned int FileIdHash = FileId.getHashValue();
+    if (StdFileIDs.find(FileIdHash) != StdFileIDs.end()) {
+      // The function is declared in a standard library header file.
+      // Ignore the argument comment check.
+      return;
+    }
+
+    if (NotStdFileIDs.find(FileIdHash) == NotStdFileIDs.end()) {
+      // Currently, we don't know whether this function is declared
+      // in a standard library header file or not. Let's make the
+      // following assumption: if the header file of this function
+      // exists under the same folder (or sub folder) of <string>
+      // or <stdio.h>, we assume this function is declared in a
+      // header file of standard library.
+      const FileEntry* FileEntry = SourceMgr.getFileEntryForID(FileId);
+      if (FileEntry) {
+        llvm::StringRef Path = FileEntry->tryGetRealPathName();
+        while (llvm::sys::path::has_parent_path(Path)) {
+          Path = llvm::sys::path::parent_path(Path);
+          SmallString<256> StdStringFilePath = Path, StdioFilePath = Path;
+          llvm::sys::path::append(StdStringFilePath, "string");
+          llvm::sys::path::append(StdioFilePath, "stdio.h");
+          if (llvm::sys::fs::exists(StdStringFilePath) ||
+              llvm::sys::fs::exists(StdioFilePath)) {
+            // Find <string> or <stdio.h> in the same folder or
+            // one of the parent folder. Assume the function is
+            // declared in a standard library header file also.
+            // Save the file id hash for next check and ignore
+            // the argument comment check.
+            StdFileIDs.insert(FileIdHash);
+            return;
+          }
+        }
+      }
+      // Can't find <string> or <stdio.h> in the same folder or
+      // all of the parent folders. Assume the function is not
+      // declared in a header file of standard library. Save the
+      // file id hash for next check and continue the argument
+      // comment check.
+      NotStdFileIDs.insert(FileIdHash);
+    }
+  }
+
   auto MakeFileCharRange = [Ctx](SourceLocation Begin, SourceLocation End) {
     return Lexer::makeFileCharRange(CharSourceRange::getCharRange(Begin, End),
                                     Ctx->getSourceManager(),

clang-tools-extra/clang-tidy/bugprone/ArgumentCommentCheck.h

@@ -11,6 +11,7 @@
 
 #include "../ClangTidyCheck.h"
 #include "llvm/Support/Regex.h"
+#include <unordered_set>
 
 namespace clang {
 namespace tidy {
@@ -42,6 +43,7 @@ class ArgumentCommentCheck : public ClangTidyCheck {
 private:
   const unsigned StrictMode : 1;
   const unsigned IgnoreSingleArgument : 1;
+  const unsigned IgnoreStdFunctionArguments : 1;
   const unsigned CommentBoolLiterals : 1;
   const unsigned CommentIntegerLiterals : 1;
   const unsigned CommentFloatLiterals : 1;
@@ -50,6 +52,8 @@ class ArgumentCommentCheck : public ClangTidyCheck {
   const unsigned CommentCharacterLiterals : 1;
   const unsigned CommentNullPtrs : 1;
   llvm::Regex IdentRE;
+  std::unordered_set<unsigned> StdFileIDs;
+  std::unordered_set<unsigned> NotStdFileIDs;
 
   void checkCallArgs(ASTContext *Ctx, const FunctionDecl *Callee,
                      SourceLocation ArgBeginLoc,

clang-tools-extra/docs/clang-tidy/checks/bugprone-argument-comment.rst

@@ -32,6 +32,10 @@ Options
 
    When true, the check will ignore the single argument.
 
+.. option:: IgnoreStdFunctionArguments
+
+   When true, the check will ignore functions declared in standard libraries.
+
 .. option:: CommentBoolLiterals
 
    When true, the check will add argument comments in the format

clang-tools-extra/test/clang-tidy/bugprone-argument-comment-ignore-std-function-arguments.cpp

@@ -0,0 +1,18 @@
+// RUN: %check_clang_tidy %s bugprone-argument-comment %t -- \
+// RUN:   -config="{CheckOptions: [ \
+// RUN:     {key: bugprone-argument-comment.IgnoreStdFunctionArguments, value: 1}, \
+// RUN:     {key: bugprone-argument-comment.CommentIntegerLiterals, value: 1}]}" --
+
+#include <string.h>
+
+void g(int i);
+
+void foo()
+{
+    g(1);
+    // CHECK-MESSAGES: [[@LINE-1]]:7: warning: argument comment missing for literal argument 'i' [bugprone-argument-comment]
+    // CHECK-FIXES: g(/*i=*/1);
+
+    char buffer[1024];
+    memset(buffer, 0, sizeof(buffer));
+}