clang-tools-extra/clang-tidy/utils/FormatStringConverter.h

   1 //===--- FormatStringConverter.h - clang-tidy--------------------*- C++ -*-===//
   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 /// \file
  10 /// Declaration of the FormatStringConverter class which is used to convert
  11 /// printf format strings to C++ std::formatter format strings.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H
  16 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H
  17
  18 #include "clang/AST/ASTContext.h"
  19 #include "clang/AST/FormatString.h"
  20 #include "clang/ASTMatchers/ASTMatchers.h"
  21 #include <string>
  22
  23 namespace clang::tidy::utils {
  24
  25 /// Convert a printf-style format string to a std::formatter-style one, and
  26 /// prepare any casts that are required to wrap the arguments to retain printf
  27 /// compatibility. This class is expecting to work on the already-cooked format
  28 /// string (i.e. all the escapes have been converted) so we have to convert them
  29 /// back. This means that we might not convert them back using the same form.
  30 class FormatStringConverter
  31     : public clang::analyze_format_string::FormatStringHandler {
  32 public:
  33   using ConversionSpecifier = clang::analyze_format_string::ConversionSpecifier;
  34   using PrintfSpecifier = analyze_printf::PrintfSpecifier;
  35   FormatStringConverter(ASTContext *Context, const CallExpr *Call,
  36                         unsigned FormatArgOffset, bool StrictMode,
  37                         const LangOptions &LO);
  38
  39   bool canApply() const { return ConversionNotPossibleReason.empty(); }
  40   const std::string &conversionNotPossibleReason() const {
  41     return ConversionNotPossibleReason;
  42   }
  43   void applyFixes(DiagnosticBuilder &Diag, SourceManager &SM);
  44   bool usePrintNewlineFunction() const { return UsePrintNewlineFunction; }
  45
  46 private:
  47   ASTContext *Context;
  48   const bool CastMismatchedIntegerTypes;
  49   const Expr *const *Args;
  50   const unsigned NumArgs;
  51   unsigned ArgsOffset;
  52   const LangOptions &LangOpts;
  53   std::string ConversionNotPossibleReason;
  54   bool FormatStringNeededRewriting = false;
  55   bool UsePrintNewlineFunction = false;
  56   size_t PrintfFormatStringPos = 0U;
  57   StringRef PrintfFormatString;
  58
  59   /// Lazily-created c_str() call matcher
  60   std::optional<clang::ast_matchers::StatementMatcher>
  61       StringCStrCallExprMatcher;
  62
  63   const StringLiteral *FormatExpr;
  64   std::string StandardFormatString;
  65
  66   /// Casts to be used to wrap arguments to retain printf compatibility.
  67   std::vector<std::tuple<const Expr *, std::string>> ArgFixes;
  68   std::vector<clang::ast_matchers::BoundNodes> ArgCStrRemovals;
  69
  70   // Argument rotations to cope with the fact that std::print puts the value to
  71   // be formatted first and the width and precision afterwards whereas printf
  72   // puts the width and preicision first.
  73   std::vector<std::tuple<unsigned, unsigned>> ArgRotates;
  74
  75   void emitAlignment(const PrintfSpecifier &FS, std::string &FormatSpec);
  76   void emitSign(const PrintfSpecifier &FS, std::string &FormatSpec);
  77   void emitAlternativeForm(const PrintfSpecifier &FS, std::string &FormatSpec);
  78   void emitFieldWidth(const PrintfSpecifier &FS, std::string &FormatSpec);
  79   void emitPrecision(const PrintfSpecifier &FS, std::string &FormatSpec);
  80   void emitStringArgument(const Expr *Arg);
  81   bool emitIntegerArgument(ConversionSpecifier::Kind ArgKind, const Expr *Arg,
  82                            unsigned ArgIndex, std::string &FormatSpec);
  83
  84   bool emitType(const PrintfSpecifier &FS, const Expr *Arg,
  85                 std::string &FormatSpec);
  86   bool convertArgument(const PrintfSpecifier &FS, const Expr *Arg,
  87                        std::string &StandardFormatString);
  88
  89   void maybeRotateArguments(const PrintfSpecifier &FS);
  90
  91   bool HandlePrintfSpecifier(const PrintfSpecifier &FS,
  92                              const char *StartSpecifier, unsigned SpecifierLen,
  93                              const TargetInfo &Target) override;
  94
  95   void appendFormatText(StringRef Text);
  96   void finalizeFormatText();
  97   bool conversionNotPossible(std::string Reason) {
  98     ConversionNotPossibleReason = std::move(Reason);
  99     return false;
 100   }
 101 };
 102
 103 } // namespace clang::tidy::utils
 104
 105 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_UTILS_FORMATSTRINGCONVERTER_H