Introduce basic support for parsing module map files.

Module map files provide a way to map between headers and modules, so
that we can layer a module system on top of existing headers without
changing those headers at all.

This commit introduces the module map file parser and the module map
that it generates, and wires up the module map file parser so that
we'll automatically find module map files as part of header
search. Note that we don't yet use the information stored in the
module map.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@144402 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 160 insertions, 1 deletions

diff --git a/include/clang/Basic/DiagnosticLexKinds.td b/include/clang/Basic/DiagnosticLexKinds.td
index f1e8c75d6b..97095e792c 100644
--- a/include/clang/Basic/DiagnosticLexKinds.td
+++ b/include/clang/Basic/DiagnosticLexKinds.td
@@ -374,4 +374,19 @@ def err_pp_include_in_arc_cf_code_audited : Error<
 def err_pp_eof_in_arc_cf_code_audited : Error<
   "'#pragma clang arc_cf_code_audited' was not ended within this file">;
 
+// Module map parsing
+def err_mmap_unknown_token : Error<"skipping stray token">;
+def err_mmap_expected_module : Error<"expected module declaration">;
+def err_mmap_expected_module_after_explicit : Error<
+  "expected 'module' keyword after 'explicit'">;
+def err_mmap_expected_module_name : Error<"expected module name">;
+def err_mmap_expected_lbrace : Error<"expected '{' to start module '%0'">;
+def err_mmap_expected_rbrace : Error<"expected '}'">;
+def note_mmap_lbrace_match : Note<"to match this '{'">;
+def err_mmap_expected_member : Error<
+  "expected umbrella header, header, or submodule">;
+def err_mmap_expected_header : Error<"expected a header name after '%0'">;
+def err_mmap_module_redefinition : Error<
+  "redefinition of module '%0'">;
+def note_mmap_prev_definition : Note<"previously defined here">;
 }
diff --git a/include/clang/Lex/HeaderSearch.h b/include/clang/Lex/HeaderSearch.h
index 0b21373858..995deab9dc 100644
--- a/include/clang/Lex/HeaderSearch.h
+++ b/include/clang/Lex/HeaderSearch.h
@@ -15,6 +15,7 @@
 #define LLVM_CLANG_LEX_HEADERSEARCH_H
 
 #include "clang/Lex/DirectoryLookup.h"
