1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
| //===--- RestrictSystemIncludesCheck.cpp - clang-tidy----------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "RestrictSystemIncludesCheck.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Lex/HeaderSearch.h"
#include "clang/Lex/PPCallbacks.h"
#include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Path.h"
#include <cstring>
namespace clang {
namespace tidy {
namespace fuchsia {
class RestrictedIncludesPPCallbacks : public PPCallbacks {
public:
explicit RestrictedIncludesPPCallbacks(RestrictSystemIncludesCheck &Check,
const SourceManager &SM)
: Check(Check), SM(SM) {}
void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
StringRef FileName, bool IsAngled,
CharSourceRange FilenameRange, const FileEntry *File,
StringRef SearchPath, StringRef RelativePath,
const Module *Imported,
SrcMgr::CharacteristicKind FileType) override;
void EndOfMainFile() override;
private:
struct IncludeDirective {
IncludeDirective() = default;
IncludeDirective(SourceLocation Loc, CharSourceRange Range,
StringRef Filename, StringRef FullPath, bool IsInMainFile)
: Loc(Loc), Range(Range), IncludeFile(Filename), IncludePath(FullPath),
IsInMainFile(IsInMainFile) {}
SourceLocation Loc; // '#' location in the include directive
CharSourceRange Range; // SourceRange for the file name
std::string IncludeFile; // Filename as a string
std::string IncludePath; // Full file path as a string
bool IsInMainFile; // Whether or not the include is in the main file
};
using FileIncludes = llvm::SmallVector<IncludeDirective, 8>;
llvm::SmallDenseMap<FileID, FileIncludes> IncludeDirectives;
RestrictSystemIncludesCheck &Check;
const SourceManager &SM;
};
void RestrictedIncludesPPCallbacks::InclusionDirective(
SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
StringRef SearchPath, StringRef RelativePath, const Module *Imported,
SrcMgr::CharacteristicKind FileType) {
if (!Check.contains(FileName) && SrcMgr::isSystem(FileType)) {
SmallString<256> FullPath;
llvm::sys::path::append(FullPath, SearchPath);
llvm::sys::path::append(FullPath, RelativePath);
// Bucket the allowed include directives by the id of the file they were
// declared in.
IncludeDirectives[SM.getFileID(HashLoc)].emplace_back(
HashLoc, FilenameRange, FileName, FullPath.str(),
SM.isInMainFile(HashLoc));
}
}
void RestrictedIncludesPPCallbacks::EndOfMainFile() {
for (const auto &Bucket : IncludeDirectives) {
const FileIncludes &FileDirectives = Bucket.second;
// Emit fixits for all restricted includes.
for (const auto &Include : FileDirectives) {
// Fetch the length of the include statement from the start to just after
// the newline, for finding the end (including the newline).
unsigned ToLen = std::strcspn(SM.getCharacterData(Include.Loc), "\n") + 1;
CharSourceRange ToRange = CharSourceRange::getCharRange(
Include.Loc, Include.Loc.getLocWithOffset(ToLen));
if (!Include.IsInMainFile) {
auto D = Check.diag(
Include.Loc,
"system include %0 not allowed, transitively included from %1");
D << Include.IncludeFile << SM.getFilename(Include.Loc);
D << FixItHint::CreateRemoval(ToRange);
continue;
}
auto D = Check.diag(Include.Loc, "system include %0 not allowed");
D << Include.IncludeFile;
D << FixItHint::CreateRemoval(ToRange);
}
}
}
void RestrictSystemIncludesCheck::registerPPCallbacks(
const SourceManager &SM, Preprocessor *PP, Preprocessor *ModuleExpanderPP) {
PP->addPPCallbacks(
std::make_unique<RestrictedIncludesPPCallbacks>(*this, SM));
}
void RestrictSystemIncludesCheck::storeOptions(
ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "Includes", AllowedIncludes);
}
} // namespace fuchsia
} // namespace tidy
} // namespace clang
|