[modules] A using-declaration doesn't introduce a new entity, just a new name

for an existing entity, and as such a using-declaration doesn't need to
conflict with a hidden entity (nor vice versa).

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

diff --git a/include/clang/Sema/Lookup.h b/include/clang/Sema/Lookup.h
index bc8574c201677193c02a35d7855f3e37404f8676..ed447ba1497596e4a0eb1f07d56affa2b85ad32c 100644 (file)
--- a/include/clang/Sema/Lookup.h
+++ b/include/clang/Sema/Lookup.h
@@ -237,6 +237,11 @@ public:
   /// \brief Determine whether this lookup is permitted to see hidden
   /// declarations, such as those in modules that have not yet been imported.
   bool isHiddenDeclarationVisible(NamedDecl *ND) const {
+    // If a using-shadow declaration is hidden, it's never visible, not
+    // even to redeclaration lookup.
+    // FIXME: Should this apply to typedefs and namespace aliases too?
+    if (isa<UsingShadowDecl>(ND))
+      return false;
     return (AllowHidden &&
             (AllowHiddenInternal || ND->isExternallyVisible())) ||
            LookupKind == Sema::LookupTagName;

diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index e80cde76e10cee375f36b3b0bc992c6c56e39e4b..ff9c93d2f6964a4ca435cbc15dbba46cdbc2aafc 100644 (file)
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -7821,7 +7821,8 @@ bool Sema::CheckUsingShadowDecl(UsingDecl *Using, NamedDecl *Orig,
       FoundEquivalentDecl = true;
     }
 
-    (isa<TagDecl>(D) ? Tag : NonTag) = D;
+    if (isVisible(D))
+      (isa<TagDecl>(D) ? Tag : NonTag) = D;
   }
 
   if (FoundEquivalentDecl)

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index 34a03abb96fb8865c29b2c85dc9e7a22101ee496..0ba559830151ea138731ed709c965bbd1bb43503 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -896,6 +896,11 @@ Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
       OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
     }
 
+    // A using-declaration does not conflict with another declaration
+    // if one of them is hidden.
+    if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
+      continue;
+
     // If either declaration was introduced by a using declaration,
     // we'll need to use slightly different rules for matching.
     // Essentially, these rules are the normal rules, except that

diff --git a/test/Modules/Inputs/using-decl-b.h b/test/Modules/Inputs/using-decl-b.h
index b82526f39ff448e6830e4d4330286c81c9cd93a8..b4f206fa443126b204c2dfc1390e3e2cf6ae6854 100644 (file)
--- a/test/Modules/Inputs/using-decl-b.h
+++ b/test/Modules/Inputs/using-decl-b.h
@@ -9,3 +9,29 @@ namespace UsingDecl {
   using ::using_decl_type;
   using ::using_decl_var;
 }
+
+namespace X {
+  int conflicting_hidden_using_decl;
+  int conflicting_hidden_using_decl_fn();
+  int conflicting_hidden_using_decl_var;
+  struct conflicting_hidden_using_decl_struct;
+
+  int conflicting_hidden_using_decl_mixed_1;
+  int conflicting_hidden_using_decl_mixed_2();
+  struct conflicting_hidden_using_decl_mixed_3 {};
+}
+
+using X::conflicting_hidden_using_decl;
+using X::conflicting_hidden_using_decl_fn;
+using X::conflicting_hidden_using_decl_var;
+using X::conflicting_hidden_using_decl_struct;
+int conflicting_hidden_using_decl_fn_2();
+int conflicting_hidden_using_decl_var_2;
+struct conflicting_hidden_using_decl_struct_2 {};
+
+using X::conflicting_hidden_using_decl_mixed_1;
+using X::conflicting_hidden_using_decl_mixed_2;
+using X::conflicting_hidden_using_decl_mixed_3;
+int conflicting_hidden_using_decl_mixed_4;
+int conflicting_hidden_using_decl_mixed_5();
+struct conflicting_hidden_using_decl_mixed_6 {};

diff --git a/test/Modules/using-decl.cpp b/test/Modules/using-decl.cpp
index a388a5b7e711309dd6eb0aa8c42eb745deb24080..f01688498c551340c39bd4ff7b7b9e2b32279293 100644 (file)
--- a/test/Modules/using-decl.cpp
+++ b/test/Modules/using-decl.cpp
@@ -1,8 +1,80 @@
 // RUN: rm -rf %t
-// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify
+// RUN: %clang_cc1 -x objective-c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -DEARLY_IMPORT
+// RUN: %clang_cc1 -x objective-c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -UEARLY_IMPORT
+// RUN: %clang_cc1 -x objective-c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -DEARLY_IMPORT -fno-modules-hide-internal-linkage
+// RUN: %clang_cc1 -x objective-c++ -std=c++11 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t -I %S/Inputs %s -verify -UEARLY_IMPORT -fno-modules-hide-internal-linkage
 
+#ifdef EARLY_IMPORT
 @import using_decl.a;
+#endif
+
+namespace Y {
+  int conflicting_hidden_using_decl;
+  int conflicting_hidden_using_decl_fn_2();
+  int conflicting_hidden_using_decl_var_2;
+  struct conflicting_hidden_using_decl_struct_2;
+
+  struct conflicting_hidden_using_decl_mixed_4 {};
+  int conflicting_hidden_using_decl_mixed_5;
+  int conflicting_hidden_using_decl_mixed_6();
+}
+
+using Y::conflicting_hidden_using_decl;
+int conflicting_hidden_using_decl_fn();
+int conflicting_hidden_using_decl_var;
+struct conflicting_hidden_using_decl_struct {};
+using Y::conflicting_hidden_using_decl_fn_2;
+using Y::conflicting_hidden_using_decl_var_2;
+using Y::conflicting_hidden_using_decl_struct_2;
+
+struct conflicting_hidden_using_decl_mixed_1 {};
+int conflicting_hidden_using_decl_mixed_2;
+int conflicting_hidden_using_decl_mixed_3();
+using Y::conflicting_hidden_using_decl_mixed_4;
+using Y::conflicting_hidden_using_decl_mixed_5;
+using Y::conflicting_hidden_using_decl_mixed_6;
+
+template<typename T> int use(T);
+void test_conflicting() {
+  use(conflicting_hidden_using_decl);
+  use(conflicting_hidden_using_decl_fn());
+  use(conflicting_hidden_using_decl_var);
+  use(conflicting_hidden_using_decl_fn_2());
+  use(conflicting_hidden_using_decl_var_2);
+  use(conflicting_hidden_using_decl_mixed_1());
+  use(conflicting_hidden_using_decl_mixed_2);
+  use(conflicting_hidden_using_decl_mixed_3());
+  use(conflicting_hidden_using_decl_mixed_4());
+  use(conflicting_hidden_using_decl_mixed_5);
+  use(conflicting_hidden_using_decl_mixed_6());
+}
+
+#ifndef EARLY_IMPORT
+@import using_decl.a;
+#endif
 
-// expected-no-diagnostics
 UsingDecl::using_decl_type x = UsingDecl::using_decl_var;
 UsingDecl::inner y = x;
+
+@import using_decl.b;
+
+void test_conflicting_2() {
+  use(conflicting_hidden_using_decl);         // expected-error {{ambiguous}}
+  use(conflicting_hidden_using_decl_fn());    // expected-error {{ambiguous}}
+  use(conflicting_hidden_using_decl_var);     // expected-error {{ambiguous}}
+  use(conflicting_hidden_using_decl_fn_2());  // expected-error {{ambiguous}}
+  use(conflicting_hidden_using_decl_var_2);   // expected-error {{ambiguous}}
+  use(conflicting_hidden_using_decl_mixed_1); // ok, struct hidden
+  use(conflicting_hidden_using_decl_mixed_2); // expected-error {{ambiguous}}
+  use(conflicting_hidden_using_decl_mixed_3); // ok, struct hidden
+  use(conflicting_hidden_using_decl_mixed_4); // ok, struct hidden
+  use(conflicting_hidden_using_decl_mixed_5); // expected-error {{ambiguous}}
+  use(conflicting_hidden_using_decl_mixed_6); // ok, struct hidden
+  // expected-note@using-decl.cpp:* 7{{candidate}}
+  // expected-note@using-decl-b.h:* 7{{candidate}}
+
+  int conflicting_hidden_using_decl_mixed_1::*p1;
+  int conflicting_hidden_using_decl_mixed_3::*p3;
+  int conflicting_hidden_using_decl_mixed_4::*p4;
+  int conflicting_hidden_using_decl_mixed_6::*p6;
+}