FormatvStringCheck.cpp

Go to the documentation of this file.

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "FormatvStringCheck.h"
#include "../utils/OptionsUtils.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Expr.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "llvm/ADT/SmallBitVector.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Error.h"
 
using namespace clang::ast_matchers;
 
namespace clang::tidy::llvm_check {
 
namespace {
 
struct ParseResult {
  SmallVector<unsigned, 4> Indices;
  unsigned MaxIndex = 0;
};
 
} // namespace
 
static Expected<ParseResult> parseFormatvString(StringRef Fmt) {
  ParseResult Result;
  unsigned NextAutoIndex = 0;
  bool HasAutomatic = false;
  bool HasExplicit = false;
 
  while (!Fmt.empty()) {
    const size_t OpenBrace = Fmt.find('{');
    if (OpenBrace == StringRef::npos)
      break;
 
    Fmt = Fmt.drop_front(OpenBrace);
 
    // Handle escaped braces '{{'.
    if (Fmt.consume_front("{{"))
      continue;
 
    // Find the closing '}'.
    const size_t CloseBrace = Fmt.find('}');
    if (CloseBrace == StringRef::npos)
      return llvm::createStringError("unterminated brace in format string");
 
    // Extract the content between braces.
    const StringRef Content = Fmt.substr(1, CloseBrace - 1);
    Fmt = Fmt.drop_front(CloseBrace + 1);
 
    // Parse the replacement field: [index] ["," layout] [":" format]
    StringRef IndexStr = Content.substr(0, Content.find_first_of(",:"));
 
    IndexStr = IndexStr.trim();
 
    unsigned Index = 0;
    if (IndexStr.empty()) {
      Index = NextAutoIndex++;
      HasAutomatic = true;
    } else {
      if (IndexStr.getAsInteger(10, Index))
        return llvm::createStringError(
            "invalid replacement index in format string");
      HasExplicit = true;
    }
 
    Result.Indices.push_back(Index);
    Result.MaxIndex = std::max(Result.MaxIndex, Index);
  }
 
  if (HasAutomatic && HasExplicit)
    return llvm::createStringError(
        "format string mixes automatic and explicit indices");
 
  return Result;
}
 
FormatvStringCheck::FormatvStringCheck(StringRef Name,
                                       ClangTidyContext *Context)
    : ClangTidyCheck(Name, Context),
      AdditionalFunctions(Options.get("AdditionalFunctions", "")) {
  Functions = utils::options::parseStringList(AdditionalFunctions);
  Functions.emplace_back("::llvm::formatv");
  Functions.emplace_back("::llvm::createStringErrorV");
}
 
void FormatvStringCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
  Options.store(Opts, "AdditionalFunctions", AdditionalFunctions);
}
 
void FormatvStringCheck::registerMatchers(MatchFinder *Finder) {
  // Build a matcher for all configured function names.
  Finder->addMatcher(
      callExpr(callee(functionDecl(hasAnyName(Functions),
                                   ast_matchers::isTemplateInstantiation())),
               argumentCountAtLeast(1))
          .bind("call"),
      this);
}
 
void FormatvStringCheck::check(const MatchFinder::MatchResult &Result) {
  const auto *Call = Result.Nodes.getNodeAs<CallExpr>("call");
  assert(Call && Call->getNumArgs() > 0);
 
  const auto *FD = Call->getDirectCallee();
  assert(FD);
 
  // Find the format string index from the template signature: it's the
  // parameter immediately before the trailing parameter pack.
  const FunctionDecl *TemplateDecl = FD;
  if (const FunctionTemplateDecl *Primary = FD->getPrimaryTemplate())
    TemplateDecl = Primary->getTemplatedDecl();
 
  const unsigned NumDeclParams = TemplateDecl->getNumParams();
  if (NumDeclParams < 2)
    return;
 
  const unsigned PackParamIndex = NumDeclParams - 1;
  if (!TemplateDecl->getParamDecl(PackParamIndex)->isParameterPack())
    return;
 
  const unsigned FmtStringIndex = PackParamIndex - 1;
 
  if (Call->getNumArgs() <= FmtStringIndex)
    return;
 
  // Extract the format string literal.
  const Expr *FmtArg = Call->getArg(FmtStringIndex)->IgnoreParenImpCasts();
  const auto *FmtLiteral = dyn_cast<StringLiteral>(FmtArg);
  if (!FmtLiteral)
    return;
 
  const StringRef FmtString = FmtLiteral->getString();
  const int NumFmtArgs = Call->getNumArgs() - PackParamIndex;
 
  auto ParsedOrErr = parseFormatvString(FmtString);
  if (!ParsedOrErr) {
    diag(FmtLiteral->getBeginLoc(), toString(ParsedOrErr.takeError()));
    return;
  }
 
  const ParseResult &Parsed = *ParsedOrErr;
  const int NumRequiredArgs = Parsed.Indices.empty() ? 0 : Parsed.MaxIndex + 1;
 
  if (NumRequiredArgs > NumFmtArgs) {
    diag(FmtLiteral->getBeginLoc(),
         "format string requires %0 argument%s0, but %1 argument%s1 "
         "%plural{1:was|:were}1 provided")
        << NumRequiredArgs << NumFmtArgs;
    return;
  }
 
  // Check for unused arguments: both indices not referenced by the format
  // string, and trailing arguments beyond what the format string requires.
  llvm::SmallBitVector UnusedIndices(NumFmtArgs, true);
  for (const unsigned Index : Parsed.Indices)
    UnusedIndices.reset(Index);
 
  for (const auto UnusedIndex : UnusedIndices.set_bits()) {
    const Expr *UnusedArg = Call->getArg(PackParamIndex + UnusedIndex);
    diag(UnusedArg->getBeginLoc(), "argument unused in format string");
  }
}
 
} // namespace clang::tidy::llvm_check