clang-tools  10.0.0svn
CoverageChecker.h
Go to the documentation of this file.
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.
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 
127  /// Collect headers rferenced from an umbrella file.
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.
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.
159 };
160 
161 } // end namespace Modularize
162 
163 #endif // COVERAGECHECKER_H
bool collectUmbrellaHeaders(llvm::StringRef UmbrellaDirName)
Collect headers from an umbrella directory.
std::string HeaderName
CoverageChecker(llvm::StringRef ModuleMapPath, std::vector< std::string > &IncludePaths, llvm::ArrayRef< std::string > CommandLine, clang::ModuleMap *ModuleMap)
Constructor.
void collectModuleHeaders()
Collect module headers.
void collectUmbrellaHeaderHeader(llvm::StringRef HeaderName)
Called from CoverageCheckerCallbacks to track a header included from an umbrella header.
void findUnaccountedForHeaders()
Find headers unaccounted-for in module map.
bool collectUmbrellaHeaderHeaders(llvm::StringRef UmbrellaHeaderName)
Collect headers rferenced from an umbrella file.
static std::unique_ptr< CoverageChecker > createCoverageChecker(llvm::StringRef ModuleMapPath, std::vector< std::string > &IncludePaths, llvm::ArrayRef< std::string > CommandLine, clang::ModuleMap *ModuleMap)
Create instance of CoverageChecker.
std::error_code doChecks()
Do checks.
bool collectFileSystemHeaders()
Collect file system header files.
Module map checker class.