Revert r342019, "Track definition merging on the canonical declaration

even when [...]"

Further testing has revealed that this causes build breaks during
explicit module compilations.

llvm-svn: 342020

5 files changed, 28 insertions, 46 deletions

diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index b107e8bd2a3..0ed52ffd351 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -932,7 +932,10 @@ void ASTContext::mergeDefinitionIntoModule(NamedDecl *ND, Module *M,
     if (auto *Listener = getASTMutationListener())
       Listener->RedefinedHiddenDefinition(ND, M);
 
-  MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M);
+  if (getLangOpts().ModulesLocalVisibility)
+    MergedDefModules[cast<NamedDecl>(ND->getCanonicalDecl())].push_back(M);
+  else
+    ND->setVisibleDespiteOwningModule();
 }
 
 void ASTContext::deduplicateMergedDefinitonsFor(NamedDecl *ND) {
diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp
index 819f9ef8a48..900ccb18c7e 100644
--- a/clang/lib/Sema/SemaType.cpp
+++ b/clang/lib/Sema/SemaType.cpp
@@ -7623,15 +7623,8 @@ bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested,
 
     // A visible module might have a merged definition instead.
     if (D->isModulePrivate() ? hasMergedDefinitionInCurrentModule(D)
-                             : hasVisibleMergedDefinition(D)) {
-      if (CodeSynthesisContexts.empty() &&
-          !getLangOpts().ModulesLocalVisibility) {
-        // Cache the fact that this definition is implicitly visible because
-        // there is a visible merged definition.
-        D->setVisibleDespiteOwningModule();
-      }
+                             : hasVisibleMergedDefinition(D))
       return true;
-    }
 
     return false;
   };
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index ac3b7374018..b60e5f14a67 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -3780,15 +3780,22 @@ void ASTReader::makeModuleVisible(Module *Mod,
 /// visible.
 void ASTReader::mergeDefinitionVisibility(NamedDecl *Def,
                                           NamedDecl *MergedDef) {
+  // FIXME: This doesn't correctly handle the case where MergedDef is visible
+  // in modules other than its owning module. We should instead give the
+  // ASTContext a list of merged definitions for Def.
   if (Def->isHidden()) {
     // If MergedDef is visible or becomes visible, make the definition visible.
     if (!MergedDef->isHidden())
       Def->setVisibleDespiteOwningModule();
-    else {
+    else if (getContext().getLangOpts().ModulesLocalVisibility) {
       getContext().mergeDefinitionIntoModule(
           Def, MergedDef->getImportedOwningModule(),
           /*NotifyListeners*/ false);
       PendingMergedDefinitionsToDeduplicate.insert(Def);
+    } else {
+      auto SubmoduleID = MergedDef->getOwningModuleID();
+      assert(SubmoduleID && "hidden definition in no module");
+      HiddenNamesMap[getSubmodule(SubmoduleID)].push_back(Def);
     }
   }
 }
diff --git a/clang/lib/Serialization/ASTReaderDecl.cpp b/clang/lib/Serialization/ASTReaderDecl.cpp
index 82951074764..00fad25eeac 100644
--- a/clang/lib/Serialization/ASTReaderDecl.cpp
+++ b/clang/lib/Serialization/ASTReaderDecl.cpp
@@ -4419,9 +4419,22 @@ void ASTDeclReader::UpdateDecl(Decl *D,
     case UPD_DECL_EXPORTED: {
       unsigned SubmoduleID = readSubmoduleID();
       auto *Exported = cast<NamedDecl>(D);
+      if (auto *TD = dyn_cast<TagDecl>(Exported))
+        Exported = TD->getDefinition();
       Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
-      Reader.getContext().mergeDefinitionIntoModule(Exported, Owner);
-      Reader.PendingMergedDefinitionsToDeduplicate.insert(Exported);
+      if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
+        Reader.getContext().mergeDefinitionIntoModule(cast<NamedDecl>(Exported),
+                                                      Owner);
+        Reader.PendingMergedDefinitionsToDeduplicate.insert(
+            cast<NamedDecl>(Exported));
+      } else if (Owner && Owner->NameVisibility != Module::AllVisible) {
+        // If Owner is made visible at some later point, make this declaration
+        // visible too.
+        Reader.HiddenNamesMap[Owner].push_back(Exported);
+      } else {
+        // The declaration is now visible.
+        Exported->setVisibleDespiteOwningModule();
+      }
       break;
     }
 
diff --git a/clang/test/Modules/merge-template-pattern-visibility-3.cpp b/clang/test/Modules/merge-template-pattern-visibility-3.cpp
deleted file mode 100644
index 9ac1b6699da..00000000000
--- a/clang/test/Modules/merge-template-pattern-visibility-3.cpp
+++ /dev/null
@@ -1,34 +0,0 @@
-// RUN: %clang_cc1 -fmodules -emit-llvm-only %s -verify
-
-#pragma clang module build A
-module A {}
-#pragma clang module contents
-#pragma clang module begin A
-template<typename T> void f(const T&) { T::error; }
-#pragma clang module end
-#pragma clang module endbuild
-
-#pragma clang module build B
-module B {}
-#pragma clang module contents
-#pragma clang module begin B
-template<typename T> void f(const T&) { T::error; }
-#pragma clang module end
-#pragma clang module endbuild
-
-#pragma clang module build C
-module C {}
-#pragma clang module contents
-#pragma clang module begin C
-#pragma clang module load B
-template<typename T> void f(const T&) { T::error; }
-#pragma clang module end
-#pragma clang module endbuild
-
-#pragma clang module load A
-inline void f() {}
-void x() { f(); }
-
-#pragma clang module import C
-// expected-error@* {{cannot be used prior to}}
-void y(int n) { f(n); } // expected-note {{instantiation of}}