Index: clang-tools-extra/trunk/clang-tidy/bugprone/BugproneTidyModule.cpp =================================================================== --- clang-tools-extra/trunk/clang-tidy/bugprone/BugproneTidyModule.cpp +++ clang-tools-extra/trunk/clang-tidy/bugprone/BugproneTidyModule.cpp @@ -13,6 +13,7 @@ #include "CopyConstructorInitCheck.h" #include "IntegerDivisionCheck.h" #include "MisplacedOperatorInStrlenInAllocCheck.h" +#include "StringConstructorCheck.h" #include "SuspiciousMemsetUsageCheck.h" #include "UndefinedMemoryManipulationCheck.h" @@ -29,6 +30,8 @@ "bugprone-integer-division"); CheckFactories.registerCheck( "bugprone-misplaced-operator-in-strlen-in-alloc"); + CheckFactories.registerCheck( + "bugprone-string-constructor"); CheckFactories.registerCheck( "bugprone-suspicious-memset-usage"); CheckFactories.registerCheck( Index: clang-tools-extra/trunk/clang-tidy/bugprone/CMakeLists.txt =================================================================== --- clang-tools-extra/trunk/clang-tidy/bugprone/CMakeLists.txt +++ clang-tools-extra/trunk/clang-tidy/bugprone/CMakeLists.txt @@ -5,6 +5,7 @@ CopyConstructorInitCheck.cpp IntegerDivisionCheck.cpp MisplacedOperatorInStrlenInAllocCheck.cpp + StringConstructorCheck.cpp SuspiciousMemsetUsageCheck.cpp UndefinedMemoryManipulationCheck.cpp Index: clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.h =================================================================== --- clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.h +++ clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.h @@ -0,0 +1,39 @@ +//===--- 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 Index: clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.cpp =================================================================== --- clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.cpp +++ clang-tools-extra/trunk/clang-tidy/bugprone/StringConstructorCheck.cpp @@ -0,0 +1,134 @@ +//===--- 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("constructor"); + assert(E && "missing constructor expression"); + SourceLocation Loc = E->getLocStart(); + + if (Result.Nodes.getNodeAs("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("empty-string")) { + diag(Loc, "constructor creating an empty string"); + } else if (Result.Nodes.getNodeAs("negative-length")) { + diag(Loc, "negative value used as length parameter"); + } else if (Result.Nodes.getNodeAs("large-length")) { + if (WarnOnLargeLength) + diag(Loc, "suspicious large length parameter"); + } else if (Result.Nodes.getNodeAs("literal-with-length")) { + const auto *Str = Result.Nodes.getNodeAs("str"); + const auto *Lit = Result.Nodes.getNodeAs("int"); + if (Lit->getValue().ugt(Str->getLength())) { + diag(Loc, "length is bigger then string literal size"); + } + } +} + +} // namespace bugprone +} // namespace tidy +} // namespace clang Index: clang-tools-extra/trunk/clang-tidy/misc/CMakeLists.txt =================================================================== --- clang-tools-extra/trunk/clang-tidy/misc/CMakeLists.txt +++ clang-tools-extra/trunk/clang-tidy/misc/CMakeLists.txt @@ -31,7 +31,6 @@ SizeofExpressionCheck.cpp StaticAssertCheck.cpp StringCompareCheck.cpp - StringConstructorCheck.cpp StringIntegerAssignmentCheck.cpp StringLiteralWithEmbeddedNulCheck.cpp SuspiciousEnumUsageCheck.cpp Index: clang-tools-extra/trunk/clang-tidy/misc/MiscTidyModule.cpp =================================================================== --- clang-tools-extra/trunk/clang-tidy/misc/MiscTidyModule.cpp +++ clang-tools-extra/trunk/clang-tidy/misc/MiscTidyModule.cpp @@ -38,7 +38,6 @@ #include "SizeofExpressionCheck.h" #include "StaticAssertCheck.h" #include "StringCompareCheck.h" -#include "StringConstructorCheck.h" #include "StringIntegerAssignmentCheck.h" #include "StringLiteralWithEmbeddedNulCheck.h" #include "SuspiciousEnumUsageCheck.h" @@ -114,8 +113,6 @@ "misc-sizeof-expression"); CheckFactories.registerCheck("misc-static-assert"); CheckFactories.registerCheck("misc-string-compare"); - CheckFactories.registerCheck( - "misc-string-constructor"); CheckFactories.registerCheck( "misc-string-integer-assignment"); CheckFactories.registerCheck( Index: clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.h =================================================================== --- clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.h +++ clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.h @@ -1,39 +0,0 @@ -//===--- 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 Index: clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.cpp =================================================================== --- clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.cpp +++ clang-tools-extra/trunk/clang-tidy/misc/StringConstructorCheck.cpp @@ -1,134 +0,0 @@ -//===--- 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("constructor"); - assert(E && "missing constructor expression"); - SourceLocation Loc = E->getLocStart(); - - if (Result.Nodes.getNodeAs("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("empty-string")) { - diag(Loc, "constructor creating an empty string"); - } else if (Result.Nodes.getNodeAs("negative-length")) { - diag(Loc, "negative value used as length parameter"); - } else if (Result.Nodes.getNodeAs("large-length")) { - if (WarnOnLargeLength) - diag(Loc, "suspicious large length parameter"); - } else if (Result.Nodes.getNodeAs("literal-with-length")) { - const auto *Str = Result.Nodes.getNodeAs("str"); - const auto *Lit = Result.Nodes.getNodeAs("int"); - if (Lit->getValue().ugt(Str->getLength())) { - diag(Loc, "length is bigger then string literal size"); - } - } -} - -} // namespace misc -} // namespace tidy -} // namespace clang Index: clang-tools-extra/trunk/docs/ReleaseNotes.rst =================================================================== --- clang-tools-extra/trunk/docs/ReleaseNotes.rst +++ clang-tools-extra/trunk/docs/ReleaseNotes.rst @@ -57,6 +57,9 @@ Improvements to clang-tidy -------------------------- +- The 'misc-string-constructor' check was renamed to `bugprone-string-constructor + `_ + - New `google-avoid-throwing-objc-exception `_ check Index: clang-tools-extra/trunk/docs/clang-tidy/checks/bugprone-string-constructor.rst =================================================================== --- clang-tools-extra/trunk/docs/clang-tidy/checks/bugprone-string-constructor.rst +++ clang-tools-extra/trunk/docs/clang-tidy/checks/bugprone-string-constructor.rst @@ -0,0 +1,44 @@ +.. 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`. Index: clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst =================================================================== --- clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst +++ clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst @@ -20,6 +20,7 @@ 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) @@ -132,7 +133,6 @@ 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 Index: clang-tools-extra/trunk/docs/clang-tidy/checks/misc-string-constructor.rst =================================================================== --- clang-tools-extra/trunk/docs/clang-tidy/checks/misc-string-constructor.rst +++ clang-tools-extra/trunk/docs/clang-tidy/checks/misc-string-constructor.rst @@ -1,44 +0,0 @@ -.. 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`. Index: clang-tools-extra/trunk/test/clang-tidy/bugprone-string-constructor.cpp =================================================================== --- clang-tools-extra/trunk/test/clang-tidy/bugprone-string-constructor.cpp +++ clang-tools-extra/trunk/test/clang-tidy/bugprone-string-constructor.cpp @@ -0,0 +1,56 @@ +// RUN: %check_clang_tidy %s bugprone-string-constructor %t + +namespace std { +template +class allocator {}; +template +class char_traits {}; +template , typename A = std::allocator > +struct basic_string { + basic_string(); + basic_string(const C*, unsigned int size); + basic_string(unsigned int size, C c); +}; +typedef basic_string string; +typedef basic_string 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); +} Index: clang-tools-extra/trunk/test/clang-tidy/misc-string-constructor.cpp =================================================================== --- clang-tools-extra/trunk/test/clang-tidy/misc-string-constructor.cpp +++ clang-tools-extra/trunk/test/clang-tidy/misc-string-constructor.cpp @@ -1,56 +0,0 @@ -// RUN: %check_clang_tidy %s misc-string-constructor %t - -namespace std { -template -class allocator {}; -template -class char_traits {}; -template , typename A = std::allocator > -struct basic_string { - basic_string(); - basic_string(const C*, unsigned int size); - basic_string(unsigned int size, C c); -}; -typedef basic_string string; -typedef basic_string 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); -}