1 | //===- extra/modularize/Modularize.cpp - Check modularized headers --------===// |
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 | // Introduction |
10 | // |
11 | // This file implements a tool that checks whether a set of headers provides |
12 | // the consistent definitions required to use modules. It can also check an |
13 | // existing module map for full coverage of the headers in a directory tree. |
14 | // |
15 | // For example, in examining headers, it detects whether the same entity |
16 | // (say, a NULL macro or size_t typedef) is defined in multiple headers |
17 | // or whether a header produces different definitions under |
18 | // different circumstances. These conditions cause modules built from the |
19 | // headers to behave poorly, and should be fixed before introducing a module |
20 | // map. |
21 | // |
22 | // Modularize takes as input either one or more module maps (by default, |
23 | // "module.modulemap") or one or more text files containing lists of headers |
24 | // to check. |
25 | // |
26 | // In the case of a module map, the module map must be well-formed in |
27 | // terms of syntax. Modularize will extract the header file names |
28 | // from the map. Only normal headers are checked, assuming headers |
29 | // marked "private", "textual", or "exclude" are not to be checked |
30 | // as a top-level include, assuming they either are included by |
31 | // other headers which are checked, or they are not suitable for |
32 | // modules. |
33 | // |
34 | // In the case of a file list, the list is a newline-separated list of headers |
35 | // to check with respect to each other. |
36 | // Lines beginning with '#' and empty lines are ignored. |
37 | // Header file names followed by a colon and other space-separated |
38 | // file names will include those extra files as dependencies. |
39 | // The file names can be relative or full paths, but must be on the |
40 | // same line. |
41 | // |
42 | // Modularize also accepts regular clang front-end arguments. |
43 | // |
44 | // Usage: modularize [(modularize options)] |
45 | // [(include-files_list)|(module map)]+ [(front-end-options) ...] |
46 | // |
47 | // Options: |
48 | // -prefix=(optional header path prefix) |
49 | // Note that unless a "-prefix (header path)" option is specified, |
50 | // non-absolute file paths in the header list file will be relative |
51 | // to the header list file directory. Use -prefix to specify a |
52 | // different directory. |
53 | // -module-map-path=(module map) |
54 | // Skip the checks, and instead act as a module.map generation |
55 | // assistant, generating a module map file based on the header list. |
56 | // An optional "-root-module=(rootName)" argument can specify a root |
57 | // module to be created in the generated module.map file. Note that |
58 | // you will likely need to edit this file to suit the needs of your |
59 | // headers. |
60 | // -problem-files-list=(problem files list file name) |
61 | // For use only with module map assistant. Input list of files that |
62 | // have problems with respect to modules. These will still be |
63 | // included in the generated module map, but will be marked as |
64 | // "excluded" headers. |
65 | // -root-module=(root module name) |
66 | // Specifies a root module to be created in the generated module.map |
67 | // file. |
68 | // -block-check-header-list-only |
69 | // Only warn if #include directives are inside extern or namespace |
70 | // blocks if the included header is in the header list. |
71 | // -no-coverage-check |
72 | // Don't do the coverage check. |
73 | // -coverage-check-only |
74 | // Only do the coverage check. |
75 | // -display-file-lists |
76 | // Display lists of good files (no compile errors), problem files, |
77 | // and a combined list with problem files preceded by a '#'. |
78 | // This can be used to quickly determine which files have problems. |
79 | // The latter combined list might be useful in starting to modularize |
80 | // a set of headers. You can start with a full list of headers, |
81 | // use -display-file-lists option, and then use the combined list as |
82 | // your intermediate list, uncommenting-out headers as you fix them. |
83 | // |
84 | // Note that by default, the modularize assumes .h files contain C++ source. |
85 | // If your .h files in the file list contain another language, you should |
86 | // append an appropriate -x option to your command line, i.e.: -x c |
87 | // |
88 | // Modularization Issue Checks |
89 | // |
90 | // In the process of checking headers for modularization issues, modularize |
91 | // will do normal parsing, reporting normal errors and warnings, |
92 | // but will also report special error messages like the following: |
93 | // |
94 | // error: '(symbol)' defined at multiple locations: |
95 | // (file):(row):(column) |
96 | // (file):(row):(column) |
97 | // |
98 | // error: header '(file)' has different contents depending on how it was |
99 | // included |
100 | // |
101 | // The latter might be followed by messages like the following: |
102 | // |
103 | // note: '(symbol)' in (file) at (row):(column) not always provided |
104 | // |
105 | // Checks will also be performed for macro expansions, defined(macro) |
106 | // expressions, and preprocessor conditional directives that evaluate |
107 | // inconsistently, and can produce error messages like the following: |
108 | // |
109 | // (...)/SubHeader.h:11:5: |
110 | // #if SYMBOL == 1 |
111 | // ^ |
112 | // error: Macro instance 'SYMBOL' has different values in this header, |
113 | // depending on how it was included. |
114 | // 'SYMBOL' expanded to: '1' with respect to these inclusion paths: |
115 | // (...)/Header1.h |
116 | // (...)/SubHeader.h |
117 | // (...)/SubHeader.h:3:9: |
118 | // #define SYMBOL 1 |
119 | // ^ |
120 | // Macro defined here. |
121 | // 'SYMBOL' expanded to: '2' with respect to these inclusion paths: |
122 | // (...)/Header2.h |
123 | // (...)/SubHeader.h |
124 | // (...)/SubHeader.h:7:9: |
125 | // #define SYMBOL 2 |
126 | // ^ |
127 | // Macro defined here. |
128 | // |
129 | // Checks will also be performed for '#include' directives that are |
130 | // nested inside 'extern "C/C++" {}' or 'namespace (name) {}' blocks, |
131 | // and can produce error message like the following: |
132 | // |
133 | // IncludeInExtern.h:2:3 |
134 | // #include "Empty.h" |
135 | // ^ |
136 | // error: Include directive within extern "C" {}. |
137 | // IncludeInExtern.h:1:1 |
138 | // extern "C" { |
139 | // ^ |
140 | // The "extern "C" {}" block is here. |
141 | // |
142 | // See PreprocessorTracker.cpp for additional details. |
143 | // |
144 | // Module Map Coverage Check |
145 | // |
146 | // The coverage check uses the Clang ModuleMap class to read and parse the |
147 | // module map file. Starting at the module map file directory, or just the |
148 | // include paths, if specified, it will collect the names of all the files it |
149 | // considers headers (no extension, .h, or .inc--if you need more, modify the |
150 | // isHeader function). It then compares the headers against those referenced |
151 | // in the module map, either explicitly named, or implicitly named via an |
152 | // umbrella directory or umbrella file, as parsed by the ModuleMap object. |
153 | // If headers are found which are not referenced or covered by an umbrella |
154 | // directory or file, warning messages will be produced, and this program |
155 | // will return an error code of 1. Other errors result in an error code of 2. |
156 | // If no problems are found, an error code of 0 is returned. |
157 | // |
158 | // Note that in the case of umbrella headers, this tool invokes the compiler |
159 | // to preprocess the file, and uses a callback to collect the header files |
160 | // included by the umbrella header or any of its nested includes. If any |
161 | // front end options are needed for these compiler invocations, these |
162 | // can be included on the command line after the module map file argument. |
163 | // |
164 | // Warning message have the form: |
165 | // |
166 | // warning: module.modulemap does not account for file: Level3A.h |
167 | // |
168 | // Note that for the case of the module map referencing a file that does |
169 | // not exist, the module map parser in Clang will (at the time of this |
170 | // writing) display an error message. |
171 | // |
172 | // Module Map Assistant - Module Map Generation |
173 | // |
174 | // Modularize also has an option ("-module-map-path=module.modulemap") that will |
175 | // skip the checks, and instead act as a module.modulemap generation assistant, |
176 | // generating a module map file based on the header list. An optional |
177 | // "-root-module=(rootName)" argument can specify a root module to be |
178 | // created in the generated module.modulemap file. Note that you will likely |
179 | // need to edit this file to suit the needs of your headers. |
180 | // |
181 | // An example command line for generating a module.modulemap file: |
182 | // |
183 | // modularize -module-map-path=module.modulemap -root-module=myroot \ |
184 | // headerlist.txt |
185 | // |
186 | // Note that if the headers in the header list have partial paths, sub-modules |
187 | // will be created for the subdirectories involved, assuming that the |
188 | // subdirectories contain headers to be grouped into a module, but still with |
189 | // individual modules for the headers in the subdirectory. |
190 | // |
191 | // See the ModuleAssistant.cpp file comments for additional details about the |
192 | // implementation of the assistant mode. |
193 | // |
194 | // Future directions: |
195 | // |
196 | // Basically, we want to add new checks for whatever we can check with respect |
197 | // to checking headers for module'ability. |
198 | // |
199 | // Some ideas: |
200 | // |
201 | // 1. Omit duplicate "not always provided" messages |
202 | // |
203 | // 2. Add options to disable any of the checks, in case |
204 | // there is some problem with them, or the messages get too verbose. |
205 | // |
206 | // 3. Try to figure out the preprocessor conditional directives that |
207 | // contribute to problems and tie them to the inconsistent definitions. |
208 | // |
209 | // 4. There are some legitimate uses of preprocessor macros that |
210 | // modularize will flag as errors, such as repeatedly #include'ing |
211 | // a file and using interleaving defined/undefined macros |
212 | // to change declarations in the included file. Is there a way |
213 | // to address this? Maybe have modularize accept a list of macros |
214 | // to ignore. Otherwise you can just exclude the file, after checking |
215 | // for legitimate errors. |
216 | // |
217 | // 5. What else? |
218 | // |
219 | // General clean-up and refactoring: |
220 | // |
221 | // 1. The Location class seems to be something that we might |
222 | // want to design to be applicable to a wider range of tools, and stick it |
223 | // somewhere into Tooling/ in mainline |
224 | // |
225 | //===----------------------------------------------------------------------===// |
226 | |
227 | #include "Modularize.h" |
228 | #include "ModularizeUtilities.h" |
229 | #include "PreprocessorTracker.h" |
230 | #include "clang/AST/ASTConsumer.h" |
231 | #include "clang/AST/ASTContext.h" |
232 | #include "clang/AST/RecursiveASTVisitor.h" |
233 | #include "clang/Basic/SourceManager.h" |
234 | #include "clang/Driver/Options.h" |
235 | #include "clang/Frontend/CompilerInstance.h" |
236 | #include "clang/Frontend/FrontendAction.h" |
237 | #include "clang/Frontend/FrontendActions.h" |
238 | #include "clang/Lex/Preprocessor.h" |
239 | #include "clang/Tooling/CompilationDatabase.h" |
240 | #include "clang/Tooling/Tooling.h" |
241 | #include "llvm/Option/Arg.h" |
242 | #include "llvm/Option/ArgList.h" |
243 | #include "llvm/Option/OptTable.h" |
244 | #include "llvm/Option/Option.h" |
245 | #include "llvm/Support/CommandLine.h" |
246 | #include "llvm/Support/FileSystem.h" |
247 | #include "llvm/Support/MemoryBuffer.h" |
248 | #include "llvm/Support/Path.h" |
249 | #include <algorithm> |
250 | #include <iterator> |
251 | #include <map> |
252 | #include <string> |
253 | #include <vector> |
254 | |
255 | using namespace clang; |
256 | using namespace clang::driver; |
257 | using namespace clang::driver::options; |
258 | using namespace clang::tooling; |
259 | using namespace llvm; |
260 | using namespace llvm::opt; |
261 | using namespace Modularize; |
262 | |
263 | // Option to specify a file name for a list of header files to check. |
264 | static cl::list<std::string> |
265 | ListFileNames(cl::Positional, cl::value_desc("list" ), |
266 | cl::desc("<list of one or more header list files>" ), |
267 | cl::CommaSeparated); |
268 | |
269 | // Collect all other arguments, which will be passed to the front end. |
270 | static cl::list<std::string> |
271 | CC1Arguments(cl::ConsumeAfter, |
272 | cl::desc("<arguments to be passed to front end>..." )); |
273 | |
274 | // Option to specify a prefix to be prepended to the header names. |
275 | static cl::opt<std::string> ( |
276 | "prefix" , cl::init("" ), |
277 | cl::desc( |
278 | "Prepend header file paths with this prefix." |
279 | " If not specified," |
280 | " the files are considered to be relative to the header list file." )); |
281 | |
282 | // Option for assistant mode, telling modularize to output a module map |
283 | // based on the headers list, and where to put it. |
284 | static cl::opt<std::string> ModuleMapPath( |
285 | "module-map-path" , cl::init("" ), |
286 | cl::desc("Turn on module map output and specify output path or file name." |
287 | " If no path is specified and if prefix option is specified," |
288 | " use prefix for file path." )); |
289 | |
290 | // Option to specify list of problem files for assistant. |
291 | // This will cause assistant to exclude these files. |
292 | static cl::opt<std::string> ProblemFilesList( |
293 | "problem-files-list" , cl::init("" ), |
294 | cl::desc( |
295 | "List of files with compilation or modularization problems for" |
296 | " assistant mode. This will be excluded." )); |
297 | |
298 | // Option for assistant mode, telling modularize the name of the root module. |
299 | static cl::opt<std::string> |
300 | RootModule("root-module" , cl::init("" ), |
301 | cl::desc("Specify the name of the root module." )); |
302 | |
303 | // Option for limiting the #include-inside-extern-or-namespace-block |
304 | // check to only those headers explicitly listed in the header list. |
305 | // This is a work-around for private includes that purposefully get |
306 | // included inside blocks. |
307 | static cl::opt<bool> |
308 | ("block-check-header-list-only" , cl::init(false), |
309 | cl::desc("Only warn if #include directives are inside extern or namespace" |
310 | " blocks if the included header is in the header list." )); |
311 | |
312 | // Option for include paths for coverage check. |
313 | static cl::list<std::string> |
314 | IncludePaths("I" , cl::desc("Include path for coverage check." ), |
315 | cl::value_desc("path" )); |
316 | |
317 | // Option for disabling the coverage check. |
318 | static cl::opt<bool> NoCoverageCheck("no-coverage-check" , |
319 | cl::desc("Don't do the coverage check." )); |
320 | |
321 | // Option for just doing the coverage check. |
322 | static cl::opt<bool> |
323 | CoverageCheckOnly("coverage-check-only" , cl::init(false), |
324 | cl::desc("Only do the coverage check." )); |
325 | |
326 | // Option for displaying lists of good, bad, and mixed files. |
327 | static cl::opt<bool> |
328 | DisplayFileLists("display-file-lists" , cl::init(false), |
329 | cl::desc("Display lists of good files (no compile errors), problem files," |
330 | " and a combined list with problem files preceded by a '#'." )); |
331 | |
332 | // Save the program name for error messages. |
333 | const char *Argv0; |
334 | // Save the command line for comments. |
335 | std::string CommandLine; |
336 | |
337 | // Helper function for finding the input file in an arguments list. |
338 | static std::string findInputFile(const CommandLineArguments &CLArgs) { |
339 | const unsigned IncludedFlagsBitmask = options::CC1Option; |
340 | unsigned MissingArgIndex, MissingArgCount; |
341 | SmallVector<const char *, 256> Argv; |
342 | for (auto I = CLArgs.begin(), E = CLArgs.end(); I != E; ++I) |
343 | Argv.push_back(I->c_str()); |
344 | InputArgList Args = getDriverOptTable().ParseArgs( |
345 | Argv, MissingArgIndex, MissingArgCount, IncludedFlagsBitmask); |
346 | std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT); |
347 | return ModularizeUtilities::getCanonicalPath(Inputs.back()); |
348 | } |
349 | |
350 | // This arguments adjuster inserts "-include (file)" arguments for header |
351 | // dependencies. It also inserts a "-w" option and a "-x c++", |
352 | // if no other "-x" option is present. |
353 | static ArgumentsAdjuster |
354 | getModularizeArgumentsAdjuster(DependencyMap &Dependencies) { |
355 | return [&Dependencies](const CommandLineArguments &Args, |
356 | StringRef /*unused*/) { |
357 | std::string InputFile = findInputFile(Args); |
358 | DependentsVector &FileDependents = Dependencies[InputFile]; |
359 | CommandLineArguments NewArgs(Args); |
360 | if (int Count = FileDependents.size()) { |
361 | for (int Index = 0; Index < Count; ++Index) { |
362 | NewArgs.push_back("-include" ); |
363 | std::string File(std::string("\"" ) + FileDependents[Index] + |
364 | std::string("\"" )); |
365 | NewArgs.push_back(FileDependents[Index]); |
366 | } |
367 | } |
368 | // Ignore warnings. (Insert after "clang_tool" at beginning.) |
369 | NewArgs.insert(NewArgs.begin() + 1, "-w" ); |
370 | // Since we are compiling .h files, assume C++ unless given a -x option. |
371 | if (!llvm::is_contained(NewArgs, "-x" )) { |
372 | NewArgs.insert(NewArgs.begin() + 2, "-x" ); |
373 | NewArgs.insert(NewArgs.begin() + 3, "c++" ); |
374 | } |
375 | return NewArgs; |
376 | }; |
377 | } |
378 | |
379 | // FIXME: The Location class seems to be something that we might |
380 | // want to design to be applicable to a wider range of tools, and stick it |
381 | // somewhere into Tooling/ in mainline |
382 | struct Location { |
383 | const FileEntry *File; |
384 | unsigned Line, Column; |
385 | |
386 | Location() : File(), Line(), Column() {} |
387 | |
388 | Location(SourceManager &SM, SourceLocation Loc) : File(), Line(), Column() { |
389 | Loc = SM.getExpansionLoc(Loc); |
390 | if (Loc.isInvalid()) |
391 | return; |
392 | |
393 | std::pair<FileID, unsigned> Decomposed = SM.getDecomposedLoc(Loc); |
394 | File = SM.getFileEntryForID(Decomposed.first); |
395 | if (!File) |
396 | return; |
397 | |
398 | Line = SM.getLineNumber(Decomposed.first, Decomposed.second); |
399 | Column = SM.getColumnNumber(Decomposed.first, Decomposed.second); |
400 | } |
401 | |
402 | operator bool() const { return File != nullptr; } |
403 | |
404 | friend bool operator==(const Location &X, const Location &Y) { |
405 | return X.File == Y.File && X.Line == Y.Line && X.Column == Y.Column; |
406 | } |
407 | |
408 | friend bool operator!=(const Location &X, const Location &Y) { |
409 | return !(X == Y); |
410 | } |
411 | |
412 | friend bool operator<(const Location &X, const Location &Y) { |
413 | if (X.File != Y.File) |
414 | return X.File < Y.File; |
415 | if (X.Line != Y.Line) |
416 | return X.Line < Y.Line; |
417 | return X.Column < Y.Column; |
418 | } |
419 | friend bool operator>(const Location &X, const Location &Y) { return Y < X; } |
420 | friend bool operator<=(const Location &X, const Location &Y) { |
421 | return !(Y < X); |
422 | } |
423 | friend bool operator>=(const Location &X, const Location &Y) { |
424 | return !(X < Y); |
425 | } |
426 | }; |
427 | |
428 | struct Entry { |
429 | enum EntryKind { |
430 | EK_Tag, |
431 | EK_Value, |
432 | EK_Macro, |
433 | |
434 | EK_NumberOfKinds |
435 | } Kind; |
436 | |
437 | Location Loc; |
438 | |
439 | StringRef getKindName() { return getKindName(Kind); } |
440 | static StringRef getKindName(EntryKind kind); |
441 | }; |
442 | |
443 | // Return a string representing the given kind. |
444 | StringRef Entry::getKindName(Entry::EntryKind kind) { |
445 | switch (kind) { |
446 | case EK_Tag: |
447 | return "tag" ; |
448 | case EK_Value: |
449 | return "value" ; |
450 | case EK_Macro: |
451 | return "macro" ; |
452 | case EK_NumberOfKinds: |
453 | break; |
454 | } |
455 | llvm_unreachable("invalid Entry kind" ); |
456 | } |
457 | |
458 | struct { |
459 | std::string ; |
460 | Location ; |
461 | |
462 | friend bool (const HeaderEntry &X, const HeaderEntry &Y) { |
463 | return X.Loc == Y.Loc && X.Name == Y.Name; |
464 | } |
465 | friend bool (const HeaderEntry &X, const HeaderEntry &Y) { |
466 | return !(X == Y); |
467 | } |
468 | friend bool (const HeaderEntry &X, const HeaderEntry &Y) { |
469 | return X.Loc < Y.Loc || (X.Loc == Y.Loc && X.Name < Y.Name); |
470 | } |
471 | friend bool (const HeaderEntry &X, const HeaderEntry &Y) { |
472 | return Y < X; |
473 | } |
474 | friend bool (const HeaderEntry &X, const HeaderEntry &Y) { |
475 | return !(Y < X); |
476 | } |
477 | friend bool (const HeaderEntry &X, const HeaderEntry &Y) { |
478 | return !(X < Y); |
479 | } |
480 | }; |
481 | |
482 | typedef std::vector<HeaderEntry> ; |
483 | |
484 | class EntityMap : public std::map<std::string, SmallVector<Entry, 2>> { |
485 | public: |
486 | DenseMap<const FileEntry *, HeaderContents> ; |
487 | |
488 | void add(const std::string &Name, enum Entry::EntryKind Kind, Location Loc) { |
489 | // Record this entity in its header. |
490 | HeaderEntry HE = { Name, Loc }; |
491 | CurHeaderContents[Loc.File].push_back(HE); |
492 | |
493 | // Check whether we've seen this entry before. |
494 | SmallVector<Entry, 2> &Entries = (*this)[Name]; |
495 | for (unsigned I = 0, N = Entries.size(); I != N; ++I) { |
496 | if (Entries[I].Kind == Kind && Entries[I].Loc == Loc) |
497 | return; |
498 | } |
499 | |
500 | // We have not seen this entry before; record it. |
501 | Entry E = { Kind, Loc }; |
502 | Entries.push_back(E); |
503 | } |
504 | |
505 | void () { |
506 | for (DenseMap<const FileEntry *, HeaderContents>::iterator |
507 | H = CurHeaderContents.begin(), |
508 | HEnd = CurHeaderContents.end(); |
509 | H != HEnd; ++H) { |
510 | // Sort contents. |
511 | llvm::sort(H->second); |
512 | |
513 | // Check whether we've seen this header before. |
514 | DenseMap<const FileEntry *, HeaderContents>::iterator KnownH = |
515 | AllHeaderContents.find(H->first); |
516 | if (KnownH == AllHeaderContents.end()) { |
517 | // We haven't seen this header before; record its contents. |
518 | AllHeaderContents.insert(*H); |
519 | continue; |
520 | } |
521 | |
522 | // If the header contents are the same, we're done. |
523 | if (H->second == KnownH->second) |
524 | continue; |
525 | |
526 | // Determine what changed. |
527 | std::set_symmetric_difference( |
528 | H->second.begin(), H->second.end(), KnownH->second.begin(), |
529 | KnownH->second.end(), |
530 | std::back_inserter(HeaderContentMismatches[H->first])); |
531 | } |
532 | |
533 | CurHeaderContents.clear(); |
534 | } |
535 | |
536 | private: |
537 | DenseMap<const FileEntry *, HeaderContents> ; |
538 | DenseMap<const FileEntry *, HeaderContents> ; |
539 | }; |
540 | |
541 | class CollectEntitiesVisitor |
542 | : public RecursiveASTVisitor<CollectEntitiesVisitor> { |
543 | public: |
544 | CollectEntitiesVisitor(SourceManager &SM, EntityMap &Entities, |
545 | Preprocessor &PP, PreprocessorTracker &PPTracker, |
546 | int &HadErrors) |
547 | : SM(SM), Entities(Entities), PP(PP), PPTracker(PPTracker), |
548 | HadErrors(HadErrors) {} |
549 | |
550 | bool TraverseStmt(Stmt *S) { return true; } |
551 | bool TraverseType(QualType T) { return true; } |
552 | bool TraverseTypeLoc(TypeLoc TL) { return true; } |
553 | bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS) { return true; } |
554 | bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) { |
555 | return true; |
556 | } |
557 | bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo) { |
558 | return true; |
559 | } |
560 | bool TraverseTemplateName(TemplateName Template) { return true; } |
561 | bool TraverseTemplateArgument(const TemplateArgument &Arg) { return true; } |
562 | bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) { |
563 | return true; |
564 | } |
565 | bool TraverseTemplateArguments(ArrayRef<TemplateArgument>) { return true; } |
566 | bool TraverseConstructorInitializer(CXXCtorInitializer *Init) { return true; } |
567 | bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C, |
568 | Expr *Init) { |
569 | return true; |
570 | } |
571 | |
572 | // Check 'extern "*" {}' block for #include directives. |
573 | bool VisitLinkageSpecDecl(LinkageSpecDecl *D) { |
574 | // Bail if not a block. |
575 | if (!D->hasBraces()) |
576 | return true; |
577 | SourceRange BlockRange = D->getSourceRange(); |
578 | const char *LinkageLabel; |
579 | switch (D->getLanguage()) { |
580 | case LinkageSpecDecl::lang_c: |
581 | LinkageLabel = "extern \"C\" {}" ; |
582 | break; |
583 | case LinkageSpecDecl::lang_cxx: |
584 | LinkageLabel = "extern \"C++\" {}" ; |
585 | break; |
586 | } |
587 | if (!PPTracker.checkForIncludesInBlock(PP, BlockRange, LinkageLabel, |
588 | errs())) |
589 | HadErrors = 1; |
590 | return true; |
591 | } |
592 | |
593 | // Check 'namespace (name) {}' block for #include directives. |
594 | bool VisitNamespaceDecl(const NamespaceDecl *D) { |
595 | SourceRange BlockRange = D->getSourceRange(); |
596 | std::string Label("namespace " ); |
597 | Label += D->getName(); |
598 | Label += " {}" ; |
599 | if (!PPTracker.checkForIncludesInBlock(PP, BlockRange, Label.c_str(), |
600 | errs())) |
601 | HadErrors = 1; |
602 | return true; |
603 | } |
604 | |
605 | // Collect definition entities. |
606 | bool VisitNamedDecl(NamedDecl *ND) { |
607 | // We only care about file-context variables. |
608 | if (!ND->getDeclContext()->isFileContext()) |
609 | return true; |
610 | |
611 | // Skip declarations that tend to be properly multiply-declared. |
612 | if (isa<NamespaceDecl>(ND) || isa<UsingDirectiveDecl>(ND) || |
613 | isa<NamespaceAliasDecl>(ND) || |
614 | isa<ClassTemplateSpecializationDecl>(ND) || isa<UsingDecl>(ND) || |
615 | isa<ClassTemplateDecl>(ND) || isa<TemplateTypeParmDecl>(ND) || |
616 | isa<TypeAliasTemplateDecl>(ND) || isa<UsingShadowDecl>(ND) || |
617 | isa<FunctionDecl>(ND) || isa<FunctionTemplateDecl>(ND) || |
618 | (isa<TagDecl>(ND) && |
619 | !cast<TagDecl>(ND)->isThisDeclarationADefinition())) |
620 | return true; |
621 | |
622 | // Skip anonymous declarations. |
623 | if (!ND->getDeclName()) |
624 | return true; |
625 | |
626 | // Get the qualified name. |
627 | std::string Name; |
628 | llvm::raw_string_ostream OS(Name); |
629 | ND->printQualifiedName(OS); |
630 | OS.flush(); |
631 | if (Name.empty()) |
632 | return true; |
633 | |
634 | Location Loc(SM, ND->getLocation()); |
635 | if (!Loc) |
636 | return true; |
637 | |
638 | Entities.add(Name, isa<TagDecl>(ND) ? Entry::EK_Tag : Entry::EK_Value, Loc); |
639 | return true; |
640 | } |
641 | |
642 | private: |
643 | SourceManager &SM; |
644 | EntityMap &Entities; |
645 | Preprocessor &PP; |
646 | PreprocessorTracker &PPTracker; |
647 | int &HadErrors; |
648 | }; |
649 | |
650 | class CollectEntitiesConsumer : public ASTConsumer { |
651 | public: |
652 | CollectEntitiesConsumer(EntityMap &Entities, |
653 | PreprocessorTracker &preprocessorTracker, |
654 | Preprocessor &PP, StringRef InFile, int &HadErrors) |
655 | : Entities(Entities), PPTracker(preprocessorTracker), PP(PP), |
656 | HadErrors(HadErrors) { |
657 | PPTracker.handlePreprocessorEntry(PP, InFile); |
658 | } |
659 | |
660 | ~CollectEntitiesConsumer() override { PPTracker.handlePreprocessorExit(); } |
661 | |
662 | void HandleTranslationUnit(ASTContext &Ctx) override { |
663 | SourceManager &SM = Ctx.getSourceManager(); |
664 | |
665 | // Collect declared entities. |
666 | CollectEntitiesVisitor(SM, Entities, PP, PPTracker, HadErrors) |
667 | .TraverseDecl(Ctx.getTranslationUnitDecl()); |
668 | |
669 | // Collect macro definitions. |
670 | for (Preprocessor::macro_iterator M = PP.macro_begin(), |
671 | MEnd = PP.macro_end(); |
672 | M != MEnd; ++M) { |
673 | Location Loc(SM, M->second.getLatest()->getLocation()); |
674 | if (!Loc) |
675 | continue; |
676 | |
677 | Entities.add(M->first->getName().str(), Entry::EK_Macro, Loc); |
678 | } |
679 | |
680 | // Merge header contents. |
681 | Entities.mergeCurHeaderContents(); |
682 | } |
683 | |
684 | private: |
685 | EntityMap &Entities; |
686 | PreprocessorTracker &PPTracker; |
687 | Preprocessor &PP; |
688 | int &HadErrors; |
689 | }; |
690 | |
691 | class CollectEntitiesAction : public SyntaxOnlyAction { |
692 | public: |
693 | CollectEntitiesAction(EntityMap &Entities, |
694 | PreprocessorTracker &preprocessorTracker, |
695 | int &HadErrors) |
696 | : Entities(Entities), PPTracker(preprocessorTracker), |
697 | HadErrors(HadErrors) {} |
698 | |
699 | protected: |
700 | std::unique_ptr<clang::ASTConsumer> |
701 | CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { |
702 | return std::make_unique<CollectEntitiesConsumer>( |
703 | Entities, PPTracker, CI.getPreprocessor(), InFile, HadErrors); |
704 | } |
705 | |
706 | private: |
707 | EntityMap &Entities; |
708 | PreprocessorTracker &PPTracker; |
709 | int &HadErrors; |
710 | }; |
711 | |
712 | class ModularizeFrontendActionFactory : public FrontendActionFactory { |
713 | public: |
714 | ModularizeFrontendActionFactory(EntityMap &Entities, |
715 | PreprocessorTracker &preprocessorTracker, |
716 | int &HadErrors) |
717 | : Entities(Entities), PPTracker(preprocessorTracker), |
718 | HadErrors(HadErrors) {} |
719 | |
720 | std::unique_ptr<FrontendAction> create() override { |
721 | return std::make_unique<CollectEntitiesAction>(Entities, PPTracker, |
722 | HadErrors); |
723 | } |
724 | |
725 | private: |
726 | EntityMap &Entities; |
727 | PreprocessorTracker &PPTracker; |
728 | int &HadErrors; |
729 | }; |
730 | |
731 | class CompileCheckVisitor |
732 | : public RecursiveASTVisitor<CompileCheckVisitor> { |
733 | public: |
734 | CompileCheckVisitor() {} |
735 | |
736 | bool TraverseStmt(Stmt *S) { return true; } |
737 | bool TraverseType(QualType T) { return true; } |
738 | bool TraverseTypeLoc(TypeLoc TL) { return true; } |
739 | bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS) { return true; } |
740 | bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) { |
741 | return true; |
742 | } |
743 | bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo) { |
744 | return true; |
745 | } |
746 | bool TraverseTemplateName(TemplateName Template) { return true; } |
747 | bool TraverseTemplateArgument(const TemplateArgument &Arg) { return true; } |
748 | bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) { |
749 | return true; |
750 | } |
751 | bool TraverseTemplateArguments(ArrayRef<TemplateArgument>) { return true; } |
752 | bool TraverseConstructorInitializer(CXXCtorInitializer *Init) { return true; } |
753 | bool TraverseLambdaCapture(LambdaExpr *LE, const LambdaCapture *C, |
754 | Expr *Init) { |
755 | return true; |
756 | } |
757 | |
758 | // Check 'extern "*" {}' block for #include directives. |
759 | bool VisitLinkageSpecDecl(LinkageSpecDecl *D) { |
760 | return true; |
761 | } |
762 | |
763 | // Check 'namespace (name) {}' block for #include directives. |
764 | bool VisitNamespaceDecl(const NamespaceDecl *D) { |
765 | return true; |
766 | } |
767 | |
768 | // Collect definition entities. |
769 | bool VisitNamedDecl(NamedDecl *ND) { |
770 | return true; |
771 | } |
772 | }; |
773 | |
774 | class CompileCheckConsumer : public ASTConsumer { |
775 | public: |
776 | CompileCheckConsumer() {} |
777 | |
778 | void HandleTranslationUnit(ASTContext &Ctx) override { |
779 | CompileCheckVisitor().TraverseDecl(Ctx.getTranslationUnitDecl()); |
780 | } |
781 | }; |
782 | |
783 | class CompileCheckAction : public SyntaxOnlyAction { |
784 | public: |
785 | CompileCheckAction() {} |
786 | |
787 | protected: |
788 | std::unique_ptr<clang::ASTConsumer> |
789 | CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override { |
790 | return std::make_unique<CompileCheckConsumer>(); |
791 | } |
792 | }; |
793 | |
794 | class CompileCheckFrontendActionFactory : public FrontendActionFactory { |
795 | public: |
796 | CompileCheckFrontendActionFactory() {} |
797 | |
798 | std::unique_ptr<FrontendAction> create() override { |
799 | return std::make_unique<CompileCheckAction>(); |
800 | } |
801 | }; |
802 | |
803 | int main(int Argc, const char **Argv) { |
804 | |
805 | // Save program name for error messages. |
806 | Argv0 = Argv[0]; |
807 | |
808 | // Save program arguments for use in module.modulemap comment. |
809 | CommandLine = std::string(sys::path::stem(sys::path::filename(Argv0))); |
810 | for (int ArgIndex = 1; ArgIndex < Argc; ArgIndex++) { |
811 | CommandLine.append(" " ); |
812 | CommandLine.append(Argv[ArgIndex]); |
813 | } |
814 | |
815 | // This causes options to be parsed. |
816 | cl::ParseCommandLineOptions(Argc, Argv, "modularize.\n" ); |
817 | |
818 | // No go if we have no header list file. |
819 | if (ListFileNames.size() == 0) { |
820 | cl::PrintHelpMessage(); |
821 | return 1; |
822 | } |
823 | |
824 | std::unique_ptr<ModularizeUtilities> ModUtil; |
825 | int HadErrors = 0; |
826 | |
827 | ModUtil.reset( |
828 | ModularizeUtilities::createModularizeUtilities( |
829 | ListFileNames, HeaderPrefix, ProblemFilesList)); |
830 | |
831 | // Get header file names and dependencies. |
832 | if (ModUtil->loadAllHeaderListsAndDependencies()) |
833 | HadErrors = 1; |
834 | |
835 | // If we are in assistant mode, output the module map and quit. |
836 | if (ModuleMapPath.length() != 0) { |
837 | if (!createModuleMap(ModuleMapPath, ModUtil->HeaderFileNames, |
838 | ModUtil->ProblemFileNames, |
839 | ModUtil->Dependencies, HeaderPrefix, RootModule)) |
840 | return 1; // Failed. |
841 | return 0; // Success - Skip checks in assistant mode. |
842 | } |
843 | |
844 | // If we're doing module maps. |
845 | if (!NoCoverageCheck && ModUtil->HasModuleMap) { |
846 | // Do coverage check. |
847 | if (ModUtil->doCoverageCheck(IncludePaths, CommandLine)) |
848 | HadErrors = 1; |
849 | } |
850 | |
851 | // Bail early if only doing the coverage check. |
852 | if (CoverageCheckOnly) |
853 | return HadErrors; |
854 | |
855 | // Create the compilation database. |
856 | SmallString<256> PathBuf; |
857 | sys::fs::current_path(PathBuf); |
858 | std::unique_ptr<CompilationDatabase> Compilations; |
859 | Compilations.reset( |
860 | new FixedCompilationDatabase(Twine(PathBuf), CC1Arguments)); |
861 | |
862 | // Create preprocessor tracker, to watch for macro and conditional problems. |
863 | std::unique_ptr<PreprocessorTracker> PPTracker( |
864 | PreprocessorTracker::create(ModUtil->HeaderFileNames, |
865 | BlockCheckHeaderListOnly)); |
866 | |
867 | // Coolect entities here. |
868 | EntityMap Entities; |
869 | |
870 | // Because we can't easily determine which files failed |
871 | // during the tool run, if we're collecting the file lists |
872 | // for display, we do a first compile pass on individual |
873 | // files to find which ones don't compile stand-alone. |
874 | if (DisplayFileLists) { |
875 | // First, make a pass to just get compile errors. |
876 | for (auto &CompileCheckFile : ModUtil->HeaderFileNames) { |
877 | llvm::SmallVector<std::string, 32> CompileCheckFileArray; |
878 | CompileCheckFileArray.push_back(CompileCheckFile); |
879 | ClangTool CompileCheckTool(*Compilations, CompileCheckFileArray); |
880 | CompileCheckTool.appendArgumentsAdjuster( |
881 | getModularizeArgumentsAdjuster(ModUtil->Dependencies)); |
882 | int CompileCheckFileErrors = 0; |
883 | // FIXME: use newFrontendActionFactory. |
884 | CompileCheckFrontendActionFactory CompileCheckFactory; |
885 | CompileCheckFileErrors |= CompileCheckTool.run(&CompileCheckFactory); |
886 | if (CompileCheckFileErrors != 0) { |
887 | ModUtil->addUniqueProblemFile(CompileCheckFile); // Save problem file. |
888 | HadErrors |= 1; |
889 | } |
890 | else |
891 | ModUtil->addNoCompileErrorsFile(CompileCheckFile); // Save good file. |
892 | } |
893 | } |
894 | |
895 | // Then we make another pass on the good files to do the rest of the work. |
896 | ClangTool Tool(*Compilations, |
897 | (DisplayFileLists ? ModUtil->GoodFileNames : ModUtil->HeaderFileNames)); |
898 | Tool.appendArgumentsAdjuster( |
899 | getModularizeArgumentsAdjuster(ModUtil->Dependencies)); |
900 | ModularizeFrontendActionFactory Factory(Entities, *PPTracker, HadErrors); |
901 | HadErrors |= Tool.run(&Factory); |
902 | |
903 | // Create a place to save duplicate entity locations, separate bins per kind. |
904 | typedef SmallVector<Location, 8> LocationArray; |
905 | typedef SmallVector<LocationArray, Entry::EK_NumberOfKinds> EntryBinArray; |
906 | EntryBinArray EntryBins; |
907 | int KindIndex; |
908 | for (KindIndex = 0; KindIndex < Entry::EK_NumberOfKinds; ++KindIndex) { |
909 | LocationArray Array; |
910 | EntryBins.push_back(Array); |
911 | } |
912 | |
913 | // Check for the same entity being defined in multiple places. |
914 | for (EntityMap::iterator E = Entities.begin(), EEnd = Entities.end(); |
915 | E != EEnd; ++E) { |
916 | // If only one occurrence, exit early. |
917 | if (E->second.size() == 1) |
918 | continue; |
919 | // Clear entity locations. |
920 | for (EntryBinArray::iterator CI = EntryBins.begin(), CE = EntryBins.end(); |
921 | CI != CE; ++CI) { |
922 | CI->clear(); |
923 | } |
924 | // Walk the entities of a single name, collecting the locations, |
925 | // separated into separate bins. |
926 | for (unsigned I = 0, N = E->second.size(); I != N; ++I) { |
927 | EntryBins[E->second[I].Kind].push_back(E->second[I].Loc); |
928 | } |
929 | // Report any duplicate entity definition errors. |
930 | int KindIndex = 0; |
931 | for (EntryBinArray::iterator DI = EntryBins.begin(), DE = EntryBins.end(); |
932 | DI != DE; ++DI, ++KindIndex) { |
933 | int ECount = DI->size(); |
934 | // If only 1 occurrence of this entity, skip it, we only report duplicates. |
935 | if (ECount <= 1) |
936 | continue; |
937 | LocationArray::iterator FI = DI->begin(); |
938 | StringRef kindName = Entry::getKindName((Entry::EntryKind)KindIndex); |
939 | errs() << "error: " << kindName << " '" << E->first |
940 | << "' defined at multiple locations:\n" ; |
941 | for (LocationArray::iterator FE = DI->end(); FI != FE; ++FI) { |
942 | errs() << " " << FI->File->getName() << ":" << FI->Line << ":" |
943 | << FI->Column << "\n" ; |
944 | ModUtil->addUniqueProblemFile(std::string(FI->File->getName())); |
945 | } |
946 | HadErrors = 1; |
947 | } |
948 | } |
949 | |
950 | // Complain about macro instance in header files that differ based on how |
951 | // they are included. |
952 | if (PPTracker->reportInconsistentMacros(errs())) |
953 | HadErrors = 1; |
954 | |
955 | // Complain about preprocessor conditional directives in header files that |
956 | // differ based on how they are included. |
957 | if (PPTracker->reportInconsistentConditionals(errs())) |
958 | HadErrors = 1; |
959 | |
960 | // Complain about any headers that have contents that differ based on how |
961 | // they are included. |
962 | // FIXME: Could we provide information about which preprocessor conditionals |
963 | // are involved? |
964 | for (DenseMap<const FileEntry *, HeaderContents>::iterator |
965 | H = Entities.HeaderContentMismatches.begin(), |
966 | HEnd = Entities.HeaderContentMismatches.end(); |
967 | H != HEnd; ++H) { |
968 | if (H->second.empty()) { |
969 | errs() << "internal error: phantom header content mismatch\n" ; |
970 | continue; |
971 | } |
972 | |
973 | HadErrors = 1; |
974 | ModUtil->addUniqueProblemFile(std::string(H->first->getName())); |
975 | errs() << "error: header '" << H->first->getName() |
976 | << "' has different contents depending on how it was included.\n" ; |
977 | for (unsigned I = 0, N = H->second.size(); I != N; ++I) { |
978 | errs() << "note: '" << H->second[I].Name << "' in " |
979 | << H->second[I].Loc.File->getName() << " at " |
980 | << H->second[I].Loc.Line << ":" << H->second[I].Loc.Column |
981 | << " not always provided\n" ; |
982 | } |
983 | } |
984 | |
985 | if (DisplayFileLists) { |
986 | ModUtil->displayProblemFiles(); |
987 | ModUtil->displayGoodFiles(); |
988 | ModUtil->displayCombinedFiles(); |
989 | } |
990 | |
991 | return HadErrors; |
992 | } |
993 | |