For PPCallbacks::InclusionDirective() add a parameter for the module, whenever

an inclusion directive was automatically turned into a module import, and
PPCallbacks::moduleImport() for an explicit module import.

llvm-svn: 164874

clang/include/clang/Lex/PPCallbacks.h

@@ -16,6 +16,7 @@
 #define LLVM_CLANG_LEX_PPCALLBACKS_H
 
 #include "clang/Lex/DirectoryLookup.h"
+#include "clang/Lex/ModuleLoader.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/DiagnosticIDs.h"
 #include "llvm/ADT/StringRef.h"
@@ -99,9 +100,6 @@ public:
   /// \param File The actual file that may be included by this inclusion 
   /// directive.
   ///
-  /// \param EndLoc The location of the last token within the inclusion
-  /// directive.
-  ///
   /// \param SearchPath Contains the search path which was used to find the file
   /// in the file system. If the file was found via an absolute include path,
   /// SearchPath will be empty. For framework includes, the SearchPath and
@@ -113,6 +111,10 @@ public:
   ///
   /// \param RelativePath The path relative to SearchPath, at which the include
   /// file was found. This is equal to FileName except for framework includes.
+  ///
+  /// \param Imported The module, whenever an inclusion directive was
+  /// automatically turned into a module import or null otherwise.
+  ///
   virtual void InclusionDirective(SourceLocation HashLoc,
                                   const Token &IncludeTok,
                                   StringRef FileName,
@@ -120,7 +122,23 @@ public:
                                   CharSourceRange FilenameRange,
                                   const FileEntry *File,
                                   StringRef SearchPath,
-                                  StringRef RelativePath) {
+                                  StringRef RelativePath,
+                                  const Module *Imported) {
+  }
+
+  /// \brief Callback invoked whenever there was an explicit module-import
+  /// syntax.
+  ///
+  /// \param ImportLoc The location of import directive token.
+  ///
+  /// \param Path The identifiers (and their locations) of the module
+  /// "path", e.g., "std.vector" would be split into "std" and "vector".
+  ///
+  /// \param Imported The imported module; can be null if importing failed.
+  ///
+  virtual void moduleImport(SourceLocation ImportLoc,
+                            ModuleIdPath Path,
+                            const Module *Imported) {
   }
 
   /// \brief Callback invoked when the end of the main file is reached.
@@ -272,11 +290,21 @@ public:
                                   CharSourceRange FilenameRange,
                                   const FileEntry *File,
                                   StringRef SearchPath,
-                                  StringRef RelativePath) {
+                                  StringRef RelativePath,
+                                  const Module *Imported) {
     First->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
-                              FilenameRange, File, SearchPath, RelativePath);
+                              FilenameRange, File, SearchPath, RelativePath,
+                              Imported);
     Second->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
-                               FilenameRange, File, SearchPath, RelativePath);
+                               FilenameRange, File, SearchPath, RelativePath,
+                               Imported);
+  }
+
+  virtual void moduleImport(SourceLocation ImportLoc,
+                            ModuleIdPath Path,
+                            const Module *Imported) {
+    First->moduleImport(ImportLoc, Path, Imported);
+    Second->moduleImport(ImportLoc, Path, Imported);
   }
 
   virtual void EndOfMainFile() {

clang/include/clang/Lex/PreprocessingRecord.h

@@ -600,7 +600,8 @@ namespace clang {
                                     CharSourceRange FilenameRange,
                                     const FileEntry *File,
                                     StringRef SearchPath,
-                                    StringRef RelativePath);
+                                    StringRef RelativePath,
+                                    const Module *Imported);
     virtual void If(SourceLocation Loc, SourceRange ConditionRange);
     virtual void Elif(SourceLocation Loc, SourceRange ConditionRange,
                       SourceLocation IfLoc);

clang/lib/Frontend/DependencyFile.cpp

@@ -62,7 +62,8 @@ public:
                                   CharSourceRange FilenameRange,
                                   const FileEntry *File,
                                   StringRef SearchPath,
-                                  StringRef RelativePath);
+                                  StringRef RelativePath,
+                                  const Module *Imported);
 
   virtual void EndOfMainFile() {
     OutputDependencyFile();
@@ -135,7 +136,8 @@ void DependencyFileCallback::InclusionDirective(SourceLocation HashLoc,
                                                 CharSourceRange FilenameRange,
                                                 const FileEntry *File,
                                                 StringRef SearchPath,
-                                                StringRef RelativePath) {
+                                                StringRef RelativePath,
+                                                const Module *Imported) {
   if (!File) {
     if (AddMissingHeaderDeps)
       AddFilename(FileName);

clang/lib/Frontend/DependencyGraph.cpp

@@ -54,7 +54,8 @@ public:
                                   CharSourceRange FilenameRange,
                                   const FileEntry *File,
                                   StringRef SearchPath,
-                                  StringRef RelativePath);
+                                  StringRef RelativePath,
+                                  const Module *Imported);
 
   virtual void EndOfMainFile() {
     OutputGraphFile();
@@ -75,7 +76,8 @@ void DependencyGraphCallback::InclusionDirective(SourceLocation HashLoc,
                                                  CharSourceRange FilenameRange,
                                                  const FileEntry *File,
                                                  StringRef SearchPath,
-                                                 StringRef RelativePath) {
+                                                 StringRef RelativePath,
+                                                 const Module *Imported) {
   if (!File)
     return;
   

clang/lib/Lex/PPDirectives.cpp

@@ -1314,6 +1314,8 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
     return;
   }
 
+  CharSourceRange FilenameRange
+    = CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd);
   StringRef OriginalFilename = Filename;
   bool isAngled =
     GetIncludeFilenameSpelling(FilenameTok.getLocation(), Filename);
@@ -1384,10 +1386,13 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
       }
     }
     
