[clang-tidy] rename_check.py misc-string-constructor bugprone-string-constructor

[alexfh]

Summary

Rename misc-string-constructor to bugprone-string-constructor +
manually update the lenght of '==='s in the doc file.

[xazax.hun]

LG!

[hokein]

LGTM.

clang-tools-extra/trunk/clang-tidy/bugprone/BugproneTidyModule.cpp

 //===--- BugproneTidyModule.cpp - clang-tidy ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "../ClangTidy.h"
 #include "../ClangTidyModule.h"
 #include "../ClangTidyModuleRegistry.h"
 #include "CopyConstructorInitCheck.h"
 #include "IntegerDivisionCheck.h"
 #include "MisplacedOperatorInStrlenInAllocCheck.h"
+#include "StringConstructorCheck.h"
 #include "SuspiciousMemsetUsageCheck.h"
 #include "UndefinedMemoryManipulationCheck.h"
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 class BugproneModule : public ClangTidyModule {
 public:
   void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
     CheckFactories.registerCheck<CopyConstructorInitCheck>(
         "bugprone-copy-constructor-init");
     CheckFactories.registerCheck<IntegerDivisionCheck>(
         "bugprone-integer-division");
     CheckFactories.registerCheck<MisplacedOperatorInStrlenInAllocCheck>(
         "bugprone-misplaced-operator-in-strlen-in-alloc");
+    CheckFactories.registerCheck<StringConstructorCheck>(
+        "bugprone-string-constructor");
     CheckFactories.registerCheck<SuspiciousMemsetUsageCheck>(
         "bugprone-suspicious-memset-usage");
     CheckFactories.registerCheck<UndefinedMemoryManipulationCheck>(
         "bugprone-undefined-memory-manipulation");
   }
 };
 
 } // namespace bugprone

clang-tools-extra/trunk/clang-tidy/bugprone/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS support)
 
 add_clang_library(clangTidyBugproneModule
   BugproneTidyModule.cpp
   CopyConstructorInitCheck.cpp
   IntegerDivisionCheck.cpp
   MisplacedOperatorInStrlenInAllocCheck.cpp
+  StringConstructorCheck.cpp
   SuspiciousMemsetUsageCheck.cpp
   UndefinedMemoryManipulationCheck.cpp
 
   LINK_LIBS
   clangAnalysis
   clangAST
   clangASTMatchers
   clangBasic
   clangLex
   clangTidy
   clangTidyUtils
   clangTooling
   )

clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.h

+//===--- StringConstructorCheck.h - clang-tidy-------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRING_CONSTRUCTOR_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRING_CONSTRUCTOR_H
+
+#include "../ClangTidy.h"
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+/// Finds suspicious string constructor and check their parameters.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-constructor.html
+class StringConstructorCheck : public ClangTidyCheck {
+public:
+  StringConstructorCheck(StringRef Name, ClangTidyContext *Context);
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  const bool WarnOnLargeLength;
+  const unsigned int LargeLengthThreshold;
+};
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_STRING_CONSTRUCTOR_H

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

