16 #include "clang/Basic/SourceManager.h"
17 #include "clang/Driver/Options.h"
18 #include "clang/Frontend/CompilerInstance.h"
19 #include "clang/Frontend/FrontendActions.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/Support/FileUtilities.h"
23 #include "llvm/Support/MemoryBuffer.h"
24 #include "llvm/Support/Path.h"
25 #include "llvm/Support/raw_ostream.h"
28 using namespace clang;
30 using namespace Modularize;
35 class ModuleMapTargetOptions :
public clang::TargetOptions {
37 ModuleMapTargetOptions() { Triple = llvm::sys::getDefaultTargetTriple(); }
44 ModularizeUtilities::ModularizeUtilities(std::vector<std::string> &InputPaths,
45 llvm::StringRef Prefix,
46 llvm::StringRef ProblemFilesListPath)
48 ProblemFilesPath(ProblemFilesListPath), HasModuleMap(false),
49 MissingHeaderCount(0),
51 LangOpts(new LangOptions()), DiagIDs(new DiagnosticIDs()),
52 DiagnosticOpts(new DiagnosticOptions()),
53 DC(llvm::errs(), DiagnosticOpts.get()),
55 new DiagnosticsEngine(DiagIDs, DiagnosticOpts.get(), &DC, false)),
56 TargetOpts(new ModuleMapTargetOptions()),
57 Target(TargetInfo::CreateTargetInfo(*Diagnostics, TargetOpts)),
58 FileMgr(new FileManager(FileSystemOpts)),
59 SourceMgr(new SourceManager(*Diagnostics, *FileMgr, false)),
60 HeaderInfo(new HeaderSearch(std::make_shared<HeaderSearchOptions>(),
67 std::vector<std::string> &InputPaths, llvm::StringRef Prefix,
68 llvm::StringRef ProblemFilesListPath) {
77 llvm::StringRef InputPath = *I;
79 if (InputPath.endswith(
".modulemap")) {
87 errs() <<
"modularize: error: Unable to get header list '" << InputPath
88 <<
"': " << EC.message() <<
'\n';
97 errs() <<
"modularize: error: Unable to get problem header list '" <<
ProblemFilesPath
98 <<
"': " << EC.message() <<
'\n';
102 return std::error_code();
121 for (ModuleMapIndex = 0; ModuleMapIndex < ModuleMapCount; ++ModuleMapIndex) {
122 std::unique_ptr<clang::ModuleMap> &ModMap =
ModuleMaps[ModuleMapIndex];
124 InputFilePaths[ModuleMapIndex], IncludePaths, CommandLine, ModMap.get());
125 std::error_code LocalEC = Checker->
doChecks();
126 if (LocalEC.value() > 0)
134 llvm::StringRef InputPath) {
137 SmallString<256> HeaderDirectory(InputPath);
138 llvm::sys::path::remove_filename(HeaderDirectory);
139 SmallString<256> CurrentDirectory;
140 llvm::sys::fs::current_path(CurrentDirectory);
147 ErrorOr<std::unique_ptr<MemoryBuffer>> listBuffer =
148 MemoryBuffer::getFile(InputPath);
149 if (std::error_code EC = listBuffer.getError())
153 SmallVector<StringRef, 32>
Strings;
154 listBuffer.get()->getBuffer().split(Strings,
"\n", -1,
false);
157 for (SmallVectorImpl<StringRef>::iterator I = Strings.begin(),
160 StringRef
Line = I->trim();
162 if (Line.empty() || (Line[0] ==
'#'))
164 std::pair<StringRef, StringRef> TargetAndDependents = Line.split(
':');
165 SmallString<256> HeaderFileName;
167 if (llvm::sys::path::is_absolute(TargetAndDependents.first))
168 llvm::sys::path::native(TargetAndDependents.first, HeaderFileName);
170 if (HeaderDirectory.size() != 0)
171 HeaderFileName = HeaderDirectory;
173 HeaderFileName = CurrentDirectory;
174 llvm::sys::path::append(HeaderFileName, TargetAndDependents.first);
175 llvm::sys::path::native(HeaderFileName);
179 SmallVector<StringRef, 4> DependentsList;
180 TargetAndDependents.second.split(DependentsList,
" ", -1,
false);
181 int Count = DependentsList.size();
182 for (
int Index = 0; Index < Count; ++Index) {
183 SmallString<256> Dependent;
184 if (llvm::sys::path::is_absolute(DependentsList[Index]))
185 Dependent = DependentsList[Index];
187 if (HeaderDirectory.size() != 0)
188 Dependent = HeaderDirectory;
190 Dependent = CurrentDirectory;
191 llvm::sys::path::append(Dependent, DependentsList[Index]);
193 llvm::sys::path::native(Dependent);
202 return std::error_code();
207 llvm::StringRef InputPath) {
210 SmallString<256> HeaderDirectory(InputPath);
211 llvm::sys::path::remove_filename(HeaderDirectory);
212 SmallString<256> CurrentDirectory;
213 llvm::sys::fs::current_path(CurrentDirectory);
220 ErrorOr<std::unique_ptr<MemoryBuffer>> listBuffer =
221 MemoryBuffer::getFile(InputPath);
222 if (std::error_code EC = listBuffer.getError())
226 SmallVector<StringRef, 32>
Strings;
227 listBuffer.get()->getBuffer().split(Strings,
"\n", -1,
false);
230 for (SmallVectorImpl<StringRef>::iterator I = Strings.begin(),
233 StringRef
Line = I->trim();
235 if (Line.empty() || (Line[0] ==
'#'))
237 SmallString<256> HeaderFileName;
239 if (llvm::sys::path::is_absolute(Line))
240 llvm::sys::path::native(Line, HeaderFileName);
242 if (HeaderDirectory.size() != 0)
243 HeaderFileName = HeaderDirectory;
245 HeaderFileName = CurrentDirectory;
246 llvm::sys::path::append(HeaderFileName, Line);
247 llvm::sys::path::native(HeaderFileName);
254 return std::error_code();
259 llvm::StringRef InputPath) {
261 const FileEntry *ModuleMapEntry =
262 SourceMgr->getFileManager().getFile(InputPath);
265 if (!ModuleMapEntry) {
266 llvm::errs() <<
"error: File \"" << InputPath <<
"\" not found.\n";
267 return std::error_code(1, std::generic_category());
275 const DirectoryEntry *Dir = ModuleMapEntry->getDir();
276 StringRef DirName(Dir->getName());
277 if (llvm::sys::path::filename(DirName) ==
"Modules") {
278 DirName = llvm::sys::path::parent_path(DirName);
279 if (DirName.endswith(
".framework"))
280 Dir =
FileMgr->getDirectory(DirName);
283 assert(Dir &&
"parent must exist");
286 std::unique_ptr<ModuleMap> ModMap;
291 if (ModMap->parseModuleMapFile(ModuleMapEntry,
false, Dir)) {
292 return std::error_code(1, std::generic_category());
302 return std::error_code(1, std::generic_category());
312 return std::error_code(1, std::generic_category());
314 return std::error_code();
321 for (ModuleMap::module_iterator I = ModMap->module_begin(),
322 E = ModMap->module_end();
344 for (
auto MI = Mod.submodule_begin(), MIEnd = Mod.submodule_end();
348 if (
const FileEntry *UmbrellaHeader = Mod.getUmbrellaHeader().Entry) {
355 else if (
const DirectoryEntry *UmbrellaDir = Mod.getUmbrellaDir().Entry) {
357 if (Mod.Headers->size() == 0) {
369 int NormalHeaderCount = Mod.Headers[clang::Module::HK_Normal].size();
371 for (
int Index = 0; Index < NormalHeaderCount; ++Index) {
374 const clang::Module::Header &Header(
375 Mod.Headers[clang::Module::HK_Normal][Index]);
380 int MissingCountThisModule = Mod.MissingHeaders.size();
382 for (
int Index = 0; Index < MissingCountThisModule; ++Index) {
383 std::string MissingFile = Mod.MissingHeaders[Index].FileName;
384 SourceLocation
Loc = Mod.MissingHeaders[Index].FileNameLoc;
386 <<
": error : Header not found: " << MissingFile <<
"\n";
398 SmallString<256>
Directory(UmbrellaDirName);
401 llvm::sys::fs::file_status Status;
402 for (llvm::sys::fs::directory_iterator I(Directory.str(), EC), E; I != E;
406 std::string
File(I->path());
408 llvm::sys::fs::file_type Type = Status.type();
410 if (Type == llvm::sys::fs::file_type::directory_file) {
420 Dependents.push_back(HeaderPath);
428 SmallString<128> Buffer;
429 llvm::sys::path::const_iterator B = llvm::sys::path::begin(Path),
430 E = llvm::sys::path::end(Path);
432 if (B->compare(
".") == 0) {
434 else if (B->compare(
"..") == 0)
435 llvm::sys::path::remove_filename(Buffer);
437 llvm::sys::path::append(Buffer, *B);
440 if (Path.endswith(
"/") || Path.endswith(
"\\"))
441 Buffer.append(1, Path.back());
442 return Buffer.c_str();
451 std::replace(Tmp.begin(), Tmp.end(),
'\\',
'/');
453 if (Tmp2.startswith(
"./"))
454 Tmp = Tmp2.substr(2);
464 StringRef Extension = llvm::sys::path::extension(FileName);
465 if (Extension.size() == 0)
467 if (Extension.equals_lower(
".h"))
469 if (Extension.equals_lower(
".inc"))
481 sys::path::remove_filename(Directory);
482 if (Directory.size() == 0)
484 return Directory.str();
493 if (TestFilePath == FilePath)
496 ProblemFileNames.push_back(FilePath);
508 errs() <<
"\nThese are the files with possible errors:\n\n";
510 errs() << ProblemFile <<
"\n";
516 errs() <<
"\nThese are the files with no detected errors:\n\n";
520 if (ProblemFile == GoodFile) {
526 errs() << GoodFile <<
"\n";
533 "\nThese are the combined files, with problem files preceded by #:\n\n";
537 if (ProblemFile ==
File) {
542 errs() << (Good ?
"" :
"#") <<
File <<
"\n";
ModularizeUtilities(std::vector< std::string > &InputPaths, llvm::StringRef Prefix, llvm::StringRef ProblemFilesListPath)
Constructor.
SourceLocation Loc
'#' location in the include directive
void displayGoodFiles()
List files with no problems.
DependencyMap Dependencies
Map of top-level header file dependencies.
std::error_code doCoverageCheck(std::vector< std::string > &IncludePaths, llvm::ArrayRef< std::string > CommandLine)
Do coverage checks.
llvm::IntrusiveRefCntPtr< clang::DiagnosticsEngine > Diagnostics
Diagnostic engine.
static std::string getCanonicalPath(llvm::StringRef FilePath)
Convert header path to canonical form.
llvm::SmallVector< std::string, 4 > DependentsVector
void displayCombinedFiles()
List files with problem files commented out.
std::error_code loadProblemHeaderList(llvm::StringRef InputPath)
Load problem header list.
static std::string getDirectoryFromPath(llvm::StringRef Path)
Get directory path component from file path.
bool HasModuleMap
True if we have module maps.
static cl::opt< std::string > HeaderPrefix("prefix", cl::init(""), cl::desc("Prepend header file paths with this prefix."" If not specified,"" the files are considered to be relative to the header list file."))
std::error_code loadSingleHeaderListsAndDependencies(llvm::StringRef InputPath)
Load single header list and dependencies.
llvm::IntrusiveRefCntPtr< clang::TargetInfo > Target
Target information.
static ModularizeUtilities * createModularizeUtilities(std::vector< std::string > &InputPaths, llvm::StringRef Prefix, llvm::StringRef ProblemFilesListPath)
Create instance of ModularizeUtilities.
llvm::IntrusiveRefCntPtr< clang::FileManager > FileMgr
File system manager.
clang::TextDiagnosticPrinter DC
Diagnostic consumer.
std::unique_ptr< clang::HeaderSearch > HeaderInfo
Header search manager.
std::vector< HeaderHandle > Path
ModularizeUtilities class definition.
std::shared_ptr< clang::LangOptions > LangOpts
Options controlling the language variant.
bool collectModuleMapHeaders(clang::ModuleMap *ModMap)
Collect module Map headers.
llvm::StringRef ProblemFilesPath
The path of problem files list file.
static cl::opt< std::string > Directory(cl::Positional, cl::Required, cl::desc("<Search Root Directory>"))
Definitions for CoverageChecker.
int MissingHeaderCount
Missing header count.
std::error_code loadModuleMap(llvm::StringRef InputPath)
Load single module map and extract header file list.
std::error_code loadAllHeaderListsAndDependencies()
Load header list and dependencies.
llvm::SmallVector< std::string, 32 > ProblemFileNames
List of header files with problems.
std::error_code doChecks()
Do checks.
llvm::SmallVector< std::string, 32 > GoodFileNames
List of header files with no problems during the first pass, that is, no compile errors.
Modularize utilities class.
llvm::SmallVector< std::string, 32 > HeaderFileNames
List of top-level header files.
llvm::IntrusiveRefCntPtr< clang::SourceManager > SourceMgr
Source manager.
static cl::list< std::string > IncludePaths("I", cl::desc("Include path for coverage check."), cl::ZeroOrMore, cl::value_desc("path"))
llvm::StringRef HeaderPrefix
The header prefix.
bool collectModuleHeaders(const clang::Module &Mod)
Collect referenced headers from one module.
static CoverageChecker * createCoverageChecker(llvm::StringRef ModuleMapPath, std::vector< std::string > &IncludePaths, llvm::ArrayRef< std::string > CommandLine, clang::ModuleMap *ModuleMap)
Create instance of CoverageChecker.
Module map checker class.
std::vector< std::unique_ptr< clang::ModuleMap > > ModuleMaps
bool collectUmbrellaHeaders(llvm::StringRef UmbrellaDirName, DependentsVector &Dependents)
Collect headers from an umbrella directory.
void addUniqueProblemFile(std::string FilePath)
Add unique problem file.
void displayProblemFiles()
List problem files.
std::vector< std::string > InputFilePaths
The input file paths.
static std::string replaceDotDot(StringRef Path)
static bool isHeader(llvm::StringRef FileName)
Check for header file extension.
void addNoCompileErrorsFile(std::string FilePath)
Add file with no compile errors.