| 1 |
//===--- UseStdPrintCheck.cpp - 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 |
#include "UseStdPrintCheck.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 |
|
| 17 |
using namespace clang::ast_matchers; |
| 18 |
|
| 19 |
namespace clang::tidy::modernize { |
| 20 |
|
| 21 |
namespace { |
| 22 |
AST_MATCHER(StringLiteral, isOrdinary) { return Node.isOrdinary(); } |
| 23 |
} // namespace |
| 24 |
|
| 25 |
UseStdPrintCheck::UseStdPrintCheck(StringRef Name, ClangTidyContext *Context) |
| 26 |
: ClangTidyCheck(Name, Context), |
| 27 |
StrictMode(Options.getLocalOrGlobal("StrictMode", false)), |
| 28 |
PrintfLikeFunctions(utils::options::parseStringList( |
| 29 |
Options.get("PrintfLikeFunctions", ""))), |
| 30 |
FprintfLikeFunctions(utils::options::parseStringList( |
| 31 |
Options.get("FprintfLikeFunctions", ""))), |
| 32 |
ReplacementPrintFunction( |
| 33 |
Options.get("ReplacementPrintFunction", "std::print")), |
| 34 |
ReplacementPrintlnFunction( |
| 35 |
Options.get("ReplacementPrintlnFunction", "std::println")), |
| 36 |
IncludeInserter(Options.getLocalOrGlobal("IncludeStyle", |
| 37 |
utils::IncludeSorter::IS_LLVM), |
| 38 |
areDiagsSelfContained()), |
| 39 |
MaybeHeaderToInclude(Options.get("PrintHeader")) { |
| 40 |
|
| 41 |
if (PrintfLikeFunctions.empty() && FprintfLikeFunctions.empty()) { |
| 42 |
PrintfLikeFunctions.emplace_back("::printf"); |
| 43 |
PrintfLikeFunctions.emplace_back("absl::PrintF"); |
| 44 |
FprintfLikeFunctions.emplace_back("::fprintf"); |
| 45 |
FprintfLikeFunctions.emplace_back("absl::FPrintF"); |
| 46 |
} |
| 47 |
|
| 48 |
if (!MaybeHeaderToInclude && (ReplacementPrintFunction == "std::print" || |
| 49 |
ReplacementPrintlnFunction == "std::println")) |
| 50 |
MaybeHeaderToInclude = "<print>"; |
| 51 |
} |
| 52 |
|
| 53 |
void UseStdPrintCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { |
| 54 |
using utils::options::serializeStringList; |
| 55 |
Options.store(Opts, "StrictMode", StrictMode); |
| 56 |
Options.store(Opts, "PrintfLikeFunctions", |
| 57 |
serializeStringList(PrintfLikeFunctions)); |
| 58 |
Options.store(Opts, "FprintfLikeFunctions", |
| 59 |
serializeStringList(FprintfLikeFunctions)); |
| 60 |
Options.store(Opts, "ReplacementPrintFunction", ReplacementPrintFunction); |
| 61 |
Options.store(Opts, "ReplacementPrintlnFunction", ReplacementPrintlnFunction); |
| 62 |
Options.store(Opts, "IncludeStyle", IncludeInserter.getStyle()); |
| 63 |
if (MaybeHeaderToInclude) |
| 64 |
Options.store(Opts, "PrintHeader", *MaybeHeaderToInclude); |
| 65 |
} |
| 66 |
|
| 67 |
void UseStdPrintCheck::registerPPCallbacks(const SourceManager &SM, |
| 68 |
Preprocessor *PP, |
| 69 |
Preprocessor *ModuleExpanderPP) { |
| 70 |
IncludeInserter.registerPreprocessor(PP); |
| 71 |
} |
| 72 |
|
| 73 |
static clang::ast_matchers::StatementMatcher |
| 74 |
unusedReturnValue(clang::ast_matchers::StatementMatcher MatchedCallExpr) { |
| 75 |
auto UnusedInCompoundStmt = |
| 76 |
compoundStmt(forEach(MatchedCallExpr), |
| 77 |
// The checker can't currently differentiate between the |
| 78 |
// return statement and other statements inside GNU statement |
| 79 |
// expressions, so disable the checker inside them to avoid |
| 80 |
// false positives. |
| 81 |
unless(hasParent(stmtExpr()))); |
| 82 |
auto UnusedInIfStmt = |
| 83 |
ifStmt(eachOf(hasThen(MatchedCallExpr), hasElse(MatchedCallExpr))); |
| 84 |
auto UnusedInWhileStmt = whileStmt(hasBody(MatchedCallExpr)); |
| 85 |
auto UnusedInDoStmt = doStmt(hasBody(MatchedCallExpr)); |
| 86 |
auto UnusedInForStmt = |
| 87 |
forStmt(eachOf(hasLoopInit(MatchedCallExpr), |
| 88 |
hasIncrement(MatchedCallExpr), hasBody(MatchedCallExpr))); |
| 89 |
auto UnusedInRangeForStmt = cxxForRangeStmt(hasBody(MatchedCallExpr)); |
| 90 |
auto UnusedInCaseStmt = switchCase(forEach(MatchedCallExpr)); |
| 91 |
|
| 92 |
return stmt(anyOf(UnusedInCompoundStmt, UnusedInIfStmt, UnusedInWhileStmt, |
| 93 |
UnusedInDoStmt, UnusedInForStmt, UnusedInRangeForStmt, |
| 94 |
UnusedInCaseStmt)); |
| 95 |
} |
| 96 |
|
| 97 |
void UseStdPrintCheck::registerMatchers(MatchFinder *Finder) { |
| 98 |
if (!PrintfLikeFunctions.empty()) |
| 99 |
Finder->addMatcher( |
| 100 |
unusedReturnValue( |
| 101 |
callExpr(argumentCountAtLeast(1), |
| 102 |
hasArgument(0, stringLiteral(isOrdinary())), |
| 103 |
callee(functionDecl(unless(cxxMethodDecl()), |
| 104 |
matchers::matchesAnyListedName( |
| 105 |
PrintfLikeFunctions)) |
| 106 |
.bind("func_decl"))) |
| 107 |
.bind("printf")), |
| 108 |
this); |
| 109 |
|
| 110 |
if (!FprintfLikeFunctions.empty()) |
| 111 |
Finder->addMatcher( |
| 112 |
unusedReturnValue( |
| 113 |
callExpr(argumentCountAtLeast(2), |
| 114 |
hasArgument(1, stringLiteral(isOrdinary())), |
| 115 |
callee(functionDecl(unless(cxxMethodDecl()), |
| 116 |
matchers::matchesAnyListedName( |
| 117 |
FprintfLikeFunctions)) |
| 118 |
.bind("func_decl"))) |
| 119 |
.bind("fprintf")), |
| 120 |
this); |
| 121 |
} |
| 122 |
|
| 123 |
void UseStdPrintCheck::check(const MatchFinder::MatchResult &Result) { |
| 124 |
unsigned FormatArgOffset = 0; |
| 125 |
const auto *OldFunction = Result.Nodes.getNodeAs<FunctionDecl>("func_decl"); |
| 126 |
const auto *Printf = Result.Nodes.getNodeAs<CallExpr>("printf"); |
| 127 |
if (!Printf) { |
| 128 |
Printf = Result.Nodes.getNodeAs<CallExpr>("fprintf"); |
| 129 |
FormatArgOffset = 1; |
| 130 |
} |
| 131 |
|
| 132 |
utils::FormatStringConverter::Configuration ConverterConfig; |
| 133 |
ConverterConfig.StrictMode = StrictMode; |
| 134 |
ConverterConfig.AllowTrailingNewlineRemoval = true; |
| 135 |
utils::FormatStringConverter Converter( |
| 136 |
Result.Context, Printf, FormatArgOffset, ConverterConfig, getLangOpts()); |
| 137 |
const Expr *PrintfCall = Printf->getCallee(); |
| 138 |
const StringRef ReplacementFunction = Converter.usePrintNewlineFunction() |
| 139 |
? ReplacementPrintlnFunction |
| 140 |
: ReplacementPrintFunction; |
| 141 |
if (!Converter.canApply()) { |
| 142 |
diag(PrintfCall->getBeginLoc(), |
| 143 |
"unable to use '%0' instead of %1 because %2") |
| 144 |
<< PrintfCall->getSourceRange() << ReplacementFunction |
| 145 |
<< OldFunction->getIdentifier() |
| 146 |
<< Converter.conversionNotPossibleReason(); |
| 147 |
return; |
| 148 |
} |
| 149 |
|
| 150 |
DiagnosticBuilder Diag = |
| 151 |
diag(PrintfCall->getBeginLoc(), "use '%0' instead of %1") |
| 152 |
<< ReplacementFunction << OldFunction->getIdentifier(); |
| 153 |
|
| 154 |
Diag << FixItHint::CreateReplacement( |
| 155 |
CharSourceRange::getTokenRange(PrintfCall->getBeginLoc(), |
| 156 |
PrintfCall->getEndLoc()), |
| 157 |
ReplacementFunction); |
| 158 |
Converter.applyFixes(Diag, *Result.SourceManager); |
| 159 |
|
| 160 |
if (MaybeHeaderToInclude) |
| 161 |
Diag << IncludeInserter.createIncludeInsertion( |
| 162 |
Result.Context->getSourceManager().getFileID(PrintfCall->getBeginLoc()), |
| 163 |
*MaybeHeaderToInclude); |
| 164 |
} |
| 165 |
|
| 166 |
} // namespace clang::tidy::modernize |