| 1 |
//===--- HeaderIncludeCycleCheck.cpp - clang-tidy -------------------------===// |
| 2 |
// |
| 3 |
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 |
// See https://llvm.org/LICENSE.txt for license information. |
| 5 |
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 |
// |
| 7 |
//===----------------------------------------------------------------------===// |
| 8 |
|
| 9 |
#include "HeaderIncludeCycleCheck.h" |
| 10 |
#include "../utils/OptionsUtils.h" |
| 11 |
#include "clang/AST/ASTContext.h" |
| 12 |
#include "clang/ASTMatchers/ASTMatchFinder.h" |
| 13 |
#include "clang/Lex/PPCallbacks.h" |
| 14 |
#include "clang/Lex/Preprocessor.h" |
| 15 |
#include "llvm/ADT/SmallVector.h" |
| 16 |
#include "llvm/Support/Regex.h" |
| 17 |
#include <algorithm> |
| 18 |
#include <deque> |
| 19 |
#include <optional> |
| 20 |
#include <string> |
| 21 |
|
| 22 |
using namespace clang::ast_matchers; |
| 23 |
|
| 24 |
namespace clang::tidy::misc { |
| 25 |
|
| 26 |
namespace { |
| 27 |
|
| 28 |
struct Include { |
| 29 |
FileID Id; |
| 30 |
llvm::StringRef Name; |
| 31 |
SourceLocation Loc; |
| 32 |
}; |
| 33 |
|
| 34 |
class CyclicDependencyCallbacks : public PPCallbacks { |
| 35 |
public: |
| 36 |
CyclicDependencyCallbacks(HeaderIncludeCycleCheck &Check, |
| 37 |
const SourceManager &SM, |
| 38 |
const std::vector<StringRef> &IgnoredFilesList) |
| 39 |
: Check(Check), SM(SM) { |
| 40 |
IgnoredFilesRegexes.reserve(IgnoredFilesList.size()); |
| 41 |
for (const StringRef &It : IgnoredFilesList) { |
| 42 |
if (!It.empty()) |
| 43 |
IgnoredFilesRegexes.emplace_back(It); |
| 44 |
} |
| 45 |
} |
| 46 |
|
| 47 |
void FileChanged(SourceLocation Loc, FileChangeReason Reason, |
| 48 |
SrcMgr::CharacteristicKind FileType, |
| 49 |
FileID PrevFID) override { |
| 50 |
if (FileType != clang::SrcMgr::C_User) |
| 51 |
return; |
| 52 |
|
| 53 |
if (Reason != EnterFile && Reason != ExitFile) |
| 54 |
return; |
| 55 |
|
| 56 |
FileID Id = SM.getFileID(Loc); |
| 57 |
if (Id.isInvalid()) |
| 58 |
return; |
| 59 |
|
| 60 |
if (Reason == ExitFile) { |
| 61 |
if ((Files.size() > 1U) && (Files.back().Id == PrevFID) && |
| 62 |
(Files[Files.size() - 2U].Id == Id)) |
| 63 |
Files.pop_back(); |
| 64 |
return; |
| 65 |
} |
| 66 |
|
| 67 |
if (!Files.empty() && Files.back().Id == Id) |
| 68 |
return; |
| 69 |
|
| 70 |
std::optional<llvm::StringRef> FilePath = SM.getNonBuiltinFilenameForID(Id); |
| 71 |
llvm::StringRef FileName = |
| 72 |
FilePath ? llvm::sys::path::filename(*FilePath) : llvm::StringRef(); |
| 73 |
|
| 74 |
if (!NextToEnter) |
| 75 |
NextToEnter = Include{Id, FileName, SourceLocation()}; |
| 76 |
|
| 77 |
assert(NextToEnter->Name == FileName); |
| 78 |
NextToEnter->Id = Id; |
| 79 |
Files.emplace_back(*NextToEnter); |
| 80 |
NextToEnter.reset(); |
| 81 |
} |
| 82 |
|
| 83 |
void InclusionDirective(SourceLocation, const Token &, StringRef FilePath, |
| 84 |
bool, CharSourceRange Range, |
| 85 |
OptionalFileEntryRef File, StringRef, StringRef, |
| 86 |
const Module *, bool, |
| 87 |
SrcMgr::CharacteristicKind FileType) override { |
| 88 |
if (FileType != clang::SrcMgr::C_User) |
| 89 |
return; |
| 90 |
|
| 91 |
llvm::StringRef FileName = llvm::sys::path::filename(FilePath); |
| 92 |
NextToEnter = {FileID(), FileName, Range.getBegin()}; |
| 93 |
|
| 94 |
if (!File) |
| 95 |
return; |
| 96 |
|
| 97 |
FileID Id = SM.translateFile(*File); |
| 98 |
if (Id.isInvalid()) |
| 99 |
return; |
| 100 |
|
| 101 |
checkForDoubleInclude(Id, FileName, Range.getBegin()); |
| 102 |
} |
| 103 |
|
| 104 |
void EndOfMainFile() override { |
| 105 |
if (!Files.empty() && Files.back().Id == SM.getMainFileID()) |
| 106 |
Files.pop_back(); |
| 107 |
|
| 108 |
assert(Files.empty()); |
| 109 |
} |
| 110 |
|
| 111 |
void checkForDoubleInclude(FileID Id, llvm::StringRef FileName, |
| 112 |
SourceLocation Loc) { |
| 113 |
auto It = |
| 114 |
std::find_if(Files.rbegin(), Files.rend(), |
| 115 |
[&](const Include &Entry) { return Entry.Id == Id; }); |
| 116 |
if (It == Files.rend()) |
| 117 |
return; |
| 118 |
|
| 119 |
const std::optional<StringRef> FilePath = SM.getNonBuiltinFilenameForID(Id); |
| 120 |
if (!FilePath || isFileIgnored(*FilePath)) |
| 121 |
return; |
| 122 |
|
| 123 |
if (It == Files.rbegin()) { |
| 124 |
Check.diag(Loc, "direct self-inclusion of header file '%0'") << FileName; |
| 125 |
return; |
| 126 |
} |
| 127 |
|
| 128 |
Check.diag(Loc, "circular header file dependency detected while including " |
| 129 |
"'%0', please check the include path") |
| 130 |
<< FileName; |
| 131 |
|
| 132 |
const bool IsIncludePathValid = |
| 133 |
std::all_of(Files.rbegin(), It + 1, [](const Include &Elem) { |
| 134 |
return !Elem.Name.empty() && Elem.Loc.isValid(); |
| 135 |
}); |
| 136 |
if (!IsIncludePathValid) |
| 137 |
return; |
| 138 |
|
| 139 |
for (const Include &I : llvm::make_range(Files.rbegin(), It + 1)) |
| 140 |
Check.diag(I.Loc, "'%0' included from here", DiagnosticIDs::Note) |
| 141 |
<< I.Name; |
| 142 |
} |
| 143 |
|
| 144 |
bool isFileIgnored(StringRef FileName) const { |
| 145 |
return llvm::any_of(IgnoredFilesRegexes, [&](const llvm::Regex &It) { |
| 146 |
return It.match(FileName); |
| 147 |
}); |
| 148 |
} |
| 149 |
|
| 150 |
private: |
| 151 |
std::deque<Include> Files; |
| 152 |
std::optional<Include> NextToEnter; |
| 153 |
HeaderIncludeCycleCheck &Check; |
| 154 |
const SourceManager &SM; |
| 155 |
std::vector<llvm::Regex> IgnoredFilesRegexes; |
| 156 |
}; |
| 157 |
|
| 158 |
} // namespace |
| 159 |
|
| 160 |
HeaderIncludeCycleCheck::HeaderIncludeCycleCheck(StringRef Name, |
| 161 |
ClangTidyContext *Context) |
| 162 |
: ClangTidyCheck(Name, Context), |
| 163 |
IgnoredFilesList(utils::options::parseStringList( |
| 164 |
Options.get("IgnoredFilesList", ""))) {} |
| 165 |
|
| 166 |
void HeaderIncludeCycleCheck::registerPPCallbacks( |
| 167 |
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) { |
| 168 |
PP->addPPCallbacks( |
| 169 |
std::make_unique<CyclicDependencyCallbacks>(*this, SM, IgnoredFilesList)); |
| 170 |
} |
| 171 |
|
| 172 |
void HeaderIncludeCycleCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) { |
| 173 |
Options.store(Opts, "IgnoredFilesList", |
| 174 |
utils::options::serializeStringList(IgnoredFilesList)); |
| 175 |
} |
| 176 |
|
| 177 |
} // namespace clang::tidy::misc |