1//=====-- ModularizeUtilities.h - Utilities for modularize -*- 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/// \file
10/// ModularizeUtilities class definition.
11///
12//===--------------------------------------------------------------------===//
13
14#ifndef MODULARIZEUTILITIES_H
15#define MODULARIZEUTILITIES_H
16
17#include "Modularize.h"
18#include "clang/Basic/Diagnostic.h"
19#include "clang/Basic/FileManager.h"
20#include "clang/Basic/LangOptions.h"
21#include "clang/Basic/TargetInfo.h"
22#include "clang/Basic/TargetOptions.h"
23#include "clang/Frontend/TextDiagnosticPrinter.h"
24#include "clang/Lex/HeaderSearch.h"
25#include "clang/Lex/HeaderSearchOptions.h"
26#include "clang/Lex/ModuleMap.h"
27#include "clang/Lex/Preprocessor.h"
28#include "llvm/ADT/SmallVector.h"
29#include "llvm/ADT/StringSet.h"
30#include <string>
31#include <vector>
32
33namespace Modularize {
34
35/// Modularize utilities class.
36/// Support functions and data for modularize.
37class ModularizeUtilities {
38public:
39 // Input arguments.
40
41 /// The input file paths.
42 std::vector<std::string> InputFilePaths;
43 /// The header prefix.
44 llvm::StringRef HeaderPrefix;
45 /// The path of problem files list file.
46 llvm::StringRef ProblemFilesPath;
47
48 // Output data.
49
50 /// List of top-level header files.
51 llvm::SmallVector<std::string, 32> HeaderFileNames;
52 /// Map of top-level header file dependencies.
53 DependencyMap Dependencies;
54 /// True if we have module maps.
55 bool HasModuleMap;
56 /// Missing header count.
57 int MissingHeaderCount;
58 /// List of header files with no problems during the first pass,
59 /// that is, no compile errors.
60 llvm::SmallVector<std::string, 32> GoodFileNames;
61 /// List of header files with problems.
62 llvm::SmallVector<std::string, 32> ProblemFileNames;
63
64 // Functions.
65
66 /// Constructor.
67 /// You can use the static createModularizeUtilities to create an instance
68 /// of this object.
69 /// \param InputPaths The input file paths.
70 /// \param Prefix The headear path prefix.
71 /// \param ProblemFilesListPath The problem header list path.
72 ModularizeUtilities(std::vector<std::string> &InputPaths,
73 llvm::StringRef Prefix,
74 llvm::StringRef ProblemFilesListPath);
75
76 /// Create instance of ModularizeUtilities.
77 /// \param InputPaths The input file paths.
78 /// \param Prefix The headear path prefix.
79 /// \param ProblemFilesListPath The problem header list path.
80 /// \returns Initialized ModularizeUtilities object.
81 static ModularizeUtilities *createModularizeUtilities(
82 std::vector<std::string> &InputPaths,
83 llvm::StringRef Prefix,
84 llvm::StringRef ProblemFilesListPath);
85
86 /// Load header list and dependencies.
87 /// \returns std::error_code.
88 std::error_code loadAllHeaderListsAndDependencies();
89
90 /// Do coverage checks.
91 /// For each loaded module map, do header coverage check.
92 /// Starting from the directory of the module.modulemap file,
93 /// Find all header files, optionally looking only at files
94 /// covered by the include path options, and compare against
95 /// the headers referenced by the module.modulemap file.
96 /// Display warnings for unaccounted-for header files.
97 /// \param IncludePaths The include paths to check for files.
98 /// (Note that other directories above these paths are ignored.
99 /// To expect all files to be accounted for from the module.modulemap
100 /// file directory on down, leave this empty.)
101 /// \param CommandLine Compile command line arguments.
102 /// \returns 0 if there were no errors or warnings, 1 if there
103 /// were warnings, 2 if any other problem, such as a bad
104 /// module map path argument was specified.
105 std::error_code doCoverageCheck(std::vector<std::string> &IncludePaths,
106 llvm::ArrayRef<std::string> CommandLine);
107
108 /// Add unique problem file.
109 /// Also standardizes the path.
110 /// \param FilePath Problem file path.
111 void addUniqueProblemFile(std::string FilePath);
112
113 /// Add file with no compile errors.
114 /// Also standardizes the path.
115 /// \param FilePath Problem file path.
116 void addNoCompileErrorsFile(std::string FilePath);
117
118 /// List problem files.
119 void displayProblemFiles();
120
121 /// List files with no problems.
122 void displayGoodFiles();
123
124 /// List files with problem files commented out.
125 void displayCombinedFiles();
126
127 // Internal.
128
129protected:
130
131 /// Load single header list and dependencies.
132 /// \param InputPath The input file path.
133 /// \returns std::error_code.
134 std::error_code loadSingleHeaderListsAndDependencies(
135 llvm::StringRef InputPath);
136
137 /// Load problem header list.
138 /// \param InputPath The input file path.
139 /// \returns std::error_code.
140 std::error_code loadProblemHeaderList(
141 llvm::StringRef InputPath);
142
143 /// Load single module map and extract header file list.
144 /// \param InputPath The input file path.
145 /// \returns std::error_code.
146 std::error_code loadModuleMap(
147 llvm::StringRef InputPath);
148
149 /// Collect module Map headers.
150 /// Walks the modules and collects referenced headers into
151 /// HeaderFileNames.
152 /// \param ModMap A loaded module map object.
153 /// \return True if no errors.
154 bool collectModuleMapHeaders(clang::ModuleMap *ModMap);
155
156 /// Collect referenced headers from one module.
157 /// Collects the headers referenced in the given module into
158 /// HeaderFileNames.
159 /// \param Mod The module reference.
160 /// \return True if no errors.
161 bool collectModuleHeaders(const clang::Module &Mod);
162
163 /// Collect headers from an umbrella directory.
164 /// \param UmbrellaDirName The umbrella directory name.
165 /// \return True if no errors.
166 bool collectUmbrellaHeaders(llvm::StringRef UmbrellaDirName,
167 DependentsVector &Dependents);
168
169public:
170
171 // Utility functions.
172
173 /// Convert header path to canonical form.
174 /// The canonical form is basically just use forward slashes,
175 /// and remove "./".
176 /// \param FilePath The file path.
177 /// \returns The file path in canonical form.
178 static std::string getCanonicalPath(llvm::StringRef FilePath);
179
180 /// Check for header file extension.
181 /// If the file extension is .h, .inc, or missing, it's
182 /// assumed to be a header.
183 /// \param FileName The file name. Must not be a directory.
184 /// \returns true if it has a header extension or no extension.
185 static bool isHeader(llvm::StringRef FileName);
186
187 /// Get directory path component from file path.
188 /// \returns the component of the given path, which will be
189 /// relative if the given path is relative, absolute if the
190 /// given path is absolute, or "." if the path has no leading
191 /// path component.
192 static std::string getDirectoryFromPath(llvm::StringRef Path);
193
194 // Internal data.
195
196 /// Options controlling the language variant.
197 std::shared_ptr<clang::LangOptions> LangOpts;
198 /// Diagnostic IDs.
199 const llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagIDs;
200 /// Options controlling the diagnostic engine.
201 clang::DiagnosticOptions DiagnosticOpts;
202 /// Diagnostic consumer.
203 clang::TextDiagnosticPrinter DC;
204 /// Diagnostic engine.
205 llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> Diagnostics;
206 /// Options controlling the target.
207 std::shared_ptr<clang::TargetOptions> TargetOpts;
208 /// Target information.
209 llvm::IntrusiveRefCntPtr<clang::TargetInfo> Target;
210 /// Options controlling the file system manager.
211 clang::FileSystemOptions FileSystemOpts;
212 /// File system manager.
213 llvm::IntrusiveRefCntPtr<clang::FileManager> FileMgr;
214 /// Source manager.
215 llvm::IntrusiveRefCntPtr<clang::SourceManager> SourceMgr;
216 /// Header search options.
217 clang::HeaderSearchOptions HSOpts;
218 /// Header search manager.
219 std::unique_ptr<clang::HeaderSearch> HeaderInfo;
220 // The loaded module map objects.
221 std::vector<std::unique_ptr<clang::ModuleMap>> ModuleMaps;
222};
223
224} // end namespace Modularize
225
226#endif // MODULARIZEUTILITIES_H
227

source code of clang-tools-extra/modularize/ModularizeUtilities.h