+//===--- StringConstructorCheck.cpp - clang-tidy---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "StringConstructorCheck.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/FixIt.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace bugprone {
+
+AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
+  return Node.getValue().getZExtValue() > N;
+}
+
+StringConstructorCheck::StringConstructorCheck(StringRef Name,
+                                               ClangTidyContext *Context)
+    : ClangTidyCheck(Name, Context),
+      WarnOnLargeLength(Options.get("WarnOnLargeLength", 1) != 0),
+      LargeLengthThreshold(Options.get("LargeLengthThreshold", 0x800000)) {}
+
+void StringConstructorCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "WarnOnLargeLength", WarnOnLargeLength);
+  Options.store(Opts, "LargeLengthThreshold", LargeLengthThreshold);
+}
+
+void StringConstructorCheck::registerMatchers(MatchFinder *Finder) {
+  if (!getLangOpts().CPlusPlus)
+    return;
+
+  const auto ZeroExpr = expr(ignoringParenImpCasts(integerLiteral(equals(0))));
+  const auto CharExpr = expr(ignoringParenImpCasts(characterLiteral()));
+  const auto NegativeExpr = expr(ignoringParenImpCasts(
+      unaryOperator(hasOperatorName("-"),
+                    hasUnaryOperand(integerLiteral(unless(equals(0)))))));
+  const auto LargeLengthExpr = expr(ignoringParenImpCasts(
+      integerLiteral(isBiggerThan(LargeLengthThreshold))));
+  const auto CharPtrType = type(anyOf(pointerType(), arrayType()));
+
+  // Match a string-literal; even through a declaration with initializer.
+  const auto BoundStringLiteral = stringLiteral().bind("str");
+  const auto ConstStrLiteralDecl = varDecl(
+      isDefinition(), hasType(constantArrayType()), hasType(isConstQualified()),
+      hasInitializer(ignoringParenImpCasts(BoundStringLiteral)));
+  const auto ConstPtrStrLiteralDecl = varDecl(
+      isDefinition(),
+      hasType(pointerType(pointee(isAnyCharacter(), isConstQualified()))),
+      hasInitializer(ignoringParenImpCasts(BoundStringLiteral)));
+  const auto ConstStrLiteral = expr(ignoringParenImpCasts(anyOf(
+      BoundStringLiteral, declRefExpr(hasDeclaration(anyOf(
+                              ConstPtrStrLiteralDecl, ConstStrLiteralDecl))))));
+
+  // Check the fill constructor. Fills the string with n consecutive copies of
+  // character c. [i.e string(size_t n, char c);].
+  Finder->addMatcher(
+      cxxConstructExpr(
+          hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
+          hasArgument(0, hasType(qualType(isInteger()))),
+          hasArgument(1, hasType(qualType(isInteger()))),
+          anyOf(
+              // Detect the expression: string('x', 40);
+              hasArgument(0, CharExpr.bind("swapped-parameter")),
+              // Detect the expression: string(0, ...);
+              hasArgument(0, ZeroExpr.bind("empty-string")),
+              // Detect the expression: string(-4, ...);
+              hasArgument(0, NegativeExpr.bind("negative-length")),
+              // Detect the expression: string(0x1234567, ...);
+              hasArgument(0, LargeLengthExpr.bind("large-length"))))
+          .bind("constructor"),
+      this);
+
+  // Check the literal string constructor with char pointer and length
+  // parameters. [i.e. string (const char* s, size_t n);]
+  Finder->addMatcher(
+      cxxConstructExpr(
+          hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
+          hasArgument(0, hasType(CharPtrType)),
+          hasArgument(1, hasType(isInteger())),
+          anyOf(
+              // Detect the expression: string("...", 0);
+              hasArgument(1, ZeroExpr.bind("empty-string")),
+              // Detect the expression: string("...", -4);
+              hasArgument(1, NegativeExpr.bind("negative-length")),
+              // Detect the expression: string("lit", 0x1234567);
+              hasArgument(1, LargeLengthExpr.bind("large-length")),
+              // Detect the expression: string("lit", 5)
+              allOf(hasArgument(0, ConstStrLiteral.bind("literal-with-length")),
+                    hasArgument(1, ignoringParenImpCasts(
+                                       integerLiteral().bind("int"))))))
+          .bind("constructor"),
+      this);
+}
+
+void StringConstructorCheck::check(const MatchFinder::MatchResult &Result) {
+  const ASTContext &Ctx = *Result.Context;
+  const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("constructor");
+  assert(E && "missing constructor expression");
+  SourceLocation Loc = E->getLocStart();
+
+  if (Result.Nodes.getNodeAs<Expr>("swapped-parameter")) {
+    const Expr *P0 = E->getArg(0);
+    const Expr *P1 = E->getArg(1);
+    diag(Loc, "string constructor parameters are probably swapped;"
+              " expecting string(count, character)")
+        << tooling::fixit::createReplacement(*P0, *P1, Ctx)
+        << tooling::fixit::createReplacement(*P1, *P0, Ctx);
+  } else if (Result.Nodes.getNodeAs<Expr>("empty-string")) {
+    diag(Loc, "constructor creating an empty string");
+  } else if (Result.Nodes.getNodeAs<Expr>("negative-length")) {
+    diag(Loc, "negative value used as length parameter");
+  } else if (Result.Nodes.getNodeAs<Expr>("large-length")) {
+    if (WarnOnLargeLength)
+      diag(Loc, "suspicious large length parameter");
+  } else if (Result.Nodes.getNodeAs<Expr>("literal-with-length")) {
+    const auto *Str = Result.Nodes.getNodeAs<StringLiteral>("str");
+    const auto *Lit = Result.Nodes.getNodeAs<IntegerLiteral>("int");
+    if (Lit->getValue().ugt(Str->getLength())) {
+      diag(Loc, "length is bigger then string literal size");
+    }
+  }
+}
+
+} // namespace bugprone
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/clang-tidy/misc/CMakeLists.txt

