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

   1 //===--- SuspiciousMissingCommaCheck.cpp - clang-tidy----------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "SuspiciousMissingCommaCheck.h"
  10 #include "clang/AST/ASTContext.h"
  11 #include "clang/ASTMatchers/ASTMatchFinder.h"
  12
  13 using namespace clang::ast_matchers;
  14
  15 namespace clang::tidy::bugprone {
  16
  17 namespace {
  18
  19 bool isConcatenatedLiteralsOnPurpose(ASTContext *Ctx,
  20                                      const StringLiteral *Lit) {
  21   // String literals surrounded by parentheses are assumed to be on purpose.
  22   //    i.e.:  const char* Array[] = { ("a" "b" "c"), "d", [...] };
  23
  24   TraversalKindScope RAII(*Ctx, TK_AsIs);
  25   auto Parents = Ctx->getParents(*Lit);
  26   if (Parents.size() == 1 && Parents[0].get<ParenExpr>() != nullptr)
  27     return true;
  28
  29   // Appropriately indented string literals are assumed to be on purpose.
  30   // The following frequent indentation is accepted:
  31   //     const char* Array[] = {
  32   //       "first literal"
  33   //           "indented literal"
  34   //           "indented literal",
  35   //       "second literal",
  36   //       [...]
  37   //     };
  38   const SourceManager &SM = Ctx->getSourceManager();
  39   bool IndentedCorrectly = true;
  40   SourceLocation FirstToken = Lit->getStrTokenLoc(0);
  41   FileID BaseFID = SM.getFileID(FirstToken);
  42   unsigned int BaseIndent = SM.getSpellingColumnNumber(FirstToken);
  43   unsigned int BaseLine = SM.getSpellingLineNumber(FirstToken);
  44   for (unsigned int TokNum = 1; TokNum < Lit->getNumConcatenated(); ++TokNum) {
  45     SourceLocation Token = Lit->getStrTokenLoc(TokNum);
  46     FileID FID = SM.getFileID(Token);
  47     unsigned int Indent = SM.getSpellingColumnNumber(Token);
  48     unsigned int Line = SM.getSpellingLineNumber(Token);
  49     if (FID != BaseFID || Line != BaseLine + TokNum || Indent <= BaseIndent) {
  50       IndentedCorrectly = false;
  51       break;
  52     }
  53   }
  54   if (IndentedCorrectly)
  55     return true;
  56
  57   // There is no pattern recognized by the checker, assume it's not on purpose.
  58   return false;
  59 }
  60
  61 AST_MATCHER_P(StringLiteral, isConcatenatedLiteral, unsigned,
  62               MaxConcatenatedTokens) {
  63   return Node.getNumConcatenated() > 1 &&
  64          Node.getNumConcatenated() < MaxConcatenatedTokens &&
  65          !isConcatenatedLiteralsOnPurpose(&Finder->getASTContext(), &Node);
  66 }
  67
  68 } // namespace
  69
  70 SuspiciousMissingCommaCheck::SuspiciousMissingCommaCheck(
  71     StringRef Name, ClangTidyContext *Context)
  72     : ClangTidyCheck(Name, Context),
  73       SizeThreshold(Options.get("SizeThreshold", 5U)),
  74       RatioThreshold(std::stod(Options.get("RatioThreshold", ".2").str())),
  75       MaxConcatenatedTokens(Options.get("MaxConcatenatedTokens", 5U)) {}
  76
  77 void SuspiciousMissingCommaCheck::storeOptions(
  78     ClangTidyOptions::OptionMap &Opts) {
  79   Options.store(Opts, "SizeThreshold", SizeThreshold);
  80   Options.store(Opts, "RatioThreshold", std::to_string(RatioThreshold));
  81   Options.store(Opts, "MaxConcatenatedTokens", MaxConcatenatedTokens);
  82 }
  83
  84 void SuspiciousMissingCommaCheck::registerMatchers(MatchFinder *Finder) {
  85   const auto ConcatenatedStringLiteral =
  86       stringLiteral(isConcatenatedLiteral(MaxConcatenatedTokens)).bind("str");
  87
  88   const auto StringsInitializerList =
  89       initListExpr(hasType(constantArrayType()),
  90                    has(ignoringParenImpCasts(expr(ConcatenatedStringLiteral))));
  91
  92   Finder->addMatcher(StringsInitializerList.bind("list"), this);
  93 }
  94
  95 void SuspiciousMissingCommaCheck::check(
  96     const MatchFinder::MatchResult &Result) {
  97   const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list");
  98   const auto *ConcatenatedLiteral =
  99       Result.Nodes.getNodeAs<StringLiteral>("str");
 100   assert(InitializerList && ConcatenatedLiteral);
 101
 102   // Skip small arrays as they often generate false-positive.
 103   unsigned int Size = InitializerList->getNumInits();
 104   if (Size < SizeThreshold)
 105     return;
 106
 107   // Count the number of occurrence of concatenated string literal.
 108   unsigned int Count = 0;
 109   for (unsigned int I = 0; I < Size; ++I) {
 110     const Expr *Child = InitializerList->getInit(I)->IgnoreImpCasts();
 111     if (const auto *Literal = dyn_cast<StringLiteral>(Child)) {
 112       if (Literal->getNumConcatenated() > 1)
 113         ++Count;
 114     }
 115   }
 116
 117   // Warn only when concatenation is not common in this initializer list.
 118   // The current threshold is set to less than 1/5 of the string literals.
 119   if (double(Count) / Size > RatioThreshold)
 120     return;
 121
 122   diag(ConcatenatedLiteral->getBeginLoc(),
 123        "suspicious string literal, probably missing a comma");
 124 }
 125
 126 } // namespace clang::tidy::bugprone