Modularize assistant mode

[jtsoftware]

Summary

The patch features a new mode for modularize in which it generates a module map file as a starting point for a real module.map file, based on the header list input to modularize.

Please see the file comments for details.

[silvas]

Do you think that this may benefit in the future from being interactive?

modularize/ModuleAssistant.cpp

33–39

http://llvm.org/docs/CodingStandards.html#include-style (the most "local" headers go first).

40–41

I don't think I've ever a namespace explicitly opened in a .cpp file in the LLVM codebase. Usually there is just a "using namespace Modularize", which works when you then define Module::foo.

All classes that are actually declared in the .cpp file (e.g. class Module and class ModuleAssistantImpl below) are only visible in this .cpp file and should be enclosed in an anonymous namespace http://llvm.org/docs/CodingStandards.html#anonymous-namespaces.

96

Ew. Can you use raw_ostream::indent to achieve this more cleanly OS.indent(...) << ...? Or maybe a member function getIndent()?

99–100

Method names are not capitalized http://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

143

LLVM style uses 0 for the null pointer. E.g. http://llvm.org/docs/CodingStandards.html#use-early-exits-and-continue-to-simplify-code. Of course, once we have C++11, nullptr is the obvious thing.

153–159

1-3 here are really helpful comments. 4 is not as helpful; can you improve 4?

205–208