add_clang_library(clangTidyMiscModule
   NewDeleteOverloadsCheck.cpp
   NoexceptMoveConstructorCheck.cpp
   NonCopyableObjects.cpp
   RedundantExpressionCheck.cpp
   SizeofContainerCheck.cpp
   SizeofExpressionCheck.cpp
   StaticAssertCheck.cpp
   StringCompareCheck.cpp
-  StringConstructorCheck.cpp
   StringIntegerAssignmentCheck.cpp
   StringLiteralWithEmbeddedNulCheck.cpp
   SuspiciousEnumUsageCheck.cpp
   SuspiciousMissingCommaCheck.cpp
   SuspiciousSemicolonCheck.cpp
   SuspiciousStringCompareCheck.cpp
   SwappedArgumentsCheck.cpp
   ThrowByValueCatchByReferenceCheck.cpp

clang-tools-extra/trunk/clang-tidy/misc/MiscTidyModule.cpp

 #include "NewDeleteOverloadsCheck.h"
 #include "NoexceptMoveConstructorCheck.h"
 #include "NonCopyableObjects.h"
 #include "RedundantExpressionCheck.h"
 #include "SizeofContainerCheck.h"
 #include "SizeofExpressionCheck.h"
 #include "StaticAssertCheck.h"
 #include "StringCompareCheck.h"
-#include "StringConstructorCheck.h"
 #include "StringIntegerAssignmentCheck.h"
 #include "StringLiteralWithEmbeddedNulCheck.h"
 #include "SuspiciousEnumUsageCheck.h"
 #include "SuspiciousMissingCommaCheck.h"
 #include "SuspiciousSemicolonCheck.h"
 #include "SuspiciousStringCompareCheck.h"
 #include "SwappedArgumentsCheck.h"
 #include "ThrowByValueCatchByReferenceCheck.h"
CheckFactories.registerCheck<NonCopyableObjectsCheck>(
         "misc-non-copyable-objects");
     CheckFactories.registerCheck<RedundantExpressionCheck>(
         "misc-redundant-expression");
     CheckFactories.registerCheck<SizeofContainerCheck>("misc-sizeof-container");
     CheckFactories.registerCheck<SizeofExpressionCheck>(
         "misc-sizeof-expression");
     CheckFactories.registerCheck<StaticAssertCheck>("misc-static-assert");
     CheckFactories.registerCheck<StringCompareCheck>("misc-string-compare");
-    CheckFactories.registerCheck<StringConstructorCheck>(
-        "misc-string-constructor");
     CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
         "misc-string-integer-assignment");
     CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>(
         "misc-string-literal-with-embedded-nul");
     CheckFactories.registerCheck<SuspiciousEnumUsageCheck>(
         "misc-suspicious-enum-usage");
     CheckFactories.registerCheck<SuspiciousMissingCommaCheck>(
         "misc-suspicious-missing-comma");

clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.h

-//===--- StringConstructorCheck.h - clang-tidy-------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_CONSTRUCTOR_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_CONSTRUCTOR_H
-
-#include "../ClangTidy.h"
-
-namespace clang {
-namespace tidy {
-namespace misc {
-
-/// Finds suspicious string constructor and check their parameters.
-///
-/// For the user-facing documentation see:
-/// http://clang.llvm.org/extra/clang-tidy/checks/misc-string-constructor.html
-class StringConstructorCheck : public ClangTidyCheck {
-public:
-  StringConstructorCheck(StringRef Name, ClangTidyContext *Context);
-  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
-  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
-  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
-
-private:
-  const bool WarnOnLargeLength;
-  const unsigned int LargeLengthThreshold;
-};
-
-} // namespace misc
-} // namespace tidy
-} // namespace clang
-
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_CONSTRUCTOR_H

clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.cpp

-//===--- StringConstructorCheck.cpp - clang-tidy---------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "StringConstructorCheck.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Tooling/FixIt.h"
-
-using namespace clang::ast_matchers;
-
-namespace clang {
-namespace tidy {
-namespace misc {
-
-AST_MATCHER_P(IntegerLiteral, isBiggerThan, unsigned, N) {
-  return Node.getValue().getZExtValue() > N;
-}
-
-StringConstructorCheck::StringConstructorCheck(StringRef Name,
-                                               ClangTidyContext *Context)
-    : ClangTidyCheck(Name, Context),
-      WarnOnLargeLength(Options.get("WarnOnLargeLength", 1) != 0),
-      LargeLengthThreshold(Options.get("LargeLengthThreshold", 0x800000)) {}
-
-void StringConstructorCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
-  Options.store(Opts, "WarnOnLargeLength", WarnOnLargeLength);
-  Options.store(Opts, "LargeLengthThreshold", LargeLengthThreshold);
-}
-
-void StringConstructorCheck::registerMatchers(MatchFinder *Finder) {
-  if (!getLangOpts().CPlusPlus)
-    return;
-
-  const auto ZeroExpr = expr(ignoringParenImpCasts(integerLiteral(equals(0))));
-  const auto CharExpr = expr(ignoringParenImpCasts(characterLiteral()));
-  const auto NegativeExpr = expr(ignoringParenImpCasts(
-      unaryOperator(hasOperatorName("-"),
-                    hasUnaryOperand(integerLiteral(unless(equals(0)))))));
-  const auto LargeLengthExpr = expr(ignoringParenImpCasts(
-      integerLiteral(isBiggerThan(LargeLengthThreshold))));
-  const auto CharPtrType = type(anyOf(pointerType(), arrayType()));
-
-  // Match a string-literal; even through a declaration with initializer.
-  const auto BoundStringLiteral = stringLiteral().bind("str");
-  const auto ConstStrLiteralDecl = varDecl(
-      isDefinition(), hasType(constantArrayType()), hasType(isConstQualified()),
-      hasInitializer(ignoringParenImpCasts(BoundStringLiteral)));
-  const auto ConstPtrStrLiteralDecl = varDecl(
-      isDefinition(),
-      hasType(pointerType(pointee(isAnyCharacter(), isConstQualified()))),
-      hasInitializer(ignoringParenImpCasts(BoundStringLiteral)));
-  const auto ConstStrLiteral = expr(ignoringParenImpCasts(anyOf(
-      BoundStringLiteral, declRefExpr(hasDeclaration(anyOf(
-                              ConstPtrStrLiteralDecl, ConstStrLiteralDecl))))));
-
-  // Check the fill constructor. Fills the string with n consecutive copies of
-  // character c. [i.e string(size_t n, char c);].
-  Finder->addMatcher(
-      cxxConstructExpr(
-          hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
-          hasArgument(0, hasType(qualType(isInteger()))),
-          hasArgument(1, hasType(qualType(isInteger()))),
-          anyOf(
-              // Detect the expression: string('x', 40);
-              hasArgument(0, CharExpr.bind("swapped-parameter")),
-              // Detect the expression: string(0, ...);
-              hasArgument(0, ZeroExpr.bind("empty-string")),
-              // Detect the expression: string(-4, ...);
-              hasArgument(0, NegativeExpr.bind("negative-length")),
-              // Detect the expression: string(0x1234567, ...);
-              hasArgument(0, LargeLengthExpr.bind("large-length"))))
-          .bind("constructor"),
-      this);
-
-  // Check the literal string constructor with char pointer and length
-  // parameters. [i.e. string (const char* s, size_t n);]
-  Finder->addMatcher(
-      cxxConstructExpr(
-          hasDeclaration(cxxMethodDecl(hasName("basic_string"))),
-          hasArgument(0, hasType(CharPtrType)),
-          hasArgument(1, hasType(isInteger())),
-          anyOf(
-              // Detect the expression: string("...", 0);
-              hasArgument(1, ZeroExpr.bind("empty-string")),
-              // Detect the expression: string("...", -4);
-              hasArgument(1, NegativeExpr.bind("negative-length")),
-              // Detect the expression: string("lit", 0x1234567);
-              hasArgument(1, LargeLengthExpr.bind("large-length")),
-              // Detect the expression: string("lit", 5)
-              allOf(hasArgument(0, ConstStrLiteral.bind("literal-with-length")),
-                    hasArgument(1, ignoringParenImpCasts(
-                                       integerLiteral().bind("int"))))))
-          .bind("constructor"),
-      this);
-}
-
-void StringConstructorCheck::check(const MatchFinder::MatchResult &Result) {
-  const ASTContext &Ctx = *Result.Context;
-  const auto *E = Result.Nodes.getNodeAs<CXXConstructExpr>("constructor");
-  assert(E && "missing constructor expression");
-  SourceLocation Loc = E->getLocStart();
-
-  if (Result.Nodes.getNodeAs<Expr>("swapped-parameter")) {
-    const Expr *P0 = E->getArg(0);
-    const Expr *P1 = E->getArg(1);
-    diag(Loc, "string constructor parameters are probably swapped;"
-              " expecting string(count, character)")
-        << tooling::fixit::createReplacement(*P0, *P1, Ctx)
-        << tooling::fixit::createReplacement(*P1, *P0, Ctx);
-  } else if (Result.Nodes.getNodeAs<Expr>("empty-string")) {
-    diag(Loc, "constructor creating an empty string");
-  } else if (Result.Nodes.getNodeAs<Expr>("negative-length")) {
-    diag(Loc, "negative value used as length parameter");
-  } else if (Result.Nodes.getNodeAs<Expr>("large-length")) {
-    if (WarnOnLargeLength)
-      diag(Loc, "suspicious large length parameter");
-  } else if (Result.Nodes.getNodeAs<Expr>("literal-with-length")) {
-    const auto *Str = Result.Nodes.getNodeAs<StringLiteral>("str");
-    const auto *Lit = Result.Nodes.getNodeAs<IntegerLiteral>("int");
-    if (Lit->getValue().ugt(Str->getLength())) {
-      diag(Loc, "length is bigger then string literal size");
-    }
-  }
-}
-
-} // namespace misc
-} // namespace tidy
-} // namespace clang

