modularize - Add checks for #include in 'extern "C/C++" {}' or 'namespace (name) {}' blocks

[jtsoftware]

Summary

It's a potential problem for modules (and headers in general) if '#include' directives occur inside 'extern "C/C++" {}' or 'namespace (name) {}' blocks, because that can produce different underlying definitions if other sources include the header outside of such blocks. This patch to modularize checks for these cases, treating them as errors, and produces error message referencing both the offending '#include' and the enclosing 'extern "C/C++" {}' or 'namespace (name) {}' block.

[doug.gregor]

Very nice check. LGTM.

[jtsoftware]

Committed in r190950.

modularize/PreprocessorTracker.cpp

934

Fixed typo "with" => "within"

modularize/Modularize.cpp

 //     'SYMBOL' expanded to: '2' with respect to these inclusion paths:
 //       (...)/Header2.h
 //           (...)/SubHeader.h
 //   (...)/SubHeader.h:7:9:
 //   #define SYMBOL 2
 //             ^
 //   Macro defined here.
 //
+// Checks will also be performed for '#include' directives that are
+// nested inside 'extern "C/C++" {}' or 'namespace (name) {}' blocks,
+// and can produce error message like the following:
+//
+// IncludeInExtern.h:2:3
+//   #include "Empty.h"
+//   ^
+// error: Include directive within extern "C" {}.
+// IncludeInExtern.h:1:1
+// extern "C" {
+// ^
+// The "extern "C" {}" block is here.
+//
 // See PreprocessorTracker.cpp for additional details.
 //
 // Future directions:
 //
 // Basically, we want to add new checks for whatever we can check with respect
 // to checking headers for module'ability.
 //
 // Some ideas:

 private:
   DenseMap<const FileEntry *, HeaderContents> CurHeaderContents;
   DenseMap<const FileEntry *, HeaderContents> AllHeaderContents;
 };
 
 class CollectEntitiesVisitor
     : public RecursiveASTVisitor<CollectEntitiesVisitor> {
 public:
-  CollectEntitiesVisitor(SourceManager &SM, EntityMap &Entities)
-      : SM(SM), Entities(Entities) {}
+  CollectEntitiesVisitor(SourceManager &SM, EntityMap &Entities,
+                         Preprocessor &PP, PreprocessorTracker &PPTracker,
+                         int &HadErrors)
+      : SM(SM), Entities(Entities), PP(PP), PPTracker(PPTracker),
+        HadErrors(HadErrors) {}
 
   bool TraverseStmt(Stmt *S) { return true; }
   bool TraverseType(QualType T) { return true; }
   bool TraverseTypeLoc(TypeLoc TL) { return true; }
   bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS) { return true; }
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
     return true;
   }
   bool TraverseDeclarationNameInfo(DeclarationNameInfo NameInfo) {
     return true;
   }
   bool TraverseTemplateName(TemplateName Template) { return true; }
   bool TraverseTemplateArgument(const TemplateArgument &Arg) { return true; }
   bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &ArgLoc) {
     return true;
   }
   bool TraverseTemplateArguments(const TemplateArgument *Args,
                                  unsigned NumArgs) {
     return true;
   }
   bool TraverseConstructorInitializer(CXXCtorInitializer *Init) { return true; }
   bool TraverseLambdaCapture(LambdaExpr::Capture C) { return true; }
 
