Merge branch 'addmainunit4-altlink-sharedstmt-dieref-dwz3-inlinebug-testcategory...
[lldb.git] / clang-tools-extra / modularize / ModuleAssistant.cpp
1 //===--- ModuleAssistant.cpp - Module map generation manager --*- 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 // This file defines the module generation entry point function,
10 // createModuleMap, a Module class for representing a module,
11 // and various implementation functions for doing the underlying
12 // work, described below.
13 //
14 // The "Module" class represents a module, with members for storing the module
15 // name, associated header file names, and sub-modules, and an "output"
16 // function that recursively writes the module definitions.
17 //
18 // The "createModuleMap" function implements the top-level logic of the
19 // assistant mode.  It calls a loadModuleDescriptions function to walk
20 // the header list passed to it and creates a tree of Module objects
21 // representing the module hierarchy, represented by a "Module" object,
22 // the "RootModule".  This root module may or may not represent an actual
23 // module in the module map, depending on the "--root-module" option passed
24 // to modularize.  It then calls a writeModuleMap function to set up the
25 // module map file output and walk the module tree, outputting the module
26 // map file using a stream obtained and managed by an
27 // llvm::ToolOutputFile object.
28 //
29 //===----------------------------------------------------------------------===//
30
31 #include "Modularize.h"
32 #include "llvm/ADT/SmallString.h"
33 #include "llvm/Support/FileSystem.h"
34 #include "llvm/Support/Path.h"
35 #include "llvm/Support/ToolOutputFile.h"
36 #include <vector>
37
38 // Local definitions:
39
40 namespace {
41
42 // Internal class definitions:
43
44 // Represents a module.
45 class Module {
46 public:
47   Module(llvm::StringRef Name, bool Problem);
48   ~Module();
49   bool output(llvm::raw_fd_ostream &OS, int Indent);
50   Module *findSubModule(llvm::StringRef SubName);
51
52 public:
53   std::string Name;
54   std::vector<std::string> HeaderFileNames;
55   std::vector<Module *> SubModules;
56   bool IsProblem;
57 };
58
59 } // end anonymous namespace.
60
61 // Module functions:
62
63 // Constructors.
64 Module::Module(llvm::StringRef Name, bool Problem)
65   : Name(Name), IsProblem(Problem) {}
66
67 // Destructor.
68 Module::~Module() {
69   // Free submodules.
70   while (!SubModules.empty()) {
71     Module *last = SubModules.back();
72     SubModules.pop_back();
73     delete last;
74   }
75 }
76
77 // Write a module hierarchy to the given output stream.
78 bool Module::output(llvm::raw_fd_ostream &OS, int Indent) {
79   // If this is not the nameless root module, start a module definition.
80   if (Name.size() != 0) {
81     OS.indent(Indent);
82     OS << "module " << Name << " {\n";
83     Indent += 2;
84   }
85
86   // Output submodules.
87   for (auto I = SubModules.begin(), E = SubModules.end(); I != E; ++I) {
88     if (!(*I)->output(OS, Indent))
89       return false;
90   }
91
92   // Output header files.
93   for (auto I = HeaderFileNames.begin(), E = HeaderFileNames.end(); I != E;
94        ++I) {
95     OS.indent(Indent);
96     if (IsProblem || strstr((*I).c_str(), ".inl"))
97       OS << "exclude header \"" << *I << "\"\n";
98     else
99       OS << "header \"" << *I << "\"\n";
100   }
101
102   // If this module has header files, output export directive.
103   if (HeaderFileNames.size() != 0) {
104     OS.indent(Indent);
105     OS << "export *\n";
106   }
107
108   // If this is not the nameless root module, close the module definition.
109   if (Name.size() != 0) {
110     Indent -= 2;
111     OS.indent(Indent);
112     OS << "}\n";
113   }
114
115   return true;
116 }
117
118 // Lookup a sub-module.
119 Module *Module::findSubModule(llvm::StringRef SubName) {
120   for (auto I = SubModules.begin(), E = SubModules.end(); I != E; ++I) {
121     if ((*I)->Name == SubName)
122       return *I;
123   }
124   return nullptr;
125 }
126
127 // Implementation functions:
128
129 // Reserved keywords in module.modulemap syntax.
130 // Keep in sync with keywords in module map parser in Lex/ModuleMap.cpp,
131 // such as in ModuleMapParser::consumeToken().
132 static const char *const ReservedNames[] = {
133   "config_macros", "export",   "module", "conflict", "framework",
134   "requires",      "exclude",  "header", "private",  "explicit",
135   "link",          "umbrella", "extern", "use",      nullptr // Flag end.
136 };
137
138 // Convert module name to a non-keyword.
139 // Prepends a '_' to the name if and only if the name is a keyword.
140 static std::string
141 ensureNoCollisionWithReservedName(llvm::StringRef MightBeReservedName) {
142   std::string SafeName(MightBeReservedName);
143   for (int Index = 0; ReservedNames[Index] != nullptr; ++Index) {
144     if (MightBeReservedName == ReservedNames[Index]) {
145       SafeName.insert(0, "_");
146       break;
147     }
148   }
149   return SafeName;
150 }
151
152 // Convert module name to a non-keyword.
153 // Prepends a '_' to the name if and only if the name is a keyword.
154 static std::string
155 ensureVaidModuleName(llvm::StringRef MightBeInvalidName) {
156   std::string SafeName(MightBeInvalidName);
157   std::replace(SafeName.begin(), SafeName.end(), '-', '_');
158   std::replace(SafeName.begin(), SafeName.end(), '.', '_');
159   if (isdigit(SafeName[0]))
160     SafeName = "_" + SafeName;
161   return SafeName;
162 }
163
164 // Add one module, given a header file path.
165 static bool addModuleDescription(Module *RootModule,
166                                  llvm::StringRef HeaderFilePath,
167                                  llvm::StringRef HeaderPrefix,
168                                  DependencyMap &Dependencies,
169                                  bool IsProblemFile) {
170   Module *CurrentModule = RootModule;
171   DependentsVector &FileDependents = Dependencies[HeaderFilePath];
172   std::string FilePath;
173   // Strip prefix.
174   // HeaderFilePath should be compared to natively-canonicalized Prefix.
175   llvm::SmallString<256> NativePath, NativePrefix;
176   llvm::sys::path::native(HeaderFilePath, NativePath);
177   llvm::sys::path::native(HeaderPrefix, NativePrefix);
178   if (NativePath.startswith(NativePrefix))
179     FilePath = std::string(NativePath.substr(NativePrefix.size() + 1));
180   else
181     FilePath = std::string(HeaderFilePath);
182   int Count = FileDependents.size();
183   // Headers that go into modules must not depend on other files being
184   // included first.  If there are any dependents, warn user and omit.
185   if (Count != 0) {
186     llvm::errs() << "warning: " << FilePath
187                  << " depends on other headers being included first,"
188                     " meaning the module.modulemap won't compile."
189                     "  This header will be omitted from the module map.\n";
190     return true;
191   }
192   // Make canonical.
193   std::replace(FilePath.begin(), FilePath.end(), '\\', '/');
194   // Insert module into tree, using subdirectories as submodules.
195   for (llvm::sys::path::const_iterator I = llvm::sys::path::begin(FilePath),
196                                        E = llvm::sys::path::end(FilePath);
197        I != E; ++I) {
198     if ((*I)[0] == '.')
199       continue;
200     std::string Stem(llvm::sys::path::stem(*I));
201     Stem = ensureNoCollisionWithReservedName(Stem);
202     Stem = ensureVaidModuleName(Stem);
203     Module *SubModule = CurrentModule->findSubModule(Stem);
204     if (!SubModule) {
205       SubModule = new Module(Stem, IsProblemFile);
206       CurrentModule->SubModules.push_back(SubModule);
207     }
208     CurrentModule = SubModule;
209   }
210   // Add header file name to headers.
211   CurrentModule->HeaderFileNames.push_back(FilePath);
212   return true;
213 }
214
215 // Create the internal module tree representation.
216 static Module *loadModuleDescriptions(
217     llvm::StringRef RootModuleName, llvm::ArrayRef<std::string> HeaderFileNames,
218     llvm::ArrayRef<std::string> ProblemFileNames,
219     DependencyMap &Dependencies, llvm::StringRef HeaderPrefix) {
220
221   // Create root module.
222   auto *RootModule = new Module(RootModuleName, false);
223
224   llvm::SmallString<256> CurrentDirectory;
225   llvm::sys::fs::current_path(CurrentDirectory);
226
227   // If no header prefix, use current directory.
228   if (HeaderPrefix.size() == 0)
229     HeaderPrefix = CurrentDirectory;
230
231   // Walk the header file names and output the module map.
232   for (llvm::ArrayRef<std::string>::iterator I = HeaderFileNames.begin(),
233                                              E = HeaderFileNames.end();
234        I != E; ++I) {
235     std::string Header(*I);
236     bool IsProblemFile = false;
237     for (auto &ProblemFile : ProblemFileNames) {
238       if (ProblemFile == Header) {
239         IsProblemFile = true;
240         break;
241       }
242     }
243     // Add as a module.
244     if (!addModuleDescription(RootModule, Header, HeaderPrefix, Dependencies, IsProblemFile))
245       return nullptr;
246   }
247
248   return RootModule;
249 }
250
251 // Kick off the writing of the module map.
252 static bool writeModuleMap(llvm::StringRef ModuleMapPath,
253                            llvm::StringRef HeaderPrefix, Module *RootModule) {
254   llvm::SmallString<256> HeaderDirectory(ModuleMapPath);
255   llvm::sys::path::remove_filename(HeaderDirectory);
256   llvm::SmallString<256> FilePath;
257
258   // Get the module map file path to be used.
259   if ((HeaderDirectory.size() == 0) && (HeaderPrefix.size() != 0)) {
260     FilePath = HeaderPrefix;
261     // Prepend header file name prefix if it's not absolute.
262     llvm::sys::path::append(FilePath, ModuleMapPath);
263     llvm::sys::path::native(FilePath);
264   } else {
265     FilePath = ModuleMapPath;
266     llvm::sys::path::native(FilePath);
267   }
268
269   // Set up module map output file.
270   std::error_code EC;
271   llvm::ToolOutputFile Out(FilePath, EC, llvm::sys::fs::OF_TextWithCRLF);
272   if (EC) {
273     llvm::errs() << Argv0 << ": error opening " << FilePath << ":"
274                  << EC.message() << "\n";
275     return false;
276   }
277
278   // Get output stream from tool output buffer/manager.
279   llvm::raw_fd_ostream &OS = Out.os();
280
281   // Output file comment.
282   OS << "// " << ModuleMapPath << "\n";
283   OS << "// Generated by: " << CommandLine << "\n\n";
284
285   // Write module hierarchy from internal representation.
286   if (!RootModule->output(OS, 0))
287     return false;
288
289   // Tell ToolOutputFile that we want to keep the file.
290   Out.keep();
291
292   return true;
293 }
294
295 // Global functions:
296
297 // Module map generation entry point.
298 bool createModuleMap(llvm::StringRef ModuleMapPath,
299                      llvm::ArrayRef<std::string> HeaderFileNames,
300                      llvm::ArrayRef<std::string> ProblemFileNames,
301                      DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
302                      llvm::StringRef RootModuleName) {
303   // Load internal representation of modules.
304   std::unique_ptr<Module> RootModule(
305     loadModuleDescriptions(
306       RootModuleName, HeaderFileNames, ProblemFileNames, Dependencies,
307       HeaderPrefix));
308   if (!RootModule.get())
309     return false;
310
311   // Write module map file.
312   return writeModuleMap(ModuleMapPath, HeaderPrefix, RootModule.get());
313 }