clang-tools-extra/trunk/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- The 'misc-string-constructor' check was renamed to `bugprone-string-constructor
+  <http://clang.llvm.org/extra/clang-tidy/checks/bugprone-string-constructor.html>`_
+
 - New `google-avoid-throwing-objc-exception
   <http://clang.llvm.org/extra/clang-tidy/checks/google-objc-avoid-throwing-exception.html>`_ check
 
   Add new check to detect throwing exceptions in Objective-C code, which should be avoided.
 
 - New `objc-property-declaration
   <http://clang.llvm.org/extra/clang-tidy/checks/objc-property-declaration.html>`_ check
 

clang-tools-extra/trunk/docs/clang-tidy/checks/bugprone-string-constructor.rst

+.. title:: clang-tidy - bugprone-string-constructor
+
+bugprone-string-constructor
+===========================
+
+Finds string constructors that are suspicious and probably errors.
+
+A common mistake is to swap parameters to the 'fill' string-constructor.
+
+Examples:
+
+.. code-block:: c++
+
+  std::string str('x', 50); // should be str(50, 'x')
+
+Calling the string-literal constructor with a length bigger than the literal is
+suspicious and adds extra random characters to the string.
+
+Examples:
+
+.. code-block:: c++
+
+  std::string("test", 200);   // Will include random characters after "test".
+
+Creating an empty string from constructors with parameters is considered
+suspicious. The programmer should use the empty constructor instead.
+
+Examples:
+
+.. code-block:: c++
+
+  std::string("test", 0);   // Creation of an empty string.
+
+Options
+-------
+
+.. option::  WarnOnLargeLength
+
+   When non-zero, the check will warn on a string with a length greater than
+   `LargeLengthThreshold`. Default is `1`.
+
+.. option::  LargeLengthThreshold
+
+   An integer specifying the large length threshold. Default is `0x800000`.

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

