This is an archive of the discontinued LLVM Phabricator instance.

Differential D23343

[clang-tidy] modernize-make-{smart_ptr} private ctor bugfix
ClosedPublic

Authored by Prazek on Aug 9 2016, 9:57 PM.

Details

Reviewers
aaron.ballman
hokein
alexfh
Commits
rGd57be707b88b: [clang-tidy] modernize-make-{smart_ptr} private ctor bugfix
rCTE280180: [clang-tidy] modernize-make-{smart_ptr} private ctor bugfix
rL280180: [clang-tidy] modernize-make-{smart_ptr} private ctor bugfix
Summary

Bugfix for 27321. When the constructor of stored pointer
type is private then it is invalid to change it to
make_shared or make_unique.

Diff Detail

Event Timeline

Prazek updated this revision to Diff 67458.Aug 9 2016, 9:57 PM
Prazek retitled this revision from to [clang-tidy] modernize-make-{smart_ptr} private ctor bugfix.
Prazek updated this object.
Prazek added reviewers: alexfh, aaron.ballman, hokein.
Prazek added a subscriber: cfe-commits.
Prazek updated this revision to Diff 67459.Aug 9 2016, 10:05 PM

Added note in release notes

Herald added subscribers: nemanjai, klimek. · View Herald TranscriptAug 9 2016, 10:05 PM
Prazek updated this revision to Diff 67460.Aug 9 2016, 10:07 PM

I hate it when arc do this thing. When origin/master is not the trunk...

aaron.ballman edited edge metadata.Aug 10 2016, 5:03 AM

Good catch! Some small nits.

clang-tidy/modernize/MakeSmartPtrCheck.cpp
32–33

Nit: this reads a bit strangely, how about: Calling make_smart_ptr from within a member function of a type with a private constructor would be ill-formed.

test/clang-tidy/modernize-make-shared.cpp
109

Add comments explaining why make_shared is not correct. Also, please add a case showing that protected constructors still get the proper fix applied.

test/clang-tidy/modernize-make-unique.cpp
112

Add comments as above.

Prazek added inline comments.Aug 10 2016, 10:02 AM
test/clang-tidy/modernize-make-shared.cpp
109

You mean I should also not warn when the constructor is protected? Make sense.

Eugene.Zelenko added a subscriber: Eugene.Zelenko.Aug 10 2016, 11:18 AM
Eugene.Zelenko added inline comments.
docs/ReleaseNotes.rst
67

I think will be better to have Fixed bugs: section as we had in 3.9 release notes.

aaron.ballman added inline comments.Aug 10 2016, 11:33 AM
test/clang-tidy/modernize-make-shared.cpp
109

Correct, protected constructors should be handled like private constructors.

Prazek updated this revision to Diff 67966.Aug 13 2016, 7:15 PM
Prazek marked 6 inline comments as done.
Prazek edited edge metadata.
  • fixes
Prazek updated this revision to Diff 67967.Aug 13 2016, 7:16 PM
  • fixes
aaron.ballman accepted this revision.Aug 16 2016, 6:50 AM
aaron.ballman edited edge metadata.

LGTM with one minor nit (you can fix it during the commit).

clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

Perhaps: unless(isPublic()) instead of anyOf(isPrivate(), isProtected())?

This revision is now accepted and ready to land.Aug 16 2016, 6:50 AM
Prazek added inline comments.Aug 16 2016, 3:37 PM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

POD types doesn't have public constructors so it will fail :)

aaron.ballman added inline comments.Aug 16 2016, 3:47 PM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

Don't they have an implicit one for the purposes of a CXXConstructExpr? Looking at an AST dump for:

struct S {
  int i;
};

yields:

|-CXXRecordDecl 0x26d74ae5348 <line:25:1, line:27:1> line:25:8 referenced struct S definition
| |-CXXRecordDecl 0x26d74ae5460 <col:1, col:8> col:8 implicit struct S
| |-FieldDecl 0x26d74ae7880 <line:26:3, col:7> col:7 i 'int'
| |-CXXConstructorDecl 0x26d74ae87b8 <line:25:8> col:8 implicit used S 'void (void) noexcept' inline
| | `-CompoundStmt 0x26d74ae3850 <col:8>
| |-CXXConstructorDecl 0x26d74ae34a8 <col:8> col:8 implicit constexpr S 'void (const struct S &)' inline noexcept-unevaluated 0x26d74ae34a8
| | `-ParmVarDecl 0x26d74ae35e0 <col:8> col:8 'const struct S &'
| `-CXXConstructorDecl 0x26d74ae3678 <col:8> col:8 implicit constexpr S 'void (struct S &&)' inline noexcept-unevaluated 0x26d74ae3678
|   `-ParmVarDecl 0x26d74ae37b0 <col:8> col:8 'struct S &&'
Prazek added inline comments.Aug 16 2016, 8:46 PM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

what about std::shared_ptr<int> x = std::shared_ptr(new int); ?
If I recall correctly, it didn't work on this test.

alexfh added inline comments.Aug 17 2016, 2:56 AM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

There's no CXXConstructExpr for primitive types:

$ cat /tmp/qq.cc 
#include <memory>

struct S { S(); };
void ffff() {
  std::shared_ptr<int> p1 = std::shared_ptr<int>(new int);
  std::shared_ptr<S> p2 = std::shared_ptr<S>(new S);
}
$ clang-check -ast-dump -ast-dump-filter=ffff /tmp/qq.cc -- -std=c++11
Dumping ffff:
FunctionDecl 0x7f48270fb6e0 </tmp/qq.cc:4:1, line:7:1> line:4:6 ffff 'void (void)'
`-CompoundStmt 0x7f48271582a8 <col:13, line:7:1>
  |-DeclStmt 0x7f4827131000 <line:5:3, col:58>
  | `-VarDecl 0x7f48270fb9c8 <col:3, col:57> col:24 p1 'std::shared_ptr<int>':'class std::shared_ptr<int>' cinit
  |   `-ExprWithCleanups 0x7f4827130fe8 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>'
  |     `-CXXConstructExpr 0x7f4827130fb0 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' 'void (class std::shared_ptr<int> &&) noexcept' elidable
  |       `-MaterializeTemporaryExpr 0x7f4827130f98 <col:29, col:57> 'class std::shared_ptr<int>' xvalue
  |         `-CXXFunctionalCastExpr 0x7f48271303c8 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' functional cast to std::shared_ptr<int> <ConstructorConversion>
  |           `-CXXBindTemporaryExpr 0x7f48271303a8 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' (CXXTemporary 0x7f48271303a0)
  |             `-CXXConstructExpr 0x7f4827130338 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' 'void (int *)'
  |               `-CXXNewExpr 0x7f48270fbb58 <col:50, col:54> 'int *' Function 0x7f4826a1c000 'operator new' 'void *(std::size_t)'
  `-DeclStmt 0x7f4827158290 <line:6:3, col:52>
    `-VarDecl 0x7f4827131238 <col:3, col:51> col:22 p2 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' cinit
      `-ExprWithCleanups 0x7f4827158278 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>'
        `-CXXConstructExpr 0x7f4827158240 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' 'void (class std::shared_ptr<struct S> &&) noexcept' elidable
          `-MaterializeTemporaryExpr 0x7f4827158228 <col:27, col:51> 'class std::shared_ptr<struct S>' xvalue
            `-CXXFunctionalCastExpr 0x7f4827157658 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' functional cast to std::shared_ptr<S> <ConstructorConversion>
              `-CXXBindTemporaryExpr 0x7f4827157638 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' (CXXTemporary 0x7f4827157630)
                `-CXXConstructExpr 0x7f48271575c8 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' 'void (struct S *)'
                  `-CXXNewExpr 0x7f4827131838 <col:46, col:50> 'struct S *' Function 0x7f4826a1c000 'operator new' 'void *(std::size_t)'
                    `-CXXConstructExpr 0x7f4827131808 <col:50> 'struct S' 'void (void)'
malcolm.parsons added a subscriber: malcolm.parsons.Aug 17 2016, 7:59 AM
malcolm.parsons added inline comments.
clang-tidy/modernize/MakeSmartPtrCheck.cpp
32–33

The private constructor could also be called from a friend class.

alexfh added inline comments.Aug 17 2016, 9:34 AM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
32–33

It might only be relevant, if std::make_(shared|unique) is declared as a friend of the class in question, which is unlikely to be a common case and I don't think we need to focus on this now.

Prazek added inline comments.Aug 17 2016, 9:37 AM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
32–33

I am totally aware of it, but I never saw a friend delcaration for any class/function from libc++.

Prazek marked 8 inline comments as done.Aug 17 2016, 9:38 AM
Prazek added inline comments.
clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

exactly.

Prazek marked 2 inline comments as done.Aug 17 2016, 9:38 AM
alexfh added inline comments.Aug 17 2016, 9:49 AM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

But this means that unless(isPublic()) should work, IIUC.

Prazek added inline comments.Aug 19 2016, 8:40 PM
clang-tidy/modernize/MakeSmartPtrCheck.cpp
35

Oh I see.
Yea I remember right now what I did:
has(ignoringImpCasts(cxxConstructExpr(

hasDeclaration(decl(isPublic())))))))

This ofc not gonna work, but

unless(has(ignoringImpCasts(cxxConstructExpr(

hasDeclaration(decl(unless(isPublic())))))))

should be totally fine

Prazek updated this revision to Diff 68824.Aug 21 2016, 10:16 PM
Prazek edited edge metadata.
  • fixes
alexfh accepted this revision.Aug 22 2016, 10:29 AM
alexfh edited edge metadata.

LG. Thank you!

Closed by commit rL280180: [clang-tidy] modernize-make-{smart_ptr} private ctor bugfix (authored by Prazek). · Explain WhyAug 30 2016, 5:15 PM
This revision was automatically updated to reflect the committed changes.
Prazek added a comment.Aug 30 2016, 5:16 PM

Sorry for long delay. I had some issues with git-svn on mac.

Revision Contents

PathSize
clang-apply-replacements/
include/
clang-apply-replacements/
Tooling/
5 lines
lib/
Tooling/
79 lines
tool/
2 lines
clang-rename/
20 lines
53 lines
7 lines
28 lines
111 lines
3 lines
57 lines
tool/
7 lines
275 lines
44 lines
clang-tidy/
1 line
17 lines
58 lines
3 lines
49 lines
2 lines
cert/
2 lines
2 lines
cppcoreguidelines/
1 line
3 lines
2 lines
2 lines
2 lines
2 lines
2 lines
97 lines
134 lines
misc/
2 lines
59 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
20 lines
modernize/
12 lines
8 lines
2 lines
11 lines
mpi/
16 lines
37 lines
52 lines
336 lines
performance/
1 line
41 lines
86 lines
3 lines
4 lines
plugin/
1 line
readability/
2 lines
tool/
1 line
5 lines
docs/
19 lines
121 lines
clang-tidy/
checks/
14 lines
21 lines
3 lines
4 lines
2 lines
38 lines
20 lines
49 lines
10 lines
6 lines
include-fixer/
12 lines
54 lines
12 lines
7 lines
13 lines
7 lines
find-all-symbols/
16 lines
tool/
91 lines
25 lines
test/
clang-rename/
4 lines
4 lines
4 lines
4 lines
6 lines
8 lines
8 lines
7 lines
23 lines
4 lines
6 lines
6 lines
6 lines
6 lines
4 lines
6 lines
6 lines
6 lines
6 lines
15 lines
6 lines
10 lines
4 lines
Inputs/
6 lines
6 lines
4 lines
6 lines
2 lines
7 lines
4 lines
TemplateClassInstantiation.cpp
TemplateClassInstantiationFindByTypeUse.cpp
24 lines
4 lines
4 lines
12 lines
10 lines
4 lines
6 lines
6 lines
6 lines
clang-tidy/
Inputs/
modernize-pass-by-value/
8 lines
mpi-type-mismatch/
62 lines
11 lines
26 lines
67 lines
19 lines
9 lines
21 lines
12 lines
10 lines
12 lines
62 lines
255 lines
44 lines
include-fixer/
6 lines
13 lines
tool-template/
12 lines
unittests/
clang-tidy/
14 lines
4 lines
include-fixer/
28 lines

Diff 67459

clang-apply-replacements/include/clang-apply-replacements/Tooling/ApplyReplacements.h

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
/// ///
/// \returns \parblock /// \returns \parblock
/// \li true If all changes were applied successfully. /// \li true If all changes were applied successfully.
/// \li false If there were conflicts. /// \li false If there were conflicts.
bool mergeAndDeduplicate(const TUReplacements &TUs, bool mergeAndDeduplicate(const TUReplacements &TUs,
FileToReplacementsMap &GroupedReplacements, FileToReplacementsMap &GroupedReplacements,
clang::SourceManager &SM); clang::SourceManager &SM);
// FIXME: Remove this function after changing clang-apply-replacements to use
// Replacements class.
bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
Rewriter &Rewrite);
/// \brief Apply all replacements in \c GroupedReplacements. /// \brief Apply all replacements in \c GroupedReplacements.
/// ///
/// \param[in] GroupedReplacements Deduplicated and conflict free Replacements /// \param[in] GroupedReplacements Deduplicated and conflict free Replacements
/// to apply. /// to apply.
/// \param[out] Rewrites The results of applying replacements will be applied /// \param[out] Rewrites The results of applying replacements will be applied
/// to this Rewriter. /// to this Rewriter.
/// ///
/// \returns \parblock /// \returns \parblock
Show All 39 Lines

clang-apply-replacements/lib/Tooling/ApplyReplacements.cpp

Show First 20 Lines • Show All 116 Lines • ▼ Show 20 Lines if (R.getLength() == 0) {
if (R.getReplacementText().empty()) if (R.getReplacementText().empty())
errs() << "\n"; errs() << "\n";
else else
errs() << " with \"" << R.getReplacementText() << "\"\n"; errs() << " with \"" << R.getReplacementText() << "\"\n";
} }
} }
} }
// FIXME: Remove this function after changing clang-apply-replacements to use
// Replacements class.
bool applyAllReplacements(const std::vector<tooling::Replacement> &Replaces,
Rewriter &Rewrite) {
bool Result = true;
for (std::vector<tooling::Replacement>::const_iterator I = Replaces.begin(),
E = Replaces.end();
I != E; ++I) {
if (I->isApplicable()) {
Result = I->apply(Rewrite) && Result;
} else {
Result = false;
}
}
return Result;
}
// FIXME: moved from libToolingCore. remove this when std::vector<Replacement>
// is replaced with tooling::Replacements class.
static void deduplicate(std::vector<tooling::Replacement> &Replaces,
std::vector<tooling::Range> &Conflicts) {
if (Replaces.empty())
return;
auto LessNoPath = [](const tooling::Replacement &LHS,
const tooling::Replacement &RHS) {
if (LHS.getOffset() != RHS.getOffset())
return LHS.getOffset() < RHS.getOffset();
if (LHS.getLength() != RHS.getLength())
return LHS.getLength() < RHS.getLength();
return LHS.getReplacementText() < RHS.getReplacementText();
};
auto EqualNoPath = [](const tooling::Replacement &LHS,
const tooling::Replacement &RHS) {
return LHS.getOffset() == RHS.getOffset() &&
LHS.getLength() == RHS.getLength() &&
LHS.getReplacementText() == RHS.getReplacementText();
};
// Deduplicate. We don't want to deduplicate based on the path as we assume
// that all replacements refer to the same file (or are symlinks).
std::sort(Replaces.begin(), Replaces.end(), LessNoPath);
Replaces.erase(std::unique(Replaces.begin(), Replaces.end(), EqualNoPath),
Replaces.end());
// Detect conflicts
tooling::Range ConflictRange(Replaces.front().getOffset(),
Replaces.front().getLength());
unsigned ConflictStart = 0;
unsigned ConflictLength = 1;
for (unsigned i = 1; i < Replaces.size(); ++i) {
tooling::Range Current(Replaces[i].getOffset(), Replaces[i].getLength());
if (ConflictRange.overlapsWith(Current)) {
// Extend conflicted range
ConflictRange =
tooling::Range(ConflictRange.getOffset(),
std::max(ConflictRange.getLength(),
Current.getOffset() + Current.getLength() -
ConflictRange.getOffset()));
++ConflictLength;
} else {
if (ConflictLength > 1)
Conflicts.push_back(tooling::Range(ConflictStart, ConflictLength));
ConflictRange = Current;
ConflictStart = i;
ConflictLength = 1;
}
}
if (ConflictLength > 1)
Conflicts.push_back(tooling::Range(ConflictStart, ConflictLength));
}
/// \brief Deduplicates and tests for conflicts among the replacements for each /// \brief Deduplicates and tests for conflicts among the replacements for each
/// file in \c Replacements. Any conflicts found are reported. /// file in \c Replacements. Any conflicts found are reported.
/// ///
/// \post Replacements[i].getOffset() <= Replacements[i+1].getOffset(). /// \post Replacements[i].getOffset() <= Replacements[i+1].getOffset().
/// ///
/// \param[in,out] Replacements Container of all replacements grouped by file /// \param[in,out] Replacements Container of all replacements grouped by file
/// to be deduplicated and checked for conflicts. /// to be deduplicated and checked for conflicts.
/// \param[in] SM SourceManager required for conflict reporting. /// \param[in] SM SourceManager required for conflict reporting.
/// ///
/// \returns \parblock /// \returns \parblock
/// \li true if conflicts were detected /// \li true if conflicts were detected
/// \li false if no conflicts were detected /// \li false if no conflicts were detected
static bool deduplicateAndDetectConflicts(FileToReplacementsMap &Replacements, static bool deduplicateAndDetectConflicts(FileToReplacementsMap &Replacements,
SourceManager &SM) { SourceManager &SM) {
bool conflictsFound = false; bool conflictsFound = false;
for (auto &FileAndReplacements : Replacements) { for (auto &FileAndReplacements : Replacements) {
const FileEntry *Entry = FileAndReplacements.first; const FileEntry *Entry = FileAndReplacements.first;
auto &Replacements = FileAndReplacements.second; auto &Replacements = FileAndReplacements.second;
assert(Entry != nullptr && "No file entry!"); assert(Entry != nullptr && "No file entry!");
std::vector<tooling::Range> Conflicts; std::vector<tooling::Range> Conflicts;
tooling::deduplicate(FileAndReplacements.second, Conflicts); deduplicate(FileAndReplacements.second, Conflicts);
if (Conflicts.empty()) if (Conflicts.empty())
continue; continue;
conflictsFound = true; conflictsFound = true;
errs() << "There are conflicting changes to " << Entry->getName() << ":\n"; errs() << "There are conflicting changes to " << Entry->getName() << ":\n";
Show All 36 Linesbool applyReplacements(const FileToReplacementsMap &GroupedReplacements,
// Apply all changes // Apply all changes
// //
// FIXME: No longer certain GroupedReplacements is really the best kind of // FIXME: No longer certain GroupedReplacements is really the best kind of
// data structure for applying replacements. Rewriter certainly doesn't care. // data structure for applying replacements. Rewriter certainly doesn't care.
// However, until we nail down the design of ReplacementGroups, might as well // However, until we nail down the design of ReplacementGroups, might as well
// leave this as is. // leave this as is.
for (const auto &FileAndReplacements : GroupedReplacements) { for (const auto &FileAndReplacements : GroupedReplacements) {
if (!tooling::applyAllReplacements(FileAndReplacements.second, Rewrites)) if (!applyAllReplacements(FileAndReplacements.second, Rewrites))
return false; return false;
} }
return true; return true;
} }
RangeVector calculateChangedRanges( RangeVector calculateChangedRanges(
const std::vector<clang::tooling::Replacement> &Replaces) { const std::vector<clang::tooling::Replacement> &Replaces) {
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

clang-apply-replacements/tool/ClangApplyReplacementsMain.cpp

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
/// \returns \parblock /// \returns \parblock
/// \li true if all replacements were applied successfully. /// \li true if all replacements were applied successfully.
/// \li false if at least one replacement failed to apply. /// \li false if at least one replacement failed to apply.
static bool static bool
getRewrittenData(const std::vector<tooling::Replacement> &Replacements, getRewrittenData(const std::vector<tooling::Replacement> &Replacements,
Rewriter &Rewrites, std::string &Result) { Rewriter &Rewrites, std::string &Result) {
if (Replacements.empty()) return true; if (Replacements.empty()) return true;
if (!tooling::applyAllReplacements(Replacements, Rewrites)) if (!applyAllReplacements(Replacements, Rewrites))
return false; return false;
SourceManager &SM = Rewrites.getSourceMgr(); SourceManager &SM = Rewrites.getSourceMgr();
FileManager &Files = SM.getFileManager(); FileManager &Files = SM.getFileManager();
StringRef FileName = Replacements.begin()->getFilePath(); StringRef FileName = Replacements.begin()->getFilePath();
const clang::FileEntry *Entry = Files.getFile(FileName); const clang::FileEntry *Entry = Files.getFile(FileName);
assert(Entry && "Expected an existing file"); assert(Entry && "Expected an existing file");
▲ Show 20 Lines • Show All 160 Lines • Show Last 20 Lines

clang-rename/RenamingAction.h

Show All 19 Lines
namespace clang { namespace clang {
class ASTConsumer; class ASTConsumer;
class CompilerInstance; class CompilerInstance;
namespace rename { namespace rename {
class RenamingAction { class RenamingAction {
public: public:
RenamingAction(const std::string &NewName, const std::string &PrevName, RenamingAction(const std::vector<std::string> &NewNames,
const std::vector<std::string> &USRs, const std::vector<std::string> &PrevNames,
tooling::Replacements &Replaces, bool PrintLocations = false) const std::vector<std::vector<std::string>> &USRList,
: NewName(NewName), PrevName(PrevName), USRs(USRs), Replaces(Replaces), std::map<std::string, tooling::Replacements> &FileToReplaces,
PrintLocations(PrintLocations) { bool PrintLocations = false)
} : NewNames(NewNames), PrevNames(PrevNames), USRList(USRList),
FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {}
std::unique_ptr<ASTConsumer> newASTConsumer(); std::unique_ptr<ASTConsumer> newASTConsumer();
private: private:
const std::string &NewName, &PrevName; const std::vector<std::string> &NewNames, &PrevNames;
const std::vector<std::string> &USRs; const std::vector<std::vector<std::string>> &USRList;
tooling::Replacements &Replaces; std::map<std::string, tooling::Replacements> &FileToReplaces;
bool PrintLocations; bool PrintLocations;
}; };
} }
} }
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H_ #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_RENAMING_ACTION_H_

clang-rename/RenamingAction.cpp

Show All 28 Lines
using namespace llvm; using namespace llvm;
namespace clang { namespace clang {
namespace rename { namespace rename {
class RenamingASTConsumer : public ASTConsumer { class RenamingASTConsumer : public ASTConsumer {
public: public:
RenamingASTConsumer(const std::string &NewName, RenamingASTConsumer(
const std::string &PrevName, const std::vector<std::string> &NewNames,
const std::vector<std::string> &USRs, const std::vector<std::string> &PrevNames,
tooling::Replacements &Replaces, const std::vector<std::vector<std::string>> &USRList,
std::map<std::string, tooling::Replacements> &FileToReplaces,
bool PrintLocations) bool PrintLocations)
: NewName(NewName), PrevName(PrevName), USRs(USRs), Replaces(Replaces), : NewNames(NewNames), PrevNames(PrevNames), USRList(USRList),
PrintLocations(PrintLocations) { FileToReplaces(FileToReplaces), PrintLocations(PrintLocations) {}
}
void HandleTranslationUnit(ASTContext &Context) override { void HandleTranslationUnit(ASTContext &Context) override {
for (unsigned I = 0; I < NewNames.size(); ++I) {
HandleOneRename(Context, NewNames[I], PrevNames[I], USRList[I]);
}
}
void HandleOneRename(ASTContext &Context, const std::string &NewName,
const std::string &PrevName,
const std::vector<std::string> &USRs) {
const auto &SourceMgr = Context.getSourceManager(); const auto &SourceMgr = Context.getSourceManager();
std::vector<SourceLocation> RenamingCandidates; std::vector<SourceLocation> RenamingCandidates;
std::vector<SourceLocation> NewCandidates; std::vector<SourceLocation> NewCandidates;
for (const auto &USR : USRs) { NewCandidates =
NewCandidates = getLocationsOfUSR(USR, PrevName, getLocationsOfUSRs(USRs, PrevName, Context.getTranslationUnitDecl());
Context.getTranslationUnitDecl());
RenamingCandidates.insert(RenamingCandidates.end(), NewCandidates.begin(), RenamingCandidates.insert(RenamingCandidates.end(), NewCandidates.begin(),
NewCandidates.end()); NewCandidates.end());
NewCandidates.clear();
}
auto PrevNameLen = PrevName.length(); auto PrevNameLen = PrevName.length();
for (const auto &Loc : RenamingCandidates) { for (const auto &Loc : RenamingCandidates) {
if (PrintLocations) { if (PrintLocations) {
FullSourceLoc FullLoc(Loc, SourceMgr); FullSourceLoc FullLoc(Loc, SourceMgr);
errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(Loc) errs() << "clang-rename: renamed at: " << SourceMgr.getFilename(Loc)
<< ":" << FullLoc.getSpellingLineNumber() << ":" << ":" << FullLoc.getSpellingLineNumber() << ":"
<< FullLoc.getSpellingColumnNumber() << "\n"; << FullLoc.getSpellingColumnNumber() << "\n";
} }
Replaces.insert(tooling::Replacement(SourceMgr, Loc, PrevNameLen, // FIXME: better error handling.
NewName)); auto Replace = tooling::Replacement(SourceMgr, Loc, PrevNameLen, NewName);
auto Err = FileToReplaces[Replace.getFilePath()].add(Replace);
if (Err)
llvm::errs() << "Renaming failed in " << Replace.getFilePath() << "! "
<< llvm::toString(std::move(Err)) << "\n";
} }
} }
private: private:
const std::string &NewName, &PrevName; const std::vector<std::string> &NewNames, &PrevNames;
const std::vector<std::string> &USRs; const std::vector<std::vector<std::string>> &USRList;
tooling::Replacements &Replaces; std::map<std::string, tooling::Replacements> &FileToReplaces;
bool PrintLocations; bool PrintLocations;
}; };
std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() { std::unique_ptr<ASTConsumer> RenamingAction::newASTConsumer() {
return llvm::make_unique<RenamingASTConsumer>(NewName, PrevName, USRs, return llvm::make_unique<RenamingASTConsumer>(NewNames, PrevNames, USRList,
Replaces, PrintLocations); FileToReplaces, PrintLocations);
} }
} // namespace rename } // namespace rename
} // namespace clang } // namespace clang

clang-rename/USRFinder.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
// Converts a Decl into a USR. // Converts a Decl into a USR.
std::string getUSRForDecl(const Decl *Decl); std::string getUSRForDecl(const Decl *Decl);
// FIXME: Implement RecursiveASTVisitor<T>::VisitNestedNameSpecifier instead. // FIXME: Implement RecursiveASTVisitor<T>::VisitNestedNameSpecifier instead.
class NestedNameSpecifierLocFinder : public MatchFinder::MatchCallback { class NestedNameSpecifierLocFinder : public MatchFinder::MatchCallback {
public: public:
explicit NestedNameSpecifierLocFinder(ASTContext &Context) explicit NestedNameSpecifierLocFinder(ASTContext &Context)
: Context(Context) {} : Context(Context) {}
std::vector<NestedNameSpecifierLoc> getNestedNameSpecifierLocations() { std::vector<NestedNameSpecifierLoc> getNestedNameSpecifierLocations() {
addMatchers(); addMatchers();
Finder.matchAST(Context); Finder.matchAST(Context);
return Locations; return Locations;
} }
private: private:
void addMatchers() { void addMatchers() {
const auto NestedNameSpecifierLocMatcher = const auto NestedNameSpecifierLocMatcher =
nestedNameSpecifierLoc().bind("nestedNameSpecifierLoc"); nestedNameSpecifierLoc().bind("nestedNameSpecifierLoc");
Finder.addMatcher(NestedNameSpecifierLocMatcher, this); Finder.addMatcher(NestedNameSpecifierLocMatcher, this);
} }
virtual void run(const MatchFinder::MatchResult &Result) { virtual void run(const MatchFinder::MatchResult &Result) {
const auto *NNS = const auto *NNS = Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
Result.Nodes.getNodeAs<NestedNameSpecifierLoc>("nestedNameSpecifierLoc"); "nestedNameSpecifierLoc");
Locations.push_back(*NNS); Locations.push_back(*NNS);
} }
ASTContext &Context; ASTContext &Context;
std::vector<NestedNameSpecifierLoc> Locations; std::vector<NestedNameSpecifierLoc> Locations;
MatchFinder Finder; MatchFinder Finder;
}; };
} }
} }
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_FINDER_H

clang-rename/USRFinder.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Linespublic:
} }
// Other visitors: // Other visitors:
bool VisitTypeLoc(const TypeLoc Loc) { bool VisitTypeLoc(const TypeLoc Loc) {
const auto TypeBeginLoc = Loc.getBeginLoc(); const auto TypeBeginLoc = Loc.getBeginLoc();
const auto TypeEndLoc = Lexer::getLocForEndOfToken( const auto TypeEndLoc = Lexer::getLocForEndOfToken(
TypeBeginLoc, 0, Context.getSourceManager(), Context.getLangOpts()); TypeBeginLoc, 0, Context.getSourceManager(), Context.getLangOpts());
if (const auto *TemplateTypeParm =
dyn_cast<TemplateTypeParmType>(Loc.getType())) {
return setResult(TemplateTypeParm->getDecl(), TypeBeginLoc, TypeEndLoc);
}
if (const auto *TemplateSpecType =
dyn_cast<TemplateSpecializationType>(Loc.getType())) {
return setResult(TemplateSpecType->getTemplateName().getAsTemplateDecl(),
TypeBeginLoc, TypeEndLoc);
}
return setResult(Loc.getType()->getAsCXXRecordDecl(), TypeBeginLoc, return setResult(Loc.getType()->getAsCXXRecordDecl(), TypeBeginLoc,
TypeEndLoc); TypeEndLoc);
} }
bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
for (const auto *Initializer : ConstructorDecl->inits()) {
if (!Initializer->isWritten()) {
// Ignore implicit initializers.
continue;
}
if (const clang::FieldDecl *FieldDecl = Initializer->getMember()) {
const SourceLocation InitBeginLoc = Initializer->getSourceLocation(),
InitEndLoc = Lexer::getLocForEndOfToken(
InitBeginLoc, 0, Context.getSourceManager(),
Context.getLangOpts());
if (!setResult(FieldDecl, InitBeginLoc, InitEndLoc)) {
return false;
}
}
}
return true;
}
// Other: // Other:
const NamedDecl *getNamedDecl() { return Result; } const NamedDecl *getNamedDecl() { return Result; }
// \brief Determines if a namespace qualifier contains the point. // \brief Determines if a namespace qualifier contains the point.
// \returns false on success and sets Result. // \returns false on success and sets Result.
void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) { void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
while (NameLoc) { while (NameLoc) {
▲ Show 20 Lines • Show All 98 Lines • Show Last 20 Lines

clang-rename/USRFindingAction.cpp

Show All 14 Lines
#include "USRFindingAction.h" #include "USRFindingAction.h"
#include "USRFinder.h" #include "USRFinder.h"
#include "clang/AST/AST.h" #include "clang/AST/AST.h"
#include "clang/AST/ASTConsumer.h" #include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/AST/Decl.h" #include "clang/AST/Decl.h"
#include "clang/AST/RecursiveASTVisitor.h" #include "clang/AST/RecursiveASTVisitor.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Basic/FileManager.h" #include "clang/Basic/FileManager.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendAction.h" #include "clang/Frontend/FrontendAction.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "clang/Tooling/CommonOptionsParser.h" #include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Refactoring.h" #include "clang/Tooling/Refactoring.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include <algorithm> #include <algorithm>
#include <string>
#include <set> #include <set>
#include <string>
#include <vector> #include <vector>
using namespace llvm; using namespace llvm;
using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace rename { namespace rename {
namespace { namespace {
// \brief NamedDeclFindingConsumer should delegate finding USRs of given Decl to // \brief NamedDeclFindingConsumer should delegate finding USRs of given Decl to
// AdditionalUSRFinder. AdditionalUSRFinder adds USRs of ctor and dtor if given // AdditionalUSRFinder. AdditionalUSRFinder adds USRs of ctor and dtor if given
// Decl refers to class and adds USRs of all overridden methods if Decl refers // Decl refers to class and adds USRs of all overridden methods if Decl refers
// to virtual method. // to virtual method.
class AdditionalUSRFinder : public MatchFinder::MatchCallback { class AdditionalUSRFinder : public RecursiveASTVisitor<AdditionalUSRFinder> {
public: public:
explicit AdditionalUSRFinder(const Decl *FoundDecl, ASTContext &Context, explicit AdditionalUSRFinder(const Decl *FoundDecl, ASTContext &Context,
std::vector<std::string> *USRs) std::vector<std::string> *USRs)
: FoundDecl(FoundDecl), Context(Context), USRs(USRs), USRSet(), Finder() {} : FoundDecl(FoundDecl), Context(Context), USRs(USRs) {}
void Find() { void Find() {
// Fill OverriddenMethods and PartialSpecs storages.
TraverseDecl(Context.getTranslationUnitDecl());
if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FoundDecl)) {
addUSRsOfOverridenFunctions(MethodDecl);
for (const auto &OverriddenMethod : OverriddenMethods) {
if (checkIfOverriddenFunctionAscends(OverriddenMethod)) {
USRSet.insert(getUSRForDecl(OverriddenMethod));
}
}
} else if (const auto *RecordDecl = dyn_cast<CXXRecordDecl>(FoundDecl)) {
handleCXXRecordDecl(RecordDecl);
} else if (const auto *TemplateDecl =
dyn_cast<ClassTemplateDecl>(FoundDecl)) {
handleClassTemplateDecl(TemplateDecl);
} else {
USRSet.insert(getUSRForDecl(FoundDecl)); USRSet.insert(getUSRForDecl(FoundDecl));
addUSRsFromOverrideSetsAndCtorDtors(); }
addMatchers();
Finder.matchAST(Context);
USRs->insert(USRs->end(), USRSet.begin(), USRSet.end()); USRs->insert(USRs->end(), USRSet.begin(), USRSet.end());
} }
bool VisitCXXMethodDecl(const CXXMethodDecl *MethodDecl) {
if (MethodDecl->isVirtual()) {
OverriddenMethods.push_back(MethodDecl);
}
return true;
}
bool VisitClassTemplatePartialSpecializationDecl(
const ClassTemplatePartialSpecializationDecl *PartialSpec) {
PartialSpecs.push_back(PartialSpec);
return true;
}
private: private:
void addMatchers() { void handleCXXRecordDecl(const CXXRecordDecl *RecordDecl) {
const auto CXXMethodDeclMatcher = RecordDecl = RecordDecl->getDefinition();
cxxMethodDecl(isVirtual()).bind("cxxMethodDecl"); if (const auto *ClassTemplateSpecDecl =
Finder.addMatcher(CXXMethodDeclMatcher, this); dyn_cast<ClassTemplateSpecializationDecl>(RecordDecl)) {
handleClassTemplateDecl(ClassTemplateSpecDecl->getSpecializedTemplate());
}
addUSRsOfCtorDtors(RecordDecl);
} }
// FIXME: Implement hasOverriddenMethod and matchesUSR matchers to make void handleClassTemplateDecl(const ClassTemplateDecl *TemplateDecl) {
// lookups more efficient. for (const auto *Specialization : TemplateDecl->specializations()) {
virtual void run(const MatchFinder::MatchResult &Result) { addUSRsOfCtorDtors(Specialization);
const auto *VirtualMethod =
Result.Nodes.getNodeAs<CXXMethodDecl>("cxxMethodDecl");
bool Found = false;
for (const auto &OverriddenMethod : VirtualMethod->overridden_methods()) {
if (USRSet.find(getUSRForDecl(OverriddenMethod)) != USRSet.end()) {
Found = true;
} }
for (const auto *PartialSpec : PartialSpecs) {
if (PartialSpec->getSpecializedTemplate() == TemplateDecl) {
addUSRsOfCtorDtors(PartialSpec);
} }
if (Found) {
USRSet.insert(getUSRForDecl(VirtualMethod));
} }
addUSRsOfCtorDtors(TemplateDecl->getTemplatedDecl());
} }
void addUSRsFromOverrideSetsAndCtorDtors() { void addUSRsOfCtorDtors(const CXXRecordDecl *RecordDecl) {
// If D is CXXRecordDecl we should add all USRs of its constructors.
if (const auto *RecordDecl = dyn_cast<CXXRecordDecl>(FoundDecl)) {
RecordDecl = RecordDecl->getDefinition(); RecordDecl = RecordDecl->getDefinition();
for (const auto *CtorDecl : RecordDecl->ctors()) { for (const auto *CtorDecl : RecordDecl->ctors()) {
USRSet.insert(getUSRForDecl(CtorDecl)); USRSet.insert(getUSRForDecl(CtorDecl));
} }
USRSet.insert(getUSRForDecl(RecordDecl->getDestructor())); USRSet.insert(getUSRForDecl(RecordDecl->getDestructor()));
USRSet.insert(getUSRForDecl(RecordDecl));
} }
// If D is CXXMethodDecl we should add all USRs of its overriden methods.
if (const auto *MethodDecl = dyn_cast<CXXMethodDecl>(FoundDecl)) { void addUSRsOfOverridenFunctions(const CXXMethodDecl *MethodDecl) {
USRSet.insert(getUSRForDecl(MethodDecl));
for (auto &OverriddenMethod : MethodDecl->overridden_methods()) { for (auto &OverriddenMethod : MethodDecl->overridden_methods()) {
USRSet.insert(getUSRForDecl(OverriddenMethod)); // Recursively visit each OverridenMethod.
addUSRsOfOverridenFunctions(OverriddenMethod);
}
}
bool checkIfOverriddenFunctionAscends(const CXXMethodDecl *MethodDecl) {
for (auto &OverriddenMethod : MethodDecl->overridden_methods()) {
if (USRSet.find(getUSRForDecl(OverriddenMethod)) != USRSet.end()) {
return true;
} }
return checkIfOverriddenFunctionAscends(OverriddenMethod);
} }
return false;
} }
const Decl *FoundDecl; const Decl *FoundDecl;
ASTContext &Context; ASTContext &Context;
std::vector<std::string> *USRs; std::vector<std::string> *USRs;
std::set<std::string> USRSet; std::set<std::string> USRSet;
MatchFinder Finder; std::vector<const CXXMethodDecl *> OverriddenMethods;
std::vector<const ClassTemplatePartialSpecializationDecl *> PartialSpecs;
}; };
} // namespace } // namespace
struct NamedDeclFindingConsumer : public ASTConsumer { struct NamedDeclFindingConsumer : public ASTConsumer {
void HandleTranslationUnit(ASTContext &Context) override { void HandleTranslationUnit(ASTContext &Context) override {
const auto &SourceMgr = Context.getSourceManager(); const auto &SourceMgr = Context.getSourceManager();
// The file we look for the USR in will always be the main source file. // The file we look for the USR in will always be the main source file.
const auto Point = SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID()) const auto Point = SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

clang-rename/USRLocFinder.h

Show All 20 Lines
#include <string> #include <string>
#include <vector> #include <vector>
namespace clang { namespace clang {
namespace rename { namespace rename {
// FIXME: make this an AST matcher. Wouldn't that be awesome??? I agree! // FIXME: make this an AST matcher. Wouldn't that be awesome??? I agree!
std::vector<SourceLocation> std::vector<SourceLocation>
getLocationsOfUSR(llvm::StringRef USR, llvm::StringRef PrevName, Decl *Decl); getLocationsOfUSRs(const std::vector<std::string> &USRs,
llvm::StringRef PrevName, Decl *Decl);
} // namespace rename } // namespace rename
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_RENAME_USR_LOC_FINDER_H

clang-rename/USRLocFinder.cpp

Show All 28 Lines
namespace rename { namespace rename {
namespace { namespace {
// \brief This visitor recursively searches for all instances of a USR in a // \brief This visitor recursively searches for all instances of a USR in a
// translation unit and stores them for later usage. // translation unit and stores them for later usage.
class USRLocFindingASTVisitor class USRLocFindingASTVisitor
: public clang::RecursiveASTVisitor<USRLocFindingASTVisitor> { : public clang::RecursiveASTVisitor<USRLocFindingASTVisitor> {
public: public:
explicit USRLocFindingASTVisitor(StringRef USR, StringRef PrevName, explicit USRLocFindingASTVisitor(const std::vector<std::string> &USRs,
StringRef PrevName,
const ASTContext &Context) const ASTContext &Context)
: USR(USR), PrevName(PrevName), Context(Context) {} : USRSet(USRs.begin(), USRs.end()), PrevName(PrevName), Context(Context) {
}
// Declaration visitors: // Declaration visitors:
bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) { bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
for (auto &Initializer : ConstructorDecl->inits()) { for (const auto *Initializer : ConstructorDecl->inits()) {
if (Initializer->getSourceOrder() == -1) { if (!Initializer->isWritten()) {
// Ignore implicit initializers. // Ignore implicit initializers.
continue; continue;
} }
if (const clang::FieldDecl *FieldDecl = Initializer->getAnyMember()) { if (const clang::FieldDecl *FieldDecl = Initializer->getMember()) {
if (getUSRForDecl(FieldDecl) == USR) { if (USRSet.find(getUSRForDecl(FieldDecl)) != USRSet.end()) {
// The initializer refers to a field that is to be renamed.
SourceLocation Location = Initializer->getSourceLocation();
StringRef TokenName = Lexer::getSourceText(
CharSourceRange::getTokenRange(Location),
Context.getSourceManager(), Context.getLangOpts());
if (TokenName == PrevName) {
// The token of the source location we find actually has the old
// name.
LocationsFound.push_back(Initializer->getSourceLocation()); LocationsFound.push_back(Initializer->getSourceLocation());
} }
} }
} }
}
return true; return true;
} }
bool VisitNamedDecl(const NamedDecl *Decl) { bool VisitNamedDecl(const NamedDecl *Decl) {
if (getUSRForDecl(Decl) == USR) { if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
checkAndAddLocation(Decl->getLocation()); checkAndAddLocation(Decl->getLocation());
} }
return true; return true;
} }
// Expression visitors: // Expression visitors:
bool VisitDeclRefExpr(const DeclRefExpr *Expr) { bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
const auto *Decl = Expr->getFoundDecl(); const auto *Decl = Expr->getFoundDecl();
if (getUSRForDecl(Decl) == USR) { if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
const SourceManager &Manager = Decl->getASTContext().getSourceManager(); const SourceManager &Manager = Decl->getASTContext().getSourceManager();
SourceLocation Location = Manager.getSpellingLoc(Expr->getLocation()); SourceLocation Location = Manager.getSpellingLoc(Expr->getLocation());
checkAndAddLocation(Location); checkAndAddLocation(Location);
} }
return true; return true;
} }
bool VisitMemberExpr(const MemberExpr *Expr) { bool VisitMemberExpr(const MemberExpr *Expr) {
const auto *Decl = Expr->getFoundDecl().getDecl(); const auto *Decl = Expr->getFoundDecl().getDecl();
if (getUSRForDecl(Decl) == USR) { if (USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
const SourceManager &Manager = Decl->getASTContext().getSourceManager(); const SourceManager &Manager = Decl->getASTContext().getSourceManager();
SourceLocation Location = Manager.getSpellingLoc(Expr->getMemberLoc()); SourceLocation Location = Manager.getSpellingLoc(Expr->getMemberLoc());
checkAndAddLocation(Location); checkAndAddLocation(Location);
} }
return true; return true;
} }
// Other visitors: // Other visitors:
bool VisitTypeLoc(const TypeLoc Loc) { bool VisitTypeLoc(const TypeLoc Loc) {
if (getUSRForDecl(Loc.getType()->getAsCXXRecordDecl()) == USR) { if (USRSet.find(getUSRForDecl(Loc.getType()->getAsCXXRecordDecl())) !=
USRSet.end()) {
checkAndAddLocation(Loc.getBeginLoc());
}
if (const auto *TemplateTypeParm =
dyn_cast<TemplateTypeParmType>(Loc.getType())) {
if (USRSet.find(getUSRForDecl(TemplateTypeParm->getDecl())) !=
USRSet.end()) {
checkAndAddLocation(Loc.getBeginLoc()); checkAndAddLocation(Loc.getBeginLoc());
} }
}
return true; return true;
} }
// Non-visitors: // Non-visitors:
// \brief Returns a list of unique locations. Duplicate or overlapping // \brief Returns a list of unique locations. Duplicate or overlapping
// locations are erroneous and should be reported! // locations are erroneous and should be reported!
const std::vector<clang::SourceLocation> &getLocationsFound() const { const std::vector<clang::SourceLocation> &getLocationsFound() const {
return LocationsFound; return LocationsFound;
} }
// Namespace traversal: // Namespace traversal:
void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) { void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
while (NameLoc) { while (NameLoc) {
const auto *Decl = NameLoc.getNestedNameSpecifier()->getAsNamespace(); const auto *Decl = NameLoc.getNestedNameSpecifier()->getAsNamespace();
if (Decl && getUSRForDecl(Decl) == USR) { if (Decl && USRSet.find(getUSRForDecl(Decl)) != USRSet.end()) {
checkAndAddLocation(NameLoc.getLocalBeginLoc()); checkAndAddLocation(NameLoc.getLocalBeginLoc());
} }
NameLoc = NameLoc.getPrefix(); NameLoc = NameLoc.getPrefix();
} }
} }
private: private:
void checkAndAddLocation(SourceLocation Loc) { void checkAndAddLocation(SourceLocation Loc) {
const auto BeginLoc = Loc; const auto BeginLoc = Loc;
const auto EndLoc = Lexer::getLocForEndOfToken( const auto EndLoc = Lexer::getLocForEndOfToken(
BeginLoc, 0, Context.getSourceManager(), BeginLoc, 0, Context.getSourceManager(), Context.getLangOpts());
Context.getLangOpts());
StringRef TokenName = StringRef TokenName =
Lexer::getSourceText(CharSourceRange::getTokenRange(BeginLoc, EndLoc), Lexer::getSourceText(CharSourceRange::getTokenRange(BeginLoc, EndLoc),
Context.getSourceManager(), Context.getLangOpts()); Context.getSourceManager(), Context.getLangOpts());
size_t Offset = TokenName.find(PrevName); size_t Offset = TokenName.find(PrevName);
if (Offset != StringRef::npos) { if (Offset != StringRef::npos) {
// The token of the source location we find actually has the old // The token of the source location we find actually has the old
// name. // name.
LocationsFound.push_back(BeginLoc.getLocWithOffset(Offset)); LocationsFound.push_back(BeginLoc.getLocWithOffset(Offset));
} }
} }
// All the locations of the USR were found. const std::set<std::string> USRSet;
const std::string USR;
// Old name that is renamed.
const std::string PrevName; const std::string PrevName;
std::vector<clang::SourceLocation> LocationsFound; std::vector<clang::SourceLocation> LocationsFound;
const ASTContext &Context; const ASTContext &Context;
}; };
} // namespace } // namespace
std::vector<SourceLocation> getLocationsOfUSR(StringRef USR, StringRef PrevName, std::vector<SourceLocation>
getLocationsOfUSRs(const std::vector<std::string> &USRs, StringRef PrevName,
Decl *Decl) { Decl *Decl) {
USRLocFindingASTVisitor Visitor(USR, PrevName, Decl->getASTContext()); USRLocFindingASTVisitor Visitor(USRs, PrevName, Decl->getASTContext());
Visitor.TraverseDecl(Decl); Visitor.TraverseDecl(Decl);
NestedNameSpecifierLocFinder Finder(Decl->getASTContext()); NestedNameSpecifierLocFinder Finder(Decl->getASTContext());
for (const auto &Location : Finder.getNestedNameSpecifierLocations()) { for (const auto &Location : Finder.getNestedNameSpecifierLocations()) {
Visitor.handleNestedNameSpecifierLoc(Location); Visitor.handleNestedNameSpecifierLoc(Location);
} }
return Visitor.getLocationsFound(); return Visitor.getLocationsFound();
} }
} // namespace rename } // namespace rename
} // namespace clang } // namespace clang

clang-rename/tool/CMakeLists.txt

add_clang_executable(clang-rename ClangRename.cpp) add_clang_executable(clang-rename ClangRename.cpp)
target_link_libraries(clang-rename target_link_libraries(clang-rename
clangBasic clangBasic
clangFrontend clangFrontend
clangRename clangRename
clangRewrite clangRewrite
clangTooling clangTooling
clangToolingCore clangToolingCore
) )
install(TARGETS clang-rename RUNTIME DESTINATION bin) install(TARGETS clang-rename RUNTIME DESTINATION bin)
install(PROGRAMS clang-rename.py
DESTINATION share/clang
COMPONENT clang-rename)
install(PROGRAMS clang-rename.el
DESTINATION share/clang
COMPONENT clang-rename)

clang-rename/tool/ClangRename.cpp

//===--- tools/extra/clang-rename/ClangRename.cpp - Clang rename tool -----===// //===--- tools/extra/clang-rename/ClangRename.cpp - Clang rename tool -----===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// ///
/// \file /// \file
/// \brief This file implements a clang-rename tool that automatically finds and /// \brief This file implements a clang-rename tool that automatically finds and
/// renames symbols in C++ code. /// renames symbols in C++ code.
/// ///
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../USRFindingAction.h"
#include "../RenamingAction.h" #include "../RenamingAction.h"
#include "../USRFindingAction.h"
#include "clang/Basic/Diagnostic.h" #include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/FileManager.h" #include "clang/Basic/FileManager.h"
#include "clang/Basic/IdentifierTable.h" #include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LangOptions.h" #include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceManager.h" #include "clang/Basic/SourceManager.h"
#include "clang/Basic/TokenKinds.h" #include "clang/Basic/TokenKinds.h"
#include "clang/Frontend/TextDiagnosticPrinter.h" #include "clang/Frontend/TextDiagnosticPrinter.h"
#include "clang/Rewrite/Core/Rewriter.h" #include "clang/Rewrite/Core/Rewriter.h"
#include "clang/Tooling/CommonOptionsParser.h" #include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Refactoring.h" #include "clang/Tooling/Refactoring.h"
#include "clang/Tooling/ReplacementsYaml.h" #include "clang/Tooling/ReplacementsYaml.h"
#include "clang/Tooling/Tooling.h" #include "clang/Tooling/Tooling.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h" #include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/FileSystem.h" #include "llvm/Support/FileSystem.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Support/YAMLTraits.h" #include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/raw_ostream.h"
#include <cstdlib> #include <cstdlib>
#include <string> #include <string>
#include <system_error> #include <system_error>
using namespace llvm; using namespace llvm;
cl::OptionCategory ClangRenameCategory("Clang-rename options");
static cl::opt<std::string>
NewName(
"new-name",
cl::desc("The new name to change the symbol to."),
cl::cat(ClangRenameCategory));
static cl::opt<unsigned>
SymbolOffset(
"offset",
cl::desc("Locates the symbol by offset as opposed to <line>:<column>."),
cl::cat(ClangRenameCategory));
static cl::opt<std::string>
OldName(
"old-name",
cl::desc("The fully qualified name of the symbol, if -offset is not used."),
cl::cat(ClangRenameCategory));
static cl::opt<bool>
Inplace(
"i",
cl::desc("Overwrite edited <file>s."),
cl::cat(ClangRenameCategory));
static cl::opt<bool>
PrintName(
"pn",
cl::desc("Print the found symbol's name prior to renaming to stderr."),
cl::cat(ClangRenameCategory));
static cl::opt<bool>
PrintLocations(
"pl",
cl::desc("Print the locations affected by renaming to stderr."),
cl::cat(ClangRenameCategory));
static cl::opt<std::string>
ExportFixes(
"export-fixes",
cl::desc("YAML file to store suggested fixes in."),
cl::value_desc("filename"),
cl::cat(ClangRenameCategory));
using namespace clang; using namespace clang;
const char RenameUsage[] = "A tool to rename symbols in C/C++ code.\n\ cl::OptionCategory ClangRenameAtCategory("clang-rename rename-at options");
cl::OptionCategory ClangRenameAllCategory("clang-rename rename-all options");
const char RenameAtUsage[] = "A tool to rename symbols in C/C++ code.\n\
clang-rename renames every occurrence of a symbol found at <offset> in\n\ clang-rename renames every occurrence of a symbol found at <offset> in\n\
<source0>. If -i is specified, the edited files are overwritten to disk.\n\ <source0>. If -i is specified, the edited files are overwritten to disk.\n\
Otherwise, the results are written to stdout.\n"; Otherwise, the results are written to stdout.\n";
const char RenameAllUsage[] = "A tool to rename symbols in C/C++ code.\n\
clang-rename renames every occurrence of a symbol named <old-name>.\n";
static int renameAtMain(int argc, const char *argv[]);
static int renameAllMain(int argc, const char *argv[]);
static int helpMain(int argc, const char *argv[]);
/// \brief An oldname -> newname rename.
struct RenameAllInfo {
std::string OldName;
unsigned Offset;
std::string NewName;
RenameAllInfo() : Offset(0) {}
};
LLVM_YAML_IS_SEQUENCE_VECTOR(RenameAllInfo)
namespace llvm {
namespace yaml {
/// \brief Specialized MappingTraits to describe how a RenameAllInfo is /
/// (de)serialized.
template <> struct MappingTraits<RenameAllInfo> {
static void mapping(IO &IO, RenameAllInfo &Info) {
IO.mapOptional("OldName", Info.OldName);
IO.mapOptional("Offset", Info.Offset);
IO.mapRequired("NewName", Info.NewName);
}
};
} // end namespace yaml
} // end namespace llvm
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
tooling::CommonOptionsParser OP(argc, argv, ClangRenameCategory, RenameUsage); if (argc > 1) {
using MainFunction = std::function<int(int, const char *[])>;
MainFunction Func = StringSwitch<MainFunction>(argv[1])
.Case("rename-at", renameAtMain)
.Case("rename-all", renameAllMain)
.Cases("-help", "--help", helpMain)
.Default(nullptr);
if (Func) {
std::string Invocation = std::string(argv[0]) + " " + argv[1];
argv[1] = Invocation.c_str();
return Func(argc - 1, argv + 1);
} else {
return renameAtMain(argc, argv);
}
}
helpMain(argc, argv);
return 1;
}
int subcommandMain(bool isRenameAll, int argc, const char **argv) {
cl::OptionCategory *Category = nullptr;
const char *Usage = nullptr;
if (isRenameAll) {
Category = &ClangRenameAllCategory;
Usage = RenameAllUsage;
} else {
Category = &ClangRenameAtCategory;
Usage = RenameAtUsage;
}
cl::list<std::string> NewNames(
"new-name", cl::desc("The new name to change the symbol to."),
(isRenameAll ? cl::ZeroOrMore : cl::Required), cl::cat(*Category));
cl::list<unsigned> SymbolOffsets(
"offset",
cl::desc("Locates the symbol by offset as opposed to <line>:<column>."),
(isRenameAll ? cl::ZeroOrMore : cl::Required), cl::cat(*Category));
cl::list<std::string> OldNames(
"old-name",
cl::desc(
"The fully qualified name of the symbol, if -offset is not used."),
(isRenameAll ? cl::ZeroOrMore : cl::Optional),
cl::cat(ClangRenameAllCategory));
cl::opt<bool> Inplace("i", cl::desc("Overwrite edited <file>s."),
cl::cat(*Category));
cl::opt<bool> PrintName(
"pn",
cl::desc("Print the found symbol's name prior to renaming to stderr."),
cl::cat(ClangRenameAtCategory));
cl::opt<bool> PrintLocations(
"pl", cl::desc("Print the locations affected by renaming to stderr."),
cl::cat(ClangRenameAtCategory));
cl::opt<std::string> ExportFixes(
"export-fixes", cl::desc("YAML file to store suggested fixes in."),
cl::value_desc("filename"), cl::cat(*Category));
cl::opt<std::string> Input(
"input", cl::desc("YAML file to load oldname-newname pairs from."),
cl::Optional, cl::cat(ClangRenameAllCategory));
tooling::CommonOptionsParser OP(argc, argv, *Category, Usage);
if (!Input.empty()) {
// Populate OldNames and NewNames from a YAML file.
auto Buffer = llvm::MemoryBuffer::getFile(Input);
if (!Buffer) {
errs() << "clang-rename: failed to read " << Input << ": "
<< Buffer.getError().message() << "\n";
exit(1);
}
std::vector<RenameAllInfo> Infos;
llvm::yaml::Input YAML(Buffer.get()->getBuffer());
YAML >> Infos;
for (const auto &Info : Infos) {
if (!Info.OldName.empty())
OldNames.push_back(Info.OldName);
else
SymbolOffsets.push_back(Info.Offset);
NewNames.push_back(Info.NewName);
}
}
// Check the arguments for correctness. // Check the arguments for correctness.
if (NewName.empty()) { if (NewNames.empty()) {
errs() << "ERROR: no new name provided.\n\n"; errs() << "clang-rename: either -new-name or -input is required.\n\n";
exit(1); exit(1);
} }
// Check if NewName is a valid identifier in C++17. // Check if NewNames is a valid identifier in C++17.
for (const auto &NewName : NewNames) {
LangOptions Options; LangOptions Options;
Options.CPlusPlus = true; Options.CPlusPlus = true;
Options.CPlusPlus1z = true; Options.CPlusPlus1z = true;
IdentifierTable Table(Options); IdentifierTable Table(Options);
auto NewNameTokKind = Table.get(NewName).getTokenID(); auto NewNameTokKind = Table.get(NewName).getTokenID();
if (!tok::isAnyIdentifier(NewNameTokKind)) { if (!tok::isAnyIdentifier(NewNameTokKind)) {
errs() << "ERROR: new name is not a valid identifier in C++17.\n\n"; errs() << "ERROR: new name is not a valid identifier in C++17.\n\n";
exit(1); exit(1);
} }
}
// Get the USRs. if (!OldNames.empty() && OldNames.size() != NewNames.size()) {
errs() << "clang-rename: number of old names (" << OldNames.size()
<< ") do not equal to number of new names (" << NewNames.size()
<< ").\n\n";
cl::PrintHelpMessage();
exit(1);
}
if (!SymbolOffsets.empty() && SymbolOffsets.size() != NewNames.size()) {
errs() << "clang-rename: number of symbol offsets (" << SymbolOffsets.size()
<< ") do not equal to number of new names (" << NewNames.size()
<< ").\n\n";
cl::PrintHelpMessage();
exit(1);
}
std::vector<std::vector<std::string>> USRList;
std::vector<std::string> PrevNames;
auto Files = OP.getSourcePathList(); auto Files = OP.getSourcePathList();
tooling::RefactoringTool Tool(OP.getCompilations(), Files); tooling::RefactoringTool Tool(OP.getCompilations(), Files);
unsigned Count = OldNames.size() ? OldNames.size() : SymbolOffsets.size();
for (unsigned I = 0; I < Count; ++I) {
unsigned SymbolOffset = SymbolOffsets.empty() ? 0 : SymbolOffsets[I];
const std::string &OldName = OldNames.empty() ? std::string() : OldNames[I];
// Get the USRs.
rename::USRFindingAction USRAction(SymbolOffset, OldName); rename::USRFindingAction USRAction(SymbolOffset, OldName);
// Find the USRs. // Find the USRs.
Tool.run(tooling::newFrontendActionFactory(&USRAction).get()); Tool.run(tooling::newFrontendActionFactory(&USRAction).get());
const auto &USRs = USRAction.getUSRs(); const auto &USRs = USRAction.getUSRs();
USRList.push_back(USRs);
const auto &PrevName = USRAction.getUSRSpelling(); const auto &PrevName = USRAction.getUSRSpelling();
PrevNames.push_back(PrevName);
if (PrevName.empty()) { if (PrevName.empty()) {
// An error should have already been printed. // An error should have already been printed.
exit(1); exit(1);
} }
if (PrintName) { if (PrintName) {
errs() << "clang-rename: found name: " << PrevName << '\n'; errs() << "clang-rename: found name: " << PrevName << '\n';
} }
}
// Perform the renaming. // Perform the renaming.
rename::RenamingAction RenameAction(NewName, PrevName, USRs, rename::RenamingAction RenameAction(NewNames, PrevNames, USRList,
Tool.getReplacements(), PrintLocations); Tool.getReplacements(), PrintLocations);
auto Factory = tooling::newFrontendActionFactory(&RenameAction); auto Factory = tooling::newFrontendActionFactory(&RenameAction);
int ExitCode; int ExitCode;
if (Inplace) { if (Inplace) {
ExitCode = Tool.runAndSave(Factory.get()); ExitCode = Tool.runAndSave(Factory.get());
} else { } else {
ExitCode = Tool.run(Factory.get()); ExitCode = Tool.run(Factory.get());
if (!ExportFixes.empty()) { if (!ExportFixes.empty()) {
std::error_code EC; std::error_code EC;
llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None); llvm::raw_fd_ostream OS(ExportFixes, EC, llvm::sys::fs::F_None);
if (EC) { if (EC) {
llvm::errs() << "Error opening output file: " << EC.message() << '\n'; llvm::errs() << "Error opening output file: " << EC.message() << '\n';
exit(1); exit(1);
} }
// Export replacements. // Export replacements.
tooling::TranslationUnitReplacements TUR; tooling::TranslationUnitReplacements TUR;
const tooling::Replacements &Replacements = Tool.getReplacements(); const auto &FileToReplacements = Tool.getReplacements();
TUR.Replacements.insert(TUR.Replacements.end(), Replacements.begin(), for (const auto &Entry : FileToReplacements)
Replacements.end()); TUR.Replacements.insert(TUR.Replacements.end(), Entry.second.begin(),
Entry.second.end());
yaml::Output YAML(OS); yaml::Output YAML(OS);
YAML << TUR; YAML << TUR;
OS.close(); OS.close();
exit(0); exit(0);
} }
// Write every file to stdout. Right now we just barf the files without any // Write every file to stdout. Right now we just barf the files without any
// indication of which files start where, other than that we print the files // indication of which files start where, other than that we print the files
// in the same order we see them. // in the same order we see them.
LangOptions DefaultLangOptions; LangOptions DefaultLangOptions;
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
new DiagnosticOptions();
TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts); TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts);
DiagnosticsEngine Diagnostics( DiagnosticsEngine Diagnostics(
IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
&*DiagOpts, &DiagnosticPrinter, false); &DiagnosticPrinter, false);
auto &FileMgr = Tool.getFiles(); auto &FileMgr = Tool.getFiles();
SourceManager Sources(Diagnostics, FileMgr); SourceManager Sources(Diagnostics, FileMgr);
Rewriter Rewrite(Sources, DefaultLangOptions); Rewriter Rewrite(Sources, DefaultLangOptions);
Tool.applyAllReplacements(Rewrite); Tool.applyAllReplacements(Rewrite);
for (const auto &File : Files) { for (const auto &File : Files) {
const auto *Entry = FileMgr.getFile(File); const auto *Entry = FileMgr.getFile(File);
auto ID = Sources.translateFile(Entry); auto ID = Sources.translateFile(Entry);
Rewrite.getEditBuffer(ID).write(outs()); Rewrite.getEditBuffer(ID).write(outs());
} }
} }
exit(ExitCode); exit(ExitCode);
} }
/// \brief Top level help.
/// FIXME It would be better if this could be auto-generated.
static int helpMain(int argc, const char *argv[]) {
errs() << "Usage: clang-rename {rename-at|rename-all} [OPTION]...\n\n"
"A tool to rename symbols in C/C++ code.\n\n"
"Subcommands:\n"
" rename-at: Perform rename off of a location in a file. (This "
"is the default.)\n"
" rename-all: Perform rename of all symbols matching one or more "
"fully qualified names.\n";
return 0;
}
static int renameAtMain(int argc, const char *argv[]) {
return subcommandMain(false, argc, argv);
}
static int renameAllMain(int argc, const char *argv[]) {
return subcommandMain(true, argc, argv);
}

clang-rename/tool/clang-rename.el

  • This file was added.
;;; clang-rename.el --- Renames every occurrence of a symbol found at <offset>.
;; Keywords: tools, c
;;; Commentary:
;; To install clang-rename.el make sure the directory of this file is in your
;; 'load-path' and add
;;
;; (require 'clang-rename)
;;
;; to your .emacs configuration.
;;; Code:
(defcustom clang-rename-binary "clang-rename"
"Path to clang-rename executable."
:type 'hook
:options '(turn-on-auto-fill flyspell-mode)
:group 'wp)
(defun clang-rename (new-name)
"Rename all instances of the symbol at the point using clang-rename"
(interactive "sEnter a new name: ")
(let (;; Emacs offset is 1-based.
(offset (- (point) 1))
(orig-buf (current-buffer))
(file-name (buffer-file-name)))
(let ((rename-command
(format "bash -f -c '%s -offset=%s -new-name=%s -i %s'"
clang-rename-binary offset new-name file-name)))
(message (format "Running clang-rename command %s" rename-command))
;; Run clang-rename via bash.
(shell-command rename-command)
;; Reload buffer.
(revert-buffer t t)
)
)
)
(provide 'clang-rename)
;;; clang-rename.el ends here

clang-tidy/CMakeLists.txt

Show All 28 Lines
add_subdirectory(plugin) add_subdirectory(plugin)
add_subdirectory(boost) add_subdirectory(boost)
add_subdirectory(cert) add_subdirectory(cert)
add_subdirectory(llvm) add_subdirectory(llvm)
add_subdirectory(cppcoreguidelines) add_subdirectory(cppcoreguidelines)
add_subdirectory(google) add_subdirectory(google)
add_subdirectory(misc) add_subdirectory(misc)
add_subdirectory(modernize) add_subdirectory(modernize)
add_subdirectory(mpi)
add_subdirectory(performance) add_subdirectory(performance)
add_subdirectory(readability) add_subdirectory(readability)
add_subdirectory(utils) add_subdirectory(utils)

clang-tidy/ClangTidy.h

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linespublic:
get(StringRef LocalName, T Default) const { get(StringRef LocalName, T Default) const {
std::string Value = get(LocalName, ""); std::string Value = get(LocalName, "");
T Result = Default; T Result = Default;
if (!Value.empty()) if (!Value.empty())
StringRef(Value).getAsInteger(10, Result); StringRef(Value).getAsInteger(10, Result);
return Result; return Result;
} }
/// \brief Read a named option from the ``Context`` and parse it as an
/// integral type ``T``.
///
/// Reads the option with the check-local name \p LocalName from local or
/// global ``CheckOptions``. Gets local option first. If local is not present,
/// falls back to get global option. If global option is not present either,
/// returns Default.
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type
getLocalOrGlobal(StringRef LocalName, T Default) const {
std::string Value = getLocalOrGlobal(LocalName, "");
T Result = Default;
if (!Value.empty())
StringRef(Value).getAsInteger(10, Result);
return Result;
}
/// \brief Stores an option with the check-local name \p LocalName with string /// \brief Stores an option with the check-local name \p LocalName with string
/// value \p Value to \p Options. /// value \p Value to \p Options.
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
StringRef Value) const; StringRef Value) const;
/// \brief Stores an option with the check-local name \p LocalName with /// \brief Stores an option with the check-local name \p LocalName with
/// ``int64_t`` value \p Value to \p Options. /// ``int64_t`` value \p Value to \p Options.
void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName, void store(ClangTidyOptions::OptionMap &Options, StringRef LocalName,
▲ Show 20 Lines • Show All 153 Lines • Show Last 20 Lines

clang-tidy/ClangTidy.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
#include <algorithm> #include <algorithm>
#include <utility> #include <utility>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::driver; using namespace clang::driver;
using namespace clang::tooling; using namespace clang::tooling;
using namespace llvm; using namespace llvm;
template class llvm::Registry<clang::tidy::ClangTidyModule>; LLVM_INSTANTIATE_REGISTRY(clang::tidy::ClangTidyModuleRegistry)
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace { namespace {
static const char *AnalyzerCheckNamePrefix = "clang-analyzer-"; static const char *AnalyzerCheckNamePrefix = "clang-analyzer-";
static const StringRef StaticAnalyzerChecks[] = { static const StringRef StaticAnalyzerChecks[] = {
▲ Show 20 Lines • Show All 62 Lines • ▼ Show 20 Lines SmallVector<std::pair<SourceLocation, bool>, 4> FixLocations;
std::string Name = Error.CheckName; std::string Name = Error.CheckName;
if (Error.IsWarningAsError) { if (Error.IsWarningAsError) {
Name += ",-warnings-as-errors"; Name += ",-warnings-as-errors";
Level = DiagnosticsEngine::Error; Level = DiagnosticsEngine::Error;
WarningsAsErrors++; WarningsAsErrors++;
} }
auto Diag = Diags.Report(Loc, Diags.getCustomDiagID(Level, "%0 [%1]")) auto Diag = Diags.Report(Loc, Diags.getCustomDiagID(Level, "%0 [%1]"))
<< Message.Message << Name; << Message.Message << Name;
for (const tooling::Replacement &Fix : Error.Fix) { for (const auto &FileAndReplacements : Error.Fix) {
for (const auto &Replacement : FileAndReplacements.second) {
// Retrieve the source range for applicable fixes. Macro definitions // Retrieve the source range for applicable fixes. Macro definitions
// on the command line have locations in a virtual buffer and don't // on the command line have locations in a virtual buffer and don't
// have valid file paths and are therefore not applicable. // have valid file paths and are therefore not applicable.
SourceRange Range; SourceRange Range;
SourceLocation FixLoc; SourceLocation FixLoc;
if (Fix.isApplicable()) { if (Replacement.isApplicable()) {
SmallString<128> FixAbsoluteFilePath = Fix.getFilePath(); SmallString<128> FixAbsoluteFilePath = Replacement.getFilePath();
Files.makeAbsolutePath(FixAbsoluteFilePath); Files.makeAbsolutePath(FixAbsoluteFilePath);
FixLoc = getLocation(FixAbsoluteFilePath, Fix.getOffset()); FixLoc = getLocation(FixAbsoluteFilePath, Replacement.getOffset());
SourceLocation FixEndLoc = FixLoc.getLocWithOffset(Fix.getLength()); SourceLocation FixEndLoc =
FixLoc.getLocWithOffset(Replacement.getLength());
Range = SourceRange(FixLoc, FixEndLoc); Range = SourceRange(FixLoc, FixEndLoc);
Diag << FixItHint::CreateReplacement(Range, Fix.getReplacementText()); Diag << FixItHint::CreateReplacement(
Range, Replacement.getReplacementText());
} }
++TotalFixes; ++TotalFixes;
if (ApplyFixes) { if (ApplyFixes) {
bool Success = Fix.isApplicable() && Fix.apply(Rewrite); bool Success =
Replacement.isApplicable() && Replacement.apply(Rewrite);
if (Success) if (Success)
++AppliedFixes; ++AppliedFixes;
FixLocations.push_back(std::make_pair(FixLoc, Success)); FixLocations.push_back(std::make_pair(FixLoc, Success));
} }
} }
} }
}
for (auto Fix : FixLocations) { for (auto Fix : FixLocations) {
Diags.Report(Fix.first, Fix.second ? diag::note_fixit_applied Diags.Report(Fix.first, Fix.second ? diag::note_fixit_applied
: diag::note_fixit_failed); : diag::note_fixit_failed);
} }
for (const ClangTidyMessage &Note : Error.Notes) for (const ClangTidyMessage &Note : Error.Notes)
reportNote(Note); reportNote(Note);
} }
▲ Show 20 Lines • Show All 345 Lines • ▼ Show 20 Linesvoid handleErrors(const std::vector<ClangTidyError> &Errors, bool Fix,
} }
Reporter.Finish(); Reporter.Finish();
WarningsAsErrorsCount += Reporter.getWarningsAsErrorsCount(); WarningsAsErrorsCount += Reporter.getWarningsAsErrorsCount();
} }
void exportReplacements(const std::vector<ClangTidyError> &Errors, void exportReplacements(const std::vector<ClangTidyError> &Errors,
raw_ostream &OS) { raw_ostream &OS) {
tooling::TranslationUnitReplacements TUR; tooling::TranslationUnitReplacements TUR;
for (const ClangTidyError &Error : Errors) for (const ClangTidyError &Error : Errors) {
TUR.Replacements.insert(TUR.Replacements.end(), Error.Fix.begin(), for (const auto &FileAndFixes : Error.Fix)
Error.Fix.end()); TUR.Replacements.insert(TUR.Replacements.end(),
FileAndFixes.second.begin(),
FileAndFixes.second.end());
}
yaml::Output YAML(OS); yaml::Output YAML(OS);
YAML << TUR; YAML << TUR;
} }
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/ClangTidyDiagnosticConsumer.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines enum Level {
Error = DiagnosticsEngine::Error Error = DiagnosticsEngine::Error
}; };
ClangTidyError(StringRef CheckName, Level DiagLevel, bool IsWarningAsError, ClangTidyError(StringRef CheckName, Level DiagLevel, bool IsWarningAsError,
StringRef BuildDirectory); StringRef BuildDirectory);
std::string CheckName; std::string CheckName;
ClangTidyMessage Message; ClangTidyMessage Message;
tooling::Replacements Fix; // Fixes grouped by file path.
llvm::StringMap<tooling::Replacements> Fix;
SmallVector<ClangTidyMessage, 1> Notes; SmallVector<ClangTidyMessage, 1> Notes;
// A build directory of the diagnostic source file. // A build directory of the diagnostic source file.
// //
// It's an absolute path which is `directory` field of the source file in // It's an absolute path which is `directory` field of the source file in
// compilation database. If users don't specify the compilation database // compilation database. If users don't specify the compilation database
// directory, it is the current directory where clang-tidy runs. // directory, it is the current directory where clang-tidy runs.
// //
▲ Show 20 Lines • Show All 220 Lines • Show Last 20 Lines

clang-tidy/ClangTidyDiagnosticConsumer.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines void emitCodeContext(SourceLocation Loc, DiagnosticsEngine::Level Level,
assert(Loc.isValid()); assert(Loc.isValid());
for (const auto &FixIt : Hints) { for (const auto &FixIt : Hints) {
CharSourceRange Range = FixIt.RemoveRange; CharSourceRange Range = FixIt.RemoveRange;
assert(Range.getBegin().isValid() && Range.getEnd().isValid() && assert(Range.getBegin().isValid() && Range.getEnd().isValid() &&
"Invalid range in the fix-it hint."); "Invalid range in the fix-it hint.");
assert(Range.getBegin().isFileID() && Range.getEnd().isFileID() && assert(Range.getBegin().isFileID() && Range.getEnd().isFileID() &&
"Only file locations supported in fix-it hints."); "Only file locations supported in fix-it hints.");
Error.Fix.insert(tooling::Replacement(SM, Range, FixIt.CodeToInsert)); tooling::Replacement Replacement(SM, Range, FixIt.CodeToInsert);
llvm::Error Err = Error.Fix[Replacement.getFilePath()].add(Replacement);
// FIXME: better error handling.
if (Err) {
llvm::errs() << "Fix conflicts with existing fix! "
<< llvm::toString(std::move(Err)) << "\n";
}
assert(!Err && "Fix conflicts with existing fix!");
} }
} }
void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc, void emitIncludeLocation(SourceLocation Loc, PresumedLoc PLoc,
const SourceManager &SM) override {} const SourceManager &SM) override {}
void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc, void emitImportLocation(SourceLocation Loc, PresumedLoc PLoc,
StringRef ModuleName, StringRef ModuleName,
▲ Show 20 Lines • Show All 332 Lines • ▼ Show 20 Lines
} }
void ClangTidyDiagnosticConsumer::removeIncompatibleErrors( void ClangTidyDiagnosticConsumer::removeIncompatibleErrors(
SmallVectorImpl<ClangTidyError> &Errors) const { SmallVectorImpl<ClangTidyError> &Errors) const {
// Each error is modelled as the set of intervals in which it applies // Each error is modelled as the set of intervals in which it applies
// replacements. To detect overlapping replacements, we use a sweep line // replacements. To detect overlapping replacements, we use a sweep line
// algorithm over these sets of intervals. // algorithm over these sets of intervals.
// An event here consists of the opening or closing of an interval. During the // An event here consists of the opening or closing of an interval. During the
// proccess, we maintain a counter with the amount of open intervals. If we // process, we maintain a counter with the amount of open intervals. If we
// find an endpoint of an interval and this counter is different from 0, it // find an endpoint of an interval and this counter is different from 0, it
// means that this interval overlaps with another one, so we set it as // means that this interval overlaps with another one, so we set it as
// inapplicable. // inapplicable.
struct Event { struct Event {
// An event can be either the begin or the end of an interval. // An event can be either the begin or the end of an interval.
enum EventType { enum EventType {
ET_Begin = 1, ET_Begin = 1,
ET_End = -1, ET_End = -1,
}; };
Event(unsigned Begin, unsigned End, EventType Type, unsigned ErrorId, Event(unsigned Begin, unsigned End, EventType Type, unsigned ErrorId,
unsigned ErrorSize) unsigned ErrorSize)
: Type(Type), ErrorId(ErrorId) { : Type(Type), ErrorId(ErrorId) {
// The events are going to be sorted by their position. In case of draw: // The events are going to be sorted by their position. In case of draw:
// //
// * If an interval ends at the same position at which other interval // * If an interval ends at the same position at which other interval
// begins, this is not an overlapping, so we want to remove the ending // begins, this is not an overlapping, so we want to remove the ending
// interval before adding the starting one: end events have higher // interval before adding the starting one: end events have higher
// priority than begin events. // priority than begin events.
// //
// * If we have several begin points at the same position, we will mark as // * If we have several begin points at the same position, we will mark as
// inapplicable the ones that we proccess later, so the first one has to // inapplicable the ones that we process later, so the first one has to
// be the one with the latest end point, because this one will contain // be the one with the latest end point, because this one will contain
// all the other intervals. For the same reason, if we have several end // all the other intervals. For the same reason, if we have several end
// points in the same position, the last one has to be the one with the // points in the same position, the last one has to be the one with the
// earliest begin point. In both cases, we sort non-increasingly by the // earliest begin point. In both cases, we sort non-increasingly by the
// position of the complementary. // position of the complementary.
// //
// * In case of two equal intervals, the one whose error is bigger can // * In case of two equal intervals, the one whose error is bigger can
// potentially contain the other one, so we want to proccess its begin // potentially contain the other one, so we want to process its begin
// points before and its end points later. // points before and its end points later.
// //
// * Finally, if we have two equal intervals whose errors have the same // * Finally, if we have two equal intervals whose errors have the same
// size, none of them will be strictly contained inside the other. // size, none of them will be strictly contained inside the other.
// Sorting by ErrorId will guarantee that the begin point of the first // Sorting by ErrorId will guarantee that the begin point of the first
// one will be proccessed before, disallowing the second one, and the // one will be processed before, disallowing the second one, and the
// end point of the first one will also be proccessed before, // end point of the first one will also be processed before,
// disallowing the first one. // disallowing the first one.
if (Type == ET_Begin) if (Type == ET_Begin)
Priority = std::make_tuple(Begin, Type, -End, -ErrorSize, ErrorId); Priority = std::make_tuple(Begin, Type, -End, -ErrorSize, ErrorId);
else else
Priority = std::make_tuple(End, Type, -Begin, ErrorSize, ErrorId); Priority = std::make_tuple(End, Type, -Begin, ErrorSize, ErrorId);
} }
bool operator<(const Event &Other) const { bool operator<(const Event &Other) const {
return Priority < Other.Priority; return Priority < Other.Priority;
} }
// Determines if this event is the begin or the end of an interval. // Determines if this event is the begin or the end of an interval.
EventType Type; EventType Type;
// The index of the error to which the interval that generated this event // The index of the error to which the interval that generated this event
// belongs. // belongs.
unsigned ErrorId; unsigned ErrorId;
// The events will be sorted based on this field. // The events will be sorted based on this field.
std::tuple<unsigned, EventType, int, int, unsigned> Priority; std::tuple<unsigned, EventType, int, int, unsigned> Priority;
}; };
// Compute error sizes. // Compute error sizes.
std::vector<int> Sizes; std::vector<int> Sizes;
for (const auto &Error : Errors) { for (const auto &Error : Errors) {
int Size = 0; int Size = 0;
for (const auto &Replace : Error.Fix) for (const auto &FileAndReplaces : Error.Fix) {
for (const auto &Replace : FileAndReplaces.second)
Size += Replace.getLength(); Size += Replace.getLength();
}
Sizes.push_back(Size); Sizes.push_back(Size);
} }
// Build events from error intervals. // Build events from error intervals.
std::map<std::string, std::vector<Event>> FileEvents; std::map<std::string, std::vector<Event>> FileEvents;
for (unsigned I = 0; I < Errors.size(); ++I) { for (unsigned I = 0; I < Errors.size(); ++I) {
for (const auto &Replace : Errors[I].Fix) { for (const auto &FileAndReplace : Errors[I].Fix) {
for (const auto &Replace : FileAndReplace.second) {
unsigned Begin = Replace.getOffset(); unsigned Begin = Replace.getOffset();
unsigned End = Begin + Replace.getLength(); unsigned End = Begin + Replace.getLength();
const std::string &FilePath = Replace.getFilePath(); const std::string &FilePath = Replace.getFilePath();
// FIXME: Handle empty intervals, such as those from insertions. // FIXME: Handle empty intervals, such as those from insertions.
if (Begin == End) if (Begin == End)
continue; continue;
FileEvents[FilePath].push_back( FileEvents[FilePath].push_back(
Event(Begin, End, Event::ET_Begin, I, Sizes[I])); Event(Begin, End, Event::ET_Begin, I, Sizes[I]));
FileEvents[FilePath].push_back( FileEvents[FilePath].push_back(
Event(Begin, End, Event::ET_End, I, Sizes[I])); Event(Begin, End, Event::ET_End, I, Sizes[I]));
} }
} }
}
std::vector<bool> Apply(Errors.size(), true); std::vector<bool> Apply(Errors.size(), true);
for (auto &FileAndEvents : FileEvents) { for (auto &FileAndEvents : FileEvents) {
std::vector<Event> &Events = FileAndEvents.second; std::vector<Event> &Events = FileAndEvents.second;
// Sweep. // Sweep.
std::sort(Events.begin(), Events.end()); std::sort(Events.begin(), Events.end());
int OpenIntervals = 0; int OpenIntervals = 0;
for (const auto &Event : Events) { for (const auto &Event : Events) {
▲ Show 20 Lines • Show All 53 Lines • Show Last 20 Lines

clang-tidy/ClangTidyModuleRegistry.h

//===--- ClangTidyModuleRegistry.h - clang-tidy -----------------*- C++ -*-===// //===--- ClangTidyModuleRegistry.h - clang-tidy -----------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H
#include "ClangTidyModule.h" #include "ClangTidyModule.h"
#include "llvm/Support/Registry.h" #include "llvm/Support/Registry.h"
extern template class llvm::Registry<clang::tidy::ClangTidyModule>;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
typedef llvm::Registry<ClangTidyModule> ClangTidyModuleRegistry; typedef llvm::Registry<ClangTidyModule> ClangTidyModuleRegistry;
} // end namespace tidy } // end namespace tidy
} // end namespace clang } // end namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANGTIDYMODULEREGISTRY_H

clang-tidy/cert/LICENSE.TXT

------------------------------------------------------------------------------ ------------------------------------------------------------------------------
clang-tidy CERT Files clang-tidy CERT Files
------------------------------------------------------------------------------ ------------------------------------------------------------------------------
All clang-tidy files are licensed under the LLVM license with the following All clang-tidy files are licensed under the LLVM license with the following
additions: additions:
Any file referencing a CERT Secure Coding guideline: Any file referencing a CERT Secure Coding guideline:
Please allow this letter to serve as confirmation that open source projects on Please allow this letter to serve as confirmation that open source projects on
http://llvm.org are permitted to link via hypertext to the CERT(R) secure coding http://llvm.org are permitted to link via hypertext to the CERT(R) secure coding
guidelines available at https://www.securecoding.cert.org. guidelines available at https://www.securecoding.cert.org.
The foregoing is permitted by the Terms of Use as follows: The foregoing is permitted by the Terms of Use as follows:
"Linking to the Service "Linking to the Service
Because we update many of our Web documents regularly, we would prefer that you Because we update many of our Web documents regularly, we would prefer that you
link to our Web pages whenever possible rather than reproduce them. It is not link to our Web pages whenever possible rather than reproduce them. It is not
necessary to request permission to make referential hypertext links to The necessary to request permission to make referential hypertext links to The
Service." Service."
http://www.sei.cmu.edu/legal/ip/index.cfm. http://www.sei.cmu.edu/legal/ip/index.cfm.
Please allow this letter to also confirm that no formal permission is required Please allow this letter to also confirm that no formal permission is required
to reproduce the title of the content being linked to, nor to reproduce any to reproduce the title of the content being linked to, nor to reproduce any
de Minimis description of such content. de Minimis description of such content.

clang-tidy/cert/StrToNumCheck.cpp

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 LinesConversionKind ClassifyFormatString(StringRef Fmt, const LangOptions &LO,
public: public:
Handler() : CK(ConversionKind::None) {} Handler() : CK(ConversionKind::None) {}
ConversionKind get() const { return CK; } ConversionKind get() const { return CK; }
}; };
Handler H; Handler H;
analyze_format_string::ParseScanfString(H, Fmt.begin(), Fmt.end(), LO, TI); analyze_format_string::ParseScanfString(H, Fmt.begin(), Fmt.end(), LO, TI);
return H.get(); return H.get();
} }
StringRef ClassifyConversionType(ConversionKind K) { StringRef ClassifyConversionType(ConversionKind K) {
switch (K) { switch (K) {
case ConversionKind::None: case ConversionKind::None:
assert(false && "Unexpected conversion kind"); assert(false && "Unexpected conversion kind");
case ConversionKind::ToInt: case ConversionKind::ToInt:
▲ Show 20 Lines • Show All 97 Lines • Show Last 20 Lines

clang-tidy/cppcoreguidelines/CMakeLists.txt

set(LLVM_LINK_COMPONENTS support) set(LLVM_LINK_COMPONENTS support)
add_clang_library(clangTidyCppCoreGuidelinesModule add_clang_library(clangTidyCppCoreGuidelinesModule
CppCoreGuidelinesTidyModule.cpp CppCoreGuidelinesTidyModule.cpp
InterfacesGlobalInitCheck.cpp InterfacesGlobalInitCheck.cpp
ProBoundsArrayToPointerDecayCheck.cpp ProBoundsArrayToPointerDecayCheck.cpp
ProBoundsConstantArrayIndexCheck.cpp ProBoundsConstantArrayIndexCheck.cpp
ProBoundsPointerArithmeticCheck.cpp ProBoundsPointerArithmeticCheck.cpp
ProTypeConstCastCheck.cpp ProTypeConstCastCheck.cpp
ProTypeCstyleCastCheck.cpp ProTypeCstyleCastCheck.cpp
ProTypeMemberInitCheck.cpp ProTypeMemberInitCheck.cpp
ProTypeReinterpretCastCheck.cpp ProTypeReinterpretCastCheck.cpp
ProTypeStaticCastDowncastCheck.cpp ProTypeStaticCastDowncastCheck.cpp
ProTypeUnionAccessCheck.cpp ProTypeUnionAccessCheck.cpp
ProTypeVarargCheck.cpp ProTypeVarargCheck.cpp
SpecialMemberFunctionsCheck.cpp
SlicingCheck.cpp SlicingCheck.cpp
LINK_LIBS LINK_LIBS
clangAST clangAST
clangASTMatchers clangASTMatchers
clangBasic clangBasic
clangLex clangLex
clangTidy clangTidy
clangTidyMiscModule clangTidyMiscModule
clangTidyUtils clangTidyUtils
clangTooling clangTooling
) )

clang-tidy/cppcoreguidelines/CppCoreGuidelinesTidyModule.cpp

Show All 16 Lines
#include "ProBoundsPointerArithmeticCheck.h" #include "ProBoundsPointerArithmeticCheck.h"
#include "ProTypeConstCastCheck.h" #include "ProTypeConstCastCheck.h"
#include "ProTypeCstyleCastCheck.h" #include "ProTypeCstyleCastCheck.h"
#include "ProTypeMemberInitCheck.h" #include "ProTypeMemberInitCheck.h"
#include "ProTypeReinterpretCastCheck.h" #include "ProTypeReinterpretCastCheck.h"
#include "ProTypeStaticCastDowncastCheck.h" #include "ProTypeStaticCastDowncastCheck.h"
#include "ProTypeUnionAccessCheck.h" #include "ProTypeUnionAccessCheck.h"
#include "ProTypeVarargCheck.h" #include "ProTypeVarargCheck.h"
#include "SpecialMemberFunctionsCheck.h"
#include "SlicingCheck.h" #include "SlicingCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// A module containing checks of the C++ Core Guidelines /// A module containing checks of the C++ Core Guidelines
class CppCoreGuidelinesModule : public ClangTidyModule { class CppCoreGuidelinesModule : public ClangTidyModule {
Show All 16 Lines void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<ProTypeReinterpretCastCheck>( CheckFactories.registerCheck<ProTypeReinterpretCastCheck>(
"cppcoreguidelines-pro-type-reinterpret-cast"); "cppcoreguidelines-pro-type-reinterpret-cast");
CheckFactories.registerCheck<ProTypeStaticCastDowncastCheck>( CheckFactories.registerCheck<ProTypeStaticCastDowncastCheck>(
"cppcoreguidelines-pro-type-static-cast-downcast"); "cppcoreguidelines-pro-type-static-cast-downcast");
CheckFactories.registerCheck<ProTypeUnionAccessCheck>( CheckFactories.registerCheck<ProTypeUnionAccessCheck>(
"cppcoreguidelines-pro-type-union-access"); "cppcoreguidelines-pro-type-union-access");
CheckFactories.registerCheck<ProTypeVarargCheck>( CheckFactories.registerCheck<ProTypeVarargCheck>(
"cppcoreguidelines-pro-type-vararg"); "cppcoreguidelines-pro-type-vararg");
CheckFactories.registerCheck<SpecialMemberFunctionsCheck>(
"cppcoreguidelines-special-member-functions");
CheckFactories.registerCheck<SlicingCheck>( CheckFactories.registerCheck<SlicingCheck>(
"cppcoreguidelines-slicing"); "cppcoreguidelines-slicing");
CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>( CheckFactories.registerCheck<misc::UnconventionalAssignOperatorCheck>(
"cppcoreguidelines-c-copy-assignment-signature"); "cppcoreguidelines-c-copy-assignment-signature");
} }
}; };
// Register the LLVMTidyModule using this statically initialized variable. // Register the LLVMTidyModule using this statically initialized variable.
Show All 11 Lines

clang-tidy/cppcoreguidelines/ProBoundsArrayToPointerDecayCheck.h

Show All 9 Lines
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_BOUNDS_ARRAY_TO_POINTER_DECAY_H
#include "../ClangTidy.h" #include "../ClangTidy.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This check flags all array to pointer decays /// This check flags all array to pointer decays
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-array-to-pointer-decay.html /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-bounds-array-to-pointer-decay.html
class ProBoundsArrayToPointerDecayCheck : public ClangTidyCheck { class ProBoundsArrayToPointerDecayCheck : public ClangTidyCheck {
public: public:
ProBoundsArrayToPointerDecayCheck(StringRef Name, ClangTidyContext *Context) ProBoundsArrayToPointerDecayCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
Show All 9 Lines

clang-tidy/cppcoreguidelines/ProTypeConstCastCheck.h

Show All 9 Lines
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_CONST_CAST_H
#include "../ClangTidy.h" #include "../ClangTidy.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// This check flags all instances of const_cast /// This check flags all instances of const_cast
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-const-cast.html /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-const-cast.html
class ProTypeConstCastCheck : public ClangTidyCheck { class ProTypeConstCastCheck : public ClangTidyCheck {
public: public:
ProTypeConstCastCheck(StringRef Name, ClangTidyContext *Context) ProTypeConstCastCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
Show All 9 Lines

clang-tidy/cppcoreguidelines/ProTypeConstCastCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
void ProTypeConstCastCheck::registerMatchers(MatchFinder *Finder) { void ProTypeConstCastCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
Finder->addMatcher(cxxConstCastExpr().bind("cast"), this); Finder->addMatcher(cxxConstCastExpr().bind("cast"), this);
} }
void ProTypeConstCastCheck::check(const MatchFinder::MatchResult &Result) { void ProTypeConstCastCheck::check(const MatchFinder::MatchResult &Result) {
const auto *MatchedCast = Result.Nodes.getNodeAs<CXXConstCastExpr>("cast"); const auto *MatchedCast = Result.Nodes.getNodeAs<CXXConstCastExpr>("cast");
diag(MatchedCast->getOperatorLoc(), "do not use const_cast"); diag(MatchedCast->getOperatorLoc(), "do not use const_cast");
} }
} // namespace cppcoreguidelines } // namespace cppcoreguidelines
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.h

Show All 9 Lines
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_PRO_TYPE_STATIC_CAST_DOWNCAST_H
#include "../ClangTidy.h" #include "../ClangTidy.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
/// Checks for usages of static_cast, where a base class is downcasted to a derived class. /// Checks for usages of static_cast, where a base class is downcasted to a derived class.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-static-cast-downcast.html /// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-pro-type-static-cast-downcast.html
class ProTypeStaticCastDowncastCheck : public ClangTidyCheck { class ProTypeStaticCastDowncastCheck : public ClangTidyCheck {
public: public:
ProTypeStaticCastDowncastCheck(StringRef Name, ClangTidyContext *Context) ProTypeStaticCastDowncastCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
Show All 9 Lines

clang-tidy/cppcoreguidelines/ProTypeStaticCastDowncastCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace cppcoreguidelines { namespace cppcoreguidelines {
void ProTypeStaticCastDowncastCheck::registerMatchers(MatchFinder *Finder) { void ProTypeStaticCastDowncastCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
Finder->addMatcher( Finder->addMatcher(
cxxStaticCastExpr(unless(isInTemplateInstantiation())).bind("cast"), cxxStaticCastExpr(unless(isInTemplateInstantiation())).bind("cast"),
this); this);
} }
Show All 27 Lines

clang-tidy/cppcoreguidelines/SpecialMemberFunctionsCheck.h

  • This file was added.
//===--- SpecialMemberFunctionsCheck.h - clang-tidy--------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SPECIAL_MEMBER_FUNCTIONS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SPECIAL_MEMBER_FUNCTIONS_H
#include "../ClangTidy.h"
#include "llvm/ADT/DenseMapInfo.h"
namespace clang {
namespace tidy {
namespace cppcoreguidelines {
/// Checks for classes where some, but not all, of the special member functions
/// are defined.
///
/// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-special-member-functions.html
class SpecialMemberFunctionsCheck : public ClangTidyCheck {
public:
SpecialMemberFunctionsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void onEndOfTranslationUnit() override;
enum class SpecialMemberFunctionKind {
Destructor,
CopyConstructor,
CopyAssignment,
MoveConstructor,
MoveAssignment
};
using ClassDefId = std::pair<SourceLocation, std::string>;
using ClassDefiningSpecialMembersMap =
llvm::DenseMap<ClassDefId,
llvm::SmallSetVector<SpecialMemberFunctionKind, 5>>;
private:
ClassDefiningSpecialMembersMap ClassWithSpecialMembers;
};
} // namespace cppcoreguidelines
} // namespace tidy
} // namespace clang
namespace llvm {
/// Specialisation of DenseMapInfo to allow ClassDefId objects in DenseMaps
/// FIXME: Move this to the corresponding cpp file as is done for
/// clang-tidy/readability/IdentifierNamingCheck.cpp.
template <>
struct DenseMapInfo<
clang::tidy::cppcoreguidelines::SpecialMemberFunctionsCheck::ClassDefId> {
using ClassDefId =
clang::tidy::cppcoreguidelines::SpecialMemberFunctionsCheck::ClassDefId;
static inline ClassDefId getEmptyKey() {
return ClassDefId(
clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-1)),
"EMPTY");
}
static inline ClassDefId getTombstoneKey() {
return ClassDefId(
clang::SourceLocation::getFromRawEncoding(static_cast<unsigned>(-2)),
"TOMBSTONE");
}
static unsigned getHashValue(ClassDefId Val) {
assert(Val != getEmptyKey() && "Cannot hash the empty key!");
assert(Val != getTombstoneKey() && "Cannot hash the tombstone key!");
std::hash<ClassDefId::second_type> SecondHash;
return Val.first.getRawEncoding() + SecondHash(Val.second);
}
static bool isEqual(ClassDefId LHS, ClassDefId RHS) {
if (RHS == getEmptyKey())
return LHS == getEmptyKey();
if (RHS == getTombstoneKey())
return LHS == getTombstoneKey();
return LHS == RHS;
}
};
} // namespace llvm
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CPPCOREGUIDELINES_SPECIAL_MEMBER_FUNCTIONS_H

clang-tidy/cppcoreguidelines/SpecialMemberFunctionsCheck.cpp

  • This file was added.
//===--- SpecialMemberFunctionsCheck.cpp - clang-tidy----------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "SpecialMemberFunctionsCheck.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/ADT/StringExtras.h"
#define DEBUG_TYPE "clang-tidy"
using namespace clang::ast_matchers;
namespace clang {
namespace tidy {
namespace cppcoreguidelines {
void SpecialMemberFunctionsCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
Finder->addMatcher(
cxxRecordDecl(
eachOf(
has(cxxDestructorDecl(unless(isImplicit())).bind("dtor")),
has(cxxConstructorDecl(isCopyConstructor(), unless(isImplicit()))
.bind("copy-ctor")),
has(cxxMethodDecl(isCopyAssignmentOperator(),
unless(isImplicit()))
.bind("copy-assign")),
has(cxxConstructorDecl(isMoveConstructor(), unless(isImplicit()))
.bind("move-ctor")),
has(cxxMethodDecl(isMoveAssignmentOperator(),
unless(isImplicit()))
.bind("move-assign"))))
.bind("class-def"),
this);
}
static llvm::StringRef
toString(SpecialMemberFunctionsCheck::SpecialMemberFunctionKind K) {
switch (K) {
case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::Destructor:
return "a destructor";
case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::CopyConstructor:
return "a copy constructor";
case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::CopyAssignment:
return "a copy assignment operator";
case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::MoveConstructor:
return "a move constructor";
case SpecialMemberFunctionsCheck::SpecialMemberFunctionKind::MoveAssignment:
return "a move assignment operator";
}
llvm_unreachable("Unhandled SpecialMemberFunctionKind");
}
static std::string
join(ArrayRef<SpecialMemberFunctionsCheck::SpecialMemberFunctionKind> SMFS,
llvm::StringRef AndOr) {
assert(!SMFS.empty() &&
"List of defined or undefined members should never be empty.");
std::string Buffer;
llvm::raw_string_ostream Stream(Buffer);
Stream << toString(SMFS[0]);
size_t LastIndex = SMFS.size() - 1;
for (size_t i = 1; i < LastIndex; ++i) {
Stream << ", " << toString(SMFS[i]);
}
if (LastIndex != 0) {
Stream << AndOr << toString(SMFS[LastIndex]);
}
return Stream.str();
}
void SpecialMemberFunctionsCheck::check(
const MatchFinder::MatchResult &Result) {
const CXXRecordDecl *MatchedDecl =
Result.Nodes.getNodeAs<CXXRecordDecl>("class-def");
if (!MatchedDecl)
return;
ClassDefId ID(MatchedDecl->getLocation(), MatchedDecl->getName());
std::initializer_list<std::pair<std::string, SpecialMemberFunctionKind>>
Matchers = {{"dtor", SpecialMemberFunctionKind::Destructor},
{"copy-ctor", SpecialMemberFunctionKind::CopyConstructor},
{"copy-assign", SpecialMemberFunctionKind::CopyAssignment},
{"move-ctor", SpecialMemberFunctionKind::MoveConstructor},
{"move-assign", SpecialMemberFunctionKind::MoveAssignment}};
for (const auto &KV : Matchers)
if (Result.Nodes.getNodeAs<CXXMethodDecl>(KV.first))
ClassWithSpecialMembers[ID].insert(KV.second);
}
void SpecialMemberFunctionsCheck::onEndOfTranslationUnit() {
llvm::SmallVector<SpecialMemberFunctionKind, 5> AllSpecialMembers = {
SpecialMemberFunctionKind::Destructor,
SpecialMemberFunctionKind::CopyConstructor,
SpecialMemberFunctionKind::CopyAssignment};
if (getLangOpts().CPlusPlus11) {
AllSpecialMembers.push_back(SpecialMemberFunctionKind::MoveConstructor);
AllSpecialMembers.push_back(SpecialMemberFunctionKind::MoveAssignment);
}
for (const auto &C : ClassWithSpecialMembers) {
const auto &DefinedSpecialMembers = C.second;
if (DefinedSpecialMembers.size() == AllSpecialMembers.size())
continue;
llvm::SmallVector<SpecialMemberFunctionKind, 5> UndefinedSpecialMembers;
std::set_difference(AllSpecialMembers.begin(), AllSpecialMembers.end(),
DefinedSpecialMembers.begin(),
DefinedSpecialMembers.end(),
std::back_inserter(UndefinedSpecialMembers));
diag(C.first.first, "class '%0' defines %1 but does not define %2")
<< C.first.second << join(DefinedSpecialMembers.getArrayRef(), " and ")
<< join(UndefinedSpecialMembers, " or ");
}
}
} // namespace cppcoreguidelines
} // namespace tidy
} // namespace clang

clang-tidy/misc/ArgumentCommentCheck.h

Show All 31 Lines
/// ///
/// The check tries to detect typos and suggest automated fixes for them. /// The check tries to detect typos and suggest automated fixes for them.
class ArgumentCommentCheck : public ClangTidyCheck { class ArgumentCommentCheck : public ClangTidyCheck {
public: public:
ArgumentCommentCheck(StringRef Name, ClangTidyContext *Context); ArgumentCommentCheck(StringRef Name, ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap& Opts) override;
private: private:
const bool StrictMode;
llvm::Regex IdentRE; llvm::Regex IdentRE;
bool isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params, StringRef ArgName, bool isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params, StringRef ArgName,
unsigned ArgIndex); unsigned ArgIndex);
void checkCallArgs(ASTContext *Ctx, const FunctionDecl *Callee, void checkCallArgs(ASTContext *Ctx, const FunctionDecl *Callee,
SourceLocation ArgBeginLoc, SourceLocation ArgBeginLoc,
llvm::ArrayRef<const Expr *> Args); llvm::ArrayRef<const Expr *> Args);
}; };
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ARGUMENTCOMMENTCHECK_H #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_ARGUMENTCOMMENTCHECK_H

clang-tidy/misc/ArgumentCommentCheck.cpp

Show All 16 Lines
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name, ArgumentCommentCheck::ArgumentCommentCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
StrictMode(Options.getLocalOrGlobal("StrictMode", 0) != 0),
IdentRE("^(/\\* *)([_A-Za-z][_A-Za-z0-9]*)( *= *\\*/)$") {} IdentRE("^(/\\* *)([_A-Za-z][_A-Za-z0-9]*)( *= *\\*/)$") {}
void ArgumentCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "StrictMode", StrictMode);
}
void ArgumentCommentCheck::registerMatchers(MatchFinder *Finder) { void ArgumentCommentCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
callExpr(unless(cxxOperatorCallExpr()), callExpr(unless(cxxOperatorCallExpr()),
// NewCallback's arguments relate to the pointed function, don't // NewCallback's arguments relate to the pointed function, don't
// check them against NewCallback's parameter names. // check them against NewCallback's parameter names.
// FIXME: Make this configurable. // FIXME: Make this configurable.
unless(hasDeclaration(functionDecl(anyOf( unless(hasDeclaration(functionDecl(
hasName("NewCallback"), hasName("NewPermanentCallback")))))) hasAnyName("NewCallback", "NewPermanentCallback")))))
.bind("expr"), .bind("expr"),
this); this);
Finder->addMatcher(cxxConstructExpr().bind("expr"), this); Finder->addMatcher(cxxConstructExpr().bind("expr"), this);
} }
static std::vector<std::pair<SourceLocation, StringRef>> static std::vector<std::pair<SourceLocation, StringRef>>
getCommentsInRange(ASTContext *Ctx, CharSourceRange Range) { getCommentsInRange(ASTContext *Ctx, CharSourceRange Range) {
std::vector<std::pair<SourceLocation, StringRef>> Comments; std::vector<std::pair<SourceLocation, StringRef>> Comments;
Show All 30 Lines if (Tok.getKind() == tok::comment) {
Tok.getLocation(), Tok.getLocation(),
StringRef(Buffer.begin() + CommentLoc.second, Tok.getLength())); StringRef(Buffer.begin() + CommentLoc.second, Tok.getLength()));
} }
} }
return Comments; return Comments;
} }
bool bool ArgumentCommentCheck::isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params,
ArgumentCommentCheck::isLikelyTypo(llvm::ArrayRef<ParmVarDecl *> Params,
StringRef ArgName, unsigned ArgIndex) { StringRef ArgName, unsigned ArgIndex) {
std::string ArgNameLower = ArgName.lower(); std::string ArgNameLowerStr = ArgName.lower();
StringRef ArgNameLower = ArgNameLowerStr;
// The threshold is arbitrary.
unsigned UpperBound = (ArgName.size() + 2) / 3 + 1; unsigned UpperBound = (ArgName.size() + 2) / 3 + 1;
unsigned ThisED = StringRef(ArgNameLower).edit_distance( unsigned ThisED = ArgNameLower.edit_distance(
Params[ArgIndex]->getIdentifier()->getName().lower(), Params[ArgIndex]->getIdentifier()->getName().lower(),
/*AllowReplacements=*/true, UpperBound); /*AllowReplacements=*/true, UpperBound);
if (ThisED >= UpperBound) if (ThisED >= UpperBound)
return false; return false;
for (unsigned I = 0, E = Params.size(); I != E; ++I) { for (unsigned I = 0, E = Params.size(); I != E; ++I) {
if (I == ArgIndex) if (I == ArgIndex)
continue; continue;
IdentifierInfo *II = Params[I]->getIdentifier(); IdentifierInfo *II = Params[I]->getIdentifier();
if (!II) if (!II)
continue; continue;
const unsigned Threshold = 2; const unsigned Threshold = 2;
// Other parameters must be an edit distance at least Threshold more away // Other parameters must be an edit distance at least Threshold more away
// from this parameter. This gives us greater confidence that this is a typo // from this parameter. This gives us greater confidence that this is a typo
// of this parameter and not one with a similar name. // of this parameter and not one with a similar name.
unsigned OtherED = StringRef(ArgNameLower).edit_distance( unsigned OtherED = ArgNameLower.edit_distance(II->getName().lower(),
II->getName().lower(), /*AllowReplacements=*/true,
/*AllowReplacements=*/true, ThisED + Threshold); ThisED + Threshold);
if (OtherED < ThisED + Threshold) if (OtherED < ThisED + Threshold)
return false; return false;
} }
return true; return true;
} }
static bool sameName(StringRef InComment, StringRef InDecl, bool StrictMode) {
if (StrictMode)
return InComment == InDecl;
InComment = InComment.trim('_');
InDecl = InDecl.trim('_');
// FIXME: compare_lower only works for ASCII.
return InComment.compare_lower(InDecl) == 0;
}
void ArgumentCommentCheck::checkCallArgs(ASTContext *Ctx, void ArgumentCommentCheck::checkCallArgs(ASTContext *Ctx,
const FunctionDecl *Callee, const FunctionDecl *Callee,
SourceLocation ArgBeginLoc, SourceLocation ArgBeginLoc,
llvm::ArrayRef<const Expr *> Args) { llvm::ArrayRef<const Expr *> Args) {
Callee = Callee->getFirstDecl(); Callee = Callee->getFirstDecl();
for (unsigned i = 0, for (unsigned I = 0,
e = std::min<unsigned>(Args.size(), Callee->getNumParams()); E = std::min<unsigned>(Args.size(), Callee->getNumParams());
i != e; ++i) { I != E; ++I) {
const ParmVarDecl *PVD = Callee->getParamDecl(i); const ParmVarDecl *PVD = Callee->getParamDecl(I);
IdentifierInfo *II = PVD->getIdentifier(); IdentifierInfo *II = PVD->getIdentifier();
if (!II) if (!II)
continue; continue;
if (auto Template = Callee->getTemplateInstantiationPattern()) { if (auto Template = Callee->getTemplateInstantiationPattern()) {
// Don't warn on arguments for parameters instantiated from template // Don't warn on arguments for parameters instantiated from template
// parameter packs. If we find more arguments than the template definition // parameter packs. If we find more arguments than the template definition
// has, it also means that they correspond to a parameter pack. // has, it also means that they correspond to a parameter pack.
if (Template->getNumParams() <= i || if (Template->getNumParams() <= I ||
Template->getParamDecl(i)->isParameterPack()) { Template->getParamDecl(I)->isParameterPack()) {
continue; continue;
} }
} }
CharSourceRange BeforeArgument = CharSourceRange::getCharRange( CharSourceRange BeforeArgument = CharSourceRange::getCharRange(
i == 0 ? ArgBeginLoc : Args[i - 1]->getLocEnd(), I == 0 ? ArgBeginLoc : Args[I - 1]->getLocEnd(),
Args[i]->getLocStart()); Args[I]->getLocStart());
BeforeArgument = Lexer::makeFileCharRange( BeforeArgument = Lexer::makeFileCharRange(
BeforeArgument, Ctx->getSourceManager(), Ctx->getLangOpts()); BeforeArgument, Ctx->getSourceManager(), Ctx->getLangOpts());
for (auto Comment : getCommentsInRange(Ctx, BeforeArgument)) { for (auto Comment : getCommentsInRange(Ctx, BeforeArgument)) {
llvm::SmallVector<StringRef, 2> Matches; llvm::SmallVector<StringRef, 2> Matches;
if (IdentRE.match(Comment.second, &Matches)) { if (IdentRE.match(Comment.second, &Matches)) {
if (Matches[2] != II->getName()) { if (!sameName(Matches[2], II->getName(), StrictMode)) {
{ {
DiagnosticBuilder Diag = DiagnosticBuilder Diag =
diag(Comment.first, "argument name '%0' in comment does not " diag(Comment.first, "argument name '%0' in comment does not "
"match parameter name %1") "match parameter name %1")
<< Matches[2] << II; << Matches[2] << II;
if (isLikelyTypo(Callee->parameters(), Matches[2], i)) { if (isLikelyTypo(Callee->parameters(), Matches[2], I)) {
Diag << FixItHint::CreateReplacement( Diag << FixItHint::CreateReplacement(
Comment.first, Comment.first,
(Matches[1] + II->getName() + Matches[3]).str()); (Matches[1] + II->getName() + Matches[3]).str());
} }
} }
diag(PVD->getLocation(), "%0 declared here", DiagnosticIDs::Note) diag(PVD->getLocation(), "%0 declared here", DiagnosticIDs::Note)
<< II; << II;
} }
} }
} }
} }
} }
void ArgumentCommentCheck::check(const MatchFinder::MatchResult &Result) { void ArgumentCommentCheck::check(const MatchFinder::MatchResult &Result) {
const Expr *E = Result.Nodes.getNodeAs<Expr>("expr"); const Expr *E = Result.Nodes.getNodeAs<Expr>("expr");
if (auto Call = dyn_cast<CallExpr>(E)) { if (const auto *Call = dyn_cast<CallExpr>(E)) {
const FunctionDecl *Callee = Call->getDirectCallee(); const FunctionDecl *Callee = Call->getDirectCallee();
if (!Callee) if (!Callee)
return; return;
checkCallArgs(Result.Context, Callee, Call->getCallee()->getLocEnd(), checkCallArgs(Result.Context, Callee, Call->getCallee()->getLocEnd(),
llvm::makeArrayRef(Call->getArgs(), Call->getNumArgs())); llvm::makeArrayRef(Call->getArgs(), Call->getNumArgs()));
} else { } else {
auto Construct = cast<CXXConstructExpr>(E); const auto *Construct = cast<CXXConstructExpr>(E);
checkCallArgs( checkCallArgs(
Result.Context, Construct->getConstructor(), Result.Context, Construct->getConstructor(),
Construct->getParenOrBraceRange().getBegin(), Construct->getParenOrBraceRange().getBegin(),
llvm::makeArrayRef(Construct->getArgs(), Construct->getNumArgs())); llvm::makeArrayRef(Construct->getArgs(), Construct->getNumArgs()));
} }
} }
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/misc/MacroParenthesesCheck.cpp

Show First 20 Lines • Show All 148 Lines • ▼ Show 20 Lines Check->diag(Loc, "macro replacement list should be enclosed in parentheses")
<< FixItHint::CreateInsertion(Last.getLocation().getLocWithOffset( << FixItHint::CreateInsertion(Last.getLocation().getLocWithOffset(
PP->getSpelling(Last).length()), PP->getSpelling(Last).length()),
")"); ")");
} }
} }
void MacroParenthesesPPCallbacks::argument(const Token &MacroNameTok, void MacroParenthesesPPCallbacks::argument(const Token &MacroNameTok,
const MacroInfo *MI) { const MacroInfo *MI) {
// Skip variable declaration. // Skip variable declaration.
bool VarDecl = possibleVarDecl(MI, MI->tokens_begin()); bool VarDecl = possibleVarDecl(MI, MI->tokens_begin());
for (auto TI = MI->tokens_begin(), TE = MI->tokens_end(); TI != TE; ++TI) { for (auto TI = MI->tokens_begin(), TE = MI->tokens_end(); TI != TE; ++TI) {
// First token. // First token.
if (TI == MI->tokens_begin()) if (TI == MI->tokens_begin())
continue; continue;
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

clang-tidy/misc/MiscTidyModule.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 Lines CheckFactories.registerCheck<StringIntegerAssignmentCheck>(
"misc-string-integer-assignment"); "misc-string-integer-assignment");
CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>( CheckFactories.registerCheck<StringLiteralWithEmbeddedNulCheck>(
"misc-string-literal-with-embedded-nul"); "misc-string-literal-with-embedded-nul");
CheckFactories.registerCheck<SuspiciousMissingCommaCheck>( CheckFactories.registerCheck<SuspiciousMissingCommaCheck>(
"misc-suspicious-missing-comma"); "misc-suspicious-missing-comma");
CheckFactories.registerCheck<SuspiciousSemicolonCheck>( CheckFactories.registerCheck<SuspiciousSemicolonCheck>(
"misc-suspicious-semicolon"); "misc-suspicious-semicolon");
CheckFactories.registerCheck<SuspiciousStringCompareCheck>( CheckFactories.registerCheck<SuspiciousStringCompareCheck>(
"misc-suspicious-string-compare"); "misc-suspicious-string-compare");
CheckFactories.registerCheck<SwappedArgumentsCheck>( CheckFactories.registerCheck<SwappedArgumentsCheck>(
"misc-swapped-arguments"); "misc-swapped-arguments");
CheckFactories.registerCheck<ThrowByValueCatchByReferenceCheck>( CheckFactories.registerCheck<ThrowByValueCatchByReferenceCheck>(
"misc-throw-by-value-catch-by-reference"); "misc-throw-by-value-catch-by-reference");
CheckFactories.registerCheck<UndelegatedConstructorCheck>( CheckFactories.registerCheck<UndelegatedConstructorCheck>(
"misc-undelegated-constructor"); "misc-undelegated-constructor");
CheckFactories.registerCheck<UniqueptrResetReleaseCheck>( CheckFactories.registerCheck<UniqueptrResetReleaseCheck>(
"misc-uniqueptr-reset-release"); "misc-uniqueptr-reset-release");
Show All 24 Lines

clang-tidy/misc/MoveConstructorInitCheck.cpp

Show First 20 Lines • Show All 127 Lines • ▼ Show 20 Linesvoid MoveConstructorInitCheck::handleMoveConstructor(
const auto *CopyCtor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor"); const auto *CopyCtor = Result.Nodes.getNodeAs<CXXConstructorDecl>("ctor");
const auto *Initializer = Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init"); const auto *Initializer = Result.Nodes.getNodeAs<CXXCtorInitializer>("move-init");
// Do not diagnose if the expression used to perform the initialization is a // Do not diagnose if the expression used to perform the initialization is a
// trivially-copyable type. // trivially-copyable type.
QualType QT = Initializer->getInit()->getType(); QualType QT = Initializer->getInit()->getType();
if (QT.isTriviallyCopyableType(*Result.Context)) if (QT.isTriviallyCopyableType(*Result.Context))
return; return;
const auto *RD = QT->getAsCXXRecordDecl(); const auto *RD = QT->getAsCXXRecordDecl();
if (RD && RD->isTriviallyCopyable()) if (RD && RD->isTriviallyCopyable())
return; return;
// Diagnose when the class type has a move constructor available, but the // Diagnose when the class type has a move constructor available, but the
// ctor-initializer uses the copy constructor instead. // ctor-initializer uses the copy constructor instead.
const CXXConstructorDecl *Candidate = nullptr; const CXXConstructorDecl *Candidate = nullptr;
for (const auto *Ctor : CopyCtor->getParent()->ctors()) { for (const auto *Ctor : CopyCtor->getParent()->ctors()) {
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines

clang-tidy/misc/SizeofContainerCheck.cpp

Show All 9 Lines
#include "SizeofContainerCheck.h" #include "SizeofContainerCheck.h"
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) { void SizeofContainerCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
expr(unless(isInTemplateInstantiation()), expr(unless(isInTemplateInstantiation()),
expr(sizeOfExpr(has(ignoringParenImpCasts( expr(sizeOfExpr(has(ignoringParenImpCasts(
expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl( expr(hasType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
matchesName("^(::std::|::string)"), matchesName("^(::std::|::string)"),
unless(matchesName("^::std::(bitset|array)$")), unless(matchesName("^::std::(bitset|array)$")),
Show All 24 Lines

clang-tidy/misc/StaticAssertCheck.h

Show All 10 Lines
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STATICASSERTCHECK_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STATICASSERTCHECK_H
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include <string> #include <string>
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// Replaces `assert()` with `static_assert()` if the condition is evaluatable /// Replaces `assert()` with `static_assert()` if the condition is evaluatable
/// at compile time. /// at compile time.
/// ///
/// The condition of `static_assert()` is evaluated at compile time which is /// The condition of `static_assert()` is evaluated at compile time which is
/// safer and more efficient. /// safer and more efficient.
class StaticAssertCheck : public ClangTidyCheck { class StaticAssertCheck : public ClangTidyCheck {
public: public:
Show All 14 Lines

clang-tidy/misc/StaticAssertCheck.cpp

Show All 16 Lines
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include <string> #include <string>
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context) StaticAssertCheck::StaticAssertCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void StaticAssertCheck::registerMatchers(MatchFinder *Finder) { void StaticAssertCheck::registerMatchers(MatchFinder *Finder) {
// This checker only makes sense for languages that have static assertion // This checker only makes sense for languages that have static assertion
// capabilities: C++11 and C11. // capabilities: C++11 and C11.
if (!(getLangOpts().CPlusPlus11 || getLangOpts().C11)) if (!(getLangOpts().CPlusPlus11 || getLangOpts().C11))
▲ Show 20 Lines • Show All 142 Lines • Show Last 20 Lines

clang-tidy/misc/StringIntegerAssignmentCheck.h

//===--- StringIntegerAssignmentCheck.h - clang-tidy-------------*- C++ -*-===// //===--- StringIntegerAssignmentCheck.h - clang-tidy-------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_STRING_INTEGER_ASSIGNMENT_H
#include "../ClangTidy.h" #include "../ClangTidy.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// Finds instances where an integer is assigned to a string. /// Finds instances where an integer is assigned to a string.
/// ///
/// For more details see: /// For more details see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-string-assignment.html /// http://clang.llvm.org/extra/clang-tidy/checks/misc-string-assignment.html
class StringIntegerAssignmentCheck : public ClangTidyCheck { class StringIntegerAssignmentCheck : public ClangTidyCheck {
public: public:
StringIntegerAssignmentCheck(StringRef Name, ClangTidyContext *Context) StringIntegerAssignmentCheck(StringRef Name, ClangTidyContext *Context)
Show All 11 Lines

clang-tidy/misc/StringIntegerAssignmentCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Lex/Lexer.h" #include "clang/Lex/Lexer.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
void StringIntegerAssignmentCheck::registerMatchers(MatchFinder *Finder) { void StringIntegerAssignmentCheck::registerMatchers(MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus) if (!getLangOpts().CPlusPlus)
return; return;
Finder->addMatcher( Finder->addMatcher(
cxxOperatorCallExpr( cxxOperatorCallExpr(
anyOf(hasOverloadedOperatorName("="), anyOf(hasOverloadedOperatorName("="),
hasOverloadedOperatorName("+=")), hasOverloadedOperatorName("+=")),
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

clang-tidy/misc/SuspiciousMissingCommaCheck.h

Show All 17 Lines
/// This check finds string literals which are probably concatenated accidentally. /// This check finds string literals which are probably concatenated accidentally.
/// ///
/// For the user-facing documentation see: /// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/misc-suspicious-missing-comma.html /// http://clang.llvm.org/extra/clang-tidy/checks/misc-suspicious-missing-comma.html
class SuspiciousMissingCommaCheck : public ClangTidyCheck { class SuspiciousMissingCommaCheck : public ClangTidyCheck {
public: public:
SuspiciousMissingCommaCheck(StringRef Name, ClangTidyContext *Context); SuspiciousMissingCommaCheck(StringRef Name, ClangTidyContext *Context);
void storeOptions(ClangTidyOptions::OptionMap &Opts) override; void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private: private:
// Minimal size of a string literals array to be considered by the checker. // Minimal size of a string literals array to be considered by the checker.
const unsigned SizeThreshold; const unsigned SizeThreshold;
// Maximal threshold ratio of suspicious string literals to be considered. // Maximal threshold ratio of suspicious string literals to be considered.
const double RatioThreshold; const double RatioThreshold;
Show All 9 Lines

clang-tidy/misc/SuspiciousMissingCommaCheck.cpp

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Lines
} }
void SuspiciousMissingCommaCheck::check( void SuspiciousMissingCommaCheck::check(
const MatchFinder::MatchResult &Result) { const MatchFinder::MatchResult &Result) {
const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list"); const auto *InitializerList = Result.Nodes.getNodeAs<InitListExpr>("list");
const auto *ConcatenatedLiteral = const auto *ConcatenatedLiteral =
Result.Nodes.getNodeAs<StringLiteral>("str"); Result.Nodes.getNodeAs<StringLiteral>("str");
assert(InitializerList && ConcatenatedLiteral); assert(InitializerList && ConcatenatedLiteral);
// Skip small arrays as they often generate false-positive. // Skip small arrays as they often generate false-positive.
unsigned int Size = InitializerList->getNumInits(); unsigned int Size = InitializerList->getNumInits();
if (Size < SizeThreshold) return; if (Size < SizeThreshold) return;
// Count the number of occurence of concatenated string literal. // Count the number of occurence of concatenated string literal.
unsigned int Count = 0; unsigned int Count = 0;
for (unsigned int i = 0; i < Size; ++i) { for (unsigned int i = 0; i < Size; ++i) {
const Expr *Child = InitializerList->getInit(i)->IgnoreImpCasts(); const Expr *Child = InitializerList->getInit(i)->IgnoreImpCasts();
Show All 16 Lines

clang-tidy/misc/SwappedArgumentsCheck.cpp

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines for (unsigned I = 1, E = Call->getNumArgs(); I < E; ++I) {
// Emit a warning and fix-its that swap the arguments. // Emit a warning and fix-its that swap the arguments.
diag(Call->getLocStart(), "argument with implicit conversion from %0 " diag(Call->getLocStart(), "argument with implicit conversion from %0 "
"to %1 followed by argument converted from " "to %1 followed by argument converted from "
"%2 to %3, potentially swapped arguments.") "%2 to %3, potentially swapped arguments.")
<< LHS->getType() << LHSFrom->getType() << RHS->getType() << LHS->getType() << LHSFrom->getType() << RHS->getType()
<< RHSFrom->getType() << RHSFrom->getType()
<< tooling::fixit::createReplacement(*LHS, *RHS, Ctx) << tooling::fixit::createReplacement(*LHS, *RHS, Ctx)
<< tooling::fixit::createReplacement(*RHS, *LHS, Ctx); << tooling::fixit::createReplacement(*RHS, *LHS, Ctx);
// Remember that we emitted a warning for this argument. // Remember that we emitted a warning for this argument.
UsedArgs.insert(RHSCast); UsedArgs.insert(RHSCast);
} }
} }
} // namespace misc } // namespace misc
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/misc/ThrowByValueCatchByReferenceCheck.cpp

Show All 10 Lines
#include "clang/AST/ASTContext.h" #include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/AST/OperationKinds.h" #include "clang/AST/OperationKinds.h"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
ThrowByValueCatchByReferenceCheck::ThrowByValueCatchByReferenceCheck( ThrowByValueCatchByReferenceCheck::ThrowByValueCatchByReferenceCheck(
StringRef Name, ClangTidyContext *Context) StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
CheckAnonymousTemporaries(Options.get("CheckThrowTemporaries", true)) {} CheckAnonymousTemporaries(Options.get("CheckThrowTemporaries", true)) {}
void ThrowByValueCatchByReferenceCheck::registerMatchers(MatchFinder *Finder) { void ThrowByValueCatchByReferenceCheck::registerMatchers(MatchFinder *Finder) {
// This is a C++ only check thus we register the matchers only for C++ // This is a C++ only check thus we register the matchers only for C++
▲ Show 20 Lines • Show All 134 Lines • Show Last 20 Lines

clang-tidy/misc/UnusedAliasDeclsCheck.h

Show All 9 Lines
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_ALIAS_DECLS_H
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "llvm/ADT/DenseMap.h" #include "llvm/ADT/DenseMap.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// Finds unused namespace alias declarations. /// Finds unused namespace alias declarations.
class UnusedAliasDeclsCheck : public ClangTidyCheck { class UnusedAliasDeclsCheck : public ClangTidyCheck {
public: public:
UnusedAliasDeclsCheck(StringRef Name, ClangTidyContext *Context) UnusedAliasDeclsCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override; void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
Show All 12 Lines

clang-tidy/misc/UnusedParametersCheck.h

//===--- UnusedParametersCheck.h - clang-tidy--------------------*- C++ -*-===// //===--- UnusedParametersCheck.h - clang-tidy--------------------*- C++ -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H #define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MISC_UNUSED_PARAMETERS_H
#include "../ClangTidy.h" #include "../ClangTidy.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace misc { namespace misc {
/// Finds unused parameters and fixes them, so that `-Wunused-parameter` can be /// Finds unused parameters and fixes them, so that `-Wunused-parameter` can be
/// turned on. /// turned on.
class UnusedParametersCheck : public ClangTidyCheck { class UnusedParametersCheck : public ClangTidyCheck {
public: public:
UnusedParametersCheck(StringRef Name, ClangTidyContext *Context) UnusedParametersCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {} : ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override; void registerMatchers(ast_matchers::MatchFinder *Finder) override;
Show All 14 Lines

clang-tidy/misc/UnusedUsingDeclsCheck.cpp

Show All 31 Linesvoid UnusedUsingDeclsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this); Finder->addMatcher(usingDecl(isExpansionInMainFile()).bind("using"), this);
auto DeclMatcher = hasDeclaration(namedDecl().bind("used")); auto DeclMatcher = hasDeclaration(namedDecl().bind("used"));
Finder->addMatcher(loc(enumType(DeclMatcher)), this); Finder->addMatcher(loc(enumType(DeclMatcher)), this);
Finder->addMatcher(loc(recordType(DeclMatcher)), this); Finder->addMatcher(loc(recordType(DeclMatcher)), this);
Finder->addMatcher(loc(templateSpecializationType(DeclMatcher)), this); Finder->addMatcher(loc(templateSpecializationType(DeclMatcher)), this);
Finder->addMatcher(declRefExpr().bind("used"), this); Finder->addMatcher(declRefExpr().bind("used"), this);
Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))), Finder->addMatcher(callExpr(callee(unresolvedLookupExpr().bind("used"))),
this); this);
Finder->addMatcher(
callExpr(hasDeclaration(functionDecl(hasAnyTemplateArgument(
anyOf(refersToTemplate(templateName().bind("used")),
refersToDeclaration(functionDecl().bind("used"))))))),
this);
} }
void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) { void UnusedUsingDeclsCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) { if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
// Ignores using-declarations defined in macros. // Ignores using-declarations defined in macros.
if (Using->getLocation().isMacroID()) if (Using->getLocation().isMacroID())
return; return;
Show All 18 Lines for (const auto *UsingShadow : Using->shadows()) {
const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl(); const auto *TargetDecl = UsingShadow->getTargetDecl()->getCanonicalDecl();
if (ShouldCheckDecl(TargetDecl)) if (ShouldCheckDecl(TargetDecl))
Context.UsingTargetDecls.insert(TargetDecl); Context.UsingTargetDecls.insert(TargetDecl);
} }
if (!Context.UsingTargetDecls.empty()) if (!Context.UsingTargetDecls.empty())
Contexts.push_back(Context); Contexts.push_back(Context);
return; return;
} }
// Mark using declarations as used by setting FoundDecls' value to zero. As // Mark using declarations as used by setting FoundDecls' value to zero. As
// the AST is walked in order, usages are only marked after a the // the AST is walked in order, usages are only marked after a the
// corresponding using declaration has been found. // corresponding using declaration has been found.
// FIXME: This currently doesn't look at whether the type reference is // FIXME: This currently doesn't look at whether the type reference is
// actually found with the help of the using declaration. // actually found with the help of the using declaration.
if (const auto *Used = Result.Nodes.getNodeAs<NamedDecl>("used")) { if (const auto *Used = Result.Nodes.getNodeAs<NamedDecl>("used")) {
if (const auto *Specialization = if (const auto *FD = dyn_cast<FunctionDecl>(Used)) {
dyn_cast<ClassTemplateSpecializationDecl>(Used)) removeFromFoundDecls(FD->getPrimaryTemplate());
} else if (const auto *Specialization =
dyn_cast<ClassTemplateSpecializationDecl>(Used)) {
Used = Specialization->getSpecializedTemplate(); Used = Specialization->getSpecializedTemplate();
}
removeFromFoundDecls(Used); removeFromFoundDecls(Used);
return; return;
} }
if (const auto *Used = Result.Nodes.getNodeAs<TemplateName>("used")) {
removeFromFoundDecls(Used->getAsTemplateDecl());
return;
}
if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>("used")) { if (const auto *DRE = Result.Nodes.getNodeAs<DeclRefExpr>("used")) {
if (const auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) { if (const auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl())) {
if (const auto *FDT = FD->getPrimaryTemplate()) if (const auto *FDT = FD->getPrimaryTemplate())
removeFromFoundDecls(FDT); removeFromFoundDecls(FDT);
else else
removeFromFoundDecls(FD); removeFromFoundDecls(FD);
} else if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) { } else if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl())) {
removeFromFoundDecls(VD); removeFromFoundDecls(VD);
} else if (const auto *ECD = dyn_cast<EnumConstantDecl>(DRE->getDecl())) { } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(DRE->getDecl())) {
removeFromFoundDecls(ECD); removeFromFoundDecls(ECD);
if (const auto *ET = ECD->getType()->getAs<EnumType>()) if (const auto *ET = ECD->getType()->getAs<EnumType>())
removeFromFoundDecls(ET->getDecl()); removeFromFoundDecls(ET->getDecl());
} }
} }
// Check the uninstantiated template function usage. // Check the uninstantiated template function usage.
if (const auto *ULE = Result.Nodes.getNodeAs<UnresolvedLookupExpr>("used")) { if (const auto *ULE = Result.Nodes.getNodeAs<UnresolvedLookupExpr>("used")) {
for (const NamedDecl* ND : ULE->decls()) { for (const NamedDecl* ND : ULE->decls()) {
if (const auto *USD = dyn_cast<UsingShadowDecl>(ND)) if (const auto *USD = dyn_cast<UsingShadowDecl>(ND))
removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl()); removeFromFoundDecls(USD->getTargetDecl()->getCanonicalDecl());
} }
} }
} }
void UnusedUsingDeclsCheck::removeFromFoundDecls(const Decl *D) { void UnusedUsingDeclsCheck::removeFromFoundDecls(const Decl *D) {
if (!D)
return;
// FIXME: Currently, we don't handle the using-decls being used in different // FIXME: Currently, we don't handle the using-decls being used in different
// scopes (such as different namespaces, different functions). Instead of // scopes (such as different namespaces, different functions). Instead of
// giving an incorrect message, we mark all of them as used. // giving an incorrect message, we mark all of them as used.
// //
// FIXME: Use a more efficient way to find a matching context. // FIXME: Use a more efficient way to find a matching context.
for (auto &Context : Contexts) { for (auto &Context : Contexts) {
if (Context.UsingTargetDecls.count(D->getCanonicalDecl()) > 0) if (Context.UsingTargetDecls.count(D->getCanonicalDecl()) > 0)
Context.IsUsed = true; Context.IsUsed = true;
Show All 17 Lines

clang-tidy/modernize/LoopConvertUtils.cpp

Show First 20 Lines • Show All 799 Lines • ▼ Show 20 Lines if (CurrStmtParent) {
} }
} }
} }
return true; return true;
} }
bool ForLoopIndexUseVisitor::TraverseStmt(Stmt *S) { bool ForLoopIndexUseVisitor::TraverseStmt(Stmt *S) {
// If this is an initialization expression for a lambda capture, prune the
// traversal so that we don't end up diagnosing the contained DeclRefExpr as
// inconsistent usage. No need to record the usage here -- this is done in
// TraverseLambdaCapture().
if (const auto *LE = dyn_cast_or_null<LambdaExpr>(NextStmtParent)) {
// Any child of a LambdaExpr that isn't the body is an initialization
// expression.
if (S != LE->getBody()) {
return true;
}
}
// All this pointer swapping is a mechanism for tracking immediate parentage // All this pointer swapping is a mechanism for tracking immediate parentage
// of Stmts. // of Stmts.
const Stmt *OldNextParent = NextStmtParent; const Stmt *OldNextParent = NextStmtParent;
CurrStmtParent = NextStmtParent; CurrStmtParent = NextStmtParent;
NextStmtParent = S; NextStmtParent = S;
bool Result = VisitorBase::TraverseStmt(S); bool Result = VisitorBase::TraverseStmt(S);
NextStmtParent = OldNextParent; NextStmtParent = OldNextParent;
return Result; return Result;
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

clang-tidy/modernize/MakeSmartPtrCheck.cpp

Show All 23 LinesMakeSmartPtrCheck::MakeSmartPtrCheck(StringRef Name, ClangTidyContext *Context,
std::string makeSmartPtrFunctionName) std::string makeSmartPtrFunctionName)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
makeSmartPtrFunctionName(std::move(makeSmartPtrFunctionName)) {} makeSmartPtrFunctionName(std::move(makeSmartPtrFunctionName)) {}
void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) { void MakeSmartPtrCheck::registerMatchers(ast_matchers::MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus11) if (!getLangOpts().CPlusPlus11)
return; return;
// It is possible to make smart ptr calling private ctor inside of a member
// function. Change to make_smart_ptr will be invalid.
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Nit: this reads a bit strangely, how about: Calling make_smart_ptr from within a member function of a type with a private constructor would be ill-formed.

aaron.ballman: Nit: this reads a bit strangely, how about: `Calling make_smart_ptr from within a member…
malcolm.parsonsUnsubmitted
Done
ReplyInline Actions

The private constructor could also be called from a friend class.

malcolm.parsons: The private constructor could also be called from a friend class.
alexfhUnsubmitted
Done
ReplyInline Actions

It might only be relevant, if std::make_(shared|unique) is declared as a friend of the class in question, which is unlikely to be a common case and I don't think we need to focus on this now.

alexfh: It might only be relevant, if `std::make_(shared|unique)` is declared as a friend of the class…
PrazekAuthorUnsubmitted
Done
ReplyInline Actions

I am totally aware of it, but I never saw a friend delcaration for any class/function from libc++.

Prazek: I am totally aware of it, but I never saw a friend delcaration for any class/function from…
auto CallsPrivateCtor = has(
ignoringImpCasts(cxxConstructExpr(hasDeclaration(decl(isPrivate())))));
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Perhaps: unless(isPublic()) instead of anyOf(isPrivate(), isProtected())?

aaron.ballman: Perhaps: `unless(isPublic())` instead of `anyOf(isPrivate(), isProtected())`?
PrazekAuthorUnsubmitted
Done
ReplyInline Actions

POD types doesn't have public constructors so it will fail :)

Prazek: POD types doesn't have public constructors so it will fail :)
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Don't they have an implicit one for the purposes of a CXXConstructExpr? Looking at an AST dump for:

struct S {
  int i;
};

yields:

|-CXXRecordDecl 0x26d74ae5348 <line:25:1, line:27:1> line:25:8 referenced struct S definition
| |-CXXRecordDecl 0x26d74ae5460 <col:1, col:8> col:8 implicit struct S
| |-FieldDecl 0x26d74ae7880 <line:26:3, col:7> col:7 i 'int'
| |-CXXConstructorDecl 0x26d74ae87b8 <line:25:8> col:8 implicit used S 'void (void) noexcept' inline
| | `-CompoundStmt 0x26d74ae3850 <col:8>
| |-CXXConstructorDecl 0x26d74ae34a8 <col:8> col:8 implicit constexpr S 'void (const struct S &)' inline noexcept-unevaluated 0x26d74ae34a8
| | `-ParmVarDecl 0x26d74ae35e0 <col:8> col:8 'const struct S &'
| `-CXXConstructorDecl 0x26d74ae3678 <col:8> col:8 implicit constexpr S 'void (struct S &&)' inline noexcept-unevaluated 0x26d74ae3678
|   `-ParmVarDecl 0x26d74ae37b0 <col:8> col:8 'struct S &&'
aaron.ballman: Don't they have an implicit one for the purposes of a CXXConstructExpr? Looking at an AST dump…
PrazekAuthorUnsubmitted
Done
ReplyInline Actions

what about std::shared_ptr<int> x = std::shared_ptr(new int); ?
If I recall correctly, it didn't work on this test.

Prazek: what about std::shared_ptr<int> x = std::shared_ptr(new int); ? If I recall correctly, it…
alexfhUnsubmitted
Done
ReplyInline Actions

There's no CXXConstructExpr for primitive types:

$ cat /tmp/qq.cc 
#include <memory>

struct S { S(); };
void ffff() {
  std::shared_ptr<int> p1 = std::shared_ptr<int>(new int);
  std::shared_ptr<S> p2 = std::shared_ptr<S>(new S);
}
$ clang-check -ast-dump -ast-dump-filter=ffff /tmp/qq.cc -- -std=c++11
Dumping ffff:
FunctionDecl 0x7f48270fb6e0 </tmp/qq.cc:4:1, line:7:1> line:4:6 ffff 'void (void)'
`-CompoundStmt 0x7f48271582a8 <col:13, line:7:1>
  |-DeclStmt 0x7f4827131000 <line:5:3, col:58>
  | `-VarDecl 0x7f48270fb9c8 <col:3, col:57> col:24 p1 'std::shared_ptr<int>':'class std::shared_ptr<int>' cinit
  |   `-ExprWithCleanups 0x7f4827130fe8 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>'
  |     `-CXXConstructExpr 0x7f4827130fb0 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' 'void (class std::shared_ptr<int> &&) noexcept' elidable
  |       `-MaterializeTemporaryExpr 0x7f4827130f98 <col:29, col:57> 'class std::shared_ptr<int>' xvalue
  |         `-CXXFunctionalCastExpr 0x7f48271303c8 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' functional cast to std::shared_ptr<int> <ConstructorConversion>
  |           `-CXXBindTemporaryExpr 0x7f48271303a8 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' (CXXTemporary 0x7f48271303a0)
  |             `-CXXConstructExpr 0x7f4827130338 <col:29, col:57> 'std::shared_ptr<int>':'class std::shared_ptr<int>' 'void (int *)'
  |               `-CXXNewExpr 0x7f48270fbb58 <col:50, col:54> 'int *' Function 0x7f4826a1c000 'operator new' 'void *(std::size_t)'
  `-DeclStmt 0x7f4827158290 <line:6:3, col:52>
    `-VarDecl 0x7f4827131238 <col:3, col:51> col:22 p2 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' cinit
      `-ExprWithCleanups 0x7f4827158278 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>'
        `-CXXConstructExpr 0x7f4827158240 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' 'void (class std::shared_ptr<struct S> &&) noexcept' elidable
          `-MaterializeTemporaryExpr 0x7f4827158228 <col:27, col:51> 'class std::shared_ptr<struct S>' xvalue
            `-CXXFunctionalCastExpr 0x7f4827157658 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' functional cast to std::shared_ptr<S> <ConstructorConversion>
              `-CXXBindTemporaryExpr 0x7f4827157638 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' (CXXTemporary 0x7f4827157630)
                `-CXXConstructExpr 0x7f48271575c8 <col:27, col:51> 'std::shared_ptr<S>':'class std::shared_ptr<struct S>' 'void (struct S *)'
                  `-CXXNewExpr 0x7f4827131838 <col:46, col:50> 'struct S *' Function 0x7f4826a1c000 'operator new' 'void *(std::size_t)'
                    `-CXXConstructExpr 0x7f4827131808 <col:50> 'struct S' 'void (void)'
alexfh: There's no `CXXConstructExpr` for primitive types: ``` $ cat /tmp/qq.cc #include <memory>…
PrazekAuthorUnsubmitted
Done
ReplyInline Actions

exactly.

Prazek: exactly.
alexfhUnsubmitted
Not Done
ReplyInline Actions

But this means that unless(isPublic()) should work, IIUC.

alexfh: But this means that `unless(isPublic())` should work, IIUC.
PrazekAuthorUnsubmitted
Not Done
ReplyInline Actions

Oh I see.
Yea I remember right now what I did:
has(ignoringImpCasts(cxxConstructExpr(

hasDeclaration(decl(isPublic())))))))

This ofc not gonna work, but

unless(has(ignoringImpCasts(cxxConstructExpr(

hasDeclaration(decl(unless(isPublic())))))))

should be totally fine

Prazek: Oh I see. Yea I remember right now what I did: has(ignoringImpCasts(cxxConstructExpr…
Finder->addMatcher( Finder->addMatcher(
cxxBindTemporaryExpr(has(ignoringParenImpCasts( cxxBindTemporaryExpr(has(ignoringParenImpCasts(
cxxConstructExpr( cxxConstructExpr(
hasType(getSmartPointerTypeMatcher()), argumentCountIs(1), hasType(getSmartPointerTypeMatcher()), argumentCountIs(1),
hasArgument(0, hasArgument(0,
cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType( cxxNewExpr(hasType(pointsTo(qualType(hasCanonicalType(
equalsBoundNode(PointerType)))))) equalsBoundNode(PointerType))))),
unless(CallsPrivateCtor))
.bind(NewExpression))) .bind(NewExpression)))
.bind(ConstructorCall)))), .bind(ConstructorCall)))),
this); this);
} }
void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) { void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
// 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other // 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other
// pointer, 'make_smart_ptr' refers to 'std::make_shared' or // pointer, 'make_smart_ptr' refers to 'std::make_shared' or
▲ Show 20 Lines • Show All 104 Lines • Show Last 20 Lines

clang-tidy/modernize/PassByValueCheck.cpp

Show First 20 Lines • Show All 177 Lines • ▼ Show 20 Linesvoid PassByValueCheck::check(const MatchFinder::MatchResult &Result) {
// If the parameter is used or anything other than the copy, do not apply // If the parameter is used or anything other than the copy, do not apply
// the changes. // the changes.
if (!paramReferredExactlyOnce(Ctor, ParamDecl)) if (!paramReferredExactlyOnce(Ctor, ParamDecl))
return; return;
// If the parameter is trivial to copy, don't move it. Moving a trivivally // If the parameter is trivial to copy, don't move it. Moving a trivivally
// copyable type will cause a problem with misc-move-const-arg // copyable type will cause a problem with misc-move-const-arg
if (ParamDecl->getType().isTriviallyCopyableType(*Result.Context)) if (ParamDecl->getType().isTriviallyCopyableType(*Result.Context))
return; return;
auto Diag = diag(ParamDecl->getLocStart(), "pass by value and use std::move"); auto Diag = diag(ParamDecl->getLocStart(), "pass by value and use std::move");
// Iterate over all declarations of the constructor. // Iterate over all declarations of the constructor.
for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) { for (const ParmVarDecl *ParmDecl : collectParamDecls(Ctor, ParamDecl)) {
auto ParamTL = ParmDecl->getTypeSourceInfo()->getTypeLoc(); auto ParamTL = ParmDecl->getTypeSourceInfo()->getTypeLoc();
auto RefTL = ParamTL.getAs<ReferenceTypeLoc>(); auto RefTL = ParamTL.getAs<ReferenceTypeLoc>();
Show All 33 Lines

clang-tidy/modernize/UseBoolLiteralsCheck.cpp

Show All 23 Linesvoid UseBoolLiteralsCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher( Finder->addMatcher(
implicitCastExpr( implicitCastExpr(
has(ignoringParenImpCasts(integerLiteral().bind("literal"))), has(ignoringParenImpCasts(integerLiteral().bind("literal"))),
hasImplicitDestinationType(qualType(booleanType())), hasImplicitDestinationType(qualType(booleanType())),
unless(isInTemplateInstantiation()), unless(isInTemplateInstantiation()),
anyOf(hasParent(explicitCastExpr().bind("cast")), anything())), anyOf(hasParent(explicitCastExpr().bind("cast")), anything())),
this); this);
Finder->addMatcher(
conditionalOperator(
hasParent(implicitCastExpr(
hasImplicitDestinationType(qualType(booleanType())),
unless(isInTemplateInstantiation()))),
eachOf(hasTrueExpression(
ignoringParenImpCasts(integerLiteral().bind("literal"))),
hasFalseExpression(
ignoringParenImpCasts(integerLiteral().bind("literal"))))),
this);
} }
void UseBoolLiteralsCheck::check(const MatchFinder::MatchResult &Result) { void UseBoolLiteralsCheck::check(const MatchFinder::MatchResult &Result) {
const auto *Literal = Result.Nodes.getNodeAs<IntegerLiteral>("literal"); const auto *Literal = Result.Nodes.getNodeAs<IntegerLiteral>("literal");
const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast"); const auto *Cast = Result.Nodes.getNodeAs<Expr>("cast");
bool LiteralBooleanValue = Literal->getValue().getBoolValue(); bool LiteralBooleanValue = Literal->getValue().getBoolValue();
if (Literal->isInstantiationDependent()) if (Literal->isInstantiationDependent())
Show All 16 Lines

clang-tidy/mpi/CMakeLists.txt

  • This file was added.
set(LLVM_LINK_COMPONENTS support)
add_clang_library(clangTidyMPIModule
MPITidyModule.cpp
TypeMismatchCheck.cpp
LINK_LIBS
clangAST
clangASTMatchers
clangBasic
clangLex
clangTidy
clangTidyUtils
clangTooling
clangStaticAnalyzerCheckers
)

clang-tidy/mpi/MPITidyModule.cpp

  • This file was added.
//===--- MPITidyModule.cpp - clang-tidy -----------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "../ClangTidy.h"
#include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h"
#include "TypeMismatchCheck.h"
namespace clang {
namespace tidy {
namespace mpi {
class MPIModule : public ClangTidyModule {
public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<TypeMismatchCheck>("mpi-type-mismatch");
}
};
} // namespace mpi
// Register the MPITidyModule using this statically initialized variable.
static ClangTidyModuleRegistry::Add<mpi::MPIModule>
X("mpi-module", "Adds MPI clang-tidy checks.");
// This anchor is used to force the linker to link in the generated object file
// and thus register the MPIModule.
volatile int MPIModuleAnchorSource = 0;
} // namespace tidy
} // namespace clang

clang-tidy/mpi/TypeMismatchCheck.h

  • This file was added.
//===--- TypeMismatchCheck.h - clang-tidy------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H
#include "../ClangTidy.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
namespace clang {
namespace tidy {
namespace mpi {
/// This check verifies if buffer type and MPI (Message Passing Interface)
/// datatype pairs match. All MPI datatypes defined by the MPI standard (3.1)
/// are verified by this check. User defined typedefs, custom MPI datatypes and
/// null pointer constants are skipped, in the course of verification.
///
/// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/mpi-type-mismatch.html
class TypeMismatchCheck : public ClangTidyCheck {
public:
TypeMismatchCheck(StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context) {}
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
private:
/// Check if the buffer type MPI datatype pairs match.
///
/// \param BufferTypes buffer types
/// \param BufferExprs buffer arguments as expressions
/// \param MPIDatatypes MPI datatype
/// \param LO language options
void checkArguments(ArrayRef<const Type *> BufferTypes,
ArrayRef<const Expr *> BufferExprs,
ArrayRef<StringRef> MPIDatatypes,
const LangOptions &LO);
};
} // namespace mpi
} // namespace tidy
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H

clang-tidy/mpi/TypeMismatchCheck.cpp

  • This file was added.
//===--- TypeMismatchCheck.cpp - clang-tidy--------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "TypeMismatchCheck.h"
#include "clang/Lex/Lexer.h"
#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
#include "clang/Tooling/FixIt.h"
#include <map>
#include <unordered_set>
using namespace clang::ast_matchers;
namespace clang {
namespace tidy {
namespace mpi {
/// Check if a BuiltinType::Kind matches the MPI datatype.
///
/// \param MultiMap datatype group
/// \param Kind buffer type kind
/// \param MPIDatatype name of the MPI datatype
///
/// \returns true if the pair matches
static bool
isMPITypeMatching(const std::multimap<BuiltinType::Kind, std::string> &MultiMap,
const BuiltinType::Kind Kind,
const std::string &MPIDatatype) {
auto ItPair = MultiMap.equal_range(Kind);
while (ItPair.first != ItPair.second) {
if (ItPair.first->second == MPIDatatype)
return true;
++ItPair.first;
}
return false;
}
/// Check if the MPI datatype is a standard type.
///
/// \param MPIDatatype name of the MPI datatype
///
/// \returns true if the type is a standard type
static bool isStandardMPIDatatype(const std::string &MPIDatatype) {
static std::unordered_set<std::string> AllTypes = {
"MPI_C_BOOL",
"MPI_CHAR",
"MPI_SIGNED_CHAR",
"MPI_UNSIGNED_CHAR",
"MPI_WCHAR",
"MPI_INT",
"MPI_LONG",
"MPI_SHORT",
"MPI_LONG_LONG",
"MPI_LONG_LONG_INT",
"MPI_UNSIGNED",
"MPI_UNSIGNED_SHORT",
"MPI_UNSIGNED_LONG",
"MPI_UNSIGNED_LONG_LONG",
"MPI_FLOAT",
"MPI_DOUBLE",
"MPI_LONG_DOUBLE",
"MPI_C_COMPLEX",
"MPI_C_FLOAT_COMPLEX",
"MPI_C_DOUBLE_COMPLEX",
"MPI_C_LONG_DOUBLE_COMPLEX",
"MPI_INT8_T",
"MPI_INT16_T",
"MPI_INT32_T",
"MPI_INT64_T",
"MPI_UINT8_T",
"MPI_UINT16_T",
"MPI_UINT32_T",
"MPI_UINT64_T",
"MPI_CXX_BOOL",
"MPI_CXX_FLOAT_COMPLEX",
"MPI_CXX_DOUBLE_COMPLEX",
"MPI_CXX_LONG_DOUBLE_COMPLEX"};
return AllTypes.find(MPIDatatype) != AllTypes.end();
}
/// Check if a BuiltinType matches the MPI datatype.
///
/// \param Builtin the builtin type
/// \param BufferTypeName buffer type name, gets assigned
/// \param MPIDatatype name of the MPI datatype
/// \param LO language options
///
/// \returns true if the type matches
static bool isBuiltinTypeMatching(const BuiltinType *Builtin,
std::string &BufferTypeName,
const std::string &MPIDatatype,
const LangOptions &LO) {
static std::multimap<BuiltinType::Kind, std::string> BuiltinMatches = {
// On some systems like PPC or ARM, 'char' is unsigned by default which is
// why distinct signedness for the buffer and MPI type is tolerated.
{BuiltinType::SChar, "MPI_CHAR"},
{BuiltinType::SChar, "MPI_SIGNED_CHAR"},
{BuiltinType::SChar, "MPI_UNSIGNED_CHAR"},
{BuiltinType::Char_S, "MPI_CHAR"},
{BuiltinType::Char_S, "MPI_SIGNED_CHAR"},
{BuiltinType::Char_S, "MPI_UNSIGNED_CHAR"},
{BuiltinType::UChar, "MPI_CHAR"},
{BuiltinType::UChar, "MPI_SIGNED_CHAR"},
{BuiltinType::UChar, "MPI_UNSIGNED_CHAR"},
{BuiltinType::Char_U, "MPI_CHAR"},
{BuiltinType::Char_U, "MPI_SIGNED_CHAR"},
{BuiltinType::Char_U, "MPI_UNSIGNED_CHAR"},
{BuiltinType::WChar_S, "MPI_WCHAR"},
{BuiltinType::WChar_U, "MPI_WCHAR"},
{BuiltinType::Bool, "MPI_C_BOOL"},
{BuiltinType::Bool, "MPI_CXX_BOOL"},
{BuiltinType::Short, "MPI_SHORT"},
{BuiltinType::Int, "MPI_INT"},
{BuiltinType::Long, "MPI_LONG"},
{BuiltinType::LongLong, "MPI_LONG_LONG"},
{BuiltinType::LongLong, "MPI_LONG_LONG_INT"},
{BuiltinType::UShort, "MPI_UNSIGNED_SHORT"},
{BuiltinType::UInt, "MPI_UNSIGNED"},
{BuiltinType::ULong, "MPI_UNSIGNED_LONG"},
{BuiltinType::ULongLong, "MPI_UNSIGNED_LONG_LONG"},
{BuiltinType::Float, "MPI_FLOAT"},
{BuiltinType::Double, "MPI_DOUBLE"},
{BuiltinType::LongDouble, "MPI_LONG_DOUBLE"}};
if (!isMPITypeMatching(BuiltinMatches, Builtin->getKind(), MPIDatatype)) {
BufferTypeName = Builtin->getName(LO);
return false;
}
return true;
}
/// Check if a complex float/double/long double buffer type matches
/// the MPI datatype.
///
/// \param Complex buffer type
/// \param BufferTypeName buffer type name, gets assigned
/// \param MPIDatatype name of the MPI datatype
/// \param LO language options
///
/// \returns true if the type matches or the buffer type is unknown
static bool isCComplexTypeMatching(const ComplexType *const Complex,
std::string &BufferTypeName,
const std::string &MPIDatatype,
const LangOptions &LO) {
static std::multimap<BuiltinType::Kind, std::string> ComplexCMatches = {
{BuiltinType::Float, "MPI_C_COMPLEX"},
{BuiltinType::Float, "MPI_C_FLOAT_COMPLEX"},
{BuiltinType::Double, "MPI_C_DOUBLE_COMPLEX"},
{BuiltinType::LongDouble, "MPI_C_LONG_DOUBLE_COMPLEX"}};
const auto *Builtin =
Complex->getElementType().getTypePtr()->getAs<BuiltinType>();
if (Builtin &&
!isMPITypeMatching(ComplexCMatches, Builtin->getKind(), MPIDatatype)) {
BufferTypeName = (llvm::Twine(Builtin->getName(LO)) + " _Complex").str();
return false;
}
return true;
}
/// Check if a complex<float/double/long double> templated buffer type matches
/// the MPI datatype.
///
/// \param Template buffer type
/// \param BufferTypeName buffer type name, gets assigned
/// \param MPIDatatype name of the MPI datatype
/// \param LO language options
///
/// \returns true if the type matches or the buffer type is unknown
static bool
isCXXComplexTypeMatching(const TemplateSpecializationType *const Template,
std::string &BufferTypeName,
const std::string &MPIDatatype,
const LangOptions &LO) {
static std::multimap<BuiltinType::Kind, std::string> ComplexCXXMatches = {
{BuiltinType::Float, "MPI_CXX_FLOAT_COMPLEX"},
{BuiltinType::Double, "MPI_CXX_DOUBLE_COMPLEX"},
{BuiltinType::LongDouble, "MPI_CXX_LONG_DOUBLE_COMPLEX"}};
if (Template->getAsCXXRecordDecl()->getName() != "complex")
return true;
const auto *Builtin =
Template->getArg(0).getAsType().getTypePtr()->getAs<BuiltinType>();
if (Builtin &&
!isMPITypeMatching(ComplexCXXMatches, Builtin->getKind(), MPIDatatype)) {
BufferTypeName =
(llvm::Twine("complex<") + Builtin->getName(LO) + ">").str();
return false;
}
return true;
}
/// Check if a fixed size width buffer type matches the MPI datatype.
///
/// \param Typedef buffer type
/// \param BufferTypeName buffer type name, gets assigned
/// \param MPIDatatype name of the MPI datatype
///
/// \returns true if the type matches or the buffer type is unknown
static bool isTypedefTypeMatching(const TypedefType *const Typedef,
std::string &BufferTypeName,
const std::string &MPIDatatype) {
static llvm::StringMap<std::string> FixedWidthMatches = {
{"int8_t", "MPI_INT8_T"}, {"int16_t", "MPI_INT16_T"},
{"int32_t", "MPI_INT32_T"}, {"int64_t", "MPI_INT64_T"},
{"uint8_t", "MPI_UINT8_T"}, {"uint16_t", "MPI_UINT16_T"},
{"uint32_t", "MPI_UINT32_T"}, {"uint64_t", "MPI_UINT64_T"}};
const auto it = FixedWidthMatches.find(Typedef->getDecl()->getName());
// Check if the typedef is known and not matching the MPI datatype.
if (it != FixedWidthMatches.end() && it->getValue() != MPIDatatype) {
BufferTypeName = Typedef->getDecl()->getName();
return false;
}
return true;
}
/// Get the unqualified, dereferenced type of an argument.
///
/// \param CE call expression
/// \param idx argument index
///
/// \returns type of the argument
static const Type *argumentType(const CallExpr *const CE, const size_t idx) {
const QualType QT = CE->getArg(idx)->IgnoreImpCasts()->getType();
return QT.getTypePtr()->getPointeeOrArrayElementType();
}
void TypeMismatchCheck::registerMatchers(MatchFinder *Finder) {
Finder->addMatcher(callExpr().bind("CE"), this);
}
void TypeMismatchCheck::check(const MatchFinder::MatchResult &Result) {
static ento::mpi::MPIFunctionClassifier FuncClassifier(*Result.Context);
const CallExpr *const CE = Result.Nodes.getNodeAs<CallExpr>("CE");
if (!CE->getDirectCallee())
return;
const IdentifierInfo *Identifier = CE->getDirectCallee()->getIdentifier();
if (!Identifier || !FuncClassifier.isMPIType(Identifier))
return;
// These containers are used, to capture buffer, MPI datatype pairs.
SmallVector<const Type *, 1> BufferTypes;
SmallVector<const Expr *, 1> BufferExprs;
SmallVector<StringRef, 1> MPIDatatypes;
// Adds a buffer, MPI datatype pair of an MPI call expression to the
// containers. For buffers, the type and expression is captured.
auto addPair = [&CE, &Result, &BufferTypes, &BufferExprs, &MPIDatatypes](
const size_t BufferIdx, const size_t DatatypeIdx) {
// Skip null pointer constants and in place 'operators'.
if (CE->getArg(BufferIdx)->isNullPointerConstant(
*Result.Context, Expr::NPC_ValueDependentIsNull) ||
tooling::fixit::getText(*CE->getArg(BufferIdx), *Result.Context) ==
"MPI_IN_PLACE")
return;
StringRef MPIDatatype =
tooling::fixit::getText(*CE->getArg(DatatypeIdx), *Result.Context);
const Type *ArgType = argumentType(CE, BufferIdx);
// Skip unknown MPI datatypes and void pointers.
if (!isStandardMPIDatatype(MPIDatatype) || ArgType->isVoidType())
return;
BufferTypes.push_back(ArgType);
BufferExprs.push_back(CE->getArg(BufferIdx));
MPIDatatypes.push_back(MPIDatatype);
};
// Collect all buffer, MPI datatype pairs for the inspected call expression.
if (FuncClassifier.isPointToPointType(Identifier)) {
addPair(0, 2);
} else if (FuncClassifier.isCollectiveType(Identifier)) {
if (FuncClassifier.isReduceType(Identifier)) {
addPair(0, 3);
addPair(1, 3);
} else if (FuncClassifier.isScatterType(Identifier) ||
FuncClassifier.isGatherType(Identifier) ||
FuncClassifier.isAlltoallType(Identifier)) {
addPair(0, 2);
addPair(3, 5);
} else if (FuncClassifier.isBcastType(Identifier)) {
addPair(0, 2);
}
}
checkArguments(BufferTypes, BufferExprs, MPIDatatypes,
Result.Context->getLangOpts());
}
void TypeMismatchCheck::checkArguments(ArrayRef<const Type *> BufferTypes,
ArrayRef<const Expr *> BufferExprs,
ArrayRef<StringRef> MPIDatatypes,
const LangOptions &LO) {
std::string BufferTypeName;
for (size_t i = 0; i < MPIDatatypes.size(); ++i) {
const Type *const BT = BufferTypes[i];
bool Error = false;
if (const auto *Typedef = BT->getAs<TypedefType>()) {
Error = !isTypedefTypeMatching(Typedef, BufferTypeName, MPIDatatypes[i]);
} else if (const auto *Complex = BT->getAs<ComplexType>()) {
Error =
!isCComplexTypeMatching(Complex, BufferTypeName, MPIDatatypes[i], LO);
} else if (const auto *Template = BT->getAs<TemplateSpecializationType>()) {
Error = !isCXXComplexTypeMatching(Template, BufferTypeName,
MPIDatatypes[i], LO);
} else if (const auto *Builtin = BT->getAs<BuiltinType>()) {
Error =
!isBuiltinTypeMatching(Builtin, BufferTypeName, MPIDatatypes[i], LO);
}
if (Error) {
const auto Loc = BufferExprs[i]->getSourceRange().getBegin();
diag(Loc, "buffer type '%0' does not match the MPI datatype '%1'")
<< BufferTypeName << MPIDatatypes[i];
}
}
}
} // namespace mpi
} // namespace tidy
} // namespace clang

clang-tidy/performance/CMakeLists.txt

set(LLVM_LINK_COMPONENTS support) set(LLVM_LINK_COMPONENTS support)
add_clang_library(clangTidyPerformanceModule add_clang_library(clangTidyPerformanceModule
FasterStringFindCheck.cpp FasterStringFindCheck.cpp
ForRangeCopyCheck.cpp ForRangeCopyCheck.cpp
ImplicitCastInLoopCheck.cpp ImplicitCastInLoopCheck.cpp
InefficientStringConcatenationCheck.cpp
PerformanceTidyModule.cpp PerformanceTidyModule.cpp
UnnecessaryCopyInitialization.cpp UnnecessaryCopyInitialization.cpp
UnnecessaryValueParamCheck.cpp UnnecessaryValueParamCheck.cpp
LINK_LIBS LINK_LIBS
clangAST clangAST
clangASTMatchers clangASTMatchers
clangBasic clangBasic
clangLex clangLex
clangTidy clangTidy
clangTidyUtils clangTidyUtils
) )

clang-tidy/performance/InefficientStringConcatenationCheck.h

  • This file was added.
//===--- InefficientStringConcatenationCheck.h - clang-tidy-----------*- C++
//-*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENTSTRINGCONCATENATION_H
#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENTSTRINGCONCATENATION_H
#include "../ClangTidy.h"
namespace clang {
namespace tidy {
namespace performance {
/// This check is to warn about the performance overhead arising from
/// concatenating strings, using the operator+, instead of operator+=.
///
/// For the user-facing documentation see:
/// http://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-string-concatenation.html
class InefficientStringConcatenationCheck : public ClangTidyCheck {
public:
InefficientStringConcatenationCheck(StringRef Name,
ClangTidyContext *Context);
void registerMatchers(ast_matchers::MatchFinder *Finder) override;
void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
private:
const bool StrictMode;
};
} // namespace performance
} // namespace tidy
} // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_PERFORMANCE_INEFFICIENTSTRINGCONCATENATION_H

clang-tidy/performance/InefficientStringConcatenationCheck.cpp

  • This file was added.
//===--- InefficientStringConcatenationCheck.cpp - clang-tidy--------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "InefficientStringConcatenationCheck.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
using namespace clang::ast_matchers;
namespace clang {
namespace tidy {
namespace performance {
void InefficientStringConcatenationCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "StrictMode", StrictMode);
}
InefficientStringConcatenationCheck::InefficientStringConcatenationCheck(
StringRef Name, ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), StrictMode(Options.get("StrictMode", 0)) {}
void InefficientStringConcatenationCheck::registerMatchers(
MatchFinder *Finder) {
if (!getLangOpts().CPlusPlus)
return;
const auto BasicStringType =
hasType(cxxRecordDecl(hasName("::std::basic_string")));
const auto BasicStringPlusOperator = cxxOperatorCallExpr(
hasOverloadedOperatorName("+"),
hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))));
const auto PlusOperator =
cxxOperatorCallExpr(
hasOverloadedOperatorName("+"),
hasAnyArgument(ignoringImpCasts(declRefExpr(BasicStringType))),
hasDescendant(BasicStringPlusOperator))
.bind("plusOperator");
const auto AssignOperator = cxxOperatorCallExpr(
hasOverloadedOperatorName("="),
hasArgument(0, declRefExpr(BasicStringType,
hasDeclaration(decl().bind("lhsStrT")))
.bind("lhsStr")),
hasArgument(1, stmt(hasDescendant(declRefExpr(
hasDeclaration(decl(equalsBoundNode("lhsStrT"))))))),
hasDescendant(BasicStringPlusOperator));
if (StrictMode) {
Finder->addMatcher(cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator)),
this);
} else {
Finder->addMatcher(
cxxOperatorCallExpr(anyOf(AssignOperator, PlusOperator),
hasAncestor(stmt(anyOf(cxxForRangeStmt(),
whileStmt(), forStmt())))),
this);
}
}
void InefficientStringConcatenationCheck::check(
const MatchFinder::MatchResult &Result) {
const auto *LhsStr = Result.Nodes.getNodeAs<DeclRefExpr>("lhsStr");
const auto *PlusOperator =
Result.Nodes.getNodeAs<CXXOperatorCallExpr>("plusOperator");
const auto DiagMsg =
"string concatenation results in allocation of unnecessary temporary "
"strings; consider using 'operator+=' or 'string::append()' instead";
if (LhsStr)
diag(LhsStr->getExprLoc(), DiagMsg);
else if (PlusOperator)
diag(PlusOperator->getExprLoc(), DiagMsg);
}
} // namespace performance
} // namespace tidy
} // namespace clang

clang-tidy/performance/PerformanceTidyModule.cpp

//===--- PeformanceTidyModule.cpp - clang-tidy ----------------------------===// //===--- PeformanceTidyModule.cpp - clang-tidy ----------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "../ClangTidy.h" #include "../ClangTidy.h"
#include "../ClangTidyModule.h" #include "../ClangTidyModule.h"
#include "../ClangTidyModuleRegistry.h" #include "../ClangTidyModuleRegistry.h"
#include "InefficientStringConcatenationCheck.h"
#include "FasterStringFindCheck.h" #include "FasterStringFindCheck.h"
#include "ForRangeCopyCheck.h" #include "ForRangeCopyCheck.h"
#include "ImplicitCastInLoopCheck.h" #include "ImplicitCastInLoopCheck.h"
#include "UnnecessaryCopyInitialization.h" #include "UnnecessaryCopyInitialization.h"
#include "UnnecessaryValueParamCheck.h" #include "UnnecessaryValueParamCheck.h"
namespace clang { namespace clang {
namespace tidy { namespace tidy {
namespace performance { namespace performance {
class PerformanceModule : public ClangTidyModule { class PerformanceModule : public ClangTidyModule {
public: public:
void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override { void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
CheckFactories.registerCheck<FasterStringFindCheck>( CheckFactories.registerCheck<FasterStringFindCheck>(
"performance-faster-string-find"); "performance-faster-string-find");
CheckFactories.registerCheck<ForRangeCopyCheck>( CheckFactories.registerCheck<ForRangeCopyCheck>(
"performance-for-range-copy"); "performance-for-range-copy");
CheckFactories.registerCheck<ImplicitCastInLoopCheck>( CheckFactories.registerCheck<ImplicitCastInLoopCheck>(
"performance-implicit-cast-in-loop"); "performance-implicit-cast-in-loop");
CheckFactories.registerCheck<InefficientStringConcatenationCheck>(
"performance-inefficient-string-concatenation");
CheckFactories.registerCheck<UnnecessaryCopyInitialization>( CheckFactories.registerCheck<UnnecessaryCopyInitialization>(
"performance-unnecessary-copy-initialization"); "performance-unnecessary-copy-initialization");
CheckFactories.registerCheck<UnnecessaryValueParamCheck>( CheckFactories.registerCheck<UnnecessaryValueParamCheck>(
"performance-unnecessary-value-param"); "performance-unnecessary-value-param");
} }
}; };
// Register the PerformanceModule using this statically initialized variable. // Register the PerformanceModule using this statically initialized variable.
Show All 11 Lines

clang-tidy/performance/UnnecessaryValueParamCheck.cpp

Show First 20 Lines • Show All 151 Lines • ▼ Show 20 Linesvoid UnnecessaryValueParamCheck::handleMoveFix(const ParmVarDecl &Var,
auto Diag = diag(CopyArgument.getLocStart(), auto Diag = diag(CopyArgument.getLocStart(),
"parameter %0 is passed by value and only copied once; " "parameter %0 is passed by value and only copied once; "
"consider moving it to avoid unnecessary copies") "consider moving it to avoid unnecessary copies")
<< &Var; << &Var;
// Do not propose fixes in macros since we cannot place them correctly. // Do not propose fixes in macros since we cannot place them correctly.
if (CopyArgument.getLocStart().isMacroID()) if (CopyArgument.getLocStart().isMacroID())
return; return;
const auto &SM = Context.getSourceManager(); const auto &SM = Context.getSourceManager();
auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM, auto EndLoc = Lexer::getLocForEndOfToken(CopyArgument.getLocation(), 0, SM,
Context.getLangOpts()); Context.getLangOpts());
Diag << FixItHint::CreateInsertion(CopyArgument.getLocStart(), "std::move(") Diag << FixItHint::CreateInsertion(CopyArgument.getLocStart(), "std::move(")
<< FixItHint::CreateInsertion(EndLoc, ")"); << FixItHint::CreateInsertion(EndLoc, ")");
if (auto IncludeFixit = Inserter->CreateIncludeInsertion( if (auto IncludeFixit = Inserter->CreateIncludeInsertion(
SM.getFileID(CopyArgument.getLocStart()), "utility", SM.getFileID(CopyArgument.getLocStart()), "utility",
/*IsAngled=*/true)) /*IsAngled=*/true))
Diag << *IncludeFixit; Diag << *IncludeFixit;
} }
} // namespace performance } // namespace performance
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

clang-tidy/plugin/CMakeLists.txt

Show All 9 Linesadd_clang_library(clangTidyPlugin
clangTidy clangTidy
clangTidyBoostModule clangTidyBoostModule
clangTidyCERTModule clangTidyCERTModule
clangTidyCppCoreGuidelinesModule clangTidyCppCoreGuidelinesModule
clangTidyGoogleModule clangTidyGoogleModule
clangTidyLLVMModule clangTidyLLVMModule
clangTidyMiscModule clangTidyMiscModule
clangTidyModernizeModule clangTidyModernizeModule
clangTidyMPIModule
clangTidyPerformanceModule clangTidyPerformanceModule
clangTidyReadabilityModule clangTidyReadabilityModule
clangTooling clangTooling
) )

clang-tidy/readability/IdentifierNamingCheck.cpp

//===--- IdentifierNamingCheck.cpp - clang-tidy ---------------------------===// //===--- IdentifierNamingCheck.cpp - clang-tidy ---------------------------===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
// This file is distributed under the University of Illinois Open Source // This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details. // License. See LICENSE.TXT for details.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "IdentifierNamingCheck.h" #include "IdentifierNamingCheck.h"
#include "llvm/ADT/DenseMapInfo.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/Format.h" #include "llvm/Support/Format.h"
#include "clang/ASTMatchers/ASTMatchFinder.h" #include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/Frontend/CompilerInstance.h" #include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/PPCallbacks.h" #include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h" #include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/DenseMapInfo.h"
#define DEBUG_TYPE "clang-tidy" #define DEBUG_TYPE "clang-tidy"
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
namespace llvm { namespace llvm {
/// Specialisation of DenseMapInfo to allow NamingCheckId objects in DenseMaps /// Specialisation of DenseMapInfo to allow NamingCheckId objects in DenseMaps
template <> template <>
▲ Show 20 Lines • Show All 847 Lines • Show Last 20 Lines

clang-tidy/tool/CMakeLists.txt

Show All 14 Linestarget_link_libraries(clang-tidy
clangTidy clangTidy
clangTidyBoostModule clangTidyBoostModule
clangTidyCERTModule clangTidyCERTModule
clangTidyCppCoreGuidelinesModule clangTidyCppCoreGuidelinesModule
clangTidyGoogleModule clangTidyGoogleModule
clangTidyLLVMModule clangTidyLLVMModule
clangTidyMiscModule clangTidyMiscModule
clangTidyModernizeModule clangTidyModernizeModule
clangTidyMPIModule
clangTidyPerformanceModule clangTidyPerformanceModule
clangTidyReadabilityModule clangTidyReadabilityModule
clangTooling clangTooling
) )
install(TARGETS clang-tidy install(TARGETS clang-tidy
RUNTIME DESTINATION bin) RUNTIME DESTINATION bin)
install(PROGRAMS clang-tidy-diff.py DESTINATION share/clang) install(PROGRAMS clang-tidy-diff.py DESTINATION share/clang)
install(PROGRAMS run-clang-tidy.py DESTINATION share/clang) install(PROGRAMS run-clang-tidy.py DESTINATION share/clang)

clang-tidy/tool/ClangTidyMain.cpp

Show First 20 Lines • Show All 448 Lines • ▼ Show 20 Lines
static int LLVM_ATTRIBUTE_UNUSED MiscModuleAnchorDestination = static int LLVM_ATTRIBUTE_UNUSED MiscModuleAnchorDestination =
MiscModuleAnchorSource; MiscModuleAnchorSource;
// This anchor is used to force the linker to link the ModernizeModule. // This anchor is used to force the linker to link the ModernizeModule.
extern volatile int ModernizeModuleAnchorSource; extern volatile int ModernizeModuleAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED ModernizeModuleAnchorDestination = static int LLVM_ATTRIBUTE_UNUSED ModernizeModuleAnchorDestination =
ModernizeModuleAnchorSource; ModernizeModuleAnchorSource;
// This anchor is used to force the linker to link the MPIModule.
extern volatile int MPIModuleAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED MPIModuleAnchorDestination =
MPIModuleAnchorSource;
// This anchor is used to force the linker to link the PerformanceModule. // This anchor is used to force the linker to link the PerformanceModule.
extern volatile int PerformanceModuleAnchorSource; extern volatile int PerformanceModuleAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED PerformanceModuleAnchorDestination = static int LLVM_ATTRIBUTE_UNUSED PerformanceModuleAnchorDestination =
PerformanceModuleAnchorSource; PerformanceModuleAnchorSource;
// This anchor is used to force the linker to link the ReadabilityModule. // This anchor is used to force the linker to link the ReadabilityModule.
extern volatile int ReadabilityModuleAnchorSource; extern volatile int ReadabilityModuleAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED ReadabilityModuleAnchorDestination = static int LLVM_ATTRIBUTE_UNUSED ReadabilityModuleAnchorDestination =
ReadabilityModuleAnchorSource; ReadabilityModuleAnchorSource;
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
return clang::tidy::clangTidyMain(argc, argv); return clang::tidy::clangTidyMain(argc, argv);
} }

docs/ReleaseNotes.rst

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines
Improvements to clang-tidy Improvements to clang-tidy
-------------------------- --------------------------
- New `cppcoreguidelines-slicing - New `cppcoreguidelines-slicing
<http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-slicing.html>`_ check <http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-slicing.html>`_ check
Flags slicing of member variables or vtable. Flags slicing of member variables or vtable.
- New `cppcoreguidelines-special-member-functions
Eugene.ZelenkoUnsubmitted
Done
ReplyInline Actions

I think will be better to have Fixed bugs: section as we had in 3.9 release notes.

Eugene.Zelenko: I think will be better to have //Fixed bugs:// section as we had in 3.9 release notes.
<http://clang.llvm.org/extra/clang-tidy/checks/cppcoreguidelines-special-member-functions.html>`_ check
Flags classes where some, but not all, special member functions are user-defined.
- New `performance-inefficient-string-concatenation
<http://clang.llvm.org/extra/clang-tidy/checks/performance-inefficient-string-concatenation.html>`_ check
This check warns about the performance overhead arising from concatenating
strings using the ``operator+``, instead of ``operator+=``.
- Bugfix for `modernize-make-unique
<http://clang.llvm.org/extra/clang-tidy/checks/modernize-make-unique.html>`_
and `modernize-make-shared
<http://clang.llvm.org/extra/clang-tidy/checks/modernize-make-shared.html>`_
checks
It is invalid to use ``make_{smart_ptr}`` when the called constructor is
private.
Improvements to include-fixer Improvements to include-fixer
----------------------------- -----------------------------
The improvements are... The improvements are...
Improvements to modularize Improvements to modularize
-------------------------- --------------------------
The improvements are... The improvements are...

docs/clang-rename.rst

============ ============
Clang-Rename Clang-Rename
============ ============
.. contents:: .. contents::
See also: See also:
.. toctree:: .. toctree::
:maxdepth: 1 :maxdepth: 1
:program:`clang-rename` is a clang-based C++ "linter" tool. Its purpose is to :program:`clang-rename` is a C++ refactoring tool. Its purpose is to perform
perform efficient renaming actions in large-scale projects such as renaming efficient renaming actions in large-scale projects such as renaming classes,
classes, functions, variables, arguments, namespaces etc. functions, variables, arguments, namespaces etc.
The tool is in a very early development stage, so you might encounter bugs and The tool is in a very early development stage, so you might encounter bugs and
crashes. Submitting reports with information about how to reproduce the issue crashes. Submitting reports with information about how to reproduce the issue
to `the LLVM bugtracker <https://llvm.org/bugs>`_ will definitely help the to `the LLVM bugtracker <https://llvm.org/bugs>`_ will definitely help the
project. If you have any ideas or suggestions, you might want to put a feature project. If you have any ideas or suggestions, you might want to put a feature
request there. request there.
Using clang-rename Using Clang-Rename
================== ==================
:program:`clang-rename` is a `LibTooling :program:`clang-rename` is a `LibTooling
<http://clang.llvm.org/docs/LibTooling.html>`_-based tool, and it's easier to <http://clang.llvm.org/docs/LibTooling.html>`_-based tool, and it's easier to
work with if you set up a compile command database for your project (for an work with if you set up a compile command database for your project (for an
example of how to do this see `How To Setup Tooling For LLVM example of how to do this see `How To Setup Tooling For LLVM
<http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html>`_). You can also <http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html>`_). You can also
specify compilation options on the command line after ``--``: specify compilation options on the command line after `--`:
.. code-block:: console .. code-block:: console
$ clang-rename -offset=42 -new-name=foo test.cpp -- -Imy_project/include -DMY_DEFINES ... $ clang-rename -offset=42 -new-name=foo test.cpp -- -Imy_project/include -DMY_DEFINES ...
To get an offset of a symbol in a file run To get an offset of a symbol in a file run
.. code-block:: console .. code-block:: console
$ grep -FUbo 'foo' file.cpp $ grep -FUbo 'foo' file.cpp
The tool currently supports renaming actions inside a single Translation Unit The tool currently supports renaming actions inside a single Translation Unit
only. It is planned to extend the tool's functionality to support multi-TU only. It is planned to extend the tool's functionality to support multi-TU
renaming actions in the future. renaming actions in the future.
:program:`clang-rename` also aims to be easily integrated into popular text :program:`clang-rename` also aims to be easily integrated into popular text
editors, such as Vim, and improve the workflow of users. editors, such as Vim and Emacs, and improve the workflow of users.
Although a command line interface exists, it is highly recommended to use the Although a command line interface exists, it is highly recommended to use the
text editor interface instead for better experience. text editor interface instead for better experience.
You can also identify one or more symbols to be renamed by giving the fully qualified
name:
.. code-block:: console
$ clang-rename rename-all -old-name=foo -new-name=bar test.cpp
Alternatively, old name / new name pairs can be put into a YAML file:
.. code-block:: yaml
---
- OldName: foo
NewName: bar
...
That way you can avoid spelling out all the names as commandline arguments:
.. code-block:: console
$ clang-rename rename-all -input=test.yaml test.cpp
The YAML file also supports offsets:
.. code-block:: yaml
---
- Offset: 42
NewName: foo
...
:program:`clang-rename` offers the following options:
.. code-block:: console .. code-block:: console
$ clang-rename -help $ clang-rename -help
Usage: clang-rename {rename-at|rename-all} [OPTION]...
A tool to rename symbols in C/C++ code.
Subcommands:
rename-at: Perform rename off of a location in a file. (This is the default.)
rename-all: Perform rename of all symbols matching one or more fully qualified names.
.. code-block:: console
$ clang-rename rename-at -help
OVERVIEW: A tool to rename symbols in C/C++ code. OVERVIEW: A tool to rename symbols in C/C++ code.
clang-rename renames every occurrence of a symbol found at <offset> in clang-rename renames every occurrence of a symbol found at <offset> in
<source0>. If -i is specified, the edited files are overwritten to disk. <source0>. If -i is specified, the edited files are overwritten to disk.
Otherwise, the results are written to stdout. Otherwise, the results are written to stdout.
USAGE: clang-rename [subcommand] [options] <source0> [... <sourceN>] USAGE: clang-rename rename-at [subcommand] [options] <source0> [... <sourceN>]
OPTIONS: OPTIONS:
Clang-rename options: Generic Options:
-help - Display available options (-help-hidden for more)
-help-list - Display list of available options (-help-list-hidden for more)
-version - Display the version of this program
clang-rename rename-at options:
-export-fixes=<filename> - YAML file to store suggested fixes in. -export-fixes=<filename> - YAML file to store suggested fixes in.
-extra-arg=<string> - Additional argument to append to the compiler command line -extra-arg=<string> - Additional argument to append to the compiler command line
-extra-arg-before=<string> - Additional argument to prepend to the compiler command line -extra-arg-before=<string> - Additional argument to prepend to the compiler command line
-i - Overwrite edited <file>s. -i - Overwrite edited <file>s.
-new-name=<string> - The new name to change the symbol to. -new-name=<string> - The new name to change the symbol to.
-offset=<uint> - Locates the symbol by offset as opposed to <line>:<column>. -offset=<uint> - Locates the symbol by offset as opposed to <line>:<column>.
-old-name=<string> - The fully qualified name of the symbol, if -offset is not used.
-p=<string> - Build path -p=<string> - Build path
-pl - Print the locations affected by renaming to stderr. -pl - Print the locations affected by renaming to stderr.
-pn - Print the found symbol's name prior to renaming to stderr. -pn - Print the found symbol's name prior to renaming to stderr.
.. code-block:: console
$ clang-rename rename-all -help
OVERVIEW: A tool to rename symbols in C/C++ code.
clang-rename renames every occurrence of a symbol named <old-name>.
USAGE: clang-rename rename-all [subcommand] [options] <source0> [... <sourceN>]
OPTIONS:
Generic Options: Generic Options:
-help - Display available options (-help-hidden for more) -help - Display available options (-help-hidden for more)
-help-list - Display list of available options (-help-list-hidden for more) -help-list - Display list of available options (-help-list-hidden for more)
-version - Display the version of this program -version - Display the version of this program
clang-rename rename-all options:
-export-fixes=<filename> - YAML file to store suggested fixes in.
-extra-arg=<string> - Additional argument to append to the compiler command line
-extra-arg-before=<string> - Additional argument to prepend to the compiler command line
-i - Overwrite edited <file>s.
-input=<string> - YAML file to load oldname-newname pairs from.
-new-name=<string> - The new name to change the symbol to.
-offset=<uint> - Locates the symbol by offset as opposed to <line>:<column>.
-old-name=<string> - The fully qualified name of the symbol, if -offset is not used.
-p=<string> - Build path
clang-rename Vim integration Vim Integration
============================ ===============
You can call :program:`clang-rename` directly from Vim! To set up You can call :program:`clang-rename` directly from Vim! To set up
:program:`clang-rename` integration for Vim see :program:`clang-rename` integration for Vim see
`clang-rename/tool/clang-rename.py `clang-rename/tool/clang-rename.py
<http://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-rename/tool/clang-rename.py>`_. <http://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-rename/tool/clang-rename.py>`_.
Please note that **you have to save all buffers, in which the replacement will Please note that **you have to save all buffers, in which the replacement will
happen before running the tool**. happen before running the tool**.
Once installed, you can point your cursor to symbols you want to rename, press Once installed, you can point your cursor to symbols you want to rename, press
``<leader>cr`` and print new desired name. The `<leader>cr` and type new desired name. The `<leader> key
[``<leader> key``](http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_3)#Map_leader) <http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_3)#Map_leader>`_
is a reference to a specific key defined by the mapleader variable and is bound is a reference to a specific key defined by the mapleader variable and is bound
to backslash by default. to backslash by default.
Emacs Integration
=================
You can also use :program:`clang-rename` while using Emacs! To set up
:program:`clang-rename` integration for Emacs see
`clang-rename/tool/clang-rename.el
<http://reviews.llvm.org/diffusion/L/browse/clang-tools-extra/trunk/clang-rename/tool/clang-rename.el>`_.
Once installed, you can point your cursor to symbols you want to rename, press
`M-X`, type `clang-rename` and new desired name.
Please note that **you have to save all buffers, in which the replacement will
happen before running the tool**.

docs/clang-tidy/checks/cppcoreguidelines-slicing.rst

.. title:: clang-tidy - cppcoreguidelines-slicing .. title:: clang-tidy - cppcoreguidelines-slicing
cppcoreguidelines-slicing cppcoreguidelines-slicing
========================= =========================
Flags slicing of member variables or vtable. Slicing happens when copying a Flags slicing of member variables or vtable. Slicing happens when copying a
derived object into a base object: the members of the derived object (both derived object into a base object: the members of the derived object (both
member variables and virtual member functions) will be discarded. member variables and virtual member functions) will be discarded.
This can be misleading especially for member function slicing, for example: This can be misleading especially for member function slicing, for example:
.. code:: c++ .. code:: c++
struct B { int a; virtual int f(); }; struct B { int a; virtual int f(); };
struct D : B { int b; int f() override; }; struct D : B { int b; int f() override; };
void use(B b) { // Missing reference, intended ? void use(B b) { // Missing reference, intended ?
b.f(); // Calls B::f. b.f(); // Calls B::f.
} }
D d; D d;
use(d); // Slice. use(d); // Slice.
See the relevant CppCoreGuidelines sections for details: See the relevant CppCoreGuidelines sections for details:
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es63-dont-slice https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#es63-dont-slice
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c145-access-polymorphic-objects-through-pointers-and-references https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c145-access-polymorphic-objects-through-pointers-and-references

docs/clang-tidy/checks/cppcoreguidelines-special-member-functions.rst

  • This file was added.
.. title:: clang-tidy - cppcoreguidelines-special-member-functions
cppcoreguidelines-special-member-functions
==========================================
The check finds classes where some but not all of the special member functions
are defined.
By default the compiler defines a copy constructor, copy assignment operator,
move constructor, move assignment operator and destructor. The default can be
supressed by explicit user-definitions. The relationship between which
functions will be supressed by definitions of other functions is complicated
and it is advised that all five are defaulted or explicitly defined.
Note that defining a function with ``= delete`` is considered to be a
definition.
This rule is part of the "Constructors, assignments, and destructors" profile of the C++ Core
Guidelines, corresponding to rule C.21. See
https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c21-if-you-define-or-delete-any-default-operation-define-or-delete-them-all.

docs/clang-tidy/checks/list.rst

Show All 24 Lines.. toctree::
cppcoreguidelines-pro-type-const-cast cppcoreguidelines-pro-type-const-cast
cppcoreguidelines-pro-type-cstyle-cast cppcoreguidelines-pro-type-cstyle-cast
cppcoreguidelines-pro-type-member-init cppcoreguidelines-pro-type-member-init
cppcoreguidelines-pro-type-reinterpret-cast cppcoreguidelines-pro-type-reinterpret-cast
cppcoreguidelines-pro-type-static-cast-downcast cppcoreguidelines-pro-type-static-cast-downcast
cppcoreguidelines-pro-type-union-access cppcoreguidelines-pro-type-union-access
cppcoreguidelines-pro-type-vararg cppcoreguidelines-pro-type-vararg
cppcoreguidelines-slicing cppcoreguidelines-slicing
cppcoreguidelines-special-member-functions
google-build-explicit-make-pair google-build-explicit-make-pair
google-build-namespaces google-build-namespaces
google-build-using-namespace google-build-using-namespace
google-default-arguments google-default-arguments
google-explicit-constructor google-explicit-constructor
google-global-names-in-headers google-global-names-in-headers
google-readability-braces-around-statements (redirects to readability-braces-around-statements) <google-readability-braces-around-statements> google-readability-braces-around-statements (redirects to readability-braces-around-statements) <google-readability-braces-around-statements>
google-readability-casting google-readability-casting
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines.. toctree::
modernize-shrink-to-fit modernize-shrink-to-fit
modernize-use-auto modernize-use-auto
modernize-use-bool-literals modernize-use-bool-literals
modernize-use-default modernize-use-default
modernize-use-emplace modernize-use-emplace
modernize-use-nullptr modernize-use-nullptr
modernize-use-override modernize-use-override
modernize-use-using modernize-use-using
mpi-type-mismatch
performance-faster-string-find performance-faster-string-find
performance-for-range-copy performance-for-range-copy
performance-implicit-cast-in-loop performance-implicit-cast-in-loop
performance-inefficient-string-concatenation
performance-unnecessary-copy-initialization performance-unnecessary-copy-initialization
performance-unnecessary-value-param performance-unnecessary-value-param
readability-avoid-const-params-in-decls readability-avoid-const-params-in-decls
readability-braces-around-statements readability-braces-around-statements
readability-container-size-empty readability-container-size-empty
readability-deleted-default readability-deleted-default
readability-else-after-return readability-else-after-return
readability-function-size readability-function-size
Show All 11 Lines

docs/clang-tidy/checks/misc-argument-comment.rst

Show All 12 Lines.. code:: c++
void f(bool foo); void f(bool foo);
... ...
f(/*bar=*/true); f(/*bar=*/true);
// warning: argument name 'bar' in comment does not match parameter name 'foo' // warning: argument name 'bar' in comment does not match parameter name 'foo'
The check tries to detect typos and suggest automated fixes for them. The check tries to detect typos and suggest automated fixes for them.
Supported options:
- `StrictMode` (local or global): when non-zero, the check will ignore leading
and trailing underscores and case when comparing parameter names.

docs/clang-tidy/checks/modernize-use-bool-literals.rst

.. title:: clang-tidy - modernize-use-bool-literals .. title:: clang-tidy - modernize-use-bool-literals
modernize-use-bool-literals modernize-use-bool-literals
=========================== ===========================
Finds integer literals which are cast to ``bool``. Finds integer literals which are cast to ``bool``.
.. code-block:: c++ .. code-block:: c++
bool p = 1; bool p = 1;
bool f = static_cast<bool>(1); bool f = static_cast<bool>(1);
std::ios_base::sync_with_stdio(0); std::ios_base::sync_with_stdio(0);
bool x = p ? 1 : 0;
// transforms to // transforms to
bool p = true; bool p = true;
bool f = true; bool f = true;
std::ios_base::sync_with_stdio(false); std::ios_base::sync_with_stdio(false);
bool x = p ? true : false;

docs/clang-tidy/checks/modernize-use-emplace.rst

Show All 14 Lines
By default only ``std::vector``, ``std::deque``, ``std::list`` are considered. By default only ``std::vector``, ``std::deque``, ``std::list`` are considered.
This list can be modified by passing a semicolon-separated list of class names This list can be modified by passing a semicolon-separated list of class names
using the `ContainersWithPushBack` option. using the `ContainersWithPushBack` option.
Before: Before:
.. code:: c++ .. code:: c++
std::vector<MyClass> v; std::vector<MyClass> v;
v.push_back(MyClass(21, 37)); v.push_back(MyClass(21, 37));
std::vector<std::pair<int,int>> w; std::vector<std::pair<int,int>> w;
w.push_back(std::pair<int,int>(21, 37)); w.push_back(std::pair<int,int>(21, 37));
w.push_back(std::make_pair(21L, 37L)); w.push_back(std::make_pair(21L, 37L));
After: After:
.. code:: c++ .. code:: c++
std::vector<MyClass> v; std::vector<MyClass> v;
v.emplace_back(21, 37); v.emplace_back(21, 37);
std::vector<std::pair<int,int>> w; std::vector<std::pair<int,int>> w;
w.emplace_back(21, 37); w.emplace_back(21, 37);
// This will be fixed to w.push_back(21, 37); in next version // This will be fixed to w.push_back(21, 37); in next version
w.emplace_back(std::make_pair(21L, 37L); w.emplace_back(std::make_pair(21L, 37L);
The other situation is when we pass arguments that will be converted to a type The other situation is when we pass arguments that will be converted to a type
inside a container. inside a container.
Before: Before:
.. code:: c++ .. code:: c++
std::vector<boost::optional<std::string> > v; std::vector<boost::optional<std::string> > v;
v.push_back("abc"); v.push_back("abc");
After: After:
.. code:: c++ .. code:: c++
std::vector<boost::optional<std::string> > v; std::vector<boost::optional<std::string> > v;
v.emplace_back("abc"); v.emplace_back("abc");
In some cases the transformation would be valid, but the code In some cases the transformation would be valid, but the code
wouldn't be exception safe. wouldn't be exception safe.
In this case the calls of ``push_back`` won't be replaced. In this case the calls of ``push_back`` won't be replaced.
.. code:: c++ .. code:: c++
std::vector<std::unique_ptr<int>> v; std::vector<std::unique_ptr<int>> v;
v.push_back(std::unique_ptr<int>(new int(0))); v.push_back(std::unique_ptr<int>(new int(0)));
auto *ptr = new int(1); auto *ptr = new int(1);
v.push_back(std::unique_ptr<int>(ptr)); v.push_back(std::unique_ptr<int>(ptr));
This is because replacing it with ``emplace_back`` could cause a leak of this This is because replacing it with ``emplace_back`` could cause a leak of this
pointer if ``emplace_back`` would throw exception before emplacement pointer if ``emplace_back`` would throw exception before emplacement
(e.g. not enough memory to add new element). (e.g. not enough memory to add new element).
For more info read item 42 - "Consider emplacement instead of insertion." For more info read item 42 - "Consider emplacement instead of insertion."
of Scott Meyers Effective Modern C++. of Scott Meyers Effective Modern C++.
Show All 12 Lines

docs/clang-tidy/checks/mpi-type-mismatch.rst

  • This file was added.
.. title:: clang-tidy - mpi-type-mismatch
mpi-type-mismatch
=================
This check verifies if buffer type and MPI (Message Passing Interface) datatype
pairs match for used MPI functions. All MPI datatypes defined by the MPI
standard (3.1) are verified by this check. User defined typedefs, custom MPI
datatypes and null pointer constants are skipped, in the course of verification.
Example:
.. code:: c++
// In this case, the buffer type matches MPI datatype.
char buf;
MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// In the following case, the buffer type does not match MPI datatype.
int buf;
MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);

docs/clang-tidy/checks/performance-inefficient-string-concatenation.rst

  • This file was added.
.. title:: clang-tidy - performance-inefficient-string-concatenation
performance-inefficient-string-concatenation
============================================
This check warns about the performance overhead arising from concatenating strings using the ``operator+``, for instance:
.. code:: c++
std::string a("Foo"), b("Bar");
a = a + b;
Instead of this structure you should use ``operator+=`` or ``std::string``'s (``std::basic_string``) class member function ``append()``. For instance:
.. code:: c++
std::string a("Foo"), b("Baz");
for (int i = 0; i < 20000; ++i) {
a = a + "Bar" + b;
}
Could be rewritten in a greatly more efficient way like:
.. code:: c++
std::string a("Foo"), b("Baz");
for (int i = 0; i < 20000; ++i) {
a.append("Bar").append(b);
}
And this can be rewritten too:
.. code:: c++
void f(const std::string&) {}
std::string a("Foo"), b("Baz");
void g() {
f(a + "Bar" + b);
}
In a slightly more efficient way like:
.. code:: c++
void f(const std::string&) {}
std::string a("Foo"), b("Baz");
void g() {
f(std::string(a).append("Bar").append(b));
}

docs/clang-tidy/index.rst

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Lines
``-checks=`` option. However, the ``-checks=`` option does not affect ``-checks=`` option. However, the ``-checks=`` option does not affect
compilation arguments, so it can not turn on Clang warnings which are not compilation arguments, so it can not turn on Clang warnings which are not
already turned on in build configuration. The ``-warnings-as-errors=`` option already turned on in build configuration. The ``-warnings-as-errors=`` option
upgrades any warnings emitted under the ``-checks=`` flag to errors (but it upgrades any warnings emitted under the ``-checks=`` flag to errors (but it
does not enable any checks itself). does not enable any checks itself).
Clang diagnostics have check names starting with ``clang-diagnostic-``. Clang diagnostics have check names starting with ``clang-diagnostic-``.
Diagnostics which have a corresponding warning option, are named Diagnostics which have a corresponding warning option, are named
``clang-diagostic-<warning-option>``, e.g. Clang warning controlled by ``clang-diagnostic-<warning-option>``, e.g. Clang warning controlled by
``-Wliteral-conversion`` will be reported with check name ``-Wliteral-conversion`` will be reported with check name
``clang-diagnostic-literal-conversion``. ``clang-diagnostic-literal-conversion``.
The ``-fix`` flag instructs :program:`clang-tidy` to fix found errors if The ``-fix`` flag instructs :program:`clang-tidy` to fix found errors if
supported by corresponding checks. supported by corresponding checks.
An overview of all the command-line options: An overview of all the command-line options:
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines -dump-config -
printed. printed.
Use along with -checks=* to include Use along with -checks=* to include
configuration of all checks. configuration of all checks.
-enable-check-profile - -enable-check-profile -
Enable per-check timing profiles, and print a Enable per-check timing profiles, and print a
report to stderr. report to stderr.
-export-fixes=<filename> - -export-fixes=<filename> -
YAML file to store suggested fixes in. The YAML file to store suggested fixes in. The
stored fixes can be applied to the input sorce stored fixes can be applied to the input source
code with clang-apply-replacements. code with clang-apply-replacements.
-extra-arg=<string> - Additional argument to append to the compiler command line -extra-arg=<string> - Additional argument to append to the compiler command line
-extra-arg-before=<string> - Additional argument to prepend to the compiler command line -extra-arg-before=<string> - Additional argument to prepend to the compiler command line
-fix - -fix -
Apply suggested fixes. Without -fix-errors Apply suggested fixes. Without -fix-errors
clang-tidy will bail out if any compilation clang-tidy will bail out if any compilation
errors were found. errors were found.
-fix-errors - -fix-errors -
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
The interface provided by clang-tidy makes it easy to write useful and precise The interface provided by clang-tidy makes it easy to write useful and precise
checks in just a few lines of code. If you have an idea for a good check, the checks in just a few lines of code. If you have an idea for a good check, the
rest of this document explains how to do this. rest of this document explains how to do this.
There are a few tools particularly useful when developing clang-tidy checks: There are a few tools particularly useful when developing clang-tidy checks:
* ``add_new_check.py`` is a script to automate the process of adding a new * ``add_new_check.py`` is a script to automate the process of adding a new
check, it will create the check, update the CMake file and create a test; check, it will create the check, update the CMake file and create a test;
* ``rename_check.py`` does what the script name suggest, renames an existsing * ``rename_check.py`` does what the script name suggest, renames an existing
check; check;
* :program:`clang-query` is invaluable for interactive prototyping of AST * :program:`clang-query` is invaluable for interactive prototyping of AST
matchers and exploration of the Clang AST; matchers and exploration of the Clang AST;
* `clang-check`_ with the ``-ast-dump`` (and optionally ``-ast-dump-filter``) * `clang-check`_ with the ``-ast-dump`` (and optionally ``-ast-dump-filter``)
provides a convenient way to dump AST of a C++ program. provides a convenient way to dump AST of a C++ program.
.. _AST Matchers: http://clang.llvm.org/docs/LibASTMatchers.html .. _AST Matchers: http://clang.llvm.org/docs/LibASTMatchers.html
▲ Show 20 Lines • Show All 299 Lines • ▼ Show 20 Lines.. code-block:: bash
void f(int a) { void f(int a) {
int b = (int)a; int b = (int)a;
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant cast to the same type [google-readability-casting] // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: redundant cast to the same type [google-readability-casting]
// CHECK-FIXES: int b = a; // CHECK-FIXES: int b = a;
} }
There are many dark corners in the C++ language, and it may be difficult to make There are many dark corners in the C++ language, and it may be difficult to make
your check work perfectly in all cases, especially if it issues fixit hints. The your check work perfectly in all cases, especially if it issues fix-it hints. The
most frequent pitfalls are macros and templates: most frequent pitfalls are macros and templates:
1. code written in a macro body/template definition may have a different meaning 1. code written in a macro body/template definition may have a different meaning
depending on the macro expansion/template instantiation; depending on the macro expansion/template instantiation;
2. multiple macro expansions/template instantiations may result in the same code 2. multiple macro expansions/template instantiations may result in the same code
being inspected by the check multiple times (possibly, with different being inspected by the check multiple times (possibly, with different
meanings, see 1), and the same warning (or a slightly different one) may be meanings, see 1), and the same warning (or a slightly different one) may be
issued by the check multipe times; clang-tidy will deduplicate _identical_ issued by the check multiple times; clang-tidy will deduplicate _identical_
warnings, but if the warnings are slightly different, all of them will be warnings, but if the warnings are slightly different, all of them will be
shown to the user (and used for applying fixes, if any); shown to the user (and used for applying fixes, if any);
3. making replacements to a macro body/template definition may be fine for some 3. making replacements to a macro body/template definition may be fine for some
macro expansions/template instantiations, but easily break some other macro expansions/template instantiations, but easily break some other
expansions/instantiations. expansions/instantiations.
.. _lit: http://llvm.org/docs/CommandGuide/lit.html .. _lit: http://llvm.org/docs/CommandGuide/lit.html
.. _FileCheck: http://llvm.org/docs/CommandGuide/FileCheck.html .. _FileCheck: http://llvm.org/docs/CommandGuide/FileCheck.html
Show All 33 Lines

docs/include-fixer.rst

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
To run `clang-include-fixer` on a potentially unsaved buffer in Vim. Add the To run `clang-include-fixer` on a potentially unsaved buffer in Vim. Add the
following key binding to your ``.vimrc``: following key binding to your ``.vimrc``:
.. code-block:: console .. code-block:: console
noremap <leader>cf :pyf path/to/llvm/source/tools/clang/tools/extra/include-fixer/tool/clang-include-fixer.py<cr> noremap <leader>cf :pyf path/to/llvm/source/tools/clang/tools/extra/include-fixer/tool/clang-include-fixer.py<cr>
This enables `clang-include-fixer` for NORMAL and VISUAL mode. Change This enables `clang-include-fixer` for NORMAL and VISUAL mode. Change
``<leader>cf`` to another binding if you need clang-include-fixer on a different `<leader>cf` to another binding if you need clang-include-fixer on a different
key. The key. The `<leader> key
[``<leader> key``](http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_3)#Map_leader) <http://vim.wikia.com/wiki/Mapping_keys_in_Vim_-_Tutorial_(Part_3)#Map_leader>`_
is a reference to a specific key defined by the mapleader variable and is bound is a reference to a specific key defined by the mapleader variable and is bound
to backslash by default. to backslash by default.
Make sure vim can find :program:`clang-include-fixer`: Make sure vim can find :program:`clang-include-fixer`:
- Add the path to :program:`clang-include-fixer` to the PATH environment variable. - Add the path to :program:`clang-include-fixer` to the PATH environment variable.
- Or set ``g:clang_include_fixer_path`` in vimrc: ``let g:clang_include_fixer_path=path/to/clang-include-fixer`` - Or set ``g:clang_include_fixer_path`` in vimrc: ``let g:clang_include_fixer_path=path/to/clang-include-fixer``
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

include-fixer/IncludeFixer.h

Show All 24 Lines
class FileManager; class FileManager;
class PCHContainerOperations; class PCHContainerOperations;
namespace include_fixer { namespace include_fixer {
class IncludeFixerActionFactory : public clang::tooling::ToolAction { class IncludeFixerActionFactory : public clang::tooling::ToolAction {
public: public:
/// \param SymbolIndexMgr A source for matching symbols to header files. /// \param SymbolIndexMgr A source for matching symbols to header files.
/// \param Context A context for the symbol being queried. /// \param Contexts The contexts for the symbols being queried.
/// \param StyleName Fallback style for reformatting. /// \param StyleName Fallback style for reformatting.
/// \param MinimizeIncludePaths whether inserted include paths are optimized. /// \param MinimizeIncludePaths whether inserted include paths are optimized.
IncludeFixerActionFactory(SymbolIndexManager &SymbolIndexMgr, IncludeFixerActionFactory(SymbolIndexManager &SymbolIndexMgr,
IncludeFixerContext &Context, StringRef StyleName, std::vector<IncludeFixerContext> &Contexts,
StringRef StyleName,
bool MinimizeIncludePaths = true); bool MinimizeIncludePaths = true);
~IncludeFixerActionFactory() override; ~IncludeFixerActionFactory() override;
bool bool
runInvocation(clang::CompilerInvocation *Invocation, runInvocation(clang::CompilerInvocation *Invocation,
clang::FileManager *Files, clang::FileManager *Files,
std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps, std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
clang::DiagnosticConsumer *Diagnostics) override; clang::DiagnosticConsumer *Diagnostics) override;
private: private:
/// The client to use to find cross-references. /// The client to use to find cross-references.
SymbolIndexManager &SymbolIndexMgr; SymbolIndexManager &SymbolIndexMgr;
/// The context that contains all information about the symbol being queried. /// Multiple contexts for files being processed.
IncludeFixerContext &Context; std::vector<IncludeFixerContext> &Contexts;
/// Whether inserted include paths should be optimized. /// Whether inserted include paths should be optimized.
bool MinimizeIncludePaths; bool MinimizeIncludePaths;
/// The fallback format style for formatting after insertion if no /// The fallback format style for formatting after insertion if no
/// clang-format config file was found. /// clang-format config file was found.
std::string FallbackStyle; std::string FallbackStyle;
}; };
/// Create replacements, which are generated by clang-format, for the /// Create replacements, which are generated by clang-format, for the
/// missing header and mising qualifiers insertions. The function uses the /// missing header and mising qualifiers insertions. The function uses the
/// first header for insertion. /// first header for insertion.
/// ///
/// \param Code The source code. /// \param Code The source code.
/// \param FilePath The source file path.
/// \param Context The context which contains all information for creating /// \param Context The context which contains all information for creating
/// include-fixer replacements. /// include-fixer replacements.
/// \param Style clang-format style being used. /// \param Style clang-format style being used.
/// \param AddQualifiers Whether we should add qualifiers to all instances of /// \param AddQualifiers Whether we should add qualifiers to all instances of
/// an unidentified symbol. /// an unidentified symbol.
/// ///
/// \return Formatted replacements for inserting, sorting headers and adding /// \return Formatted replacements for inserting, sorting headers and adding
/// qualifiers on success; otherwise, an llvm::Error carrying llvm::StringError /// qualifiers on success; otherwise, an llvm::Error carrying llvm::StringError
/// is returned. /// is returned.
llvm::Expected<tooling::Replacements> createIncludeFixerReplacements( llvm::Expected<tooling::Replacements> createIncludeFixerReplacements(
StringRef Code, StringRef FilePath, const IncludeFixerContext &Context, StringRef Code, const IncludeFixerContext &Context,
const format::FormatStyle &Style = format::getLLVMStyle(), const format::FormatStyle &Style = format::getLLVMStyle(),
bool AddQualifiers = true); bool AddQualifiers = true);
} // namespace include_fixer } // namespace include_fixer
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H

include-fixer/IncludeFixer.cpp

Show All 31 Lines
public: public:
explicit Action(SymbolIndexManager &SymbolIndexMgr, bool MinimizeIncludePaths) explicit Action(SymbolIndexManager &SymbolIndexMgr, bool MinimizeIncludePaths)
: SymbolIndexMgr(SymbolIndexMgr), : SymbolIndexMgr(SymbolIndexMgr),
MinimizeIncludePaths(MinimizeIncludePaths) {} MinimizeIncludePaths(MinimizeIncludePaths) {}
std::unique_ptr<clang::ASTConsumer> std::unique_ptr<clang::ASTConsumer>
CreateASTConsumer(clang::CompilerInstance &Compiler, CreateASTConsumer(clang::CompilerInstance &Compiler,
StringRef InFile) override { StringRef InFile) override {
FilePath = InFile;
return llvm::make_unique<clang::ASTConsumer>(); return llvm::make_unique<clang::ASTConsumer>();
} }
void ExecuteAction() override { void ExecuteAction() override {
clang::CompilerInstance *Compiler = &getCompilerInstance(); clang::CompilerInstance *Compiler = &getCompilerInstance();
assert(!Compiler->hasSema() && "CI already has Sema"); assert(!Compiler->hasSema() && "CI already has Sema");
// Set up our hooks into sema and parse the AST. // Set up our hooks into sema and parse the AST.
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines for (const auto &Symbol : MatchedSymbols) {
((FilePath[0] == '"' || FilePath[0] == '<') ? FilePath ((FilePath[0] == '"' || FilePath[0] == '<') ? FilePath
: "\"" + FilePath + "\""), : "\"" + FilePath + "\""),
SourceManager, HeaderSearch); SourceManager, HeaderSearch);
SymbolCandidates.emplace_back(Symbol.getName(), Symbol.getSymbolKind(), SymbolCandidates.emplace_back(Symbol.getName(), Symbol.getSymbolKind(),
MinimizedFilePath, Symbol.getLineNumber(), MinimizedFilePath, Symbol.getLineNumber(),
Symbol.getContexts(), Symbol.getContexts(),
Symbol.getNumOccurrences()); Symbol.getNumOccurrences());
} }
return IncludeFixerContext(QuerySymbolInfos, SymbolCandidates); return IncludeFixerContext(FilePath, QuerySymbolInfos, SymbolCandidates);
} }
private: private:
/// Query the database for a given identifier. /// Query the database for a given identifier.
bool query(StringRef Query, StringRef ScopedQualifiers, bool query(StringRef Query, StringRef ScopedQualifiers,
tooling::Range Range) { tooling::Range Range) {
assert(!Query.empty() && "Empty query!"); assert(!Query.empty() && "Empty query!");
Show All 30 Lines bool query(StringRef Query, StringRef ScopedQualifiers,
// //
// namespace a { // namespace a {
// b::foo f; // b::foo f;
// } // }
// //
// 1. lookup a::b::foo. // 1. lookup a::b::foo.
// 2. lookup b::foo. // 2. lookup b::foo.
std::string QueryString = ScopedQualifiers.str() + Query.str(); std::string QueryString = ScopedQualifiers.str() + Query.str();
MatchedSymbols = SymbolIndexMgr.search(QueryString); // It's unsafe to do nested search for the identifier with scoped namespace
if (MatchedSymbols.empty() && !ScopedQualifiers.empty()) // context, it might treat the identifier as a nested class of the scoped
// namespace.
MatchedSymbols = SymbolIndexMgr.search(QueryString, /*IsNestedSearch=*/false);
if (MatchedSymbols.empty())
MatchedSymbols = SymbolIndexMgr.search(Query); MatchedSymbols = SymbolIndexMgr.search(Query);
DEBUG(llvm::dbgs() << "Having found " << MatchedSymbols.size() DEBUG(llvm::dbgs() << "Having found " << MatchedSymbols.size()
<< " symbols\n"); << " symbols\n");
return !MatchedSymbols.empty(); return !MatchedSymbols.empty();
} }
/// The client to use to find cross-references. /// The client to use to find cross-references.
SymbolIndexManager &SymbolIndexMgr; SymbolIndexManager &SymbolIndexMgr;
/// The information of the symbols being queried. /// The information of the symbols being queried.
std::vector<IncludeFixerContext::QuerySymbolInfo> QuerySymbolInfos; std::vector<IncludeFixerContext::QuerySymbolInfo> QuerySymbolInfos;
/// All symbol candidates which match QuerySymbol. We only include the first /// All symbol candidates which match QuerySymbol. We only include the first
/// discovered identifier to avoid getting caught in results from error /// discovered identifier to avoid getting caught in results from error
/// recovery. /// recovery.
std::vector<find_all_symbols::SymbolInfo> MatchedSymbols; std::vector<find_all_symbols::SymbolInfo> MatchedSymbols;
/// The file path to the file being processed.
std::string FilePath;
/// Whether we should use the smallest possible include path. /// Whether we should use the smallest possible include path.
bool MinimizeIncludePaths = true; bool MinimizeIncludePaths = true;
}; };
} // namespace } // namespace
IncludeFixerActionFactory::IncludeFixerActionFactory( IncludeFixerActionFactory::IncludeFixerActionFactory(
SymbolIndexManager &SymbolIndexMgr, IncludeFixerContext &Context, SymbolIndexManager &SymbolIndexMgr,
StringRef StyleName, bool MinimizeIncludePaths) std::vector<IncludeFixerContext> &Contexts, StringRef StyleName,
: SymbolIndexMgr(SymbolIndexMgr), Context(Context), bool MinimizeIncludePaths)
: SymbolIndexMgr(SymbolIndexMgr), Contexts(Contexts),
MinimizeIncludePaths(MinimizeIncludePaths) {} MinimizeIncludePaths(MinimizeIncludePaths) {}
IncludeFixerActionFactory::~IncludeFixerActionFactory() = default; IncludeFixerActionFactory::~IncludeFixerActionFactory() = default;
bool IncludeFixerActionFactory::runInvocation( bool IncludeFixerActionFactory::runInvocation(
clang::CompilerInvocation *Invocation, clang::FileManager *Files, clang::CompilerInvocation *Invocation, clang::FileManager *Files,
std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps, std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
clang::DiagnosticConsumer *Diagnostics) { clang::DiagnosticConsumer *Diagnostics) {
Show All 14 Linesbool IncludeFixerActionFactory::runInvocation(
// fatal. A missing #include can cause thousands of errors. // fatal. A missing #include can cause thousands of errors.
Compiler.getDiagnostics().setErrorLimit(0); Compiler.getDiagnostics().setErrorLimit(0);
// Run the parser, gather missing includes. // Run the parser, gather missing includes.
auto ScopedToolAction = auto ScopedToolAction =
llvm::make_unique<Action>(SymbolIndexMgr, MinimizeIncludePaths); llvm::make_unique<Action>(SymbolIndexMgr, MinimizeIncludePaths);
Compiler.ExecuteAction(*ScopedToolAction); Compiler.ExecuteAction(*ScopedToolAction);
Context = ScopedToolAction->getIncludeFixerContext( Contexts.push_back(ScopedToolAction->getIncludeFixerContext(
Compiler.getSourceManager(), Compiler.getSourceManager(),
Compiler.getPreprocessor().getHeaderSearchInfo()); Compiler.getPreprocessor().getHeaderSearchInfo()));
// Technically this should only return true if we're sure that we have a // Technically this should only return true if we're sure that we have a
// parseable file. We don't know that though. Only inform users of fatal // parseable file. We don't know that though. Only inform users of fatal
// errors. // errors.
return !Compiler.getDiagnostics().hasFatalErrorOccurred(); return !Compiler.getDiagnostics().hasFatalErrorOccurred();
} }
llvm::Expected<tooling::Replacements> createIncludeFixerReplacements( llvm::Expected<tooling::Replacements> createIncludeFixerReplacements(
StringRef Code, StringRef FilePath, const IncludeFixerContext &Context, StringRef Code, const IncludeFixerContext &Context,
const clang::format::FormatStyle &Style, bool AddQualifiers) { const clang::format::FormatStyle &Style, bool AddQualifiers) {
if (Context.getHeaderInfos().empty()) if (Context.getHeaderInfos().empty())
return tooling::Replacements(); return tooling::Replacements();
StringRef FilePath = Context.getFilePath();
std::string IncludeName = std::string IncludeName =
"#include " + Context.getHeaderInfos().front().Header + "\n"; "#include " + Context.getHeaderInfos().front().Header + "\n";
// Create replacements for the new header. // Create replacements for the new header.
clang::tooling::Replacements Insertions = { clang::tooling::Replacements Insertions;
tooling::Replacement(FilePath, UINT_MAX, 0, IncludeName)}; auto Err =
Insertions.add(tooling::Replacement(FilePath, UINT_MAX, 0, IncludeName));
if (Err)
return std::move(Err);
auto CleanReplaces = cleanupAroundReplacements(Code, Insertions, Style); auto CleanReplaces = cleanupAroundReplacements(Code, Insertions, Style);
if (!CleanReplaces) if (!CleanReplaces)
return CleanReplaces; return CleanReplaces;
auto Replaces = std::move(*CleanReplaces);
if (AddQualifiers) { if (AddQualifiers) {
for (const auto &Info : Context.getQuerySymbolInfos()) { for (const auto &Info : Context.getQuerySymbolInfos()) {
// Ignore the empty range. // Ignore the empty range.
if (Info.Range.getLength() > 0) if (Info.Range.getLength() > 0) {
CleanReplaces->insert({FilePath, Info.Range.getOffset(), auto R = tooling::Replacement(
Info.Range.getLength(), {FilePath, Info.Range.getOffset(), Info.Range.getLength(),
Context.getHeaderInfos().front().QualifiedName}); Context.getHeaderInfos().front().QualifiedName});
auto Err = Replaces.add(R);
if (Err) {
llvm::consumeError(std::move(Err));
R = tooling::Replacement(
R.getFilePath(), Replaces.getShiftedCodePosition(R.getOffset()),
R.getLength(), R.getReplacementText());
Replaces = Replaces.merge(tooling::Replacements(R));
}
}
} }
} }
return formatReplacements(Code, *CleanReplaces, Style); return formatReplacements(Code, Replaces, Style);
} }
} // namespace include_fixer } // namespace include_fixer
} // namespace clang } // namespace clang

include-fixer/IncludeFixerContext.h

Show All 12 Lines
#include "find-all-symbols/SymbolInfo.h" #include "find-all-symbols/SymbolInfo.h"
#include "clang/Tooling/Core/Replacement.h" #include "clang/Tooling/Core/Replacement.h"
#include <string> #include <string>
#include <vector> #include <vector>
namespace clang { namespace clang {
namespace include_fixer { namespace include_fixer {
/// \brief A context for the symbol being queried. /// \brief A context for a file being processed. It includes all query
/// information, e.g. symbols being queried in database, all header candidates.
class IncludeFixerContext { class IncludeFixerContext {
public: public:
struct HeaderInfo { struct HeaderInfo {
/// \brief The header where QualifiedName comes from. /// \brief The header where QualifiedName comes from.
std::string Header; std::string Header;
/// \brief A symbol name with completed namespace qualifiers which will /// \brief A symbol name with completed namespace qualifiers which will
/// replace the original symbol. /// replace the original symbol.
std::string QualifiedName; std::string QualifiedName;
Show All 11 Lines struct QuerySymbolInfo {
/// Empty if SymbolIdentifier is not in a specific scope. /// Empty if SymbolIdentifier is not in a specific scope.
std::string ScopedQualifiers; std::string ScopedQualifiers;
/// \brief The replacement range of RawIdentifier. /// \brief The replacement range of RawIdentifier.
tooling::Range Range; tooling::Range Range;
}; };
IncludeFixerContext() = default; IncludeFixerContext() = default;
IncludeFixerContext(std::vector<QuerySymbolInfo> QuerySymbols, IncludeFixerContext(StringRef FilePath,
std::vector<QuerySymbolInfo> QuerySymbols,
std::vector<find_all_symbols::SymbolInfo> Symbols); std::vector<find_all_symbols::SymbolInfo> Symbols);
/// \brief Get symbol name. /// \brief Get symbol name.
llvm::StringRef getSymbolIdentifier() const { llvm::StringRef getSymbolIdentifier() const {
return QuerySymbolInfos.front().RawIdentifier; return QuerySymbolInfos.front().RawIdentifier;
} }
/// \brief Get replacement range of the symbol. /// \brief Get replacement range of the symbol.
tooling::Range getSymbolRange() const { tooling::Range getSymbolRange() const {
return QuerySymbolInfos.front().Range; return QuerySymbolInfos.front().Range;
} }
/// \brief Get the file path to the file being processed.
StringRef getFilePath() const { return FilePath; }
/// \brief Get header information. /// \brief Get header information.
const std::vector<HeaderInfo> &getHeaderInfos() const { return HeaderInfos; } const std::vector<HeaderInfo> &getHeaderInfos() const { return HeaderInfos; }
/// \brief Get information of symbols being querid. /// \brief Get information of symbols being querid.
const std::vector<QuerySymbolInfo> &getQuerySymbolInfos() const { const std::vector<QuerySymbolInfo> &getQuerySymbolInfos() const {
return QuerySymbolInfos; return QuerySymbolInfos;
} }
private: private:
friend struct llvm::yaml::MappingTraits<IncludeFixerContext>; friend struct llvm::yaml::MappingTraits<IncludeFixerContext>;
/// \brief The file path to the file being processed.
std::string FilePath;
/// \brief All instances of an unidentified symbol being queried. /// \brief All instances of an unidentified symbol being queried.
std::vector<QuerySymbolInfo> QuerySymbolInfos; std::vector<QuerySymbolInfo> QuerySymbolInfos;
/// \brief The symbol candidates which match SymbolIdentifier. The symbols are /// \brief The symbol candidates which match SymbolIdentifier. The symbols are
/// sorted in a descending order based on the popularity info in SymbolInfo. /// sorted in a descending order based on the popularity info in SymbolInfo.
std::vector<find_all_symbols::SymbolInfo> MatchedSymbols; std::vector<find_all_symbols::SymbolInfo> MatchedSymbols;
/// \brief The header information. /// \brief The header information.
std::vector<HeaderInfo> HeaderInfos; std::vector<HeaderInfo> HeaderInfos;
}; };
} // namespace include_fixer } // namespace include_fixer
} // namespace clang } // namespace clang
#endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXERCONTEXT_H #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXERCONTEXT_H

include-fixer/IncludeFixerContext.cpp

Show All 38 Linesstd::string createQualifiedNameForReplacement(
// we strip qualifiers from the end until we find a result. So append the // we strip qualifiers from the end until we find a result. So append the
// missing stripped qualifiers here. // missing stripped qualifiers here.
// //
// Get stripped qualifiers. // Get stripped qualifiers.
auto SymbolQualifiers = SplitQualifiers(RawSymbolName); auto SymbolQualifiers = SplitQualifiers(RawSymbolName);
std::string StrippedQualifiers; std::string StrippedQualifiers;
while (!SymbolQualifiers.empty() && while (!SymbolQualifiers.empty() &&
!llvm::StringRef(QualifiedName).endswith(SymbolQualifiers.back())) { !llvm::StringRef(QualifiedName).endswith(SymbolQualifiers.back())) {
StrippedQualifiers = "::" + SymbolQualifiers.back().str(); StrippedQualifiers =
"::" + SymbolQualifiers.back().str() + StrippedQualifiers;
SymbolQualifiers.pop_back(); SymbolQualifiers.pop_back();
} }
// Append the missing stripped qualifiers. // Append the missing stripped qualifiers.
std::string FullyQualifiedName = QualifiedName + StrippedQualifiers; std::string FullyQualifiedName = QualifiedName + StrippedQualifiers;
// Try to find and skip the common prefix qualifiers. // Try to find and skip the common prefix qualifiers.
auto FullySymbolQualifiers = SplitQualifiers(FullyQualifiedName); auto FullySymbolQualifiers = SplitQualifiers(FullyQualifiedName);
auto ScopedQualifiers = SplitQualifiers(SymbolScopedQualifiersName); auto ScopedQualifiers = SplitQualifiers(SymbolScopedQualifiersName);
Show All 14 Lines for (; FullySymbolQualifiersIter != FullySymbolQualifiers.end();
Result += *FullySymbolQualifiersIter; Result += *FullySymbolQualifiersIter;
} }
return Result; return Result;
} }
} // anonymous namespace } // anonymous namespace
IncludeFixerContext::IncludeFixerContext( IncludeFixerContext::IncludeFixerContext(
std::vector<QuerySymbolInfo> QuerySymbols, StringRef FilePath, std::vector<QuerySymbolInfo> QuerySymbols,
std::vector<find_all_symbols::SymbolInfo> Symbols) std::vector<find_all_symbols::SymbolInfo> Symbols)
: QuerySymbolInfos(std::move(QuerySymbols)), : FilePath(FilePath), QuerySymbolInfos(std::move(QuerySymbols)),
MatchedSymbols(std::move(Symbols)) { MatchedSymbols(std::move(Symbols)) {
// Remove replicated QuerySymbolInfos with the same range. // Remove replicated QuerySymbolInfos with the same range.
// //
// QuerySymbolInfos may contain replicated elements. Because CorrectTypo // QuerySymbolInfos may contain replicated elements. Because CorrectTypo
// callback doesn't always work as we expected. In somecases, it will be // callback doesn't always work as we expected. In somecases, it will be
// triggered at the same position or unidentified symbol multiple times. // triggered at the same position or unidentified symbol multiple times.
std::sort(QuerySymbolInfos.begin(), QuerySymbolInfos.end(), std::sort(QuerySymbolInfos.begin(), QuerySymbolInfos.end(),
[&](const QuerySymbolInfo &A, const QuerySymbolInfo &B) { [&](const QuerySymbolInfo &A, const QuerySymbolInfo &B) {
Show All 27 Lines

include-fixer/SymbolIndexManager.h

Show All 22 Lines
public: public:
void addSymbolIndex(std::unique_ptr<SymbolIndex> DB) { void addSymbolIndex(std::unique_ptr<SymbolIndex> DB) {
SymbolIndices.push_back(std::move(DB)); SymbolIndices.push_back(std::move(DB));
} }
/// Search for header files to be included for an identifier. /// Search for header files to be included for an identifier.
/// \param Identifier The identifier being searched for. May or may not be /// \param Identifier The identifier being searched for. May or may not be
/// fully qualified. /// fully qualified.
/// \returns A list of inclusion candidates, in a format ready for being /// \param IsNestedSearch Whether searching nested classes. If true, the
/// pasted after an #include token. /// method tries to strip identifier name parts from the end until it
// FIXME: Move mapping from SymbolInfo to headers out of /// finds the corresponding candidates in database (e.g for identifier
// SymbolIndexManager::search and return SymbolInfos instead of header paths. /// "b::foo", the method will try to find "b" if it fails to find
/// "b::foo").
///
/// \returns A list of symbol candidates.
std::vector<find_all_symbols::SymbolInfo> std::vector<find_all_symbols::SymbolInfo>
search(llvm::StringRef Identifier) const; search(llvm::StringRef Identifier, bool IsNestedSearch = true) const;
private: private:
std::vector<std::unique_ptr<SymbolIndex>> SymbolIndices; std::vector<std::unique_ptr<SymbolIndex>> SymbolIndices;
}; };
} // namespace include_fixer } // namespace include_fixer
} // namespace clang } // namespace clang
#endif #endif

include-fixer/SymbolIndexManager.cpp

Show All 36 Lines std::sort(Symbols.begin(), Symbols.end(),
auto BPop = HeaderPopularity[B.getFilePath()]; auto BPop = HeaderPopularity[B.getFilePath()];
if (APop != BPop) if (APop != BPop)
return APop > BPop; return APop > BPop;
return A.getFilePath() < B.getFilePath(); return A.getFilePath() < B.getFilePath();
}); });
} }
std::vector<find_all_symbols::SymbolInfo> std::vector<find_all_symbols::SymbolInfo>
SymbolIndexManager::search(llvm::StringRef Identifier) const { SymbolIndexManager::search(llvm::StringRef Identifier,
bool IsNestedSearch) const {
// The identifier may be fully qualified, so split it and get all the context // The identifier may be fully qualified, so split it and get all the context
// names. // names.
llvm::SmallVector<llvm::StringRef, 8> Names; llvm::SmallVector<llvm::StringRef, 8> Names;
Identifier.split(Names, "::"); Identifier.split(Names, "::");
bool IsFullyQualified = false; bool IsFullyQualified = false;
if (Identifier.startswith("::")) { if (Identifier.startswith("::")) {
Names.erase(Names.begin()); // Drop first (empty) element. Names.erase(Names.begin()); // Drop first (empty) element.
IsFullyQualified = true; IsFullyQualified = true;
} }
// As long as we don't find a result keep stripping name parts from the end. // As long as we don't find a result keep stripping name parts from the end.
// This is to support nested classes which aren't recorded in the database. // This is to support nested classes which aren't recorded in the database.
// Eventually we will either hit a class (namespaces aren't in the database // Eventually we will either hit a class (namespaces aren't in the database
// either) and can report that result. // either) and can report that result.
bool TookPrefix = false; bool TookPrefix = false;
std::vector<clang::find_all_symbols::SymbolInfo> MatchedSymbols; std::vector<clang::find_all_symbols::SymbolInfo> MatchedSymbols;
while (MatchedSymbols.empty() && !Names.empty()) { do {
std::vector<clang::find_all_symbols::SymbolInfo> Symbols; std::vector<clang::find_all_symbols::SymbolInfo> Symbols;
for (const auto &DB : SymbolIndices) { for (const auto &DB : SymbolIndices) {
auto Res = DB->search(Names.back().str()); auto Res = DB->search(Names.back().str());
Symbols.insert(Symbols.end(), Res.begin(), Res.end()); Symbols.insert(Symbols.end(), Res.begin(), Res.end());
} }
DEBUG(llvm::dbgs() << "Searching " << Names.back() << "... got " DEBUG(llvm::dbgs() << "Searching " << Names.back() << "... got "
<< Symbols.size() << " results...\n"); << Symbols.size() << " results...\n");
Show All 39 Lines for (const auto &Symbol : Symbols) {
continue; continue;
MatchedSymbols.push_back(Symbol); MatchedSymbols.push_back(Symbol);
} }
} }
} }
Names.pop_back(); Names.pop_back();
TookPrefix = true; TookPrefix = true;
} } while (MatchedSymbols.empty() && !Names.empty() && IsNestedSearch);
rankByPopularity(MatchedSymbols); rankByPopularity(MatchedSymbols);
return MatchedSymbols; return MatchedSymbols;
} }
} // namespace include_fixer } // namespace include_fixer
} // namespace clang } // namespace clang

include-fixer/find-all-symbols/STLPostfixHeaderMap.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines static const HeaderMapCollector::RegexHeaderMap STLPostfixHeaderMap = {
{"bits/allocator.h$", "<string>"}, {"bits/allocator.h$", "<string>"},
{"bits/atomic_base.h$", "<atomic>"}, {"bits/atomic_base.h$", "<atomic>"},
{"bits/atomic_lockfree_defines.h$", "<exception>"}, {"bits/atomic_lockfree_defines.h$", "<exception>"},
{"bits/basic_ios.h$", "<ios>"}, {"bits/basic_ios.h$", "<ios>"},
{"bits/basic_ios.tcc$", "<ios>"}, {"bits/basic_ios.tcc$", "<ios>"},
{"bits/basic_string.h$", "<string>"}, {"bits/basic_string.h$", "<string>"},
{"bits/basic_string.tcc$", "<string>"}, {"bits/basic_string.tcc$", "<string>"},
{"bits/char_traits.h$", "<string>"}, {"bits/char_traits.h$", "<string>"},
{"bits/codecvt.h$", "<fstream>"}, {"bits/codecvt.h$", "<locale>"},
{"bits/concept_check.h$", "<numeric>"}, {"bits/concept_check.h$", "<numeric>"},
{"bits/cpp_type_traits.h$", "<cmath>"}, {"bits/cpp_type_traits.h$", "<cmath>"},
{"bits/cxxabi_forced.h$", "<cxxabi.h>"}, {"bits/cxxabi_forced.h$", "<cxxabi.h>"},
{"bits/deque.tcc$", "<deque>"}, {"bits/deque.tcc$", "<deque>"},
{"bits/exception_defines.h$", "<exception>"}, {"bits/exception_defines.h$", "<exception>"},
{"bits/exception_ptr.h$", "<exception>"}, {"bits/exception_ptr.h$", "<exception>"},
{"bits/forward_list.h$", "<forward_list>"}, {"bits/forward_list.h$", "<forward_list>"},
{"bits/forward_list.tcc$", "<forward_list>"}, {"bits/forward_list.tcc$", "<forward_list>"},
Show All 10 Lines static const HeaderMapCollector::RegexHeaderMap STLPostfixHeaderMap = {
{"bits/istream.tcc$", "<istream>"}, {"bits/istream.tcc$", "<istream>"},
{"bits/list.tcc$", "<list>"}, {"bits/list.tcc$", "<list>"},
{"bits/locale_classes.h$", "<locale>"}, {"bits/locale_classes.h$", "<locale>"},
{"bits/locale_classes.tcc$", "<locale>"}, {"bits/locale_classes.tcc$", "<locale>"},
{"bits/locale_facets.h$", "<locale>"}, {"bits/locale_facets.h$", "<locale>"},
{"bits/locale_facets.tcc$", "<locale>"}, {"bits/locale_facets.tcc$", "<locale>"},
{"bits/locale_facets_nonio.h$", "<locale>"}, {"bits/locale_facets_nonio.h$", "<locale>"},
{"bits/locale_facets_nonio.tcc$", "<locale>"}, {"bits/locale_facets_nonio.tcc$", "<locale>"},
{"bits/localefwd.h$", "<string>"}, {"bits/localefwd.h$", "<locale>"},
{"bits/mask_array.h$", "<valarray>"}, {"bits/mask_array.h$", "<valarray>"},
{"bits/memoryfwd.h$", "<string>"}, {"bits/memoryfwd.h$", "<memory>"},
{"bits/move.h$", "<utility>"}, {"bits/move.h$", "<utility>"},
{"bits/nested_exception.h$", "<exception>"}, {"bits/nested_exception.h$", "<exception>"},
{"bits/ostream.tcc$", "<ostream>"}, {"bits/ostream.tcc$", "<ostream>"},
{"bits/ostream_insert.h$", "<string>"}, {"bits/ostream_insert.h$", "<ostream>"},
{"bits/postypes.h$", "<iosfwd>"}, {"bits/postypes.h$", "<iosfwd>"},
{"bits/ptr_traits.h$", "<unordered_set>"}, {"bits/ptr_traits.h$", "<memory>"},
{"bits/random.h$", "<random>"}, {"bits/random.h$", "<random>"},
{"bits/random.tcc$", "<random>"}, {"bits/random.tcc$", "<random>"},
{"bits/range_access.h$", "<string>"}, {"bits/range_access.h$", "<iterator>"},
{"bits/regex.h$", "<regex>"}, {"bits/regex.h$", "<regex>"},
{"bits/regex_compiler.h$", "<regex>"}, {"bits/regex_compiler.h$", "<regex>"},
{"bits/regex_constants.h$", "<regex>"}, {"bits/regex_constants.h$", "<regex>"},
{"bits/regex_cursor.h$", "<regex>"}, {"bits/regex_cursor.h$", "<regex>"},
{"bits/regex_error.h$", "<regex>"}, {"bits/regex_error.h$", "<regex>"},
{"bits/regex_grep_matcher.h$", "<regex>"}, {"bits/regex_grep_matcher.h$", "<regex>"},
{"bits/regex_grep_matcher.tcc$", "<regex>"}, {"bits/regex_grep_matcher.tcc$", "<regex>"},
{"bits/regex_nfa.h$", "<regex>"}, {"bits/regex_nfa.h$", "<regex>"},
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines static const HeaderMapCollector::RegexHeaderMap STLPostfixHeaderMap = {
{"bits/wchar.h$", "<cwchar>"}, {"bits/wchar.h$", "<cwchar>"},
{"bits/wordsize.h$", "<csetjmp>"}, {"bits/wordsize.h$", "<csetjmp>"},
{"bits/xopen_lim.h$", "<climits>"}, {"bits/xopen_lim.h$", "<climits>"},
{"include/xlocale.h$", "<cstring>"}, {"include/xlocale.h$", "<cstring>"},
{"bits/atomic_word.h$", "<memory>"}, {"bits/atomic_word.h$", "<memory>"},
{"bits/basic_file.h$", "<fstream>"}, {"bits/basic_file.h$", "<fstream>"},
{"bits/c++allocator.h$", "<string>"}, {"bits/c++allocator.h$", "<string>"},
{"bits/c++config.h$", "<iosfwd>"}, {"bits/c++config.h$", "<iosfwd>"},
{"bits/c++io.h$", "<fstream>"}, {"bits/c++io.h$", "<ios>"},
{"bits/c++locale.h$", "<string>"}, {"bits/c++locale.h$", "<locale>"},
{"bits/cpu_defines.h$", "<iosfwd>"}, {"bits/cpu_defines.h$", "<iosfwd>"},
{"bits/ctype_base.h$", "<locale>"}, {"bits/ctype_base.h$", "<locale>"},
{"bits/cxxabi_tweaks.h$", "<cxxabi.h>"}, {"bits/cxxabi_tweaks.h$", "<cxxabi.h>"},
{"bits/error_constants.h$", "<system_error>"}, {"bits/error_constants.h$", "<system_error>"},
{"bits/gthr-default.h$", "<memory>"}, {"bits/gthr-default.h$", "<memory>"},
{"bits/gthr.h$", "<memory>"}, {"bits/gthr.h$", "<memory>"},
{"bits/opt_random.h$", "<random>"}, {"bits/opt_random.h$", "<random>"},
{"bits/os_defines.h$", "<iosfwd>"}, {"bits/os_defines.h$", "<iosfwd>"},
▲ Show 20 Lines • Show All 322 Lines • Show Last 20 Lines

include-fixer/tool/ClangIncludeFixer.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines static void mapping(IO &io, IncludeFixerContext::QuerySymbolInfo &Info) {
io.mapRequired("Range", Info.Range); io.mapRequired("Range", Info.Range);
} }
}; };
template <> struct MappingTraits<IncludeFixerContext> { template <> struct MappingTraits<IncludeFixerContext> {
static void mapping(IO &IO, IncludeFixerContext &Context) { static void mapping(IO &IO, IncludeFixerContext &Context) {
IO.mapRequired("QuerySymbolInfos", Context.QuerySymbolInfos); IO.mapRequired("QuerySymbolInfos", Context.QuerySymbolInfos);
IO.mapRequired("HeaderInfos", Context.HeaderInfos); IO.mapRequired("HeaderInfos", Context.HeaderInfos);
IO.mapRequired("FilePath", Context.FilePath);
} }
}; };
} // namespace yaml } // namespace yaml
} // namespace llvm } // namespace llvm
namespace { namespace {
cl::OptionCategory IncludeFixerCategory("Tool options"); cl::OptionCategory IncludeFixerCategory("Tool options");
▲ Show 20 Lines • Show All 114 Lines • ▼ Show 20 Lines case yaml: {
break; break;
} }
} }
return SymbolIndexMgr; return SymbolIndexMgr;
} }
void writeToJson(llvm::raw_ostream &OS, const IncludeFixerContext& Context) { void writeToJson(llvm::raw_ostream &OS, const IncludeFixerContext& Context) {
OS << "{\n" OS << "{\n"
" \"QuerySymbolInfos\": [\n"; << " \"FilePath\": \""
<< llvm::yaml::escape(Context.getFilePath()) << "\",\n"
<< " \"QuerySymbolInfos\": [\n";
for (const auto &Info : Context.getQuerySymbolInfos()) { for (const auto &Info : Context.getQuerySymbolInfos()) {
OS << " {\"RawIdentifier\": \"" << Info.RawIdentifier << "\",\n"; OS << " {\"RawIdentifier\": \"" << Info.RawIdentifier << "\",\n";
OS << " \"Range\":{"; OS << " \"Range\":{";
OS << "\"Offset\":" << Info.Range.getOffset() << ","; OS << "\"Offset\":" << Info.Range.getOffset() << ",";
OS << "\"Length\":" << Info.Range.getLength() << "}}"; OS << "\"Length\":" << Info.Range.getLength() << "}}";
if (&Info != &Context.getQuerySymbolInfos().back()) if (&Info != &Context.getQuerySymbolInfos().back())
OS << ",\n"; OS << ",\n";
} }
Show All 31 Lines if (STDINMode) {
} }
Code = std::move(CodeOrErr.get()); Code = std::move(CodeOrErr.get());
if (Code->getBufferSize() == 0) if (Code->getBufferSize() == 0)
return 0; // Skip empty files. return 0; // Skip empty files.
tool.mapVirtualFile(options.getSourcePathList().front(), Code->getBuffer()); tool.mapVirtualFile(options.getSourcePathList().front(), Code->getBuffer());
} }
StringRef FilePath = options.getSourcePathList().front();
format::FormatStyle InsertStyle = format::getStyle("file", FilePath, Style);
if (!InsertHeader.empty()) { if (!InsertHeader.empty()) {
if (!STDINMode) { if (!STDINMode) {
errs() << "Should be running in STDIN mode\n"; errs() << "Should be running in STDIN mode\n";
return 1; return 1;
} }
llvm::yaml::Input yin(InsertHeader); llvm::yaml::Input yin(InsertHeader);
IncludeFixerContext Context; IncludeFixerContext Context;
Show All 19 Lines if (!InsertHeader.empty()) {
// //
// Check whether all elements in HeaderInfos have the same qualified name. // Check whether all elements in HeaderInfos have the same qualified name.
bool IsUniqueQualifiedName = std::equal( bool IsUniqueQualifiedName = std::equal(
HeaderInfos.begin() + 1, HeaderInfos.end(), HeaderInfos.begin(), HeaderInfos.begin() + 1, HeaderInfos.end(), HeaderInfos.begin(),
[](const IncludeFixerContext::HeaderInfo &LHS, [](const IncludeFixerContext::HeaderInfo &LHS,
const IncludeFixerContext::HeaderInfo &RHS) { const IncludeFixerContext::HeaderInfo &RHS) {
return LHS.QualifiedName == RHS.QualifiedName; return LHS.QualifiedName == RHS.QualifiedName;
}); });
format::FormatStyle InsertStyle =
format::getStyle("file", Context.getFilePath(), Style);
auto Replacements = clang::include_fixer::createIncludeFixerReplacements( auto Replacements = clang::include_fixer::createIncludeFixerReplacements(
Code->getBuffer(), FilePath, Context, InsertStyle, Code->getBuffer(), Context, InsertStyle,
/*AddQualifiers=*/IsUniqueQualifiedName); /*AddQualifiers=*/IsUniqueQualifiedName);
if (!Replacements) { if (!Replacements) {
errs() << "Failed to create replacements: " errs() << "Failed to create replacements: "
<< llvm::toString(Replacements.takeError()) << "\n"; << llvm::toString(Replacements.takeError()) << "\n";
return 1; return 1;
} }
auto ChangedCode = auto ChangedCode =
tooling::applyAllReplacements(Code->getBuffer(), *Replacements); tooling::applyAllReplacements(Code->getBuffer(), *Replacements);
if (!ChangedCode) { if (!ChangedCode) {
llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n"; llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
return 1; return 1;
} }
llvm::outs() << *ChangedCode; llvm::outs() << *ChangedCode;
return 0; return 0;
} }
// Set up data source. // Set up data source.
std::unique_ptr<include_fixer::SymbolIndexManager> SymbolIndexMgr = std::unique_ptr<include_fixer::SymbolIndexManager> SymbolIndexMgr =
createSymbolIndexManager(options.getSourcePathList().front()); createSymbolIndexManager(options.getSourcePathList().front());
if (!SymbolIndexMgr) if (!SymbolIndexMgr)
return 1; return 1;
// Now run our tool. // Now run our tool.
include_fixer::IncludeFixerContext Context; std::vector<include_fixer::IncludeFixerContext> Contexts;
include_fixer::IncludeFixerActionFactory Factory(*SymbolIndexMgr, Context, include_fixer::IncludeFixerActionFactory Factory(*SymbolIndexMgr, Contexts,
Style, MinimizeIncludePaths); Style, MinimizeIncludePaths);
if (tool.run(&Factory) != 0) { if (tool.run(&Factory) != 0) {
llvm::errs() llvm::errs()
<< "Clang died with a fatal error! (incorrect include paths?)\n"; << "Clang died with a fatal error! (incorrect include paths?)\n";
return 1; return 1;
} }
assert(!Contexts.empty());
if (OutputHeaders) { if (OutputHeaders) {
writeToJson(llvm::outs(), Context); // FIXME: Print contexts of all processing files instead of the first one.
writeToJson(llvm::outs(), Contexts.front());
return 0; return 0;
} }
if (Context.getHeaderInfos().empty()) std::vector<tooling::Replacements> FixerReplacements;
return 0; for (const auto &Context : Contexts) {
StringRef FilePath = Context.getFilePath();
format::FormatStyle InsertStyle = format::getStyle("file", FilePath, Style);
auto Buffer = llvm::MemoryBuffer::getFile(FilePath); auto Buffer = llvm::MemoryBuffer::getFile(FilePath);
if (!Buffer) { if (!Buffer) {
errs() << "Couldn't open file: " << FilePath << ": " errs() << "Couldn't open file: " + FilePath.str() + ": "
<< Buffer.getError().message() << '\n'; << Buffer.getError().message() + "\n";
return 1; return 1;
} }
auto Replacements = clang::include_fixer::createIncludeFixerReplacements( auto Replacements = clang::include_fixer::createIncludeFixerReplacements(
/*Code=*/Buffer.get()->getBuffer(), FilePath, Context, InsertStyle); Buffer.get()->getBuffer(), Context, InsertStyle);
if (!Replacements) { if (!Replacements) {
errs() << "Failed to create header insertion replacement: " errs() << "Failed to create replacement: "
<< llvm::toString(Replacements.takeError()) << "\n"; << llvm::toString(Replacements.takeError()) << "\n";
return 1; return 1;
} }
FixerReplacements.push_back(*Replacements);
}
if (!Quiet) if (!Quiet) {
errs() << "Added #include " << Context.getHeaderInfos().front().Header for (const auto &Context : Contexts) {
<< '\n'; if (!Context.getHeaderInfos().empty()) {
llvm::errs() << "Added #include "
// Set up a new source manager for applying the resulting replacements. << Context.getHeaderInfos().front().Header << " for "
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions); << Context.getFilePath() << "\n";
DiagnosticsEngine Diagnostics(new DiagnosticIDs, &*DiagOpts); }
TextDiagnosticPrinter DiagnosticPrinter(outs(), &*DiagOpts); }
SourceManager SM(Diagnostics, tool.getFiles()); }
Diagnostics.setClient(&DiagnosticPrinter, false);
if (STDINMode) { if (STDINMode) {
auto ChangedCode = assert(FixerReplacements.size() == 1);
tooling::applyAllReplacements(Code->getBuffer(), *Replacements); auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(),
FixerReplacements.front());
if (!ChangedCode) { if (!ChangedCode) {
llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n"; llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
return 1; return 1;
} }
llvm::outs() << *ChangedCode; llvm::outs() << *ChangedCode;
return 0; return 0;
} }
// Set up a new source manager for applying the resulting replacements.
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
DiagnosticsEngine Diagnostics(new DiagnosticIDs, &*DiagOpts);
TextDiagnosticPrinter DiagnosticPrinter(outs(), &*DiagOpts);
SourceManager SM(Diagnostics, tool.getFiles());
Diagnostics.setClient(&DiagnosticPrinter, false);
// Write replacements to disk. // Write replacements to disk.
Rewriter Rewrites(SM, LangOptions()); Rewriter Rewrites(SM, LangOptions());
tooling::applyAllReplacements(*Replacements, Rewrites); for (const auto Replacement : FixerReplacements) {
if (!tooling::applyAllReplacements(Replacement, Rewrites)) {
llvm::errs() << "Failed to apply replacements.\n";
return 1;
}
}
return Rewrites.overwriteChangedFiles(); return Rewrites.overwriteChangedFiles();
} }
} // namespace } // namespace
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
return includeFixerMain(argc, argv); return includeFixerMain(argc, argv);
} }

include-fixer/tool/clang-include-fixer.py

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Lines if header not in seen:
seen.add(header) seen.add(header)
unique_headers.append(header) unique_headers.append(header)
if not unique_headers: if not unique_headers:
print "Couldn't find a header for {0}.".format(symbol) print "Couldn't find a header for {0}.".format(symbol)
return return
try: try:
# If there is only one suggested header, insert it directly. inserted_header_infos = header_infos
if len(unique_headers) == 1 or maximum_suggested_headers == 1: if len(unique_headers) > 1:
InsertHeaderToVimBuffer({"QuerySymbolInfos": query_symbol_infos, selected = GetUserSelection(
"HeaderInfos": header_infos}, text) "choose a header file for {0}.".format(symbol),
print "Added #include {0} for {1}.".format(unique_headers[0], symbol)
return
selected = GetUserSelection("choose a header file for {0}.".format(symbol),
unique_headers, maximum_suggested_headers) unique_headers, maximum_suggested_headers)
selected_header_infos = [ inserted_header_infos = [
header for header in header_infos if header["Header"] == selected] header for header in header_infos if header["Header"] == selected]
include_fixer_context["HeaderInfos"] = inserted_header_infos
# Insert a selected header. InsertHeaderToVimBuffer(include_fixer_context, text)
InsertHeaderToVimBuffer({"QuerySymbolInfos": query_symbol_infos,
"HeaderInfos": selected_header_infos}, text)
print "Added #include {0} for {1}.".format(selected, symbol) print "Added #include {0} for {1}.".format(selected, symbol)
except Exception as error: except Exception as error:
print >> sys.stderr, error.message print >> sys.stderr, error.message
return return
if __name__ == '__main__': if __name__ == '__main__':
main() main()

test/clang-rename/ClassAsTemplateArgumentFindByClass.cpp

// RUN: clang-rename -offset=74 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=136 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo {}; // CHECK: class Bar {}; class Foo {}; // CHECK: class Bar {};
template <typename T> template <typename T>
void func() {} void func() {}
template <typename T> template <typename T>
class Baz {}; class Baz {};
Show All 9 Lines

test/clang-rename/ClassAsTemplateArgumentFindByTemplateArgument.cpp

// RUN: clang-rename -offset=243 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=304 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo {}; // CHECK: class Bar {}; class Foo {}; // CHECK: class Bar {};
template <typename T> template <typename T>
void func() {} void func() {}
template <typename T> template <typename T>
class Baz {}; class Baz {};
Show All 9 Lines

test/clang-rename/ClassFindByName.cpp

// RUN: clang-rename -old-name=Foo -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename rename-all -old-name=Foo -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar class Foo { // CHECK: class Bar
}; };
int main() { int main() {
Foo *Pointer = 0; // CHECK: Bar *Pointer = 0; Foo *Pointer = 0; // CHECK: Bar *Pointer = 0;
return 0; return 0;
} }

test/clang-rename/ClassNameInFunctionDefinition.cpp

// RUN: clang-rename -offset=74 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=136 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar { class Foo { // CHECK: class Bar {
public: public:
void foo(int x); void foo(int x);
}; };
void Foo::foo(int x) {} // CHECK: void Bar::foo(int x) {} void Foo::foo(int x) {} // CHECK: void Bar::foo(int x) {}

test/clang-rename/ClassSimpleRenaming.cpp

// RUN: clang-rename -offset=74 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=136 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo {}; // CHECK: class Bar class Foo {}; // CHECK: class Bar
int main() { int main() {
Foo *Pointer = 0; // CHECK: Bar *Pointer = 0; Foo *Pointer = 0; // CHECK: Bar *Pointer = 0;
return 0; return 0;
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Foo' <file> to get the correct offset of Cla when changing
// this file. // this file.

test/clang-rename/ClassTestMulti.cpp

  • This file was added.
// RUN: cat %s > %t.cpp
// RUN: clang-rename rename-all -offset=174 -new-name=Bar1 -offset=212 -new-name=Bar2 %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo1 { // CHECK: class Bar1
};
class Foo2 { // CHECK: class Bar2
};

test/clang-rename/ClassTestMultiByName.cpp

  • This file was added.
// RUN: cat %s > %t.cpp
// RUN: clang-rename rename-all -old-name=Foo1 -new-name=Bar1 -old-name=Foo2 -new-name=Bar2 %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo1 { // CHECK: class Bar1
};
class Foo2 { // CHECK: class Bar2
};

test/clang-rename/ClassTestMultiByNameYAML.cpp

  • This file was added.
class Foo1 { // CHECK: class Bar1
};
class Foo2 { // CHECK: class Bar2
};
// RUN: clang-rename rename-all -input %S/Inputs/ClassTestMultiByNameYAMLRenameAll.yaml %s -- | sed 's,//.*,,' | FileCheck %s
// RUN: clang-rename rename-all -input %S/Inputs/ClassTestMultiByNameYAMLRenameAt.yaml %s -- | sed 's,//.*,,' | FileCheck %s

test/clang-rename/ComplexFunctionOverride.cpp

  • This file was added.
// RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=307 -new-name=bar %t.cpp -i -- -std=c++11
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
struct A {
virtual void foo(); // CHECK: virtual void bar();
};
struct B : A {
void foo() override; // CHECK: void bar() override;
};
struct C : B {
void foo() override; // CHECK: void bar() override;
};
struct D : B {
void foo() override; // CHECK: void bar() override;
};
struct E : D {
void foo() override; // CHECK: void bar() override;
};

test/clang-rename/ComplicatedClassType.cpp

// RUN: clang-rename -offset=159 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=220 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
// Forward declaration. // Forward declaration.
class Foo; // CHECK: class Bar; class Foo; // CHECK: class Bar;
class Foo { // CHECK: class Bar { class Foo { // CHECK: class Bar {
public: public:
Foo(int value = 0) : x(value) {} // CHECK: Bar(int value = 0) : x(value) {} Foo(int value = 0) : x(value) {} // CHECK: Bar(int value = 0) : x(value) {}
Show All 20 Lines

test/clang-rename/ConstCastExpr.cpp

// RUN: clang-rename -offset=74 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=136 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar { class Foo { // CHECK: class Bar {
public: public:
int getValue() { int getValue() {
return 0; return 0;
} }
}; };
int main() { int main() {
const Foo *C = new Foo(); // CHECK: const Bar *C = new Bar(); const Foo *C = new Foo(); // CHECK: const Bar *C = new Bar();
const_cast<Foo *>(C)->getValue(); // CHECK: const_cast<Bar *>(C)->getValue(); const_cast<Foo *>(C)->getValue(); // CHECK: const_cast<Bar *>(C)->getValue();
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Cla' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/ConstructExpr.cpp

// RUN: clang-rename -offset=74 -new-name=Boo %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=136 -new-name=Boo %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo {}; // CHECK: class Boo {}; class Foo {}; // CHECK: class Boo {};
int main() { int main() {
Foo *C = new Foo(); // CHECK: Boo *C = new Boo(); Foo *C = new Foo(); // CHECK: Boo *C = new Boo();
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Boo' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/CtorFindByDeclaration.cpp

// RUN: clang-rename -offset=113 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=174 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar class Foo { // CHECK: class Bar
public: public:
Foo(); // CHECK: Bar(); Foo(); // CHECK: Bar();
}; };
Foo::Foo() {} // CHECK: Bar::Bar() Foo::Foo() {} // CHECK: Bar::Bar()
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'C' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/CtorFindByDefinition.cpp

// RUN: clang-rename -offset=151 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=212 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar class Foo { // CHECK: class Bar
public: public:
Foo(); // CHECK: Bar(); Foo(); // CHECK: Bar();
}; };
Foo::Foo() {} // CHECK: Bar::Bar() Foo::Foo() {} // CHECK: Bar::Bar()
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'C' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/CtorInitializer.cpp

// RUN: clang-rename -offset=102 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=163 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Baz {}; class Baz {};
class Qux { class Qux {
Baz Foo; // CHECK: Baz Bar; Baz Foo; // CHECK: Baz Bar;
public: public:
Qux(); Qux();
}; };
Qux::Qux() : Foo() {} // CHECK: Qux::Qux() : Bar() {} Qux::Qux() : Foo() {} // CHECK: Qux::Qux() : Bar() {}
// Use grep -FUbo 'Foo' <file> to get the correct offset of foo when changing // Use grep -FUbo 'Foo' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/DeclRefExpr.cpp

// RUN: clang-rename -offset=100 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=161 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class C { class C {
public: public:
static int Foo; // CHECK: static int Bar; static int Foo; // CHECK: static int Bar;
}; };
int foo(int x) { return 0; } int foo(int x) { return 0; }
#define MACRO(a) foo(a) #define MACRO(a) foo(a)
int main() { int main() {
C::Foo = 1; // CHECK: C::Bar C::Foo = 1; // CHECK: C::Bar
MACRO(C::Foo); // CHECK: C::Bar MACRO(C::Foo); // CHECK: C::Bar
int y = C::Foo; // CHECK: C::Bar int y = C::Foo; // CHECK: C::Bar
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'X' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/DtorDeclaration.cpp

// RUN: clang-rename -offset=114 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=175 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar { class Foo { // CHECK: class Bar {
public: public:
~Foo(); // CHECK: ~Bar(); ~Foo(); // CHECK: ~Bar();
}; };
Foo::~Foo() { // CHECK: Bar::~Bar() Foo::~Foo() { // CHECK: Bar::~Bar()
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Bar' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/DtorDefinition.cpp

// RUN: clang-rename -offset=158 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=219 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar { class Foo { // CHECK: class Bar {
public: public:
~Foo(); // CHECK: ~Bar(); ~Foo(); // CHECK: ~Bar();
}; };
Foo::~Foo() {} // CHECK: Bar::~Bar() Foo::~Foo() {} // CHECK: Bar::~Bar()
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Foo' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/DynamicCastExpr.cpp

// RUN: clang-rename -offset=134 -new-name=Bar %s -- -frtti | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=195 -new-name=Bar %t.cpp -i -- -frtti
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Baz { class Baz {
virtual int getValue() const = 0; virtual int getValue() const = 0;
}; };
class Foo : public Baz { // CHECK: class Bar : public Baz { class Foo : public Baz { // CHECK: class Bar : public Baz {
public: public:
int getValue() const { int getValue() const {
return 0; return 0;
} }
}; };
int main() { int main() {
Foo foo; // FIXME: Bar foo; <- this one fails Foo foo; // FIXME: Bar foo; <- this one fails
const Baz &Reference = foo; const Baz &Reference = foo;
const Baz *Pointer = &foo; const Baz *Pointer = &foo;
dynamic_cast<const Foo &>(Reference).getValue(); // CHECK: dynamic_cast<const Bar &>(Reference).getValue(); dynamic_cast<const Foo &>(Reference).getValue(); // CHECK: dynamic_cast<const Bar &>(Reference).getValue();
dynamic_cast<const Foo *>(Pointer)->getValue(); // CHECK: dynamic_cast<const Bar *>(Pointer)->getValue(); dynamic_cast<const Foo *>(Pointer)->getValue(); // CHECK: dynamic_cast<const Bar *>(Pointer)->getValue();
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Foo' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/Field.cpp

// RUN: clang-rename -offset=87 -new-name=Bar %s -- | FileCheck %s
class Baz { class Baz {
int Foo; // CHECK: Bar; int Foo; /* Test 1 */ // CHECK: int Bar;
public: public:
Baz(); Baz();
}; };
Baz::Baz() : Foo(0) {} // CHECK: Baz::Baz() : Bar(0) {} Baz::Baz() : Foo(0) /* Test 2 */ {} // CHECK: Baz::Baz() : Bar(0)
// Test 1.
// RUN: clang-rename -offset=18 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
// Test 2.
// RUN: clang-rename -offset=89 -new-name=Bar %s -- | sed 's,//.*,,' | FileCheck %s
// Use grep -FUbo 'Foo' <file> to get the correct offset of foo when changing // To find offsets after modifying the file, use:
// this file. // grep -Ubo 'Foo.*' <file>

test/clang-rename/FunctionMacro.cpp

// RUN: clang-rename -offset=138 -new-name=macro_function %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=199 -new-name=macro_function %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
#define moo foo // CHECK: #define moo macro_function #define moo foo // CHECK: #define moo macro_function
int foo() { // CHECK: int macro_function() { int foo() { // CHECK: int macro_function() {
return 42; return 42;
} }
void boo(int value) {} void boo(int value) {}
void qoo() { void qoo() {
foo(); // CHECK: macro_function(); foo(); // CHECK: macro_function();
boo(foo()); // CHECK: boo(macro_function()); boo(foo()); // CHECK: boo(macro_function());
moo(); moo();
boo(moo()); boo(moo());
} }
// Use grep -FUbo 'foo' <file> to get the correct offset of foo when changing // Use grep -FUbo 'foo;' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/FunctionOverride.cpp

  • This file was added.
// RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=318 -new-name=bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class A { virtual void foo(); }; // CHECK: class A { virtual void bar(); };
class B : public A { void foo(); }; // CHECK: class B : public A { void bar(); };
class C : public B { void foo(); }; // CHECK: class C : public B { void bar(); };
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing
// this file.

test/clang-rename/FunctionWithClassFindByName.cpp

// RUN: clang-rename -old-name=Foo -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename rename-all -old-name=Foo -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
void foo() { void foo() {
} }
class Foo { // CHECK: class Bar class Foo { // CHECK: class Bar
}; };
int main() { int main() {
Foo *Pointer = 0; // CHECK: Bar *Pointer = 0; Foo *Pointer = 0; // CHECK: Bar *Pointer = 0;
return 0; return 0;
} }

test/clang-rename/Inputs/ClassTestMultiByNameYAMLRenameAll.yaml

  • This file was added.
---
- OldName: Foo1
NewName: Bar1
- OldName: Foo2
NewName: Bar2
...

test/clang-rename/Inputs/ClassTestMultiByNameYAMLRenameAt.yaml

  • This file was added.
---
- Offset: 6
NewName: Bar1
- Offset: 44
NewName: Bar2
...

test/clang-rename/MemberExprMacro.cpp

// RUN: clang-rename -offset=95 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=156 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Baz { class Baz {
public: public:
int Foo; // CHECK: int Bar; int Foo; // CHECK: int Bar;
}; };
int qux(int x) { return 0; } int qux(int x) { return 0; }
#define MACRO(a) qux(a) #define MACRO(a) qux(a)
Show All 10 Lines

test/clang-rename/Namespace.cpp

// RUN: clang-rename -offset=79 -new-name=llvm %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=143 -new-name=llvm %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
namespace foo { // CHECK: namespace llvm { namespace foo { // CHECK: namespace llvm {
int x; int x;
} }
void boo() { void boo() {
foo::x = 42; // CHECK: llvm::x = 42; foo::x = 42; // CHECK: llvm::x = 42;
} }
// Use grep -FUbo 'foo' <file> to get the correct offset of foo when changing // Use grep -FUbo 'foo;' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/NoNewName.cpp

// Check for an error while -new-name argument has not been passed to // Check for an error while -new-name argument has not been passed to
// clang-rename. // clang-rename.
// RUN: not clang-rename -offset=133 %s 2>&1 | FileCheck %s // RUN: not clang-rename -offset=133 %s 2>&1 | FileCheck %s
// CHECK: ERROR: no new name provided. // CHECK: clang-rename: for the -new-name option: must be specified

test/clang-rename/ReinterpretCastExpr.cpp

// RUN: clang-rename -offset=73 -new-name=X %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=133 -new-name=X %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Cla { class Cla {
public: public:
int getValue() const { int getValue() const {
return 0; return 0;
} }
}; };
int main() { int main() {
void *C = new Cla(); void *C = new Cla();
reinterpret_cast<const Cla *>(C)->getValue(); // CHECK: reinterpret_cast<const X *> reinterpret_cast<const Cla *>(C)->getValue(); // CHECK: reinterpret_cast<const X *>
} }
// Use grep -FUbo 'Cla' <file> to get the correct offset of Cla when changing // Use grep -FUbo 'Cla' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/StaticCastExpr.cpp

// RUN: clang-rename -offset=91 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=152 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Baz { class Baz {
}; };
class Foo : public Baz { // CHECK: class Bar : public Baz { class Foo : public Baz { // CHECK: class Bar : public Baz {
public: public:
int getValue() const { int getValue() const {
return 0; return 0;
Show All 14 Lines

test/clang-rename/TemplateClassInstantiation.cpp

  • This file was moved from test/clang-rename/TemplateClassInstantiationFindByTypeUse.cpp.
// RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=703 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
// Currently unsupported test.
// FIXME: clang-rename should be able to rename classes with templates
// correctly.
// XFAIL: *
template <typename T> template <typename T>
class Foo { // CHECK: class Bar; class Foo { // CHECK: class Bar {
public: public:
T foo(T arg, T& ref, T* ptr) { T foo(T arg, T& ref, T* ptr) {
T value; T value;
int number = 42; int number = 42;
value = (T)number; value = (T)number;
value = static_cast<T>(number); value = static_cast<T>(number);
return value; return value;
} }
Show All 15 Linesint main() {
Foo<bool> b; // CHECK: Bar<bool> b; Foo<bool> b; // CHECK: Bar<bool> b;
b.member = false; b.member = false;
Foo<bool>::foo(false); // CHECK: Bar<bool>::foo(false); Foo<bool>::foo(false); // CHECK: Bar<bool>::foo(false);
return 0; return 0;
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of foo when changing // RUN: cat %s > %t-0.cpp
// this file. // RUN: clang-rename -offset=29 -new-name=Bar %t-0.cpp -i -- -fno-delayed-template-parsing
// RUN: sed 's,//.*,,' %t-0.cpp | FileCheck %s
// RUN: cat %s > %t-1.cpp
// RUN: clang-rename -offset=311 -new-name=Bar %t-1.cpp -i -- -fno-delayed-template-parsing
// RUN: sed 's,//.*,,' %t-1.cpp | FileCheck %s
// RUN: cat %s > %t-2.cpp
// RUN: clang-rename -offset=445 -new-name=Bar %t-2.cpp -i -- -fno-delayed-template-parsing
// RUN: sed 's,//.*,,' %t-2.cpp | FileCheck %s

test/clang-rename/TemplateClassInstantiationFindByDeclaration.cpp

  • This file was deleted.
// RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=287 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
// Currently unsupported test.
// FIXME: clang-rename should be able to rename classes with templates
// correctly.
// XFAIL: *
template <typename T>
class Foo { // CHECK: class Bar;
public:
T foo(T arg, T& ref, T* ptr) {
T value;
int number = 42;
value = (T)number;
value = static_cast<T>(number);
return value;
}
static void foo(T value) {}
T member;
};
template <typename T>
void func() {
Foo<T> obj; // CHECK: Bar<T> obj;
obj.member = T();
Foo<T>::foo(); // CHECK: Bar<T>::foo();
}
int main() {
Foo<int> i; // CHECK: Bar<int> i;
i.member = 0;
Foo<int>::foo(0); // CHECK: Bar<int>::foo(0);
Foo<bool> b; // CHECK: Bar<bool> b;
b.member = false;
Foo<bool>::foo(false); // CHECK: Bar<bool>::foo(false);
return 0;
}
// Use grep -FUbo 'C' <file> to get the correct offset of foo when changing
// this file.

test/clang-rename/TemplateClassInstantiationFindByTypeUse.cpp

  • This file was moved to test/clang-rename/TemplateClassInstantiation.cpp.

test/clang-rename/TemplateFunctionFindByDeclaration.cpp

// RUN: clang-rename -offset=93 -new-name=bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=154 -new-name=bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
template <typename T> template <typename T>
T foo(T value) { // CHECK: T bar(T value) { T foo(T value) { // CHECK: T bar(T value) {
return value; return value;
} }
int main() { int main() {
foo<bool>(false); // CHECK: bar<bool>(false); foo<bool>(false); // CHECK: bar<bool>(false);
foo<int>(0); // CHECK: bar<int>(0); foo<int>(0); // CHECK: bar<int>(0);
return 0; return 0;
} }
// Use grep -FUbo 'foo' <file> to get the correct offset of foo when changing // Use grep -FUbo 'foo' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/TemplateFunctionFindByUse.cpp

// RUN: clang-rename -offset=172 -new-name=bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=233 -new-name=bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
template <typename T> template <typename T>
T foo(T value) { // CHECK: T bar(T value) { T foo(T value) { // CHECK: T bar(T value) {
return value; return value;
} }
int main() { int main() {
foo<bool>(false); // CHECK: bar<bool>(false); foo<bool>(false); // CHECK: bar<bool>(false);
foo<int>(0); // CHECK: bar<int>(0); foo<int>(0); // CHECK: bar<int>(0);
return 0; return 0;
} }

test/clang-rename/TemplateTypenameFindByTemplateParam.cpp

// RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=270 -new-name=U %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
// Currently unsupported test.
// FIXME: clang-rename should be able to rename template parameters correctly.
// XFAIL: *
template <typename T> // CHECK: template <typename U> template <typename T> // CHECK: template <typename U>
class Foo { class Foo {
T foo(T arg, T& ref, T* ptr) { // CHECK: U foo(U arg, U& ref, U* ptr) { T foo(T arg, T& ref, T* ptr) { // CHECK: U foo(U arg, U& ref, U* ptr) {
T value; // CHECK: U value; T value; // CHECK: U value;
int number = 42; int number = 42;
value = (T)number; // CHECK: value = (U)number; value = (T)number; // CHECK: value = (U)number;
value = static_cast<T>(number); // CHECK: value = static_cast<U>(number); value = static_cast<T>(number); // CHECK: value = static_cast<U>(number);
return value; return value;
} }
static void foo(T value) {} // CHECK: static void foo(U value) {} static void foo(T value) {} // CHECK: static void foo(U value) {}
T member; // CHECK: U member; T member; // CHECK: U member;
}; };
// RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=19 -new-name=U %t.cpp -i -- -fno-delayed-template-parsing
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s

test/clang-rename/TemplateTypenameFindByTypeInside.cpp

// RUN: clang-rename -offset=289 -new-name=U %s -- | FileCheck %s
// Currently unsupported test.
// FIXME: clang-rename should be able to rename template parameters correctly.
// XFAIL: *
template <typename T> // CHECK: template <typename U> template <typename T> // CHECK: template <typename U>
class Foo { class Foo {
T foo(T arg, T& ref, T* ptr) { // CHECK: U foo(U arg, U& ref, U* ptr) { T foo(T arg, T& ref, T* ptr) { // CHECK: U foo(U arg, U& ref, U* ptr) {
T value; // CHECK: U value; T value; // CHECK: U value;
int number = 42; int number = 42;
value = (T)number; // CHECK: value = (U)number; value = (T)number; // CHECK: value = (U)number;
value = static_cast<T>(number); // CHECK: value = static_cast<U>(number); value = static_cast<T>(number); // CHECK: value = static_cast<U>(number);
return value; return value;
} }
static void foo(T value) {} // CHECK: static void foo(U value) {} static void foo(T value) {} // CHECK: static void foo(U value) {}
T member; // CHECK: U member; T member; // CHECK: U member;
}; };
// RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=99 -new-name=U %t.cpp -i -- -fno-delayed-template-parsing
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s

test/clang-rename/UserDefinedConversion.cpp

// RUN: clang-rename -offset=143 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=205 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo {}; // CHECK: class Bar {}; class Foo {}; // CHECK: class Bar {};
class Baz { class Baz {
operator Foo() const { // CHECK: operator Bar() const { operator Foo() const { // CHECK: operator Bar() const {
// offset ^ // offset ^
Foo foo; // CHECK: Bar foo; Foo foo; // CHECK: Bar foo;
return foo; return foo;
} }
}; };

test/clang-rename/UserDefinedConversionFindByTypeDeclaration.cpp

// RUN: clang-rename -offset=75 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=136 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
class Foo { // CHECK: class Bar { class Foo { // CHECK: class Bar {
// ^ offset must be here // ^ offset must be here
public: public:
Foo() {} // CHECK: Bar() {} Foo() {} // CHECK: Bar() {}
}; };
class Baz { class Baz {
public: public:
operator Foo() const { // CHECK: operator Bar() const { operator Foo() const { // CHECK: operator Bar() const {
Foo foo; // CHECK: Bar foo; Foo foo; // CHECK: Bar foo;
return foo; return foo;
} }
}; };
int main() { int main() {
Baz boo; Baz boo;
Foo foo = static_cast<Foo>(boo); // CHECK: Bar foo = static_cast<Bar>(boo); Foo foo = static_cast<Foo>(boo); // CHECK: Bar foo = static_cast<Bar>(boo);
return 0; return 0;
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Foo' <file> to get the correct offset of Cla when changing
// this file. // this file.

test/clang-rename/Variable.cpp

// RUN: clang-rename -offset=87 -new-name=Bar %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=148 -new-name=Bar %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
namespace A { namespace A {
int Foo; // CHECK: int Bar; int Foo; // CHECK: int Bar;
} }
int Foo; // CHECK: int Foo; int Foo; // CHECK: int Foo;
int Qux = Foo; // CHECK: int Qux = Foo; int Qux = Foo; // CHECK: int Qux = Foo;
int Baz = A::Foo; // CHECK: Baz = A::Bar; int Baz = A::Foo; // CHECK: Baz = A::Bar;
void fun() { void fun() {
struct { struct {
int Foo; // CHECK: int Foo; int Foo; // CHECK: int Foo;
} b = {100}; } b = {100};
int Foo = 100; // CHECK: int Foo = 100; int Foo = 100; // CHECK: int Foo = 100;
Baz = Foo; // CHECK: Baz = Foo; Baz = Foo; // CHECK: Baz = Foo;
{ {
extern int Foo; // CHECK: extern int Foo; extern int Foo; // CHECK: extern int Foo;
Baz = Foo; // CHECK: Baz = Foo; Baz = Foo; // CHECK: Baz = Foo;
Foo = A::Foo + Baz; // CHECK: Foo = A::Bar + Baz; Foo = A::Foo + Baz; // CHECK: Foo = A::Bar + Baz;
A::Foo = b.Foo; // CHECK: A::Bar = b.Foo; A::Foo = b.Foo; // CHECK: A::Bar = b.Foo;
} }
Foo = b.Foo; // Foo = b.Foo; Foo = b.Foo; // Foo = b.Foo;
} }
// Use grep -FUbo 'Foo' <file> to get the correct offset of Foo when changing // Use grep -FUbo 'Foo' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-rename/VariableMacro.cpp

// RUN: clang-rename -offset=147 -new-name=Z %s -- | FileCheck %s // RUN: cat %s > %t.cpp
// RUN: clang-rename -offset=208 -new-name=Z %t.cpp -i --
// RUN: sed 's,//.*,,' %t.cpp | FileCheck %s
#define Y X // CHECK: #define Y Z #define Y X // CHECK: #define Y Z
void foo(int value) {} void foo(int value) {}
void macro() { void macro() {
int X; // CHECK: int Z; int X; // CHECK: int Z;
X = 42; // CHECK: Z = 42; X = 42; // CHECK: Z = 42;
Y -= 0; Y -= 0;
foo(X); // CHECK: foo(Z); foo(X); // CHECK: foo(Z);
foo(Y); foo(Y);
} }
// Use grep -FUbo 'X' <file> to get the correct offset of X when changing // Use grep -FUbo 'foo;' <file> to get the correct offset of foo when changing
// this file. // this file.

test/clang-tidy/Inputs/modernize-pass-by-value/header-with-fix.h

  • This file was added.
struct S {
S(S&&);
S(const S&);
};
struct Foo {
Foo(const S &s);
S s;
};

test/clang-tidy/Inputs/mpi-type-mismatch/mpimock.h

  • This file was added.
// This Message Passing Interface mock header is used, to mock typedefs,
// constants and functions, required for integration tests being part of
// clang-tidy MPI checks.
#ifndef MPIMOCK_H
#define MPIMOCK_H
#define NULL 0
// These typedefs are used to mock MPI types, fixed width integer types and the
// templated C++ complex number type.
typedef int MPI_Datatype;
typedef int MPI_Comm;
typedef int MPI_Request;
typedef int MPI_Status;
typedef int MPI_Op;
typedef int int8_t;
typedef int uint8_t;
typedef int uint16_t;
typedef int int64_t;
namespace std { template<class T> struct complex { T real; T imag; }; }
// These defines are used to mock MPI constants.
#define MPI_DATATYPE_NULL 0
#define MPI_CHAR 0
#define MPI_BYTE 0
#define MPI_INT 0
#define MPI_LONG 0
#define MPI_LONG_DOUBLE 0
#define MPI_UNSIGNED 0
#define MPI_INT8_T 0
#define MPI_UINT8_T 0
#define MPI_UINT16_T 0
#define MPI_C_LONG_DOUBLE_COMPLEX 0
#define MPI_FLOAT 0
#define MPI_DOUBLE 0
#define MPI_CXX_BOOL 0
#define MPI_CXX_FLOAT_COMPLEX 0
#define MPI_CXX_DOUBLE_COMPLEX 0
#define MPI_CXX_LONG_DOUBLE_COMPLEX 0
#define MPI_IN_PLACE 0
#define MPI_COMM_WORLD 0
#define MPI_STATUS_IGNORE 0
#define MPI_STATUSES_IGNORE 0
#define MPI_SUM 0
// These declarations are used to mock MPI functions.
int MPI_Comm_size(MPI_Comm, int *);
int MPI_Comm_rank(MPI_Comm, int *);
int MPI_Send(const void *, int, MPI_Datatype, int, int, MPI_Comm);
int MPI_Recv(void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *);
int MPI_Isend(const void *, int, MPI_Datatype, int, int, MPI_Comm,
MPI_Request *);
int MPI_Irecv(void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *);
int MPI_Wait(MPI_Request *, MPI_Status *);
int MPI_Waitall(int, MPI_Request[], MPI_Status[]);
int MPI_Reduce(const void *, void *, int, MPI_Datatype, MPI_Op, int, MPI_Comm);
int MPI_Ireduce(const void *, void *, int, MPI_Datatype, MPI_Op, int, MPI_Comm,
MPI_Request *);
int MPI_Bcast(void *, int count, MPI_Datatype, int, MPI_Comm);
#endif // end of include guard: MPIMOCK_H

test/clang-tidy/Inputs/unused-using-decls.h

  • This file was added.
class MyClass {
public:
template <template <typename> class S, typename T>
S<T> *func1(T *a) {
return new S<T>();
}
template <typename T, T (*S)()>
void func2(T a) {
S();
}
};

test/clang-tidy/cppcoreguidelines-special-member-functions-cxx-03.cpp

  • This file was added.
// RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t -- -- -std=c++03
class DefinesDestructor {
~DefinesDestructor();
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesDestructor' defines a destructor but does not define a copy constructor or a copy assignment operator [cppcoreguidelines-special-member-functions]
class DefinesCopyConstructor {
DefinesCopyConstructor(const DefinesCopyConstructor &);
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesCopyConstructor' defines a copy constructor but does not define a destructor or a copy assignment operator [cppcoreguidelines-special-member-functions]
class DefinesCopyAssignment {
DefinesCopyAssignment &operator=(const DefinesCopyAssignment &);
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesCopyAssignment' defines a copy assignment operator but does not define a destructor or a copy constructor [cppcoreguidelines-special-member-functions]
class DefinesNothing {
};
class DefinesEverything {
DefinesEverything(const DefinesEverything &);
DefinesEverything &operator=(const DefinesEverything &);
~DefinesEverything();
};

test/clang-tidy/cppcoreguidelines-special-member-functions.cpp

  • This file was added.
// RUN: %check_clang_tidy %s cppcoreguidelines-special-member-functions %t
class DefinesDestructor {
~DefinesDestructor();
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesDestructor' defines a destructor but does not define a copy constructor, a copy assignment operator, a move constructor or a move assignment operator [cppcoreguidelines-special-member-functions]
class DefinesCopyConstructor {
DefinesCopyConstructor(const DefinesCopyConstructor &);
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesCopyConstructor' defines a copy constructor but does not define a destructor, a copy assignment operator, a move constructor or a move assignment operator [cppcoreguidelines-special-member-functions]
class DefinesCopyAssignment {
DefinesCopyAssignment &operator=(const DefinesCopyAssignment &);
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesCopyAssignment' defines a copy assignment operator but does not define a destructor, a copy constructor, a move constructor or a move assignment operator [cppcoreguidelines-special-member-functions]
class DefinesMoveConstructor {
DefinesMoveConstructor(DefinesMoveConstructor &&);
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesMoveConstructor' defines a move constructor but does not define a destructor, a copy constructor, a copy assignment operator or a move assignment operator [cppcoreguidelines-special-member-functions]
class DefinesMoveAssignment {
DefinesMoveAssignment &operator=(DefinesMoveAssignment &&);
};
// CHECK-MESSAGES: [[@LINE-3]]:7: warning: class 'DefinesMoveAssignment' defines a move assignment operator but does not define a destructor, a copy constructor, a copy assignment operator or a move constructor [cppcoreguidelines-special-member-functions]
class DefinesNothing {
};
class DefinesEverything {
DefinesEverything(const DefinesEverything &);
DefinesEverything &operator=(const DefinesEverything &);
DefinesEverything(DefinesEverything &&);
DefinesEverything &operator=(DefinesEverything &&);
~DefinesEverything();
};
class DeletesEverything {
DeletesEverything(const DeletesEverything &) = delete;
DeletesEverything &operator=(const DeletesEverything &) = delete;
DeletesEverything(DeletesEverything &&) = delete;
DeletesEverything &operator=(DeletesEverything &&) = delete;
~DeletesEverything() = delete;
};
class DeletesCopyDefaultsMove {
DeletesCopyDefaultsMove(const DeletesCopyDefaultsMove &) = delete;
DeletesCopyDefaultsMove &operator=(const DeletesCopyDefaultsMove &) = delete;
DeletesCopyDefaultsMove(DeletesCopyDefaultsMove &&) = default;
DeletesCopyDefaultsMove &operator=(DeletesCopyDefaultsMove &&) = default;
~DeletesCopyDefaultsMove() = default;
};
template <typename T>
struct TemplateClass {
TemplateClass() = default;
TemplateClass(const TemplateClass &);
TemplateClass &operator=(const TemplateClass &);
TemplateClass(TemplateClass &&);
TemplateClass &operator=(TemplateClass &&);
~TemplateClass();
};
// Multiple instantiations of a class template will trigger multiple matches for defined special members.
// This should not cause problems.
TemplateClass<int> InstantiationWithInt;
TemplateClass<double> InstantiationWithDouble;

test/clang-tidy/misc-argument-comment-strict.cpp

  • This file was added.
// RUN: %check_clang_tidy %s misc-argument-comment %t -- \
// RUN: -config="{CheckOptions: [{key: StrictMode, value: 1}]}" --
void f(int _with_underscores_);
void g(int x_);
void ignores_underscores() {
f(/*With_Underscores=*/0);
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: argument name 'With_Underscores' in comment does not match parameter name '_with_underscores_'
// CHECK-FIXES: f(/*_with_underscores_=*/0);
f(/*with_underscores=*/1);
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: argument name 'with_underscores' in comment does not match parameter name '_with_underscores_'
// CHECK-FIXES: f(/*_with_underscores_=*/1);
f(/*_With_Underscores_=*/2);
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: argument name '_With_Underscores_' in comment does not match parameter name '_with_underscores_'
// CHECK-FIXES: f(/*_with_underscores_=*/2);
g(/*X=*/3);
// CHECK-MESSAGES: [[@LINE-1]]:5: warning: argument name 'X' in comment does not match parameter name 'x_'
// CHECK-FIXES: g(/*x_=*/3);
}

test/clang-tidy/misc-argument-comment.cpp

Show All 30 Lines
template<typename... Args> template<typename... Args>
void variadic(Args&&... args); void variadic(Args&&... args);
template<typename... Args> template<typename... Args>
void variadic2(int zzz, Args&&... args); void variadic2(int zzz, Args&&... args);
void templates() { void templates() {
variadic(/*xxx=*/0, /*yyy=*/1); variadic(/*xxx=*/0, /*yyy=*/1);
variadic2(/*zzZ=*/0, /*xxx=*/1, /*yyy=*/2); variadic2(/*zzU=*/0, /*xxx=*/1, /*yyy=*/2);
// CHECK-MESSAGES: [[@LINE-1]]:13: warning: argument name 'zzZ' in comment does not match parameter name 'zzz' // CHECK-MESSAGES: [[@LINE-1]]:13: warning: argument name 'zzU' in comment does not match parameter name 'zzz'
// CHECK-FIXES: variadic2(/*zzz=*/0, /*xxx=*/1, /*yyy=*/2); // CHECK-FIXES: variadic2(/*zzz=*/0, /*xxx=*/1, /*yyy=*/2);
} }
#define FALSE 0 #define FALSE 0
void qqq(bool aaa); void qqq(bool aaa);
void f() { qqq(/*bbb=*/FALSE); } void f() { qqq(/*bbb=*/FALSE); }
// CHECK-MESSAGES: [[@LINE-1]]:16: warning: argument name 'bbb' in comment does not match parameter name 'aaa' // CHECK-MESSAGES: [[@LINE-1]]:16: warning: argument name 'bbb' in comment does not match parameter name 'aaa'
// CHECK-FIXES: void f() { qqq(/*bbb=*/FALSE); } // CHECK-FIXES: void f() { qqq(/*bbb=*/FALSE); }
void f(bool _with_underscores_);
void ignores_underscores() {
f(/*With_Underscores=*/false);
}

test/clang-tidy/misc-unused-using-decls.cpp

// RUN: %check_clang_tidy %s misc-unused-using-decls %t -- -- -fno-delayed-template-parsing // RUN: %check_clang_tidy %s misc-unused-using-decls %t -- -- -fno-delayed-template-parsing -isystem %S/Inputs/
// ----- Definitions ----- // ----- Definitions -----
template <typename T> class vector {}; template <typename T> class vector {};
namespace n { namespace n {
class A; class A;
class B; class B;
class C; class C;
class D; class D;
Show All 39 Lines
enum Color2 { Red }; enum Color2 { Red };
enum Color3 { Yellow }; enum Color3 { Yellow };
enum Color4 { Blue }; enum Color4 { Blue };
} // namespace n } // namespace n
#include "unused-using-decls.h"
namespace ns {
template <typename T>
class AA {
T t;
};
template <typename T>
T ff() { T t; return t; }
} // namespace ns
// ----- Using declarations ----- // ----- Using declarations -----
// eol-comments aren't removed (yet) // eol-comments aren't removed (yet)
using n::A; // A using n::A; // A
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'A' is unused // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'A' is unused
// CHECK-FIXES: {{^}}// A // CHECK-FIXES: {{^}}// A
using n::B; using n::B;
using n::C; using n::C;
using n::D; using n::D;
▲ Show 20 Lines • Show All 66 Lines • ▼ Show 20 Lines
using n::Color1; using n::Color1;
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Color1' is unused // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Color1' is unused
using n::Green; using n::Green;
// CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Green' is unused // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: using decl 'Green' is unused
using n::Color2; using n::Color2;
using n::Color3; using n::Color3;
using n::Blue; using n::Blue;
using ns::AA;
using ns::ff;
// ----- Usages ----- // ----- Usages -----
void f(B b); void f(B b);
void g() { void g() {
vector<C> data; vector<C> data;
D::i = 1; D::i = 1;
F<int> f; F<int> f;
void (*func)() = &G::func; void (*func)() = &G::func;
int *i = &H::i; int *i = &H::i;
UsedInstance.i; UsedInstance.i;
UsedFunc(); UsedFunc();
UsedTemplateFunc<int>(); UsedTemplateFunc<int>();
cout << endl; cout << endl;
Color2 color2; Color2 color2;
int t1 = Color3::Yellow; int t1 = Color3::Yellow;
int t2 = Blue; int t2 = Blue;
MyClass a;
int t3 = 0;
a.func1<AA>(&t3);
a.func2<int, ff>(t3);
} }

test/clang-tidy/modernize-make-shared.cpp

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linesvoid basic() {
// This emulates std::move. // This emulates std::move.
std::shared_ptr<int> Move = static_cast<std::shared_ptr<int> &&>(P1); std::shared_ptr<int> Move = static_cast<std::shared_ptr<int> &&>(P1);
// Placemenet arguments should not be removed. // Placemenet arguments should not be removed.
int *PInt = new int; int *PInt = new int;
std::shared_ptr<int> Placement = std::shared_ptr<int>(new (PInt) int{3}); std::shared_ptr<int> Placement = std::shared_ptr<int>(new (PInt) int{3});
} }
class Private {
private:
Private(int z) {}
public:
void create() {
auto ptr = std::shared_ptr<Private>(new Private(42));
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Add comments explaining why make_shared is not correct. Also, please add a case showing that protected constructors still get the proper fix applied.

aaron.ballman: Add comments explaining why make_shared is not correct. Also, please add a case showing that…
PrazekAuthorUnsubmitted
Done
ReplyInline Actions

You mean I should also not warn when the constructor is protected? Make sense.

Prazek: You mean I should also not warn when the constructor is protected? Make sense.
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Correct, protected constructors should be handled like private constructors.

aaron.ballman: Correct, protected constructors should be handled like private constructors.
}
~Private();
};
void initialization(int T, Base b) { void initialization(int T, Base b) {
// Test different kinds of initialization of the pointee. // Test different kinds of initialization of the pointee.
// Direct initialization with parenthesis. // Direct initialization with parenthesis.
std::shared_ptr<DPair> PDir1 = std::shared_ptr<DPair>(new DPair(1, T)); std::shared_ptr<DPair> PDir1 = std::shared_ptr<DPair>(new DPair(1, T));
// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_shared instead // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_shared instead
// CHECK-FIXES: std::shared_ptr<DPair> PDir1 = std::make_shared<DPair>(1, T); // CHECK-FIXES: std::shared_ptr<DPair> PDir1 = std::make_shared<DPair>(1, T);
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/clang-tidy/modernize-make-unique.cpp

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Linesvoid basic() {
// This emulates std::move. // This emulates std::move.
std::unique_ptr<int> Move = static_cast<std::unique_ptr<int>&&>(P1); std::unique_ptr<int> Move = static_cast<std::unique_ptr<int>&&>(P1);
// Placemenet arguments should not be removed. // Placemenet arguments should not be removed.
int *PInt = new int; int *PInt = new int;
std::unique_ptr<int> Placement = std::unique_ptr<int>(new (PInt) int{3}); std::unique_ptr<int> Placement = std::unique_ptr<int>(new (PInt) int{3});
} }
class Private {
private:
Private(int z) {}
public:
void create() {
auto ptr = std::unique_ptr<Private>(new Private(42));
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Add comments as above.

aaron.ballman: Add comments as above.
}
};
void initialization(int T, Base b) { void initialization(int T, Base b) {
// Test different kinds of initialization of the pointee. // Test different kinds of initialization of the pointee.
// Direct initialization with parenthesis. // Direct initialization with parenthesis.
std::unique_ptr<DPair> PDir1 = std::unique_ptr<DPair>(new DPair(1, T)); std::unique_ptr<DPair> PDir1 = std::unique_ptr<DPair>(new DPair(1, T));
// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: use std::make_unique instead
// CHECK-FIXES: std::unique_ptr<DPair> PDir1 = std::make_unique<DPair>(1, T); // CHECK-FIXES: std::unique_ptr<DPair> PDir1 = std::make_unique<DPair>(1, T);
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

test/clang-tidy/modernize-pass-by-value-multi-fixes.cpp

  • This file was added.
// RUN: cat %S/Inputs/modernize-pass-by-value/header-with-fix.h > %T/pass-by-value-header-with-fix.h
// RUN: sed -e 's#//.*$##' %s > %t.cpp
// RUN: clang-tidy %t.cpp -checks='-*,modernize-pass-by-value' -header-filter='.*' -fix -- -std=c++11 -I %T | FileCheck %s -check-prefix=CHECK-MESSAGES -implicit-check-not="{{warning|error}}:"
// RUN: FileCheck -input-file=%t.cpp %s -check-prefix=CHECK-FIXES
// RUN: FileCheck -input-file=%T/pass-by-value-header-with-fix.h %s -check-prefix=CHECK-HEADER-FIXES
#include "pass-by-value-header-with-fix.h"
// CHECK-HEADER-FIXES: Foo(S s);
Foo::Foo(const S &s) : s(s) {}
// CHECK-MESSAGES: :9:10: warning: pass by value and use std::move [modernize-pass-by-value]
// CHECK-FIXES: #include <utility>
// CHECK-FIXES: Foo::Foo(S s) : s(std::move(s)) {}

test/clang-tidy/modernize-use-bool-literals.cpp

// RUN: %check_clang_tidy %s modernize-use-bool-literals %t // RUN: %check_clang_tidy %s modernize-use-bool-literals %t
bool IntToTrue = 1; bool IntToTrue = 1;
// CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals] // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals]
// CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}} // CHECK-FIXES: {{^}}bool IntToTrue = true;{{$}}
bool IntToFalse(0); bool IntToFalse(0);
// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}} // CHECK-FIXES: {{^}}bool IntToFalse(false);{{$}}
bool LongLongToTrue{0x1LL}; bool LongLongToTrue{0x1LL};
// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool LongLongToTrue{true};{{$}} // CHECK-FIXES: {{^}}bool LongLongToTrue{true};{{$}}
bool ExplicitCStyleIntToFalse = (bool)0; bool ExplicitCStyleIntToFalse = (bool)0;
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool ExplicitCStyleIntToFalse = false;{{$}} // CHECK-FIXES: {{^}}bool ExplicitCStyleIntToFalse = false;{{$}}
bool ExplicitFunctionalIntToFalse = bool(0); bool ExplicitFunctionalIntToFalse = bool(0);
// CHECK-MESSAGES: :[[@LINE-1]]:37: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:37: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool ExplicitFunctionalIntToFalse = false;{{$}} // CHECK-FIXES: {{^}}bool ExplicitFunctionalIntToFalse = false;{{$}}
bool ExplicitStaticIntToFalse = static_cast<bool>(0); bool ExplicitStaticIntToFalse = static_cast<bool>(0);
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:33: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool ExplicitStaticIntToFalse = false;{{$}} // CHECK-FIXES: {{^}}bool ExplicitStaticIntToFalse = false;{{$}}
#define TRUE_MACRO 1 #define TRUE_MACRO 1
// CHECK-FIXES: {{^}}#define TRUE_MACRO 1{{$}} // CHECK-FIXES: {{^}}#define TRUE_MACRO 1{{$}}
bool MacroIntToTrue = TRUE_MACRO; bool MacroIntToTrue = TRUE_MACRO;
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool, use bool literal instead [modernize-use-bool-literals] // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool MacroIntToTrue = TRUE_MACRO;{{$}} // CHECK-FIXES: {{^}}bool MacroIntToTrue = TRUE_MACRO;{{$}}
#define FALSE_MACRO bool(0) #define FALSE_MACRO bool(0)
// CHECK-FIXES: {{^}}#define FALSE_MACRO bool(0){{$}} // CHECK-FIXES: {{^}}#define FALSE_MACRO bool(0){{$}}
bool TrueBool = true; // OK bool TrueBool = true; // OK
bool FalseBool = bool(FALSE_MACRO); bool FalseBool = bool(FALSE_MACRO);
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool FalseBool = bool(FALSE_MACRO);{{$}} // CHECK-FIXES: {{^}}bool FalseBool = bool(FALSE_MACRO);{{$}}
void boolFunction(bool bar) { void boolFunction(bool bar) {
} }
char Character = 0; // OK char Character = 0; // OK
unsigned long long LongInteger = 1; // OK unsigned long long LongInteger = 1; // OK
#define MACRO_DEPENDENT_CAST(x) static_cast<bool>(x) #define MACRO_DEPENDENT_CAST(x) static_cast<bool>(x)
// CHECK-FIXES: {{^}}#define MACRO_DEPENDENT_CAST(x) static_cast<bool>(x){{$}} // CHECK-FIXES: {{^}}#define MACRO_DEPENDENT_CAST(x) static_cast<bool>(x){{$}}
bool MacroDependentBool = MACRO_DEPENDENT_CAST(0); bool MacroDependentBool = MACRO_DEPENDENT_CAST(0);
// CHECK-MESSAGES: :[[@LINE-1]]:27: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool MacroDependentBool = MACRO_DEPENDENT_CAST(0);{{$}} // CHECK-FIXES: {{^}}bool MacroDependentBool = MACRO_DEPENDENT_CAST(0);{{$}}
bool ManyMacrosDependent = MACRO_DEPENDENT_CAST(FALSE_MACRO); bool ManyMacrosDependent = MACRO_DEPENDENT_CAST(FALSE_MACRO);
// CHECK-MESSAGES: :[[@LINE-1]]:49: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: converting integer literal to bool
// CHECK-FIXES: {{^}}bool ManyMacrosDependent = MACRO_DEPENDENT_CAST(FALSE_MACRO);{{$}} // CHECK-FIXES: {{^}}bool ManyMacrosDependent = MACRO_DEPENDENT_CAST(FALSE_MACRO);{{$}}
class FooClass { class FooClass {
public: public:
FooClass() : JustBool(0) {} FooClass() : JustBool(0) {}
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}FooClass() : JustBool(false) {}{{$}} // CHECK-FIXES: {{^ *}}FooClass() : JustBool(false) {}{{$}}
FooClass(int) : JustBool{0} {} FooClass(int) : JustBool{0} {}
// CHECK-MESSAGES: :[[@LINE-1]]:28: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:28: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}FooClass(int) : JustBool{false} {}{{$}} // CHECK-FIXES: {{^ *}}FooClass(int) : JustBool{false} {}{{$}}
private: private:
bool JustBool; bool JustBool;
bool BoolWithBraces{0}; bool BoolWithBraces{0};
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}bool BoolWithBraces{false};{{$}} // CHECK-FIXES: {{^ *}}bool BoolWithBraces{false};{{$}}
bool BoolFromInt = 0; bool BoolFromInt = 0;
// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}bool BoolFromInt = false;{{$}} // CHECK-FIXES: {{^ *}}bool BoolFromInt = false;{{$}}
bool SimpleBool = true; // OK bool SimpleBool = true; // OK
}; };
template<typename type> template<typename type>
void templateFunction(type) { void templateFunction(type) {
type TemplateType = 0; type TemplateType = 0;
// CHECK-FIXES: {{^ *}}type TemplateType = 0;{{$}} // CHECK-FIXES: {{^ *}}type TemplateType = 0;{{$}}
} }
template<int c> template<int c>
void valueDependentTemplateFunction() { void valueDependentTemplateFunction() {
bool Boolean = c; bool Boolean = c;
// CHECK-FIXES: {{^ *}}bool Boolean = c;{{$}} // CHECK-FIXES: {{^ *}}bool Boolean = c;{{$}}
} }
template<typename type> template<typename type>
void anotherTemplateFunction(type) { void anotherTemplateFunction(type) {
bool JustBool = 0; bool JustBool = 0;
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}bool JustBool = false;{{$}} // CHECK-FIXES: {{^ *}}bool JustBool = false;{{$}}
} }
int main() { int main() {
boolFunction(1); boolFunction(1);
// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}boolFunction(true);{{$}} // CHECK-FIXES: {{^ *}}boolFunction(true);{{$}}
boolFunction(false); boolFunction(false);
templateFunction(0); templateFunction(0);
templateFunction(false); templateFunction(false);
valueDependentTemplateFunction<1>(); valueDependentTemplateFunction<1>();
anotherTemplateFunction(1); anotherTemplateFunction(1);
IntToTrue = 1; IntToTrue = 1;
// CHECK-MESSAGES: :[[@LINE-1]]:15: warning: {{.*}} // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}IntToTrue = true;{{$}} // CHECK-FIXES: {{^ *}}IntToTrue = true;{{$}}
} }
static int Value = 1;
bool Function1() {
bool Result = Value == 1 ? 1 : 0;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: converting integer literal to bool
// CHECK-MESSAGES: :[[@LINE-2]]:34: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}bool Result = Value == 1 ? true : false;{{$}}
return Result;
}
bool Function2() {
return Value == 1 ? 1 : 0;
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: converting integer literal to bool
// CHECK-MESSAGES: :[[@LINE-2]]:27: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}return Value == 1 ? true : false;{{$}}
}
void foo() {
bool Result;
Result = Value == 1 ? true : 0;
// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}Result = Value == 1 ? true : false;{{$}}
Result = Value == 1 ? false : bool(0);
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}Result = Value == 1 ? false : false;{{$}}
Result = Value == 1 ? (bool)0 : false;
// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: converting integer literal to bool
// CHECK-FIXES: {{^ *}}Result = Value == 1 ? false : false;{{$}}
}

test/clang-tidy/mpi-type-mismatch.cpp

  • This file was added.
// RUN: %check_clang_tidy %s mpi-type-mismatch %t -- -- -I %S/Inputs/mpi-type-mismatch
#include "mpimock.h"
void charNegativeTest() {
int buf;
MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int' does not match the MPI datatype 'MPI_CHAR'
short buf2;
MPI_Send(&buf2, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_CHAR'
long buf3;
MPI_Send(&buf3, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long' does not match the MPI datatype 'MPI_CHAR'
int8_t buf4;
MPI_Send(&buf4, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int8_t' does not match the MPI datatype 'MPI_CHAR'
uint16_t buf5;
MPI_Send(&buf5, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_CHAR'
long double _Complex buf6;
MPI_Send(&buf6, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_CHAR'
std::complex<float> buf7;
MPI_Send(&buf7, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_CHAR'
}
void intNegativeTest() {
unsigned char buf;
MPI_Send(&buf, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned char' does not match the MPI datatype 'MPI_INT'
unsigned buf2;
MPI_Send(&buf2, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_INT'
short buf3;
MPI_Send(&buf3, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_INT'
long buf4;
MPI_Send(&buf4, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long' does not match the MPI datatype 'MPI_INT'
int8_t buf5;
MPI_Send(&buf5, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int8_t' does not match the MPI datatype 'MPI_INT'
uint16_t buf6;
MPI_Send(&buf6, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_INT'
long double _Complex buf7;
MPI_Send(&buf7, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_INT'
std::complex<float> buf8;
MPI_Send(&buf8, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_INT'
}
void longNegativeTest() {
char buf;
MPI_Send(&buf, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_LONG'
unsigned buf2;
MPI_Send(&buf2, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_LONG'
unsigned short buf3;
MPI_Send(&buf3, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned short' does not match the MPI datatype 'MPI_LONG'
unsigned long buf4;
MPI_Send(&buf4, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_LONG'
int8_t buf5;
MPI_Send(&buf5, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int8_t' does not match the MPI datatype 'MPI_LONG'
uint16_t buf6;
MPI_Send(&buf6, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_LONG'
long double _Complex buf7;
MPI_Send(&buf7, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_LONG'
std::complex<float> buf8;
MPI_Send(&buf8, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_LONG'
}
void int8_tNegativeTest() {
char buf;
MPI_Send(&buf, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_INT8_T'
unsigned buf2;
MPI_Send(&buf2, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_INT8_T'
short buf3;
MPI_Send(&buf3, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_INT8_T'
unsigned long buf4;
MPI_Send(&buf4, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_INT8_T'
uint8_t buf5;
MPI_Send(&buf5, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint8_t' does not match the MPI datatype 'MPI_INT8_T'
uint16_t buf6;
MPI_Send(&buf6, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_INT8_T'
long double _Complex buf7;
MPI_Send(&buf7, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_INT8_T'
std::complex<float> buf8;
MPI_Send(&buf8, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_INT8_T'
}
void complex_c_long_double_complexNegativeTest() {
char buf;
MPI_Send(&buf, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
unsigned buf2;
MPI_Send(&buf2, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
short buf3;
MPI_Send(&buf3, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
unsigned long buf4;
MPI_Send(&buf4, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
uint8_t buf5;
MPI_Send(&buf5, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint8_t' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
uint16_t buf6;
MPI_Send(&buf6, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
double _Complex buf7;
MPI_Send(&buf7, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'double _Complex' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
std::complex<float> buf8;
MPI_Send(&buf8, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
}
void complex_cxx_float_complexNegativeTest() {
char buf;
MPI_Send(&buf, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
unsigned buf2;
MPI_Send(&buf2, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
short buf3;
MPI_Send(&buf3, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
unsigned long buf4;
MPI_Send(&buf4, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
uint8_t buf5;
MPI_Send(&buf5, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint8_t' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
uint16_t buf6;
MPI_Send(&buf6, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
double _Complex buf7;
MPI_Send(&buf7, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'double _Complex' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
std::complex<double> buf8;
MPI_Send(&buf8, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<double>' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
}
void skippedTypesTests() {
// typedefs, user defined MPI and nullptr types are skipped
typedef char CHAR;
CHAR buf;
MPI_Send(&buf, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
typedef unsigned UNSIGNED;
UNSIGNED buf2;
MPI_Send(&buf2, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
#define _MPI_LONG MPI_LONG
int buf3;
MPI_Send(&buf3, 1, _MPI_LONG, 0, 0, MPI_COMM_WORLD);
#define _MPI_CXX_FLOAT_COMPLEX MPI_CXX_FLOAT_COMPLEX
short buf4;
MPI_Send(&buf4, 1, _MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
MPI_Send(NULL, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
}
void positiveTests() {
char buf;
MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
int buf2;
MPI_Send(&buf2, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
long buf3;
MPI_Send(&buf3, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
int8_t buf4;
MPI_Send(&buf4, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
long double _Complex buf5;
MPI_Send(&buf5, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
std::complex<float> buf6;
MPI_Send(&buf6, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
uint8_t buf7;
MPI_Send(&buf7, 1, MPI_UINT8_T, 0, 0, MPI_COMM_WORLD);
uint16_t buf8;
MPI_Send(&buf8, 1, MPI_UINT16_T, 0, 0, MPI_COMM_WORLD);
// On some systems like PPC or ARM, 'char' is unsigned by default which is why
// distinct signedness for the buffer and MPI type is tolerated.
unsigned char buf9;
MPI_Send(&buf9, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
}

test/clang-tidy/performance-inefficient-string-concatenation.cpp

  • This file was added.
// RUN: %check_clang_tidy %s performance-inefficient-string-concatenation %t
namespace std {
template <typename T>
class basic_string {
public:
basic_string() {}
~basic_string() {}
basic_string<T> *operator+=(const basic_string<T> &) {}
friend basic_string<T> operator+(const basic_string<T> &, const basic_string<T> &) {}
};
typedef basic_string<char> string;
typedef basic_string<wchar_t> wstring;
}
void f(std::string) {}
std::string g(std::string) {}
int main() {
std::string mystr1, mystr2;
std::wstring mywstr1, mywstr2;
for (int i = 0; i < 10; ++i) {
f(mystr1 + mystr2 + mystr1);
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: string concatenation results in allocation of unnecessary temporary strings; consider using 'operator+=' or 'string::append()' instead
mystr1 = mystr1 + mystr2;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
mystr1 = mystr2 + mystr2 + mystr2;
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: string concatenation
mystr1 = mystr2 + mystr1;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
mywstr1 = mywstr2 + mywstr1;
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: string concatenation
mywstr1 = mywstr2 + mywstr2 + mywstr2;
// CHECK-MESSAGES: :[[@LINE-1]]:33: warning: string concatenation
mywstr1 = mywstr2 + mywstr2;
mystr1 = mystr2 + mystr2;
mystr1 += mystr2;
f(mystr2 + mystr1);
mystr1 = g(mystr1);
}
return 0;
}

test/include-fixer/commandline_options.cpp

// REQUIRES: shell // REQUIRES: shell
// RUN: echo "foo f;" > %t.cpp // RUN: echo "foo f;" > %t.cpp
// RUN: clang-include-fixer -db=fixed -input='foo= "foo.h","bar.h"' -output-headers %t.cpp -- | FileCheck %s // RUN: clang-include-fixer -db=fixed -input='foo= "foo.h","bar.h"' -output-headers %t.cpp -- | FileCheck %s
// RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"}]}' %t.cpp | FileCheck %s -check-prefix=CHECK-CODE // RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{FilePath: %t.cpp, QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"}]}' %t.cpp | FileCheck %s -check-prefix=CHECK-CODE
// RUN: cat %t.cpp | not clang-include-fixer -stdin -insert-header='{QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"},{Header: "\"foo2.h\"", QualifiedName: "foo"}]}' %t.cpp // RUN: cat %t.cpp | not clang-include-fixer -stdin -insert-header='{FilePath: %t.cpp, QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"},{Header: "\"foo2.h\"", QualifiedName: "foo"}]}' %t.cpp
// RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "a:foo"},{Header: "\"foo.h\"", QualifiedName: "b:foo"}]}' %t.cpp // RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{FilePath: %t.cpp, QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "a:foo"},{Header: "\"foo.h\"", QualifiedName: "b:foo"}]}' %t.cpp
// //
// CHECK: "HeaderInfos": [ // CHECK: "HeaderInfos": [
// CHECK-NEXT: {"Header": "\"foo.h\"", // CHECK-NEXT: {"Header": "\"foo.h\"",
// CHECK-NEXT: "QualifiedName": "foo"}, // CHECK-NEXT: "QualifiedName": "foo"},
// CHECK-NEXT: {"Header": "\"bar.h\"", // CHECK-NEXT: {"Header": "\"bar.h\"",
// CHECK-NEXT: "QualifiedName": "foo"} // CHECK-NEXT: "QualifiedName": "foo"}
// CHECK-NEXT:] // CHECK-NEXT:]
// //
// CHECK-CODE: #include "foo.h" // CHECK-CODE: #include "foo.h"
// CHECK-CODE: foo f; // CHECK-CODE: foo f;

test/include-fixer/multiple_fixes.cpp

  • This file was added.
// REQUIRES: shell
// RUN: sed -e 's#//.*$##' %s > %t.cpp
// RUN: mkdir -p %T/include-fixer/multiple-fixes
// RUN: echo 'foo f;' > %T/include-fixer/multiple-fixes/foo.cpp
// RUN: echo 'bar b;' > %T/include-fixer/multiple-fixes/bar.cpp
// RUN: clang-include-fixer -db=fixed -input='foo= "foo.h";bar= "bar.h"' %T/include-fixer/multiple-fixes/*.cpp --
// RUN: FileCheck -input-file=%T/include-fixer/multiple-fixes/bar.cpp %s -check-prefix=CHECK-BAR
// RUN: FileCheck -input-file=%T/include-fixer/multiple-fixes/foo.cpp %s -check-prefix=CHECK-FOO
//
// CHECK-FOO: #include "foo.h"
// CHECK-FOO: foo f;
// CHECK-BAR: #include "bar.h"
// CHECK-BAR: bar b;

tool-template/ToolTemplate.cpp

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
using namespace clang; using namespace clang;
using namespace clang::ast_matchers; using namespace clang::ast_matchers;
using namespace clang::tooling; using namespace clang::tooling;
using namespace llvm; using namespace llvm;
namespace { namespace {
class ToolTemplateCallback : public MatchFinder::MatchCallback { class ToolTemplateCallback : public MatchFinder::MatchCallback {
public: public:
ToolTemplateCallback(Replacements *Replace) : Replace(Replace) {} ToolTemplateCallback(std::map<std::string, Replacements> *Replace)
: Replace(Replace) {}
void run(const MatchFinder::MatchResult &Result) override { void run(const MatchFinder::MatchResult &Result) override {
// TODO: This routine will get called for each thing that the matchers find. // TODO: This routine will get called for each thing that the matchers
// find.
// At this point, you can examine the match, and do whatever you want, // At this point, you can examine the match, and do whatever you want,
// including replacing the matched text with other text // including replacing the matched text with other text
(void)Replace; // This to prevent an "unused member variable" warning; (void)Replace; // This to prevent an "unused member variable" warning;
} }
private: private:
Replacements *Replace; std::map<std::string, Replacements> *Replace;
}; };
} // end anonymous namespace } // end anonymous namespace
// Set up the command line options // Set up the command line options
static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage); static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
static cl::OptionCategory ToolTemplateCategory("tool-template options"); static cl::OptionCategory ToolTemplateCategory("tool-template options");
int main(int argc, const char **argv) { int main(int argc, const char **argv) {
Show All 13 Lines

unittests/clang-tidy/ClangTidyTest.h

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines if (!Invocation.run()) {
for (const auto &Error : Context.getErrors()) { for (const auto &Error : Context.getErrors()) {
ErrorText += Error.Message.Message + "\n"; ErrorText += Error.Message.Message + "\n";
} }
llvm::report_fatal_error(ErrorText); llvm::report_fatal_error(ErrorText);
} }
DiagConsumer.finish(); DiagConsumer.finish();
tooling::Replacements Fixes; tooling::Replacements Fixes;
for (const ClangTidyError &Error : Context.getErrors()) for (const ClangTidyError &Error : Context.getErrors()) {
Fixes.insert(Error.Fix.begin(), Error.Fix.end()); for (const auto &FileAndFixes : Error.Fix) {
for (const auto &Fix : FileAndFixes.second) {
auto Err = Fixes.add(Fix);
// FIXME: better error handling. Keep the behavior for now.
if (Err) {
llvm::errs() << llvm::toString(std::move(Err)) << "\n";
return "";
}
}
}
}
if (Errors) if (Errors)
*Errors = Context.getErrors(); *Errors = Context.getErrors();
auto Result = tooling::applyAllReplacements(Code, Fixes); auto Result = tooling::applyAllReplacements(Code, Fixes);
if (!Result) { if (!Result) {
// FIXME: propogate the error. // FIXME: propogate the error.
llvm::consumeError(Result.takeError()); llvm::consumeError(Result.takeError());
return ""; return "";
} }
Show All 11 Lines

unittests/clang-tidy/MiscModuleTest.cpp

Show All 17 Lines
TEST(ArgumentCommentCheckTest, ThisEditDistanceAboveThreshold) { TEST(ArgumentCommentCheckTest, ThisEditDistanceAboveThreshold) {
EXPECT_NO_CHANGES(ArgumentCommentCheck, EXPECT_NO_CHANGES(ArgumentCommentCheck,
"void f(int xxx); void g() { f(/*xyz=*/0); }"); "void f(int xxx); void g() { f(/*xyz=*/0); }");
} }
TEST(ArgumentCommentCheckTest, OtherEditDistanceAboveThreshold) { TEST(ArgumentCommentCheckTest, OtherEditDistanceAboveThreshold) {
EXPECT_EQ("void f(int xxx, int yyy); void g() { f(/*xxx=*/0, 0); }", EXPECT_EQ("void f(int xxx, int yyy); void g() { f(/*xxx=*/0, 0); }",
runCheckOnCode<ArgumentCommentCheck>( runCheckOnCode<ArgumentCommentCheck>(
"void f(int xxx, int yyy); void g() { f(/*Xxx=*/0, 0); }")); "void f(int xxx, int yyy); void g() { f(/*Zxx=*/0, 0); }"));
EXPECT_EQ("struct C { C(int xxx, int yyy); }; C c(/*xxx=*/0, 0);", EXPECT_EQ("struct C { C(int xxx, int yyy); }; C c(/*xxx=*/0, 0);",
runCheckOnCode<ArgumentCommentCheck>( runCheckOnCode<ArgumentCommentCheck>(
"struct C { C(int xxx, int yyy); }; C c(/*Xxx=*/0, 0);")); "struct C { C(int xxx, int yyy); }; C c(/*Zxx=*/0, 0);"));
} }
TEST(ArgumentCommentCheckTest, OtherEditDistanceBelowThreshold) { TEST(ArgumentCommentCheckTest, OtherEditDistanceBelowThreshold) {
EXPECT_NO_CHANGES(ArgumentCommentCheck, EXPECT_NO_CHANGES(ArgumentCommentCheck,
"void f(int xxx, int yyy); void g() { f(/*xxy=*/0, 0); }"); "void f(int xxx, int yyy); void g() { f(/*xxy=*/0, 0); }");
} }
} // namespace test } // namespace test
} // namespace tidy } // namespace tidy
} // namespace clang } // namespace clang

unittests/include-fixer/IncludeFixerTest.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines std::vector<SymbolInfo> Symbols = {
{SymbolInfo::ContextType::Namespace, "a"}}), {SymbolInfo::ContextType::Namespace, "a"}}),
SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 1, SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 1,
{{SymbolInfo::ContextType::Namespace, "__a"}, {{SymbolInfo::ContextType::Namespace, "__a"},
{SymbolInfo::ContextType::Namespace, "a"}}, {SymbolInfo::ContextType::Namespace, "a"}},
/*num_occurrences=*/2), /*num_occurrences=*/2),
SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 2, SymbolInfo("Vector", SymbolInfo::SymbolKind::Class, "\"Vector.h\"", 2,
{{SymbolInfo::ContextType::Namespace, "a"}}, {{SymbolInfo::ContextType::Namespace, "a"}},
/*num_occurrences=*/1), /*num_occurrences=*/1),
SymbolInfo("StrCat", SymbolInfo::SymbolKind::Class, "\"strcat.h\"",
1, {{SymbolInfo::ContextType::Namespace, "str"}}),
SymbolInfo("str", SymbolInfo::SymbolKind::Class, "\"str.h\"",
1, {}),
SymbolInfo("foo2", SymbolInfo::SymbolKind::Class, "\"foo2.h\"",
1, {}),
}; };
auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>(); auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
SymbolIndexMgr->addSymbolIndex( SymbolIndexMgr->addSymbolIndex(
llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols)); llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
IncludeFixerContext FixerContext; std::vector<IncludeFixerContext> FixerContexts;
IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContext, "llvm"); IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContexts, "llvm");
std::string FakeFileName = "input.cc"; std::string FakeFileName = "input.cc";
runOnCode(&Factory, Code, FakeFileName, ExtraArgs); runOnCode(&Factory, Code, FakeFileName, ExtraArgs);
if (FixerContext.getHeaderInfos().empty()) assert(FixerContexts.size() == 1);
if (FixerContexts.front().getHeaderInfos().empty())
return Code; return Code;
auto Replaces = clang::include_fixer::createIncludeFixerReplacements( auto Replaces = clang::include_fixer::createIncludeFixerReplacements(
Code, FakeFileName, FixerContext); Code, FixerContexts.front());
EXPECT_TRUE(static_cast<bool>(Replaces)) EXPECT_TRUE(static_cast<bool>(Replaces))
<< llvm::toString(Replaces.takeError()) << "\n"; << llvm::toString(Replaces.takeError()) << "\n";
if (!Replaces) if (!Replaces)
return ""; return "";
clang::RewriterTestContext Context; clang::RewriterTestContext Context;
clang::FileID ID = Context.createInMemoryFile(FakeFileName, Code); clang::FileID ID = Context.createInMemoryFile(FakeFileName, Code);
clang::tooling::applyAllReplacements(*Replaces, Context.Rewrite); clang::tooling::applyAllReplacements(*Replaces, Context.Rewrite);
return Context.getRewrittenText(ID); return Context.getRewrittenText(ID);
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 LinesTEST(IncludeFixer, ScopedNamespaceSymbols) {
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nvoid func() { b::bar b; }\n}", EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nvoid func() { b::bar b; }\n}",
runIncludeFixer("namespace a {\nvoid func() { b::bar b; }\n}")); runIncludeFixer("namespace a {\nvoid func() { b::bar b; }\n}"));
EXPECT_EQ("namespace A { c::b::bar b; }\n", EXPECT_EQ("namespace A { c::b::bar b; }\n",
runIncludeFixer("namespace A { c::b::bar b; }\n")); runIncludeFixer("namespace A { c::b::bar b; }\n"));
// FIXME: The header should not be added here. Remove this after we support // FIXME: The header should not be added here. Remove this after we support
// full match. // full match.
EXPECT_EQ("#include \"bar.h\"\nnamespace A {\na::b::bar b;\n}", EXPECT_EQ("#include \"bar.h\"\nnamespace A {\na::b::bar b;\n}",
runIncludeFixer("namespace A {\nb::bar b;\n}")); runIncludeFixer("namespace A {\nb::bar b;\n}"));
// Finds candidates for "str::StrCat".
EXPECT_EQ("#include \"strcat.h\"\nnamespace foo2 {\nstr::StrCat b;\n}",
runIncludeFixer("namespace foo2 {\nstr::StrCat b;\n}"));
// str::StrCat2 doesn't exist.
// In these two cases, StrCat2 is a nested class of class str.
EXPECT_EQ("#include \"str.h\"\nnamespace foo2 {\nstr::StrCat2 b;\n}",
runIncludeFixer("namespace foo2 {\nstr::StrCat2 b;\n}"));
EXPECT_EQ("#include \"str.h\"\nnamespace ns {\nstr::StrCat2 b;\n}",
runIncludeFixer("namespace ns {\nstr::StrCat2 b;\n}"));
} }
TEST(IncludeFixer, EnumConstantSymbols) { TEST(IncludeFixer, EnumConstantSymbols) {
EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n", EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n",
runIncludeFixer("int test = a::b::Green;\n")); runIncludeFixer("int test = a::b::Green;\n"));
} }
TEST(IncludeFixer, IgnoreSymbolFromHeader) { TEST(IncludeFixer, IgnoreSymbolFromHeader) {
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines EXPECT_EQ(
runIncludeFixer("namespace a {\nnamespace d {\nbar b;\n}\n}\n")); runIncludeFixer("namespace a {\nnamespace d {\nbar b;\n}\n}\n"));
EXPECT_EQ( EXPECT_EQ(
"#include \"bar.h\"\nnamespace d {\nnamespace a {\na::b::bar b;\n}\n}\n", "#include \"bar.h\"\nnamespace d {\nnamespace a {\na::b::bar b;\n}\n}\n",
runIncludeFixer("namespace d {\nnamespace a {\nbar b;\n}\n}\n")); runIncludeFixer("namespace d {\nnamespace a {\nbar b;\n}\n}\n"));
// Test nested classes. // Test nested classes.
EXPECT_EQ("#include \"bar.h\"\nnamespace d {\na::b::bar::t b;\n}\n", EXPECT_EQ("#include \"bar.h\"\nnamespace d {\na::b::bar::t b;\n}\n",
runIncludeFixer("namespace d {\nbar::t b;\n}\n")); runIncludeFixer("namespace d {\nbar::t b;\n}\n"));
EXPECT_EQ("#include \"bar2.h\"\nnamespace c {\na::c::bar::t b;\n}\n", EXPECT_EQ("#include \"bar.h\"\nnamespace c {\na::b::bar::t b;\n}\n",
runIncludeFixer("namespace c {\nbar::t b;\n}\n")); runIncludeFixer("namespace c {\nbar::t b;\n}\n"));
EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar::t b;\n}\n", EXPECT_EQ("#include \"bar.h\"\nnamespace a {\nb::bar::t b;\n}\n",
runIncludeFixer("namespace a {\nbar::t b;\n}\n")); runIncludeFixer("namespace a {\nbar::t b;\n}\n"));
EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n", EXPECT_EQ("#include \"color.h\"\nint test = a::b::Green;\n",
runIncludeFixer("int test = Green;\n")); runIncludeFixer("int test = Green;\n"));
EXPECT_EQ("#include \"color.h\"\nnamespace d {\nint test = a::b::Green;\n}\n", EXPECT_EQ("#include \"color.h\"\nnamespace d {\nint test = a::b::Green;\n}\n",
runIncludeFixer("namespace d {\nint test = Green;\n}\n")); runIncludeFixer("namespace d {\nint test = Green;\n}\n"));
▲ Show 20 Lines • Show All 81 Lines • Show Last 20 Lines
test/clang-rename/TemplateClassInstantiation.cpp