[BuildLibcalls, Attrs] Support more variants of C++'s new, add attributes for C+...
[lldb.git] / clang-tools-extra / modularize / ModularizeUtilities.h
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
33 namespace Modularize {
34
35 /// Modularize utilities class.
36 /// Support functions and data for modularize.
37 class ModularizeUtilities {
38 public:
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.map 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.map 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
129 protected:
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
169 public:
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   llvm::IntrusiveRefCntPtr<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 manager.
217   std::unique_ptr<clang::HeaderSearch> HeaderInfo;
218   // The loaded module map objects.
219   std::vector<std::unique_ptr<clang::ModuleMap>> ModuleMaps;
220 };
221
222 } // end namespace Modularize
223
224 #endif // MODULARIZEUTILITIES_H