.. toctree::
    android-cloexec-inotify-init1
    android-cloexec-memfd-create
    android-cloexec-open
    android-cloexec-socket
    boost-use-to-string
    bugprone-copy-constructor-init
    bugprone-integer-division
    bugprone-misplaced-operator-in-strlen-in-alloc
+   bugprone-string-constructor
    bugprone-suspicious-memset-usage
    bugprone-undefined-memory-manipulation
    cert-dcl03-c (redirects to misc-static-assert) <cert-dcl03-c>
    cert-dcl21-cpp
    cert-dcl50-cpp
    cert-dcl54-cpp (redirects to misc-new-delete-overloads) <cert-dcl54-cpp>
    cert-dcl58-cpp
    cert-dcl59-cpp (redirects to google-build-namespaces) <cert-dcl59-cpp>
.. toctree::
    misc-new-delete-overloads
    misc-noexcept-move-constructor
    misc-non-copyable-objects
    misc-redundant-expression
    misc-sizeof-container
    misc-sizeof-expression
    misc-static-assert
    misc-string-compare
-   misc-string-constructor
    misc-string-integer-assignment
    misc-string-literal-with-embedded-nul
    misc-suspicious-enum-usage
    misc-suspicious-missing-comma
    misc-suspicious-semicolon
    misc-suspicious-string-compare
    misc-swapped-arguments
    misc-throw-by-value-catch-by-reference

clang-tools-extra/trunk/docs/clang-tidy/checks/misc-string-constructor.rst

-.. title:: clang-tidy - misc-string-constructor
-
-misc-string-constructor
-=======================
-
-Finds string constructors that are suspicious and probably errors.
-
-A common mistake is to swap parameters to the 'fill' string-constructor.
-
-Examples:
-
-.. code-block:: c++
-
-  std::string str('x', 50); // should be str(50, 'x')
-
-Calling the string-literal constructor with a length bigger than the literal is
-suspicious and adds extra random characters to the string.
-
-Examples:
-
-.. code-block:: c++
-
-  std::string("test", 200);   // Will include random characters after "test".
-
-Creating an empty string from constructors with parameters is considered
-suspicious. The programmer should use the empty constructor instead.
-
-Examples:
-
-.. code-block:: c++
-
-  std::string("test", 0);   // Creation of an empty string.
-
-Options
--------
-
-.. option::  WarnOnLargeLength
-
-   When non-zero, the check will warn on a string with a length greater than
-   `LargeLengthThreshold`. Default is `1`.
-
-.. option::  LargeLengthThreshold
-
-   An integer specifying the large length threshold. Default is `0x800000`.

