1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
|
//===--- ReplaceDisallowCopyAndAssignMacroCheck.cpp - clang-tidy ----------===//
//
// 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 "ReplaceDisallowCopyAndAssignMacroCheck.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/MacroArgs.h"
#include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h"
#include "llvm/Support/FormatVariadic.h"
namespace clang {
namespace tidy {
namespace modernize {
namespace {
class ReplaceDisallowCopyAndAssignMacroCallbacks : public PPCallbacks {
public:
explicit ReplaceDisallowCopyAndAssignMacroCallbacks(
ReplaceDisallowCopyAndAssignMacroCheck &Check, Preprocessor &PP)
: Check(Check), PP(PP) {}
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
SourceRange Range, const MacroArgs *Args) override {
IdentifierInfo *Info = MacroNameTok.getIdentifierInfo();
if (!Info || !Args || Args->getNumMacroArguments() != 1)
return;
if (Info->getName() != Check.getMacroName())
return;
// The first argument to the DISALLOW_COPY_AND_ASSIGN macro is expected to
// be the class name.
const Token *ClassNameTok = Args->getUnexpArgument(0);
if (Args->ArgNeedsPreexpansion(ClassNameTok, PP))
// For now we only support simple argument that don't need to be
// pre-expanded.
return;
clang::IdentifierInfo *ClassIdent = ClassNameTok->getIdentifierInfo();
if (!ClassIdent)
return;
std::string Replacement = llvm::formatv(
R"cpp({0}(const {0} &) = delete;
const {0} &operator=(const {0} &) = delete{1})cpp",
ClassIdent->getName(), shouldAppendSemi(Range) ? ";" : "");
Check.diag(MacroNameTok.getLocation(),
"prefer deleting copy constructor and assignment operator over "
"using macro '%0'")
<< Check.getMacroName()
<< FixItHint::CreateReplacement(
PP.getSourceManager().getExpansionRange(Range), Replacement);
}
private:
/// \returns \c true if the next token after the given \p MacroLoc is \b not a
/// semicolon.
bool shouldAppendSemi(SourceRange MacroLoc) {
llvm::Optional<Token> Next = Lexer::findNextToken(
MacroLoc.getEnd(), PP.getSourceManager(), PP.getLangOpts());
return !(Next && Next->is(tok::semi));
}
ReplaceDisallowCopyAndAssignMacroCheck &Check;
Preprocessor &PP;
};
} // namespace
ReplaceDisallowCopyAndAssignMacroCheck::ReplaceDisallowCopyAndAssignMacroCheck(
StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context),
MacroName(Options.get("MacroName", "DISALLOW_COPY_AND_ASSIGN")) {}
void ReplaceDisallowCopyAndAssignMacroCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks(
::std::make_unique<ReplaceDisallowCopyAndAssignMacroCallbacks>(
*this, *ModuleExpanderPP));
}
void ReplaceDisallowCopyAndAssignMacroCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "MacroName", MacroName);
}
} // namespace modernize
} // namespace tidy
} // namespace clang
|
