Determine which member is visible in a namespace - c++

Question

Consider the following Code Snippet
#include <iostream>
#include <memory>
namespace Foo {
void bar() {
std::cout<<"FOO::BAR"<<std::endl;
}
}
namespace Spam {
void bar() {
std::cout<<"SPAM::BAR"<<std::endl;
}
}
namespace fallbacks {
using Foo::bar;
}
namespace Spam {
using namespace fallbacks;
}
int main() {
Spam::bar();
}
Output
SPAM::BAR
I understand that in this case, if Spam contains the member it will refer to it. However if it doesn't , then the using directive's name will be found and refer to fallbacks::bar.
But I cannot find any authentic source to back the above statement.

Answer 1

Section 3.4.3 of the standard describes qualified name lookup. In particular, section 3.4.3.2 describes the lookup of namespace members.
3.4.3.2.2: For a namespace X and name m, the
namespace-qualified lookup set S(X,m) is defined as follows: Let
S'(X,m) be the set of all declarations of m in X and the inline
namespace set of X (7.3.1). If S'(X,m) is not empty, S(X,m) is
S'(X,m); otherwise, S(X,m) is the union of S(N_i,m) for all namespaces
N_i nominated by using-directives in X and its inline namespace set.
(Source: ISO/IEC 14882:2011: C++ Standard)
The following example is given:
int x;
namespace Y {
void f(float);
void h(int);
}
namespace Z {
void h(double);
}
namespace A {
using namespace Y;
void f(int);
void g(int);
int i;
}
namespace B {
using namespace Z;
void f(char);
int i;
}
namespace AB {
using namespace A;
using namespace B;
void g();
}
void h()
{
AB::g(); // g is declared directly in AB,
// therefore S is { AB::g() } and AB::g() is chosen
AB::f(1); // f is not declared directly in AB so the rules are
// applied recursively to A and B;
// namespace Y is not searched and Y::f(float)
// is not considered;
// S is { A::f(int), B::f(char) } and overload
// resolution chooses A::f(int)
AB::f(’c’); // as above but resolution chooses B::f(char)
AB::x++; // x is not declared directly in AB, and
// is not declared in A or B , so the rules are
// applied recursively to Y and Z,
// S is { } so the program is ill-formed
AB::i++; // i is not declared directly in AB so the rules are
// applied recursively to A and B,
// S is { A::i , B::i } so the use is ambiguous
// and the program is ill-formed
AB::h(16.8); // h is not declared directly in AB and
// not declared directly in A or B so the rules are
// applied recursively to Y and Z,
// S is { Y::h(int), Z::h(double) } and overload
// resolution chooses Z::h(double)
}
(Source: ISO/IEC 14882:2011: C++ Standard)
In your example, if Spam contains bar, the set S contains {Spam::bar} and lookup stops. If the namespace Spam does not contain bar, any namespaces or bars declared via using directives inside Spam will be searched, and this logic is applied recursively until either:
A namespace is found that contains bar, or
the possible search paths are exhausted, in which case the program is ill-formed.

Answer 2

The corresponding name look-up of qualified names is described in the following paragraphs of section 3.4.3.2 Namespace members of the C++ Standard
2 For a namespace X and name m, the namespace-qualified lookup set S(X,m) is defined as follows: Let S0(X,m) be the set of all declarations of m in X and the inline namespace set of X (7.3.1). If S0(X,m) is not empty, S(X,m) is S0(X,m); otherwise, S(X,m) is the union of S(Ni,m) for all namespaces Ni nominated by using-directives in X and its inline namespace set.
3 Given X::m (where X is a user-declared namespace), or given ::m (where X is the global namespace), if S(X,m) is the empty set, the program is ill-formed. Otherwise, if S(X,m) has exactly one member, or if the context of the reference is a using-declaration (7.3.3), S(X,m) is the required set of declarations of m. Otherwise if the use of m is not one that allows a unique declaration to be chosen from S(X,m), the program is ill-formed.
In your case if to follow the quote "Let S0(X,m) be the set of all declarations of m in X and the inline namespace set of X (7.3.1). If S0(X,m) is not empty, S(X,m) is S0(X,m); " S( Spam, bar ) consists of one declaration of bar in Spam. And this declaration is the only declaration in Spam. so this name will be found.