clang-tools-extra/trunk/test/clang-tidy/bugprone-string-constructor.cpp

+// RUN: %check_clang_tidy %s bugprone-string-constructor %t
+
+namespace std {
+template <typename T>
+class allocator {};
+template <typename T>
+class char_traits {};
+template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C> >
+struct basic_string {
+  basic_string();
+  basic_string(const C*, unsigned int size);
+  basic_string(unsigned int size, C c);
+};
+typedef basic_string<char> string;
+typedef basic_string<wchar_t> wstring;
+}
+
+const char* kText = "";
+const char kText2[] = "";
+extern const char kText3[];
+
+void Test() {
+  std::string str('x', 4);
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: string constructor parameters are probably swapped; expecting string(count, character) [bugprone-string-constructor]
+  // CHECK-FIXES: std::string str(4, 'x');
+  std::wstring wstr(L'x', 4);
+  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: string constructor parameters are probably swapped
+  // CHECK-FIXES: std::wstring wstr(4, L'x');
+  std::string s0(0, 'x');
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: constructor creating an empty string
+  std::string s1(-4, 'x');
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: negative value used as length parameter
+  std::string s2(0x1000000, 'x');
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: suspicious large length parameter
+
+  std::string q0("test", 0);
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: constructor creating an empty string
+  std::string q1(kText, -4);
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: negative value used as length parameter
+  std::string q2("test", 200);
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: length is bigger then string literal size
+  std::string q3(kText, 200);
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: length is bigger then string literal size
+  std::string q4(kText2, 200);
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: length is bigger then string literal size
+  std::string q5(kText3,  0x1000000);
+  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: suspicious large length parameter
+}
+
+void Valid() {
+  std::string empty();
+  std::string str(4, 'x');
+  std::wstring wstr(4, L'x');
+  std::string s1("test", 4);
+  std::string s2("test", 3);
+}

clang-tools-extra/trunk/test/clang-tidy/misc-string-constructor.cpp

-// RUN: %check_clang_tidy %s misc-string-constructor %t
-
-namespace std {
-template <typename T>
-class allocator {};
-template <typename T>
-class char_traits {};
-template <typename C, typename T = std::char_traits<C>, typename A = std::allocator<C> >
-struct basic_string {
-  basic_string();
-  basic_string(const C*, unsigned int size);
-  basic_string(unsigned int size, C c);
-};
-typedef basic_string<char> string;
-typedef basic_string<wchar_t> wstring;
-}
-
-const char* kText = "";
-const char kText2[] = "";
-extern const char kText3[];
-
-void Test() {
-  std::string str('x', 4);
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: string constructor parameters are probably swapped; expecting string(count, character) [misc-string-constructor]
-  // CHECK-FIXES: std::string str(4, 'x');
-  std::wstring wstr(L'x', 4);
-  // CHECK-MESSAGES: [[@LINE-1]]:16: warning: string constructor parameters are probably swapped
-  // CHECK-FIXES: std::wstring wstr(4, L'x');
-  std::string s0(0, 'x');
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: constructor creating an empty string
-  std::string s1(-4, 'x');
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: negative value used as length parameter
-  std::string s2(0x1000000, 'x');
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: suspicious large length parameter
-
-  std::string q0("test", 0);
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: constructor creating an empty string
-  std::string q1(kText, -4);
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: negative value used as length parameter
-  std::string q2("test", 200);
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: length is bigger then string literal size
-  std::string q3(kText, 200);
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: length is bigger then string literal size
-  std::string q4(kText2, 200);
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: length is bigger then string literal size
-  std::string q5(kText3,  0x1000000);
-  // CHECK-MESSAGES: [[@LINE-1]]:15: warning: suspicious large length parameter
-}
-
-void Valid() {
-  std::string empty();
-  std::string str(4, 'x');
-  std::wstring wstr(4, L'x');
-  std::string s1("test", 4);
-  std::string s2("test", 3);
-}