+#include "clang/Lex/ModuleMap.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/Support/Allocator.h"
@@ -151,7 +152,6 @@ class HeaderSearch {
   llvm::StringMap<std::pair<unsigned, unsigned>, llvm::BumpPtrAllocator>
     LookupFileCache;
 
-
   /// FrameworkMap - This is a collection mapping a framework or subframework
   /// name like "Carbon" to the Carbon.framework directory.
   llvm::StringMap<const DirectoryEntry *, llvm::BumpPtrAllocator>
@@ -161,6 +161,12 @@ class HeaderSearch {
   /// headermaps.  This vector owns the headermap.
   std::vector<std::pair<const FileEntry*, const HeaderMap*> > HeaderMaps;
 
+  /// \brief The mapping between modules and headers.
+  ModuleMap ModMap;
+  
+  /// \brief Describes whether a given directory has a module map in it.
+  llvm::DenseMap<const DirectoryEntry *, bool> DirectoryHasModuleMap;
+  
   /// \brief Uniqued set of framework names, which is used to track which 
   /// headers were included as framework headers.
   llvm::StringSet<llvm::BumpPtrAllocator> FrameworkNames;
@@ -347,6 +353,20 @@ public:
   
   void IncrementFrameworkLookupCount() { ++NumFrameworkLookups; }
 
+  /// \brief Determine whether there is a module map that may map the header
+  /// with the given file name to a (sub)module.
+  ///
+  /// \param Filename The name of the file.
+  ///
+  /// \param Root The "root" directory, at which we should stop looking for
+  /// module maps.
+  bool hasModuleMap(StringRef Filename, const DirectoryEntry *Root);
+  
+  /// \brief Retrieve the module that corresponds to the given file, if any.
+  ///
+  /// FIXME: This will need to be generalized for submodules.
+  StringRef getModuleForHeader(const FileEntry *File);
+  
   typedef std::vector<HeaderFileInfo>::const_iterator header_file_iterator;
   header_file_iterator header_file_begin() const { return FileInfo.begin(); }
   header_file_iterator header_file_end() const { return FileInfo.end(); }
diff --git a/include/clang/Lex/ModuleMap.h b/include/clang/Lex/ModuleMap.h
new file mode 100644
index 0000000000..2834f6a11b
--- /dev/null
+++ b/include/clang/Lex/ModuleMap.h
@@ -0,0 +1,124 @@
+//===--- ModuleMap.h - Describe the layout of modules -----------*- 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 ModuleMap interface, which describes the layout of a
+// module as it relates to headers.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef LLVM_CLANG_LEX_MODULEMAP_H
+#define LLVM_CLANG_LEX_MODULEMAP_H
+
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceManager.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringMap.h"
+#include <string>
+
+namespace clang {
+  
+class FileEntry;
+class FileManager;
+class DiagnosticConsumer;
+class DiagnosticsEngine;
+class ModuleMapParser;
+  
+class ModuleMap {
+public:
+  /// \brief Describes a module or submodule.
+  struct Module {
+    /// \brief The name of this module.
+    std::string Name;
+    
+    /// \brief The location of the module definition.
+    SourceLocation DefinitionLoc;
+    
+    /// \brief The parent of this module. This will be NULL for the top-level
+    /// module.
+    Module *Parent;
+
+    /// \brief The umbrella header, if any.
+    ///
+    /// Only the top-level module can have an umbrella header.
+    const FileEntry *UmbrellaHeader;
+
+    /// \brief The submodules of this module, indexed by name.
+    llvm::StringMap<Module *> SubModules;
+
+    /// \brief The headers that are part of this module.
+    llvm::SmallVector<const FileEntry *, 2> Headers;
+    
+    /// \brief Whether this is an explicit submodule.
+    bool IsExplicit;
+    
+    /// \brief Construct a top-level module.
+    explicit Module(StringRef Name, SourceLocation DefinitionLoc)
+      : Name(Name), DefinitionLoc(DefinitionLoc), Parent(0), UmbrellaHeader(0),
+        IsExplicit(false) { }
+    
+    /// \brief Construct  a new module or submodule.
+    Module(StringRef Name, SourceLocation DefinitionLoc, Module *Parent, 
+           bool IsExplicit)
+      : Name(Name), DefinitionLoc(DefinitionLoc), Parent(Parent), 
+        UmbrellaHeader(0), IsExplicit(IsExplicit) {
+    }
+           
+    /// \brief Determine whether this module is a submodule.
+    bool isSubModule() const { return Parent != 0; }
+    
+    /// \brief Retrieve the full name of this module, including the path from
+    /// its top-level module.
+    std::string getFullModuleName() const;
+  };
+  
+private:
+  SourceManager *SourceMgr;
+  llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
+  LangOptions LangOpts;
+  
+  /// \brief The top-level modules that are known
+  llvm::StringMap<Module *> Modules;
+  
+  /// \brief Mapping from each header to the module that owns the contents of the
+  /// that header.
+  llvm::DenseMap<const FileEntry *, Module *> Headers;
+  
+  friend class ModuleMapParser;
+  
+public:
+  /// \brief Construct a new module map.
+  ///
+  /// \param FileMgr The file manager used to find module files and headers.
+  /// This file manager should be shared with the header-search mechanism, since
+  /// they will refer to the same headers.
+  ///
+  /// \param DC A diagnostic consumer that will be cloned for use in generating
+  /// diagnostics.
+  ModuleMap(FileManager &FileMgr, const DiagnosticConsumer &DC);
+  
+  ~ModuleMap();
+  
+  /// \brief Parse the given module map file, and record any modules we 
+  /// encounter.
+  ///
+  /// \param File The file to be parsed.
+  ///
+  /// \returns true if an error occurred, false otherwise.
+  bool parseModuleMapFile(const FileEntry *File);
+  
+  /// \brief Dump the contents of the module map, for debugging purposes.
+  void dump();
+};
+  
+}
+#endif