clang-tools 20.0.0git
UseStdFormatCheck.cpp
Go to the documentation of this file.
1//===--- UseStdFormatCheck.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 "UseStdFormatCheck.h"
10#include "../utils/FormatStringConverter.h"
11#include "../utils/Matchers.h"
12#include "../utils/OptionsUtils.h"
13#include "clang/ASTMatchers/ASTMatchFinder.h"
14#include "clang/Lex/Lexer.h"
15#include "clang/Tooling/FixIt.h"
16
17using namespace clang::ast_matchers;
18
19namespace clang::tidy::modernize {
20
21namespace {
22AST_MATCHER(StringLiteral, isOrdinary) { return Node.isOrdinary(); }
23} // namespace
24
26 : ClangTidyCheck(Name, Context),
27 StrictMode(Options.getLocalOrGlobal("StrictMode", false)),
28 StrFormatLikeFunctions(utils::options::parseStringList(
29 Options.get("StrFormatLikeFunctions", ""))),
30 ReplacementFormatFunction(
31 Options.get("ReplacementFormatFunction", "std::format")),
32 IncludeInserter(Options.getLocalOrGlobal("IncludeStyle",
33 utils::IncludeSorter::IS_LLVM),
34 areDiagsSelfContained()),
35 MaybeHeaderToInclude(Options.get("FormatHeader")) {
36 if (StrFormatLikeFunctions.empty())
37 StrFormatLikeFunctions.push_back("absl::StrFormat");
38
39 if (!MaybeHeaderToInclude && ReplacementFormatFunction == "std::format")
40 MaybeHeaderToInclude = "<format>";
41}
42
43void UseStdFormatCheck::registerPPCallbacks(const SourceManager &SM,
44 Preprocessor *PP,
45 Preprocessor *ModuleExpanderPP) {
46 IncludeInserter.registerPreprocessor(PP);
47}
48
49void UseStdFormatCheck::registerMatchers(MatchFinder *Finder) {
50 Finder->addMatcher(
51 callExpr(argumentCountAtLeast(1),
52 hasArgument(0, stringLiteral(isOrdinary())),
53 callee(functionDecl(unless(cxxMethodDecl()),
55 StrFormatLikeFunctions))
56 .bind("func_decl")))
57 .bind("strformat"),
58 this);
59}
60
63 Options.store(Opts, "StrictMode", StrictMode);
64 Options.store(Opts, "StrFormatLikeFunctions",
65 serializeStringList(StrFormatLikeFunctions));
66 Options.store(Opts, "ReplacementFormatFunction", ReplacementFormatFunction);
67 Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle());
68 if (MaybeHeaderToInclude)
69 Options.store(Opts, "FormatHeader", *MaybeHeaderToInclude);
70}
71
72void UseStdFormatCheck::check(const MatchFinder::MatchResult &Result) {
73 const unsigned FormatArgOffset = 0;
74 const auto *OldFunction = Result.Nodes.getNodeAs<FunctionDecl>("func_decl");
75 const auto *StrFormat = Result.Nodes.getNodeAs<CallExpr>("strformat");
76
78 ConverterConfig.StrictMode = StrictMode;
79 utils::FormatStringConverter Converter(Result.Context, StrFormat,
80 FormatArgOffset, ConverterConfig,
81 getLangOpts());
82 const Expr *StrFormatCall = StrFormat->getCallee();
83 if (!Converter.canApply()) {
84 diag(StrFormat->getBeginLoc(),
85 "unable to use '%0' instead of %1 because %2")
86 << StrFormatCall->getSourceRange() << ReplacementFormatFunction
87 << OldFunction->getIdentifier()
88 << Converter.conversionNotPossibleReason();
89 return;
90 }
91
92 DiagnosticBuilder Diag =
93 diag(StrFormatCall->getBeginLoc(), "use '%0' instead of %1")
94 << ReplacementFormatFunction << OldFunction->getIdentifier();
95 Diag << FixItHint::CreateReplacement(
96 CharSourceRange::getTokenRange(StrFormatCall->getSourceRange()),
97 ReplacementFormatFunction);
98 Converter.applyFixes(Diag, *Result.SourceManager);
99
100 if (MaybeHeaderToInclude)
101 Diag << IncludeInserter.createIncludeInsertion(
102 Result.Context->getSourceManager().getFileID(
103 StrFormatCall->getBeginLoc()),
104 *MaybeHeaderToInclude);
105}
106
107} // namespace clang::tidy::modernize
llvm::SmallString< 256U > Name
::clang::DynTypedNode Node
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, StringRef Value) const
Stores an option with the check-local name LocalName with string value Value to Options.
Base class for all clang-tidy checks.
DiagnosticBuilder diag(SourceLocation Loc, StringRef Description, DiagnosticIDs::Level Level=DiagnosticIDs::Warning)
Add a diagnostic with the check's name.
const LangOptions & getLangOpts() const
Returns the language options from the context.
Every ClangTidyCheck reports errors through a DiagnosticsEngine provided by this context.
void check(const ast_matchers::MatchFinder::MatchResult &Result) override
ClangTidyChecks that register ASTMatchers should do the actual work in here.
void registerMatchers(ast_matchers::MatchFinder *Finder) override
Override this to register AST matchers with Finder.
void storeOptions(ClangTidyOptions::OptionMap &Opts) override
Should store all options supported by this check with their current values or default values for opti...
void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) override
Override this to register PPCallbacks in the preprocessor.
UseStdFormatCheck(StringRef Name, ClangTidyContext *Context)
Convert a printf-style format string to a std::formatter-style one, and prepare any casts that are re...
void applyFixes(DiagnosticBuilder &Diag, SourceManager &SM)
Called by the check when it is ready to apply the fixes.
const std::string & conversionNotPossibleReason() const
void registerPreprocessor(Preprocessor *PP)
Registers this with the Preprocessor PP, must be called before this class is used.
std::optional< FixItHint > createIncludeInsertion(FileID FileID, llvm::StringRef Header)
Creates a Header inclusion directive fixit in the File FileID.
IncludeSorter::IncludeStyle getStyle() const
AST_MATCHER(Decl, declHasNoReturnAttr)
matches a Decl if it has a "no return" attribute of any kind
inline ::clang::ast_matchers::internal::Matcher< NamedDecl > matchesAnyListedName(llvm::ArrayRef< StringRef > NameList)
std::string serializeStringList(ArrayRef< StringRef > Strings)
Serialize a sequence of names that can be parsed by parseStringList.
llvm::StringMap< ClangTidyValue > OptionMap