From 30fc9a9339de86b098667a8fa9eba6da1f7232d2 Mon Sep 17 00:00:00 2001
From: Richard Smith <richard-llvm@metafoo.co.uk>
Date: Thu, 1 Sep 2016 20:15:25 +0000
Subject: [PATCH] When we reach the end of a #include of a header of a local
 submodule that we textually included, create an ImportDecl just as we would
 if we reached a #include of any other modular header. This is necessary in
 order to correctly determine the set of variables to initialize for an
 imported module.

This should hopefully make the modules selfhost buildbot green again.

llvm-svn: 280409
---
 clang/include/clang/Sema/Sema.h              |  1 +
 clang/lib/Sema/SemaDecl.cpp                  | 24 +++++++++++++++++-------
 clang/test/Modules/global-init.cpp           | 19 +++++++++++++++++++
 clang/tools/libclang/CXIndexDataConsumer.cpp |  8 ++++++++
 4 files changed, 45 insertions(+), 7 deletions(-)
 create mode 100644 clang/test/Modules/global-init.cpp

diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index b6c7b40..dfe9e36 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -1884,6 +1884,7 @@ public:
   /// \brief The parser has processed a module import translated from a
   /// #include or similar preprocessing directive.
   void ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
+  void BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod);
 
   /// \brief The parsed has entered a submodule.
   void ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod);
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 8b148af..2a514ab 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -15312,7 +15312,10 @@ DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
 
 void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
   checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext, true);
+  BuildModuleInclude(DirectiveLoc, Mod);
+}
 
+void Sema::BuildModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
   // Determine whether we're in the #include buffer for a module. The #includes
   // in that buffer do not qualify as module imports; they're just an
   // implementation detail of us building the module.
@@ -15352,20 +15355,27 @@ void Sema::ActOnModuleBegin(SourceLocation DirectiveLoc, Module *Mod) {
   VisibleModules.setVisible(Mod, DirectiveLoc);
 }
 
-void Sema::ActOnModuleEnd(SourceLocation DirectiveLoc, Module *Mod) {
-  checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
+void Sema::ActOnModuleEnd(SourceLocation EofLoc, Module *Mod) {
+  checkModuleImportContext(*this, Mod, EofLoc, CurContext);
 
   if (getLangOpts().ModulesLocalVisibility) {
-    assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&
-           "left the wrong module scope");
     VisibleModules = std::move(ModuleScopes.back().OuterVisibleModules);
-    ModuleScopes.pop_back();
-
-    VisibleModules.setVisible(Mod, DirectiveLoc);
     // Leaving a module hides namespace names, so our visible namespace cache
     // is now out of date.
     VisibleNamespaceCache.clear();
   }
+
+  assert(!ModuleScopes.empty() && ModuleScopes.back().Module == Mod &&
+         "left the wrong module scope");
+  ModuleScopes.pop_back();
+
+  // We got to the end of processing a #include of a local module. Create an
+  // ImportDecl as we would for an imported module.
+  FileID File = getSourceManager().getFileID(EofLoc);
+  assert(File != getSourceManager().getMainFileID() &&
+         "end of submodule in main source file");
+  SourceLocation DirectiveLoc = getSourceManager().getIncludeLoc(File);
+  BuildModuleInclude(DirectiveLoc, Mod);
 }
 
 void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
diff --git a/clang/test/Modules/global-init.cpp b/clang/test/Modules/global-init.cpp
new file mode 100644
index 0000000..fb42464
--- /dev/null
+++ b/clang/test/Modules/global-init.cpp
@@ -0,0 +1,19 @@
+// RUN: rm -rf %t
+// RUN: mkdir %t
+//
+// RUN: echo '#pragma once' > %t/a.h
+// RUN: echo 'struct A { A() {} int f() const; } const a;' >> %t/a.h
+//
+// RUN: echo '#include "a.h"' > %t/b.h
+//
+// RUN: echo 'module M { module b { header "b.h" export * } module a { header "a.h" export * } }' > %t/map
+//
+// RUN: %clang_cc1 -fmodules -fmodules-cache-path=%t -fmodule-map-file=%t/map -I%t %s -emit-llvm -o - -triple %itanium_abi_triple | FileCheck %s
+
+#include "b.h"
+
+// CHECK: @_ZL1a = internal global
+// CHECK: call {{.*}} @_ZN1AC1Ev({{.*}}@_ZL1a
+// CHECK: call {{.*}} @_ZNK1A1fEv({{.*}}@_ZL1a
+// CHECK: store {{.*}} @x
+int x = a.f();
diff --git a/clang/tools/libclang/CXIndexDataConsumer.cpp b/clang/tools/libclang/CXIndexDataConsumer.cpp
index 59fa92b..74d8f24 100644
--- a/clang/tools/libclang/CXIndexDataConsumer.cpp
+++ b/clang/tools/libclang/CXIndexDataConsumer.cpp
@@ -478,6 +478,14 @@ void CXIndexDataConsumer::importedModule(const ImportDecl *ImportD) {
   if (!Mod)
     return;
 
+  // If the imported module is part of the top-level module that we're
+  // indexing, it doesn't correspond to an imported AST file.
+  // FIXME: This assumes that AST files and top-level modules directly
+  // correspond, which is unlikely to remain true forever.
+  if (Module *SrcMod = ImportD->getImportedOwningModule())
+    if (SrcMod->getTopLevelModule() == Mod->getTopLevelModule())
+      return;
+
   CXIdxImportedASTFileInfo Info = {
                                     static_cast<CXFile>(
                                     const_cast<FileEntry *>(Mod->getASTFile())),
-- 
2.7.4