+  // Check 'extern "*" {}' block for #include directives.
+  bool VisitLinkageSpecDecl(LinkageSpecDecl *D) {
+    // Bail if not a block.
+    if (!D->hasBraces())
+      return true;
+    SourceRange BlockRange = D->getSourceRange();
+    const char *LinkageLabel;
+    switch (D->getLanguage()) {
+    case LinkageSpecDecl::lang_c:
+      LinkageLabel = "extern \"C\" {}";
+      break;
+    case LinkageSpecDecl::lang_cxx:
+      LinkageLabel = "extern \"C++\" {}";
+      break;
+    default:
+      LinkageLabel = "extern \"\" {}";
+    }
+    if (!PPTracker.checkForIncludesInBlock(PP, BlockRange, LinkageLabel,
+                                           errs()))
+      HadErrors = 1;
+    return true;
+  }
+
+  // Check 'namespace (name) {}' block for #include directives.
+  bool VisitNamespaceDecl(const NamespaceDecl *D) {
+    SourceRange BlockRange = D->getSourceRange();
+    std::string Label("namespace ");
+    Label += D->getName();
+    Label += " {}";
+    if (!PPTracker.checkForIncludesInBlock(PP, BlockRange, Label.c_str(),
+                                           errs()))
+      HadErrors = 1;
+    return true;
+  }
+
+  // Collect definition entities.
   bool VisitNamedDecl(NamedDecl *ND) {
     // We only care about file-context variables.
     if (!ND->getDeclContext()->isFileContext())
       return true;
 
     // Skip declarations that tend to be properly multiply-declared.
     if (isa<NamespaceDecl>(ND) || isa<UsingDirectiveDecl>(ND) ||
         isa<NamespaceAliasDecl>(ND) ||
bool VisitNamedDecl(NamedDecl *ND) {
 
     Entities.add(Name, isa<TagDecl>(ND) ? Entry::EK_Tag : Entry::EK_Value, Loc);
     return true;
   }
 
 private:
   SourceManager &SM;
   EntityMap &Entities;
+  Preprocessor &PP;
+  PreprocessorTracker &PPTracker;
+  int &HadErrors;
 };
 
 class CollectEntitiesConsumer : public ASTConsumer {
 public:
   CollectEntitiesConsumer(EntityMap &Entities,
                           PreprocessorTracker &preprocessorTracker,
-                          Preprocessor &PP, StringRef InFile)
-      : Entities(Entities), PPTracker(preprocessorTracker), PP(PP) {
+                          Preprocessor &PP, StringRef InFile, int &HadErrors)
+      : Entities(Entities), PPTracker(preprocessorTracker), PP(PP),
+        HadErrors(HadErrors) {
     PPTracker.handlePreprocessorEntry(PP, InFile);
   }
 
   ~CollectEntitiesConsumer() { PPTracker.handlePreprocessorExit(); }
 
   virtual void HandleTranslationUnit(ASTContext &Ctx) {
     SourceManager &SM = Ctx.getSourceManager();
 
     // Collect declared entities.
-    CollectEntitiesVisitor(SM, Entities)
+    CollectEntitiesVisitor(SM, Entities, PP, PPTracker, HadErrors)
         .TraverseDecl(Ctx.getTranslationUnitDecl());
 
     // Collect macro definitions.
     for (Preprocessor::macro_iterator M = PP.macro_begin(),
                                       MEnd = PP.macro_end();
          M != MEnd; ++M) {
       Location Loc(SM, M->second->getLocation());
       if (!Loc)
         continue;
 
       Entities.add(M->first->getName().str(), Entry::EK_Macro, Loc);
     }
 
     // Merge header contents.
     Entities.mergeCurHeaderContents();
   }
 
 private:
   EntityMap &Entities;
   PreprocessorTracker &PPTracker;
   Preprocessor &PP;
+  int &HadErrors;
 };
 
 class CollectEntitiesAction : public SyntaxOnlyAction {
 public:
   CollectEntitiesAction(EntityMap &Entities,
-                        PreprocessorTracker &preprocessorTracker)
-      : Entities(Entities), PPTracker(preprocessorTracker) {}
+                        PreprocessorTracker &preprocessorTracker,
+                        int &HadErrors)
+      : Entities(Entities), PPTracker(preprocessorTracker),
+        HadErrors(HadErrors) {}
 
 protected:
   virtual clang::ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
                                                 StringRef InFile) {
     return new CollectEntitiesConsumer(Entities, PPTracker,
-                                       CI.getPreprocessor(), InFile);
+                                       CI.getPreprocessor(), InFile, HadErrors);
   }
 
 private:
   EntityMap &Entities;
   PreprocessorTracker &PPTracker;
