Don't consider `LinkageSpec` when calculating DeclContext `Encloses`

[erichkeane]

Summary

We don't properly handle lookup through using declarations when there is
a linkage spec in the common chain. This is because CppLookupName and
CppNamespaceLookup end up skipping LinkageSpec's (correctly, as they
are not lookup scopes), but the UnqualUsingDirectiveSet does not.

I discovered that when we are calculating the CommonAncestor for a
using-directive, we were coming up with the LinkageSpec, instead of
the LinkageSpec's parent. Then, when we use
UnqualUsingDirectiveSet::getNamespacesFor a scope, we don't end up
finding any that were in the LinkageSpec (again, since CppLookupName
skips linkage specs), so those don't end up participating in the lookup.

The function UnqualUsingDirectiveSet::addUsingDirective calculates
this common ancestor via a loop through the the DeclSpec::Encloses
function.

Changing this Encloses function to believe that a LinkageSpec
Enclosesnothing ends up fixing the problem without breaking any other tests,
so I opted to do that. A less aggressive patch could perhaps change only
the addUsingDirective, but my examination of all uses of Encloses
showedthat it seems to be used exclusively in lookup, which makes me think
this is correct everywhere.

[rjmccall]

We don't properly handle lookup through using declarations when there is a linkage spec in the common chain.

Pedantic note: you mean using *directives*.

At some point, we should probably reconsider whether extern "C" ought to be a DeclContext at all, as opposed to ultimately just setting a bit on the decls and providing some way of recovering the source structure. We don't make individual local scopes different DCs, and those probably have more right to be one than LSD.

Anyway, this patch seems acceptable.

clang/lib/AST/DeclBase.cpp

1215

!isa<LinkageSpecDecl>(DC), please

clang/lib/AST/DeclBase.cpp

bool DeclContext::isExternCXXContext() const {
   return isLinkageSpecContext(this, LinkageSpecDecl::lang_cxx);
 }
 
 bool DeclContext::Encloses(const DeclContext *DC) const {
   if (getPrimaryContext() != this)
     return getPrimaryContext()->Encloses(DC);
 
   for (; DC; DC = DC->getParent())
-    if (DC->getPrimaryContext() == this)
+    if (!isa<LinkageSpecDecl>(DC) && DC->getPrimaryContext() == this)
       return true;
   return false;
 }
 
 DeclContext *DeclContext::getNonTransparentContext() {
   DeclContext *DC = this;
   while (DC->isTransparentContext()) {
     DC = DC->getParent();

clang/test/SemaCXX/lookup-through-linkage.cpp

+// RUN: %clang_cc1 %s -verify
+
+// expected-no-diagnostics
+
+extern "C++" {
+namespace A {
+namespace B {
+int bar;
+}
+} // namespace A
+namespace C {
+void foo() {
+  using namespace A;
+  (void)B::bar;
+}
+} // namespace C
+}
+
+extern "C" {
+extern "C++" {
+namespace D {
+namespace E {
+int bar;
+}
+} // namespace A
+namespace F {
+void foo() {
+  using namespace D;
+  (void)E::bar;
+}
+} // namespace C
+}
+}