can fold this to be just if (!addModuleDescription(*I, ...

229–231

Will the user understand what "dependents" means in this context? I sure don't.

266–267

for (int Index = ...

329–331

Ew. Can you use OwningPtr to capture these lifetime semantics? http://llvm.org/docs/doxygen/html/classllvm_1_1OwningPtr.html

modularize/ModuleAssistant.h

10–11 ↗

(On Diff #4819)

This is really unhelpful. At least give the reader a little guidance.

25–36 ↗

(On Diff #4819)

Do you expect to have multiple "module assistant" implementations? Would just a single free function

bool
createModuleMap(llvm::StringRef ModuleMapPath,
                llvm::SmallVectorImpl<std::string> &HeaderFileNames,
                DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
                llvm::StringRef RootModuleName)

be sufficient for now?

29–34 ↗

(On Diff #4819)

Please add a doxygen comment describing each parameter.

32 ↗

(On Diff #4819)

ArrayRef is probably better unless you plan on appending/modifying the SmallVector.

33 ↗

(On Diff #4819)

Where is this DependencyMap type coming from? It doesn't seem to be in any of the #includes?

[jtsoftware]

Thanks! I'll post an updated revision.

modularize/ModuleAssistant.cpp

40–41

Wow, I've been writing C++ for 24 years, and I never knew this about namespaces. Intuitively it seems wrong that you can implement class members outside of the namespace, but I bow to convention.

I put the internals in an anonymous namespace. It seems the conventions say that anonymous namespaces are only for small private chunks, but perhaps this is small enough.

96

Got it.

99–100

Got it.

143

Got it.

153–159

Got it.

205–208

Got it.

229–231

Got it.

266–267

Got it.

329–331

Got it.

modularize/ModuleAssistant.h

10–11 ↗

(On Diff #4819)

Got it.

25–36 ↗

(On Diff #4819)

Got it. Made a free function, though it relays to an implmentation.

32 ↗

(On Diff #4819)

Got it.

33 ↗

(On Diff #4819)

I added a Modularize.h file to hold definitions common to more than one file, like this one.

[jtsoftware]

I addressed all the inline comments.

[silvas]

modularize/ModuleAssistant.cpp

169–173

Looking at it again, this seems like it should just be a free function with the tool_output_file stack-allocated in it, and passing just the tool_output_file's raw_ostream to the ModuleAssistantImpl constructor. Something like:

llvm::SmallString<256> FilePath;
getModuleMapOutputPath(ModuleMapPath, HeaderPrefix, FilePath)
std::string Error;
tool_output_file Out(FilePath.c_str(), Error);
if (!Error.empty()) { ...; return; }
...

Is ModuleAssistantImpl necessary? It doesn't seem to be holding any significant state.

Side note: Notice how there is a "long-distance resource-ownership dependency" between setUpModuleMapOutput and finalizeModuleMapOutput; usually this indicates that the resource that causes those two routines to be coupled should become a stack-allocated variable, or it should become a by-value member of a class whose lifetime matches the pairing of the two coupled functions.

251

It doesn't look like this has its lifetime managed (same with RootModule above). Maybe you could just allocate these into a BumpPtrAllocator?

261–266

Please mention how this list was derived, so that it's clear how to determine if it needs updating (and how to update it).

268–278

This doesn't depend on any of the class's state, so just make it a static helper function.

Also, since you are intending to modify MightBeReservedName, it probably makes more sense to take a SmallVectorImpl&. That would also simplify the interface. The calling sequence would just be ensureNoCollisionWithReservedName(S);

283–297

this should be a static helper function.

333–335

FYI, the whole point of using an OwningPtr was so that you wouldn't need to manually free it ;)

[jtsoftware]

This update addresses the comments on the previous revision, except for revising the ensureNoCollisionWithReservedName argument, which I couldn't understand. Also, I eliminated the ModuleAssistant.h file, merging it with Modularize.h, since it only declared one function.

[silvas]

LGTM with a couple tiny changes. Doug, could you take a look at this?

Btw, does this need user-facing documentation yet? (that can be a separate commit if so)

modularize/ModuleAssistant.cpp

267–268

I don't think you need to explicitly say this.

273

The rationale in http://llvm.org/docs/CodingStandards.html#anonymous-namespaces is basically to improve locality of reference. This anonymous namespace should surround just the declaration of class Module, and the free functions that currently are in the anonymous namespace (but will not be after that change) should be marked static.

[jtsoftware]

Thank you!

Revised anonymous namespace as suggested, and removed unnecessary comment.

The user docs will follow.

[doug.gregor]

This looks really helpful!

[jtsoftware]

Committed in r191211 (docs in r192703).

modularize/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   asmparser
   support
   mc
   )
 
 add_clang_executable(modularize
   Modularize.cpp
+  ModuleAssistant.cpp
   PreprocessorTracker.cpp
   )
 
 target_link_libraries(modularize
   clangTooling
   clangBasic
   clangRewriteFrontend
   )

modularize/Modularize.h

+//===--- Modularize.h - Common definitions for Modularize -*- C++ -*-----===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===--------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Common definitions for Modularize.
+///
+//===--------------------------------------------------------------------===//
+
+#ifndef MODULARIZE_H
+#define MODULARIZE_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+#include <vector>
+
+// Save the program name for error messages.
+extern const char *Argv0;
+// Save the command line for comments.
+extern std::string CommandLine;
+
+// Dependency types.
+typedef llvm::SmallVector<std::string, 4> DependentsVector;
+typedef llvm::StringMap<DependentsVector> DependencyMap;
+
+// Global function declarations.
+
+/// Create the module map file.
+/// \param ModuleMapPath The path to the module map file to be generated.
+/// \param HeaderFileNames The list of header files, absolute native paths.
+/// \param Dependencies Map of headers that depend on other headers.
+/// \param HeaderPrefix Tells the code where the headers are, if they
+///   aren's in the current directory, allowing the generator to strip
+///   the leading, non-relative beginning of the header paths.
+/// \brief RootModuleName If not empty, specifies that a root module
+///   should be created with this name.
+/// \returns True if successful.
+bool createModuleMap(llvm::StringRef ModuleMapPath,
+                     llvm::ArrayRef<std::string> HeaderFileNames,
+                     DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
+                     llvm::StringRef RootModuleName);
+
+#endif // MODULARIZE_H

modularize/Modularize.cpp

 // error: Include directive within extern "C" {}.
 // IncludeInExtern.h:1:1
 // extern "C" {
 // ^
 // The "extern "C" {}" block is here.
 //
 // See PreprocessorTracker.cpp for additional details.
 //
+// Modularize also has an option ("-module-map-path=module.map") that will
+// skip the checks, and instead act as a module.map generation assistant,
+// generating a module map file based on the header list.  An optional
+// "-root-module=(rootName)" argument can specify a root module to be
+// created in the generated module.map file.  Note that you will likely
+// need to edit this file to suit the needs of your headers.
+//
+// An example command line for generating a module.map file:
+//
+//   modularize -module-map-path=module.map -root-module=myroot headerlist.txt
+//
+// Note that if the headers in the header list have partial paths, sub-modules
+// will be created for the subdirectires involved, assuming that the
+// subdirectories contain headers to be grouped into a module, but still with
+// individual modules for the headers in the subdirectory.
+//
+// See the ModuleAssistant.cpp file comments for additional details about the
+// implementation of the assistant mode.
+//
 // Future directions:
 //
 // Basically, we want to add new checks for whatever we can check with respect
 // to checking headers for module'ability.
 //
 // Some ideas:
 //
 // 1. Omit duplicate "not always provided" messages

 #include "clang/Basic/SourceManager.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/CompilationDatabase.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/OwningPtr.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ADT/StringMap.h"
 #include "llvm/Config/config.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Option/Option.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include <algorithm>
 #include <fstream>
 #include <iterator>
 #include <string>
 #include <vector>
+#include "Modularize.h"
 #include "PreprocessorTracker.h"
 
 using namespace clang;
 using namespace clang::driver;
 using namespace clang::driver::options;
 using namespace clang::tooling;
 using namespace llvm;
 using namespace llvm::opt;

 // Option to specify a prefix to be prepended to the header names.
 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."));
 
-typedef SmallVector<std::string, 4> DependentsVector;
-typedef StringMap<DependentsVector> DependencyMap;
+// Option for assistant mode, telling modularize to output a module map
+// based on the headers list, and where to put it.
+cl::opt<std::string> ModuleMapPath(
+    "module-map-path", cl::init(""),
+    cl::desc("Turn on module map output and specify output path or file name."
+             " If no path is specified and if prefix option is specified,"
+             " use prefix for file path."));
+
+// Option for assistant mode, telling modularize to output a module map
+// based on the headers list, and where to put it.
+cl::opt<std::string>
+RootModule("root-module", cl::init(""),
+           cl::desc("Specify the name of the root module."));
+
+// Save the program name for error messages.
+const char *Argv0;
+// Save the command line for comments.
+std::string CommandLine;
 
 // Read the header list file and collect the header file names and
 // optional dependencies.
 error_code getHeaderFileNames(SmallVectorImpl<std::string> &HeaderFileNames,
                               DependencyMap &Dependencies,
                               StringRef ListFileName, StringRef HeaderPrefix) {
   // By default, use the path component of the list file name.
   SmallString<256> HeaderDirectory(ListFileName);

 private:
   EntityMap &Entities;
   PreprocessorTracker &PPTracker;
   int &HadErrors;
 };
 
 int main(int Argc, const char **Argv) {
 
+  // Save program name for error messages.
+  Argv0 = Argv[0];
+
+  // Save program arguments for use in module.map comment.
+  CommandLine = sys::path::stem(sys::path::filename(Argv0));
+  for (int ArgIndex = 1; ArgIndex < Argc; ArgIndex++) {
+    CommandLine.append(" ");
+    CommandLine.append(Argv[ArgIndex]);
+  }
+
   // This causes options to be parsed.
   cl::ParseCommandLineOptions(Argc, Argv, "modularize.\n");
 
   // No go if we have no header list file.
   if (ListFileName.size() == 0) {
     cl::PrintHelpMessage();
     return 1;
   }
 
   // Get header file names and dependencies.
   SmallVector<std::string, 32> Headers;
   DependencyMap Dependencies;
   if (error_code EC = getHeaderFileNames(Headers, Dependencies, ListFileName,
                                          HeaderPrefix)) {
     errs() << Argv[0] << ": error: Unable to get header list '" << ListFileName
            << "': " << EC.message() << '\n';
     return 1;
   }
 
+  // If we are in assistant mode, output the module map and quit.
+  if (ModuleMapPath[0]) {
+    if (!createModuleMap(ModuleMapPath, Headers, Dependencies, HeaderPrefix,
+                         RootModule))
+      return 1; // Failed.
+    return 0;   // Success - Skip checks in assistant mode.
+  }
+
   // Create the compilation database.
   SmallString<256> PathBuf;
   sys::fs::current_path(PathBuf);
   OwningPtr<CompilationDatabase> Compilations;
   Compilations.reset(
       new FixedCompilationDatabase(Twine(PathBuf), CC1Arguments));
 
   // Create preprocessor tracker, to watch for macro and conditional problems.

modularize/ModuleAssistant.cpp

+//===--- ModuleAssistant.cpp - Module map generation manager -*- C++ -*---===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===---------------------------------------------------------------------===//
+//
+// This file defines the module generation entry point function,
+// createModuleMap, a Module class for representing a module,
+// and various implementation functions for doing the underlying
+// work, described below.
+//
+// The "Module" class represents a module, with members for storing the module
+// name, associated header file names, and sub-modules, and an "output"
+// function that recursively writes the module definitions.
+//
+// The "createModuleMap" function implements the top-level logic of the
+// assistant mode.  It calls a loadModuleDescriptions function to walk
+// the header list passed to it and creates a tree of Module objects
+// representing the module hierarchy, represented by a "Module" object,
+// the "RootModule".  This root module may or may not represent an actual
+// module in the module map, depending on the "--root-module" option passed
+// to modularize.  It then calls a writeModuleMap function to set up the
+// module map file output and walk the module tree, outputting the module
+// map file using a stream obtained and managed by an
+// llvm::tool_output_file object.
+//
+//===---------------------------------------------------------------------===//
+
+#include "Modularize.h"
+#include "llvm/ADT/OwningPtr.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/ToolOutputFile.h"
+#include <vector>
+
+// Local definitions:
+
+namespace {
+
+// Internal class definitions:
+
+// Represents a module.
+class Module {
+public:
+  Module(llvm::StringRef Name);
+  Module();
+  ~Module();
+  bool output(llvm::raw_fd_ostream &OS, int Indent);
+  Module *findSubModule(llvm::StringRef SubName);
+
+public:
+  std::string Name;
+  std::vector<std::string> HeaderFileNames;
+  std::vector<Module *> SubModules;
+};
+
+} // end anonymous namespace.
+
+// Module functions:
+
+// Constructors.
+Module::Module(llvm::StringRef Name) : Name(Name) {}
+Module::Module() {}
+
+// Destructor.
+Module::~Module() {
+  // Free submodules.
+  while (SubModules.size()) {
+    Module *last = SubModules.back();
+    SubModules.pop_back();
+    delete last;
+  }
+}
+
+// Write a module hierarchy to the given output stream.
+bool Module::output(llvm::raw_fd_ostream &OS, int Indent) {
+  // If this is not the nameless root module, start a module definition.
+  if (Name.size() != 0) {
+    OS.indent(Indent);
+    OS << "module " << Name << " {\n";
+    Indent += 2;
+  }
+
+  // Output submodules.
+  for (std::vector<Module *>::iterator I = SubModules.begin(),
+                                       E = SubModules.end();
+       I != E; ++I) {
+    if (!(*I)->output(OS, Indent))
+      return false;
+  }
+
+  // Output header files.
+  for (std::vector<std::string>::iterator I = HeaderFileNames.begin(),
+                                          E = HeaderFileNames.end();
+       I != E; ++I) {
+    OS.indent(Indent);
+    OS << "header \"" << *I << "\"\n";
+  }
+
+  // If this module has header files, output export directive.
+  if (HeaderFileNames.size() != 0) {
+    OS.indent(Indent);
+    OS << "export *\n";
+  }
+
+  // If this is not the nameless root module, close the module definition.
+  if (Name.size() != 0) {
+    Indent -= 2;
+    OS.indent(Indent);
+    OS << "}\n";
+  }
+
+  return true;
+}
+
+// Lookup a sub-module.
+Module *Module::findSubModule(llvm::StringRef SubName) {
+  for (std::vector<Module *>::iterator I = SubModules.begin(),
+                                       E = SubModules.end();
+       I != E; ++I) {
+    if ((*I)->Name == SubName)
+      return *I;
+  }
+  return 0;
+}
+
+// Implementation functions:
+
+// Reserved keywords in module.map syntax.
+// Keep in sync with keywords in module map parser in Lex/ModuleMap.cpp,
+// such as in ModuleMapParser::consumeToken().
+static const char *ReservedNames[] = {
+  "config_macros", "export",   "module", "conflict", "framework",
+  "requires",      "exclude",  "header", "private",  "explicit",
+  "link",          "umbrella", "extern", "use",      0 // Flag end.
+};
+
+// Convert module name to a non keyword.
+// Prepends a '_' to the name if and only if the name is a keyword.
+static std::string
+ensureNoCollisionWithReservedName(llvm::StringRef MightBeReservedName) {
+  std::string SafeName = MightBeReservedName;
+  for (int Index = 0; ReservedNames[Index] != 0; ++Index) {
+    if (MightBeReservedName == ReservedNames[Index]) {
+      SafeName.insert(0, "_");
+      break;
+    }
+  }
+  return SafeName;
+}
+
+// Add one module, given a header file path.
+static bool addModuleDescription(Module *RootModule,
+                                 llvm::StringRef HeaderFilePath,
+                                 llvm::StringRef HeaderPrefix,
+                                 DependencyMap &Dependencies) {
+  Module *CurrentModule = RootModule;
+  DependentsVector &FileDependents = Dependencies[HeaderFilePath];
+  std::string FilePath;
+  // Strip prefix.
+  if (HeaderFilePath.startswith(HeaderPrefix))
+    FilePath = HeaderFilePath.substr(HeaderPrefix.size() + 1);
+  else
+    FilePath = HeaderFilePath;
+  int Count = FileDependents.size();
+  // Headers that go into modules must not depend on other files being
+  // included first.  If there are any dependents, warn user and omit.
+  if (Count != 0) {
+    llvm::errs() << "warning: " << FilePath
+                 << " depends on other headers being included first,"
+                    " meaning the module.map won't compile."
+                    "  This header will be omitted from the module map.\n";
+    return true;
+  }
+  // Make canonical.
+  std::replace(FilePath.begin(), FilePath.end(), '\\', '/');
+  // Insert module into tree, using subdirectories as submodules.
+  for (llvm::sys::path::const_iterator I = llvm::sys::path::begin(FilePath),
+                                       E = llvm::sys::path::end(FilePath);
+       I != E; ++I) {
+    if ((*I)[0] == '.')
+      continue;
+    std::string Stem = llvm::sys::path::stem(*I);
+    Stem = ensureNoCollisionWithReservedName(Stem);
+    Module *SubModule = CurrentModule->findSubModule(Stem);
+    if (SubModule == 0) {
+      SubModule = new Module(Stem);
+      CurrentModule->SubModules.push_back(SubModule);
+    }
+    CurrentModule = SubModule;
+  }
+  // Add header file name to headers.
+  CurrentModule->HeaderFileNames.push_back(FilePath);
+  return true;
+}
+
+// Create the internal module tree representation.
+static Module *loadModuleDescriptions(
+    llvm::StringRef RootModuleName, llvm::ArrayRef<std::string> HeaderFileNames,
+    DependencyMap &Dependencies, llvm::StringRef HeaderPrefix) {
+
+  // Create root module.
+  Module *RootModule = new Module(RootModuleName);
+
+  llvm::SmallString<256> CurrentDirectory;
+  llvm::sys::fs::current_path(CurrentDirectory);
+
+  // If no header prefix, use current directory.
+  if (HeaderPrefix.size() == 0)
+    HeaderPrefix = CurrentDirectory;
+
+  // Walk the header file names and output the module map.
+  for (llvm::ArrayRef<std::string>::iterator I = HeaderFileNames.begin(),
+                                             E = HeaderFileNames.end();
+       I != E; ++I) {
+    // Add as a module.
+    if (!addModuleDescription(RootModule, *I, HeaderPrefix, Dependencies))
+      return false;
+  }
+
+  return RootModule;
+}
+
+// Kick off the writing of the module map.
+static bool writeModuleMap(llvm::StringRef ModuleMapPath,
+                           llvm::StringRef HeaderPrefix, Module *RootModule) {
+  llvm::SmallString<256> HeaderDirectory(ModuleMapPath);
+  llvm::sys::path::remove_filename(HeaderDirectory);
+  llvm::SmallString<256> FilePath;
+
+  // Get the module map file path to be used.
+  if ((HeaderDirectory.size() == 0) && (HeaderPrefix.size() != 0)) {
+    FilePath = HeaderPrefix;
+    // Prepend header file name prefix if it's not absolute.
+    llvm::sys::path::append(FilePath, ModuleMapPath);
+    llvm::sys::path::native(FilePath);
+  } else {
+    FilePath = ModuleMapPath;
+    llvm::sys::path::native(FilePath);
+  }
+
+  // Set up module map output file.
+  std::string Error;
+  llvm::tool_output_file Out(FilePath.c_str(), Error);
+  if (!Error.empty()) {
+    llvm::errs() << Argv0 << ": error opening " << FilePath << ":" << Error
+                 << "\n";
+    return false;
+  }
+
+  // Get output stream from tool output buffer/manager.
+  llvm::raw_fd_ostream &OS = Out.os();
+
+  // Output file comment.
+  OS << "// " << ModuleMapPath << "\n";
+  OS << "// Generated by: " << CommandLine << "\n\n";
+
+  // Write module hierarchy from internal representation.
+  if (!RootModule->output(OS, 0))
+    return false;
+
+  // Tell tool_output_file that we want to keep the file.
+  Out.keep();
+
+  return true;
+}
+
+// Global functions:
+
+// Module map generation entry point.
+bool createModuleMap(llvm::StringRef ModuleMapPath,
+                     llvm::ArrayRef<std::string> HeaderFileNames,
+                     DependencyMap &Dependencies, llvm::StringRef HeaderPrefix,
+                     llvm::StringRef RootModuleName) {
+  // Load internal representation of modules.
+  llvm::OwningPtr<Module> RootModule(loadModuleDescriptions(
+      RootModuleName, HeaderFileNames, Dependencies, HeaderPrefix));
+  if (!RootModule.get())
+    return false;
+
+  // Write module map file.
+  return writeModuleMap(ModuleMapPath, HeaderPrefix, RootModule.get());
+}

test/modularize/Inputs/SubModule1/Header1.h

+// Header1.h - Empty.

test/modularize/Inputs/SubModule1/Header2.h

+// Header2.h - Empty.

test/modularize/Inputs/SubModule2/Header3.h

+// Header3.h - Empty.

test/modularize/Inputs/SubModule2/Header4.h

+// Header4.h - Empty.

test/modularize/NoProblemsAssistant.modularize

+# RUN: modularize -module-map-path=Output/NoProblemsAssistant.txt -root-module=Root -prefix=%S/Input %s
+# RUN: FileCheck --input-file=%T/NoProblemsAssistant.txt %s
+
+SomeTypes.h
+SomeDecls.h
+SubModule1/Header1.h
+SubModule1/Header2.h
+SubModule2/Header3.h
+SubModule2/Header4.h
+SubModule2.h
+
+# CHECK: // Output/NoProblemsAssistant.txt
+# CHECK-NEXT: // Generated by: modularize -module-map-path=Output/NoProblemsAssistant.txt -root-module=Root -prefix={{.*}}{{[/\\]}}{{.*}} {{.*}}{{[/\\]}}NoProblemsAssistant.modularize
+# CHECK: module Root {
+# CHECK-NEXT:   module SomeTypes {
+# CHECK-NEXT:     header "SomeTypes.h"
+# CHECK-NEXT:     export *
+# CHECK-NEXT:   }
+# CHECK-NEXT:   module SomeDecls {
+# CHECK-NEXT:     header "SomeDecls.h"
+# CHECK-NEXT:     export *
+# CHECK-NEXT:   }
+# CHECK-NEXT:   module SubModule1 {
+# CHECK-NEXT:     module Header1 {
+# CHECK-NEXT:       header "SubModule1/Header1.h"
+# CHECK-NEXT:       export *
+# CHECK-NEXT:     }
+# CHECK-NEXT:     module Header2 {
+# CHECK-NEXT:       header "SubModule1/Header2.h"
+# CHECK-NEXT:       export *
+# CHECK-NEXT:     }
+# CHECK-NEXT:   }
+# CHECK-NEXT:   module SubModule2 {
+# CHECK-NEXT:     module Header3 {
+# CHECK-NEXT:       header "SubModule2/Header3.h"
+# CHECK-NEXT:       export *
+# CHECK-NEXT:     }
+# CHECK-NEXT:     module Header4 {
+# CHECK-NEXT:       header "SubModule2/Header4.h"
+# CHECK-NEXT:       export *
+# CHECK-NEXT:     }
+# CHECK-NEXT:     header "SubModule2.h"
+# CHECK-NEXT:     export *
+# CHECK-NEXT:   }
+# CHECK-NEXT: }

test/modularize/SubModule2.h

+// SubModule2.h - Master header with same name as directory.
+#include "SubModule2/Header3.h"
+#include "SubModule2/Header4.h"