+  int &HadErrors;
 };
 
 class ModularizeFrontendActionFactory : public FrontendActionFactory {
 public:
   ModularizeFrontendActionFactory(EntityMap &Entities,
-                                  PreprocessorTracker &preprocessorTracker)
-      : Entities(Entities), PPTracker(preprocessorTracker) {}
+                                  PreprocessorTracker &preprocessorTracker,
+                                  int &HadErrors)
+      : Entities(Entities), PPTracker(preprocessorTracker),
+        HadErrors(HadErrors) {}
 
   virtual CollectEntitiesAction *create() {
-    return new CollectEntitiesAction(Entities, PPTracker);
+    return new CollectEntitiesAction(Entities, PPTracker, HadErrors);
   }
 
 private:
   EntityMap &Entities;
   PreprocessorTracker &PPTracker;
+  int &HadErrors;
 };
 
 int main(int Argc, const char **Argv) {
 
   // This causes options to be parsed.
   cl::ParseCommandLineOptions(Argc, Argv, "modularize.\n");
 
   // No go if we have no header list file.
int main(int Argc, const char **Argv) {
 
   // Create preprocessor tracker, to watch for macro and conditional problems.
   OwningPtr<PreprocessorTracker> PPTracker(PreprocessorTracker::create());
 
   // Parse all of the headers, detecting duplicates.
   EntityMap Entities;
   ClangTool Tool(*Compilations, Headers);
   Tool.appendArgumentsAdjuster(new AddDependenciesAdjuster(Dependencies));
-  int HadErrors =
-      Tool.run(new ModularizeFrontendActionFactory(Entities, *PPTracker));
+  int HadErrors = 0;
+  HadErrors |= Tool.run(
+      new ModularizeFrontendActionFactory(Entities, *PPTracker, HadErrors));
 
   // Create a place to save duplicate entity locations, separate bins per kind.
   typedef SmallVector<Location, 8> LocationArray;
   typedef SmallVector<LocationArray, Entry::EK_NumberOfKinds> EntryBinArray;
   EntryBinArray EntryBins;
   int KindIndex;
   for (KindIndex = 0; KindIndex < Entry::EK_NumberOfKinds; ++KindIndex) {
     LocationArray Array;

modularize/PreprocessorTracker.h

public:
   // (Called after a Preprocessor object is created, but before preprocessing.)
   virtual void handlePreprocessorEntry(clang::Preprocessor &PP,
                                        llvm::StringRef RootHeaderFile) = 0;
   // Handle exiting a preprocessing session.
   // (Called after preprocessing is complete, but before the Preprocessor
   // object is destroyed.)
   virtual void handlePreprocessorExit() = 0;
 
+  // Handle include directive.
+  // This function is called every time an include directive is seen by the
+  // preprocessor, for the purpose of later checking for 'extern "" {}' or
+  // "namespace {}" blocks containing #include directives.
+  virtual void handleIncludeDirective(llvm::StringRef DirectivePath,
+                                      int DirectiveLine, int DirectiveColumn,
+                                      llvm::StringRef TargetPath) = 0;
+
+  // Check for include directives within the given source line range.
+  // Report errors if any found.  Returns true if no include directives
+  // found in block.
+  virtual bool checkForIncludesInBlock(clang::Preprocessor &PP,
+                                       clang::SourceRange BlockSourceRange,
+                                       const char *BlockIdentifierMessage,
+                                       llvm::raw_ostream &OS) = 0;
+
   // Report on inconsistent macro instances.
   // Returns true if any mismatches.
   virtual bool reportInconsistentMacros(llvm::raw_ostream &OS) = 0;
 
   // Report on inconsistent conditional directive instances.
   // Returns true if any mismatches.
   virtual bool reportInconsistentConditionals(llvm::raw_ostream &OS) = 0;
 
   // Create instance of PreprocessorTracker.
   static PreprocessorTracker *create();
 };
 
 } // end namespace Modularize
 
 #endif

modularize/PreprocessorTracker.cpp

 //===--- PreprocessorTracker.cpp - Preprocessor tracking -*- C++ -*------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===--------------------------------------------------------------------===//
 //
-// The Basic Idea
+// The Basic Idea (Macro and Conditional Checking)
 //
 // Basically we install a PPCallbacks-derived object to track preprocessor
 // activity, namely when a header file is entered/exited, when a macro
 // is expanded, when "defined" is used, and when #if, #elif, #ifdef,
 // and #ifndef are used.  We save the state of macro and "defined"
 // expressions in a map, keyed on a name/file/line/column quadruple.
 // The map entries store the different states (values) that a macro expansion,
 // "defined" expression, or condition expression has in the course of

 //     'SYMBOL' expanded to: '2' with respect to these inclusion paths:
 //       (...)/Header2.h
 //           (...)/SubHeader.h
 //   (...)/SubHeader.h:7:9:
 //   #define SYMBOL 2
 //             ^
 //   Macro defined here.
 //
-// Design and Implementation Details
+// The Basic Idea ('Extern "C/C++" {}' Or 'namespace {}') With Nested
+// '#include' Checking)
+//
+// To check for '#include' directives nested inside 'Extern "C/C++" {}'
+// or 'namespace {}' blocks, we keep track of the '#include' directives
+// while running the preprocessor, and later during a walk of the AST
+// we call a function to check for any '#include' directies inside
+// an 'Extern "C/C++" {}' or 'namespace {}' block, given its source
+// range.
+//
+// Design and Implementation Details (Macro and Conditional Checking)
 //
 // A PreprocessorTrackerImpl class implements the PreprocessorTracker
 // interface. It uses a PreprocessorCallbacks class derived from PPCallbacks
 // to track preprocessor activity, namely entering/exiting a header, macro
 // expansions, use of "defined" expressions, and #if, #elif, #ifdef, and
 // #ifndef conditional directives. PreprocessorTrackerImpl stores a map
 // of MacroExpansionTracker objects keyed on a name/file/line/column
 // value represented by a light-weight PPItemKey value object. This

 // message like the example shown previously, using the stored data.
 //
 // A potential issue is that there is some overlap between the #if/#elif
 // conditional and macro reporting.  I could disable the #if and #elif,
 // leaving just the #ifdef and #ifndef, since these don't overlap.  Or,
 // to make clearer the separate reporting phases, I could add an output
 // message marking the phases.
 //
+// Design and Implementation Details ('Extern "C/C++" {}' Or
+// 'namespace {}') With Nested '#include' Checking)
+//
+// We override the InclusionDirective in PPCallbacks to record information
+// about each '#include' directive encountered during preprocessing.
+// We co-opt the PPItemKey class to store the information about each
+// '#include' directive, including the source file name containing the
+// directive, the name of the file being included, and the source line
+// and column of the directive.  We store these object in a vector,
+// after first check to see if an entry already exists.
+//
+// Later, while the AST is being walked for other checks, we provide
+// visit handlers for 'extern "C/C++" {}' and 'namespace (name) {}'
+// blocks, checking to see if any '#include' directives occurred
+// within the blocks, reporting errors if any found.
+//
 // Future Directions
 //
 // We probably should add options to disable any of the checks, in case
 // there is some problem with them, or the messages get too verbose.
 //
 // With the map of all the macro and conditional expansion instances,
 // it might be possible to add to the existing modularize error messages
 // (the second part referring to definitions being different), attempting
std::string getSourceString(clang::Preprocessor &PP, clang::SourceRange Range) {
   clang::SourceLocation BeginLoc = Range.getBegin();
   clang::SourceLocation EndLoc = Range.getEnd();
   const char *BeginPtr = PP.getSourceManager().getCharacterData(BeginLoc);
   const char *EndPtr = PP.getSourceManager().getCharacterData(EndLoc);
   size_t Length = EndPtr - BeginPtr;
   return llvm::StringRef(BeginPtr, Length).trim().str();
 }
 
-// Retrieve source line from file image.
+// Retrieve source line from file image given a location.
 std::string getSourceLine(clang::Preprocessor &PP, clang::SourceLocation Loc) {
   const llvm::MemoryBuffer *MemBuffer =
       PP.getSourceManager().getBuffer(PP.getSourceManager().getFileID(Loc));
   const char *Buffer = MemBuffer->getBufferStart();
   const char *BufferEnd = MemBuffer->getBufferEnd();
   const char *BeginPtr = PP.getSourceManager().getCharacterData(Loc);
   const char *EndPtr = BeginPtr;
   while (BeginPtr > Buffer) {
     if (*BeginPtr == '\n') {
       BeginPtr++;
       break;
     }
     BeginPtr--;
   }
   while (EndPtr < BufferEnd) {
     if (*EndPtr == '\n') {
       break;
     }
     EndPtr++;
   }
   size_t Length = EndPtr - BeginPtr;
   return llvm::StringRef(BeginPtr, Length).str();
 }
 
+// Retrieve source line from file image given a file ID and line number.
+std::string getSourceLine(clang::Preprocessor &PP, clang::FileID FileID,
+                          int Line) {
+  const llvm::MemoryBuffer *MemBuffer = PP.getSourceManager().getBuffer(FileID);
+  const char *Buffer = MemBuffer->getBufferStart();
+  const char *BufferEnd = MemBuffer->getBufferEnd();
+  const char *BeginPtr = Buffer;
+  const char *EndPtr = BufferEnd;
+  int LineCounter = 1;
+  if (Line == 1)
+    BeginPtr = Buffer;
+  else {
+    while (Buffer < BufferEnd) {
+      if (*Buffer == '\n') {
+        if (++LineCounter == Line) {
+          BeginPtr = Buffer++ + 1;
+          break;
+        }
+      }
+      Buffer++;
+    }
+  }
+  while (Buffer < BufferEnd) {
+    if (*Buffer == '\n') {
+      EndPtr = Buffer;
+      break;
+    }
+    Buffer++;
+  }
+  size_t Length = EndPtr - BeginPtr;
+  return llvm::StringRef(BeginPtr, Length).str();
+}
+
 // Get the string for the Unexpanded macro instance.
 // The soureRange is expected to end at the last token
 // for the macro instance, which in the case of a function-style
 // macro will be a ')', but for an object-style macro, it
 // will be the macro name itself.
 std::string getMacroUnexpandedString(clang::SourceRange Range,
                                      clang::Preprocessor &PP,
                                      llvm::StringRef MacroName,

 class PreprocessorCallbacks : public clang::PPCallbacks {
 public:
   PreprocessorCallbacks(PreprocessorTrackerImpl &ppTracker,
                         clang::Preprocessor &PP, llvm::StringRef rootHeaderFile)
       : PPTracker(ppTracker), PP(PP), RootHeaderFile(rootHeaderFile) {}
   ~PreprocessorCallbacks() {}
 
   // Overridden handlers.
+  void InclusionDirective(clang::SourceLocation HashLoc,
+                          const clang::Token &IncludeTok,
+                          llvm::StringRef FileName, bool IsAngled,
+                          clang::CharSourceRange FilenameRange,
+                          const clang::FileEntry *File,
+                          llvm::StringRef SearchPath,
+                          llvm::StringRef RelativePath,
+                          const clang::Module *Imported);
   void FileChanged(clang::SourceLocation Loc,
                    clang::PPCallbacks::FileChangeReason Reason,
                    clang::SrcMgr::CharacteristicKind FileType,
                    clang::FileID PrevFID = clang::FileID());
   void MacroExpands(const clang::Token &MacroNameTok,
                     const clang::MacroDirective *MD, clang::SourceRange Range,
                     const clang::MacroArgs *Args);
   void Defined(const clang::Token &MacroNameTok,
void handlePreprocessorEntry(clang::Preprocessor &PP,
     HeadersInThisCompile.clear();
     assert((HeaderStack.size() == 0) && "Header stack should be empty.");
     pushHeaderHandle(addHeader(rootHeaderFile));
     PP.addPPCallbacks(new PreprocessorCallbacks(*this, PP, rootHeaderFile));
   }
   // Handle exiting a preprocessing session.
   void handlePreprocessorExit() { HeaderStack.clear(); }
 
+  // Handle include directive.
+  // This function is called every time an include directive is seen by the
+  // preprocessor, for the purpose of later checking for 'extern "" {}' or
+  // "namespace {}" blocks containing #include directives.
+  void handleIncludeDirective(llvm::StringRef DirectivePath, int DirectiveLine,
+                              int DirectiveColumn, llvm::StringRef TargetPath) {
+    HeaderHandle CurrentHeaderHandle = findHeaderHandle(DirectivePath);
+    StringHandle IncludeHeaderHandle = addString(TargetPath);
+    for (std::vector<PPItemKey>::const_iterator I = IncludeDirectives.begin(),
+                                                E = IncludeDirectives.end();
+         I != E; ++I) {
+      // If we already have an entry for this directive, return now.
+      if ((I->File == CurrentHeaderHandle) && (I->Line == DirectiveLine))
+        return;
+    }
+    PPItemKey IncludeDirectiveItem(IncludeHeaderHandle, CurrentHeaderHandle,
+                                   DirectiveLine, DirectiveColumn);
+    IncludeDirectives.push_back(IncludeDirectiveItem);
+  }
+
+  // Check for include directives within the given source line range.
+  // Report errors if any found.  Returns true if no include directives
+  // found in block.
+  bool checkForIncludesInBlock(clang::Preprocessor &PP,
+                               clang::SourceRange BlockSourceRange,
+                               const char *BlockIdentifierMessage,
+                               llvm::raw_ostream &OS) {
+    clang::SourceLocation BlockStartLoc = BlockSourceRange.getBegin();
+    clang::SourceLocation BlockEndLoc = BlockSourceRange.getEnd();
+    // Use block location to get FileID of both the include directive
+    // and block statement.
+    clang::FileID FileID = PP.getSourceManager().getFileID(BlockStartLoc);
+    std::string SourcePath = getSourceLocationFile(PP, BlockStartLoc);
+    HeaderHandle SourceHandle = findHeaderHandle(SourcePath);
+    int BlockStartLine, BlockStartColumn, BlockEndLine, BlockEndColumn;
+    bool returnValue = true;
+    getSourceLocationLineAndColumn(PP, BlockStartLoc, BlockStartLine,
+                                   BlockStartColumn);
+    getSourceLocationLineAndColumn(PP, BlockEndLoc, BlockEndLine,
+                                   BlockEndColumn);
+    for (std::vector<PPItemKey>::const_iterator I = IncludeDirectives.begin(),
+                                                E = IncludeDirectives.end();
+         I != E; ++I) {
+      // If we find an entry with the block, report an error.
+      if ((I->File == SourceHandle) && (I->Line >= BlockStartLine) &&
+          (I->Line < BlockEndLine)) {
+        returnValue = false;
+        OS << SourcePath << ":" << I->Line << ":" << I->Column << "\n";
+        OS << getSourceLine(PP, FileID, I->Line) << "\n";
+        if (I->Column > 0)
+          OS << std::string(I->Column - 1, ' ') << "^\n";
+        OS << "error: Include directive within " << BlockIdentifierMessage
+           << ".\n";
+        OS << SourcePath << ":" << BlockStartLine << ":" << BlockStartColumn
+           << "\n";
+        OS << getSourceLine(PP, BlockStartLoc) << "\n";
+        if (BlockStartColumn > 0)
+          OS << std::string(BlockStartColumn - 1, ' ') << "^\n";
+        OS << "The \"" << BlockIdentifierMessage << "\" block is here.\n";
+      }
+    }
+    return returnValue;
+  }
+
   // Handle entering a header source file.
   void handleHeaderEntry(clang::Preprocessor &PP, llvm::StringRef HeaderPath) {
     // Ignore <built-in> and <command-line> to reduce message clutter.
     if (HeaderPath.startswith("<"))
       return;
     HeaderHandle H = addHeader(HeaderPath);
     if (H != getCurrentHeaderHandle())
       pushHeaderHandle(H);

 
 private:
   llvm::StringPool Strings;
   std::vector<StringHandle> HeaderPaths;
   std::vector<HeaderHandle> HeaderStack;
   std::vector<HeaderInclusionPath> InclusionPaths;
   InclusionPathHandle CurrentInclusionPathHandle;
   llvm::SmallSet<HeaderHandle, 128> HeadersInThisCompile;
+  std::vector<PPItemKey> IncludeDirectives;
   MacroExpansionMap MacroExpansions;
   ConditionalExpansionMap ConditionalExpansions;
   bool InNestedHeader;
 };
 
 // PreprocessorTracker functions.
 
 // PreprocessorTracker desctructor.
 PreprocessorTracker::~PreprocessorTracker() {}
 
 // Create instance of PreprocessorTracker.
 PreprocessorTracker *PreprocessorTracker::create() {
   return new PreprocessorTrackerImpl();
 }
 
 // Preprocessor callbacks for modularize.
 
+// Handle include directive.
+void PreprocessorCallbacks::InclusionDirective(
+    clang::SourceLocation HashLoc, const clang::Token &IncludeTok,
+    llvm::StringRef FileName, bool IsAngled,
+    clang::CharSourceRange FilenameRange, const clang::FileEntry *File,
+    llvm::StringRef SearchPath, llvm::StringRef RelativePath,
+    const clang::Module *Imported) {
+  int DirectiveLine, DirectiveColumn;
+  std::string HeaderPath = getSourceLocationFile(PP, HashLoc);
+  getSourceLocationLineAndColumn(PP, HashLoc, DirectiveLine, DirectiveColumn);
+  PPTracker.handleIncludeDirective(HeaderPath, DirectiveLine, DirectiveColumn,
+                                   FileName);
+}
+
 // Handle file entry/exit.
 void PreprocessorCallbacks::FileChanged(
     clang::SourceLocation Loc, clang::PPCallbacks::FileChangeReason Reason,
     clang::SrcMgr::CharacteristicKind FileType, clang::FileID PrevFID) {
   switch (Reason) {
   case EnterFile:
     PPTracker.handleHeaderEntry(PP, getSourceLocationFile(PP, Loc));
     break;

test/modularize/Inputs/Empty.h

+// Empty header for testing #include directives in blocks.

test/modularize/Inputs/IncludeInExtern.h

+extern "C" {
+  #include "Empty.h"
+}

test/modularize/Inputs/IncludeInNamespace.h

+namespace MyNamespace {
+  #include "Empty.h"
+}

test/modularize/ProblemsExternC.modularize

+# RUN: not modularize %s -x c++ 2>&1 | FileCheck %s
+
+Inputs/IncludeInExtern.h
+
+# CHECK: {{.*}}{{[/\\]}}Inputs{{[/\\]}}IncludeInExtern.h:2:3
+# CHECK-NEXT:   #include "Empty.h"
+# CHECK-NEXT:   ^
+# CHECK-NEXT: error: Include directive within extern "C" {}.
+# CHECK-NEXT: {{.*}}{{[/\\]}}Inputs{{[/\\]}}IncludeInExtern.h:1:1
+# CHECK-NEXT: extern "C" {
+# CHECK-NEXT: ^
+# CHECK-NEXT: The "extern "C" {}" block is here.

test/modularize/ProblemsNamespace.modularize

+# RUN: not modularize %s -x c++ 2>&1 | FileCheck %s
+
+Inputs/IncludeInNamespace.h
+
+# CHECK: {{.*}}{{[/\\]}}Inputs{{[/\\]}}IncludeInNamespace.h:2:3
+# CHECK-NEXT:   #include "Empty.h"
+# CHECK-NEXT:   ^
+# CHECK-NEXT: error: Include directive within namespace MyNamespace {}.
+# CHECK-NEXT: {{.*}}{{[/\\]}}Inputs{{[/\\]}}IncludeInNamespace.h:1:1
+# CHECK-NEXT: namespace MyNamespace {
+# CHECK-NEXT: ^
+# CHECK-NEXT: The "namespace MyNamespace {}" block is here.