|
150
|
1 //===-- CoverageChecker.h - Module map coverage checker -*- 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 /// Definitions for CoverageChecker.
|
|
|
11 ///
|
|
|
12 //===--------------------------------------------------------------------===//
|
|
|
13
|
|
|
14 #ifndef COVERAGECHECKER_H
|
|
|
15 #define COVERAGECHECKER_H
|
|
|
16
|
|
|
17 #include "clang/Basic/Diagnostic.h"
|
|
|
18 #include "clang/Basic/FileManager.h"
|
|
|
19 #include "clang/Basic/LangOptions.h"
|
|
|
20 #include "clang/Basic/TargetInfo.h"
|
|
|
21 #include "clang/Basic/TargetOptions.h"
|
|
|
22 #include "clang/Frontend/TextDiagnosticPrinter.h"
|
|
|
23 #include "clang/Lex/HeaderSearch.h"
|
|
|
24 #include "clang/Lex/HeaderSearchOptions.h"
|
|
|
25 #include "clang/Lex/ModuleMap.h"
|
|
|
26 #include "clang/Lex/Preprocessor.h"
|
|
|
27 #include "llvm/ADT/StringSet.h"
|
|
|
28 #include "llvm/Support/Host.h"
|
|
|
29 #include <string>
|
|
|
30 #include <vector>
|
|
|
31
|
|
|
32 namespace Modularize {
|
|
|
33
|
|
|
34 /// Module map checker class.
|
|
|
35 /// This is the heart of the checker.
|
|
|
36 /// The doChecks function does the main work.
|
|
|
37 /// The data members store the options and internally collected data.
|
|
|
38 class CoverageChecker {
|
|
|
39 // Checker arguments.
|
|
|
40
|
|
|
41 /// The module.modulemap file path. Can be relative or absolute.
|
|
|
42 llvm::StringRef ModuleMapPath;
|
|
|
43 /// The include paths to check for files.
|
|
|
44 /// (Note that other directories above these paths are ignored.
|
|
|
45 /// To expect all files to be accounted for from the module.modulemap
|
|
|
46 /// file directory on down, leave this empty.)
|
|
|
47 std::vector<std::string> IncludePaths;
|
|
|
48 /// The remaining arguments, to be passed to the front end.
|
|
|
49 llvm::ArrayRef<std::string> CommandLine;
|
|
|
50 /// The module map.
|
|
|
51 clang::ModuleMap *ModMap;
|
|
|
52
|
|
|
53 // Internal data.
|
|
|
54
|
|
|
55 /// Directory containing the module map.
|
|
|
56 /// Might be relative to the current directory, or absolute.
|
|
|
57 std::string ModuleMapDirectory;
|
|
|
58 /// Set of all the headers found in the module map.
|
|
|
59 llvm::StringSet<llvm::MallocAllocator> ModuleMapHeadersSet;
|
|
|
60 /// All the headers found in the file system starting at the
|
|
|
61 /// module map, or the union of those from the include paths.
|
|
|
62 std::vector<std::string> FileSystemHeaders;
|
|
|
63 /// Headers found in file system, but not in module map.
|
|
|
64 std::vector<std::string> UnaccountedForHeaders;
|
|
|
65
|
|
|
66 public:
|
|
|
67 /// Constructor.
|
|
|
68 /// You can use the static createCoverageChecker to create an instance
|
|
|
69 /// of this object.
|
|
|
70 /// \param ModuleMapPath The module.modulemap file path.
|
|
|
71 /// Can be relative or absolute.
|
|
|
72 /// \param IncludePaths The include paths to check for files.
|
|
|
73 /// (Note that other directories above these paths are ignored.
|
|
|
74 /// To expect all files to be accounted for from the module.modulemap
|
|
|
75 /// file directory on down, leave this empty.)
|
|
|
76 /// \param CommandLine Compile command line arguments.
|
|
|
77 /// \param ModuleMap The module map to check.
|
|
|
78 CoverageChecker(llvm::StringRef ModuleMapPath,
|
|
|
79 std::vector<std::string> &IncludePaths,
|
|
|
80 llvm::ArrayRef<std::string> CommandLine,
|
|
|
81 clang::ModuleMap *ModuleMap);
|
|
|
82
|
|
|
83 /// Create instance of CoverageChecker.
|
|
|
84 /// \param ModuleMapPath The module.modulemap file path.
|
|
|
85 /// Can be relative or absolute.
|
|
|
86 /// \param IncludePaths The include paths to check for files.
|
|
|
87 /// (Note that other directories above these paths are ignored.
|
|
|
88 /// To expect all files to be accounted for from the module.modulemap
|
|
|
89 /// file directory on down, leave this empty.)
|
|
|
90 /// \param CommandLine Compile command line arguments.
|
|
|
91 /// \param ModuleMap The module map to check.
|
|
|
92 /// \returns Initialized CoverageChecker object.
|
|
|
93 static std::unique_ptr<CoverageChecker> createCoverageChecker(
|
|
|
94 llvm::StringRef ModuleMapPath, std::vector<std::string> &IncludePaths,
|
|
|
95 llvm::ArrayRef<std::string> CommandLine, clang::ModuleMap *ModuleMap);
|
|
|
96
|
|
|
97 /// Do checks.
|
|
|
98 /// Starting from the directory of the module.modulemap file,
|
|
|
99 /// Find all header files, optionally looking only at files
|
|
|
100 /// covered by the include path options, and compare against
|
|
|
101 /// the headers referenced by the module.modulemap file.
|
|
|
102 /// Display warnings for unaccounted-for header files.
|
|
|
103 /// \returns 0 if there were no errors or warnings, 1 if there
|
|
|
104 /// were warnings, 2 if any other problem, such as a bad
|
|
|
105 /// module map path argument was specified.
|
|
|
106 std::error_code doChecks();
|
|
|
107
|
|
|
108 // The following functions are called by doChecks.
|
|
|
109
|
|
|
110 /// Collect module headers.
|
|
|
111 /// Walks the modules and collects referenced headers into
|
|
|
112 /// ModuleMapHeadersSet.
|
|
|
113 void collectModuleHeaders();
|
|
|
114
|
|
|
115 /// Collect referenced headers from one module.
|
|
|
116 /// Collects the headers referenced in the given module into
|
|
|
117 /// ModuleMapHeadersSet.
|
|
|
118 /// \param Mod The module reference.
|
|
|
119 /// \return True if no errors.
|
|
|
120 bool collectModuleHeaders(const clang::Module &Mod);
|
|
|
121
|
|
|
122 /// Collect headers from an umbrella directory.
|
|
|
123 /// \param UmbrellaDirName The umbrella directory name.
|
|
|
124 /// \return True if no errors.
|
|
|
125 bool collectUmbrellaHeaders(llvm::StringRef UmbrellaDirName);
|
|
|
126
|
|
173
|
127 /// Collect headers referenced from an umbrella file.
|
|
150
|
128 /// \param UmbrellaHeaderName The umbrella file path.
|
|
|
129 /// \return True if no errors.
|
|
|
130 bool collectUmbrellaHeaderHeaders(llvm::StringRef UmbrellaHeaderName);
|
|
|
131
|
|
|
132 /// Called from CoverageCheckerCallbacks to track a header included
|
|
|
133 /// from an umbrella header.
|
|
|
134 /// \param HeaderName The header file path.
|
|
|
135 void collectUmbrellaHeaderHeader(llvm::StringRef HeaderName);
|
|
|
136
|
|
|
137 /// Collect file system header files.
|
|
|
138 /// This function scans the file system for header files,
|
|
|
139 /// starting at the directory of the module.modulemap file,
|
|
|
140 /// optionally filtering out all but the files covered by
|
|
|
141 /// the include path options.
|
|
|
142 /// \returns True if no errors.
|
|
|
143 bool collectFileSystemHeaders();
|
|
|
144
|
|
|
145 /// Collect file system header files from the given path.
|
|
|
146 /// This function scans the file system for header files,
|
|
|
147 /// starting at the given directory, which is assumed to be
|
|
|
148 /// relative to the directory of the module.modulemap file.
|
|
|
149 /// \returns True if no errors.
|
|
|
150 bool collectFileSystemHeaders(llvm::StringRef IncludePath);
|
|
|
151
|
|
|
152 /// Find headers unaccounted-for in module map.
|
|
|
153 /// This function compares the list of collected header files
|
|
|
154 /// against those referenced in the module map. Display
|
|
|
155 /// warnings for unaccounted-for header files.
|
|
|
156 /// Save unaccounted-for file list for possible.
|
|
|
157 /// fixing action.
|
|
|
158 void findUnaccountedForHeaders();
|
|
|
159 };
|
|
|
160
|
|
|
161 } // end namespace Modularize
|
|
|
162
|
|
|
163 #endif // COVERAGECHECKER_H
|