-    // Notify the callback object that we've seen an inclusion directive.
+    if (!SuggestedModule) {
-    Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled,
+      // Notify the callback object that we've seen an inclusion directive.
-              CharSourceRange::getCharRange(FilenameTok.getLocation(), CharEnd),
+      Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled,
-                                  File, SearchPath, RelativePath);
+                                    FilenameRange, File,
+                                    SearchPath, RelativePath,
+                                    /*ImportedModule=*/0);
+    }
   }
   
   if (File == 0) {
@@ -1485,8 +1490,24 @@ void Preprocessor::HandleIncludeDirective(SourceLocation HashLoc,
            "the imported module is different than the suggested one");
     
     // If this header isn't part of the module we're building, we're done.
-    if (!BuildingImportedModule && Imported)
+    if (!BuildingImportedModule && Imported) {
+      if (Callbacks) {
+        Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled,
+                                      FilenameRange, File,
+                                      SearchPath, RelativePath, Imported);
+      }
       return;
+    }
+  }
+
+  if (Callbacks && SuggestedModule) {
+    // We didn't notify the callback object that we've seen an inclusion
+    // directive before. Now that we are parsing the include normally and not
+    // turning it to a module import, notify the callback object.
+    Callbacks->InclusionDirective(HashLoc, IncludeTok, Filename, isAngled,
+                                  FilenameRange, File,
+                                  SearchPath, RelativePath,
+                                  /*ImportedModule=*/0);
   }
   
   // The #included file will be considered to be a system header if either it is

clang/lib/Lex/PreprocessingRecord.cpp

@@ -392,7 +392,8 @@ void PreprocessingRecord::InclusionDirective(
     CharSourceRange FilenameRange,
     const FileEntry *File,
     StringRef SearchPath,
-    StringRef RelativePath) {
+    StringRef RelativePath,
+    const Module *Imported) {
   InclusionDirective::InclusionKind Kind = InclusionDirective::Include;
   
   switch (IncludeTok.getIdentifierInfo()->getPPKeywordID()) {

clang/lib/Lex/Preprocessor.cpp

@@ -641,10 +641,14 @@ void Preprocessor::LexAfterModuleImport(Token &Result) {
   }
 
   // If we have a non-empty module path, load the named module.
-  if (!ModuleImportPath.empty())
+  if (!ModuleImportPath.empty()) {
-    (void)TheModuleLoader.loadModule(ModuleImportLoc, ModuleImportPath,
+    Module *Imported = TheModuleLoader.loadModule(ModuleImportLoc,
-                                     Module::MacrosVisible,
+                                                  ModuleImportPath,
-                                     /*IsIncludeDirective=*/false);
+                                                  Module::MacrosVisible,
+                                                  /*IsIncludeDirective=*/false);
+    if (Callbacks)
+      Callbacks->moduleImport(ModuleImportLoc, ModuleImportPath, Imported);
+  }
 }
 
 void Preprocessor::addCommentHandler(CommentHandler *Handler) {

clang/lib/Rewrite/Frontend/InclusionRewriter.cpp

@@ -60,7 +60,8 @@ private:
                                   CharSourceRange FilenameRange,
                                   const FileEntry *File,
                                   StringRef SearchPath,
-                                  StringRef RelativePath);
+                                  StringRef RelativePath,
+                                  const Module *Imported);
   void WriteLineInfo(const char *Filename, int Line,
                      SrcMgr::CharacteristicKind FileType,
                      StringRef EOL, StringRef Extra = StringRef());
@@ -155,7 +156,8 @@ void InclusionRewriter::InclusionDirective(SourceLocation HashLoc,
                                            CharSourceRange /*FilenameRange*/,
                                            const FileEntry * /*File*/,
                                            StringRef /*SearchPath*/,
-                                           StringRef /*RelativePath*/) {
+                                           StringRef /*RelativePath*/,
+                                           const Module */*Imported*/) {
   assert(LastInsertedFileChange == FileChanges.end() && "Another inclusion "
     "directive was found before the previous one was processed");
   std::pair<FileChangeMap::iterator, bool> p = FileChanges.insert(

clang/tools/libclang/Indexing.cpp

@@ -71,7 +71,8 @@ public:
                                   CharSourceRange FilenameRange,
                                   const FileEntry *File,
                                   StringRef SearchPath,
-                                  StringRef RelativePath) {
+                                  StringRef RelativePath,
+                                  const Module *Imported) {
     bool isImport = (IncludeTok.is(tok::identifier) &&
             IncludeTok.getIdentifierInfo()->getPPKeywordID() == tok::pp_import);
     IndexCtx.ppIncludedFile(HashLoc, FileName, File, isImport, IsAngled);