/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Tooling/Inclusions/HeaderIncludes.h
Line | Count | Source |
1 | | //===--- HeaderIncludes.h - Insert/Delete #includes for C++ code--*- C++-*-===// |
2 | | // |
3 | | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | | // See https://llvm.org/LICENSE.txt for license information. |
5 | | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | | // |
7 | | //===----------------------------------------------------------------------===// |
8 | | |
9 | | #ifndef LLVM_CLANG_TOOLING_INCLUSIONS_HEADERINCLUDES_H |
10 | | #define LLVM_CLANG_TOOLING_INCLUSIONS_HEADERINCLUDES_H |
11 | | |
12 | | #include "clang/Basic/SourceManager.h" |
13 | | #include "clang/Tooling/Core/Replacement.h" |
14 | | #include "clang/Tooling/Inclusions/IncludeStyle.h" |
15 | | #include "llvm/Support/Path.h" |
16 | | #include "llvm/Support/Regex.h" |
17 | | #include <list> |
18 | | #include <unordered_map> |
19 | | |
20 | | namespace clang { |
21 | | namespace tooling { |
22 | | |
23 | | /// This class manages priorities of C++ #include categories and calculates |
24 | | /// priorities for headers. |
25 | | /// FIXME(ioeric): move this class into implementation file when clang-format's |
26 | | /// include sorting functions are also moved here. |
27 | | class IncludeCategoryManager { |
28 | | public: |
29 | | IncludeCategoryManager(const IncludeStyle &Style, StringRef FileName); |
30 | | |
31 | | /// Returns the priority of the category which \p IncludeName belongs to. |
32 | | /// If \p CheckMainHeader is true and \p IncludeName is a main header, returns |
33 | | /// 0. Otherwise, returns the priority of the matching category or INT_MAX. |
34 | | /// NOTE: this API is not thread-safe! |
35 | | int getIncludePriority(StringRef IncludeName, bool CheckMainHeader) const; |
36 | | int getSortIncludePriority(StringRef IncludeName, bool CheckMainHeader) const; |
37 | | |
38 | | private: |
39 | | bool isMainHeader(StringRef IncludeName) const; |
40 | | |
41 | | const IncludeStyle Style; |
42 | | bool IsMainFile; |
43 | | std::string FileName; |
44 | | SmallVector<llvm::Regex, 4> CategoryRegexs; |
45 | | }; |
46 | | |
47 | | /// Generates replacements for inserting or deleting #include directives in a |
48 | | /// file. |
49 | | class HeaderIncludes { |
50 | | public: |
51 | | HeaderIncludes(llvm::StringRef FileName, llvm::StringRef Code, |
52 | | const IncludeStyle &Style); |
53 | | |
54 | | /// Inserts an #include directive of \p Header into the code. If \p IsAngled |
55 | | /// is true, \p Header will be quoted with <> in the directive; otherwise, it |
56 | | /// will be quoted with "". |
57 | | /// |
58 | | /// When searching for points to insert new header, this ignores #include's |
59 | | /// after the #include block(s) in the beginning of a file to avoid inserting |
60 | | /// headers into code sections where new #include's should not be added by |
61 | | /// default. These code sections include: |
62 | | /// - raw string literals (containing #include). |
63 | | /// - #if blocks. |
64 | | /// - Special #include's among declarations (e.g. functions). |
65 | | /// |
66 | | /// Returns a replacement that inserts the new header into a suitable #include |
67 | | /// block of the same category. This respects the order of the existing |
68 | | /// #includes in the block; if the existing #includes are not already sorted, |
69 | | /// this will simply insert the #include in front of the first #include of the |
70 | | /// same category in the code that should be sorted after \p IncludeName. If |
71 | | /// \p IncludeName already exists (with exactly the same spelling), this |
72 | | /// returns None. |
73 | | llvm::Optional<tooling::Replacement> insert(llvm::StringRef Header, |
74 | | bool IsAngled) const; |
75 | | |
76 | | /// Removes all existing #includes of \p Header quoted with <> if \p IsAngled |
77 | | /// is true or "" if \p IsAngled is false. |
78 | | /// This doesn't resolve the header file path; it only deletes #includes with |
79 | | /// exactly the same spelling. |
80 | | tooling::Replacements remove(llvm::StringRef Header, bool IsAngled) const; |
81 | | |
82 | | private: |
83 | | struct Include { |
84 | 194 | Include(StringRef Name, tooling::Range R) : Name(Name), R(R) {} |
85 | | |
86 | | // An include header quoted with either <> or "". |
87 | | std::string Name; |
88 | | // The range of the whole line of include directive including any leading |
89 | | // whitespaces and trailing comment. |
90 | | tooling::Range R; |
91 | | }; |
92 | | |
93 | | void addExistingInclude(Include IncludeToAdd, unsigned NextLineOffset); |
94 | | |
95 | | std::string FileName; |
96 | | std::string Code; |
97 | | |
98 | | // Map from include name (quotation trimmed) to a list of existing includes |
99 | | // (in case there are more than one) with the name in the current file. <x> |
100 | | // and "x" will be treated as the same header when deleting #includes. |
101 | | // std::list is used for pointers stability (see IncludesByPriority) |
102 | | llvm::StringMap<std::list<Include>> ExistingIncludes; |
103 | | |
104 | | /// Map from priorities of #include categories to all #includes in the same |
105 | | /// category. This is used to find #includes of the same category when |
106 | | /// inserting new #includes. #includes in the same categories are sorted in |
107 | | /// in the order they appear in the source file. |
108 | | /// See comment for "FormatStyle::IncludeCategories" for details about include |
109 | | /// priorities. |
110 | | std::unordered_map<int, llvm::SmallVector<const Include *, 8>> |
111 | | IncludesByPriority; |
112 | | |
113 | | int FirstIncludeOffset; |
114 | | // All new headers should be inserted after this offset (e.g. after header |
115 | | // guards, file comment). |
116 | | unsigned MinInsertOffset; |
117 | | // Max insertion offset in the original code. For example, we want to avoid |
118 | | // inserting new #includes into the actual code section (e.g. after a |
119 | | // declaration). |
120 | | unsigned MaxInsertOffset; |
121 | | IncludeCategoryManager Categories; |
122 | | // Record the offset of the end of the last include in each category. |
123 | | std::unordered_map<int, int> CategoryEndOffsets; |
124 | | |
125 | | // All possible priorities. |
126 | | std::set<int> Priorities; |
127 | | |
128 | | // Matches a whole #include directive. |
129 | | llvm::Regex IncludeRegex; |
130 | | }; |
131 | | |
132 | | } // namespace tooling |
133 | | } // namespace clang |
134 | | |
135 | | #endif // LLVM_CLANG_TOOLING_INCLUSIONS_HEADERINCLUDES_H |