Why does unqualified name lookup find all overloaded declarations - c++

Question

Here is an example which I'm trying to understand how does unqualified name look up work for overloaded declarations:
int foo(char a){ return 0; }
namespace A
{
int foo(int a){ return a; }
int foo(){ return 2; }
extern int j;
extern int i;
}
int A::j=foo('a'); //97
int A::i=foo(); //2
It means that int foo(char); does not found by unqualified name look up but int foo(int); and int foo() can be found. So I assume that unqualified name look up for overloaded declaration ends as soon as all overloaded declarations is found for the name. I can't find this into the standard, I can find only the following (sec. 3.4.1):
name look up ends as soon as a declaration is found for the name.
This quote doesn't say anything about overloaded declaration look up.

Answer 1

You're mixing up name lookup with overload resolution. There is no such thing as "unqualified name look up for overloaded declaration". Name lookup and overload resolution are separate.
Name lookup means determining which scope the name is found in. Once that is completed, overload resolution determines which of the declarations visible in that scope should be used.
In your code, name lookup determines that foo means A::foo. Then overload resolution selects between A::foo() and A::foo(int). The ::foo is not considered for overload resolution because it is not a definition of A::foo.
Another example:
namespace C { void f(); }
namespace B { void f(); void f(float); }
namespace C { void f(long); }
using namespace C;
int main()
{
f(1.0);
}
When processing the line f(1.0), name lookup sees void f(); and stops. The result is that f means C::f.
Then overload resolution kicks in, and all declarations of C::f are considered for overload resolution. void f(long) is chosen.

Answer 2

In a declaration in which the declarator-id is a qualified-id, names used before the qualified-id being declared
are looked up in the defining namespace scope; names following the qualified-id are looked up in the scope
of the member’s class or namespace.
(C++11 §3.4.3/3)
So in both of
int A::j=foo('a');
int A::i=foo();
the name foo is looked up in the scope of A just because you have A::j and A::i to the left, in the declarator.
Note that if you do
int k = foo();
only the global foo will be found, and you'll get an error.

Answer 3

You said
It means that int foo(char); does not found by unqualified name look up but int foo(int); and int foo() can be found. So I assume that unqualified name look up for overloaded declaration ends as soon as all overloaded declarations is found for the name.
A similar question was asked in another SO post
There is from 3.4.1/14:
If a variable member of a namespace is defined outside of the scope of its namespace then any name that appears in the definition of the member (after the declarator-id) is looked up as if the definition of the member occurred in its namespace.
Your posted code is equivalent to:
int foo(char a){ return 0; }
namespace A
{
int foo(int a){ return a; }
int foo(){ return 2; }
extern int j;
extern int i;
}
namespace A
{
int j=foo('a');
int i=foo();
}
When the definitions and initializations are put under the namespace, it becomes clear why functions used to initialize the variables are looked up in namespace A first. If an unambiguous match can be found for a function in namespace A, the search for it stops. That means, when compiling the line,
int A::j=foo('a');
The lookup for foo starts in namespace A, is resolved to int A::foo(int); and the search for foo stops.
Hope this clears the confusion.

Answer 4

In the standard (§3.4/1)
Name lookup shall
find an unambiguous declaration for the name (see 10.2). Name lookup may associate more than one declaration with a name if it finds the name to be a function name; the declarations are said to form a set
of overloaded functions (13.1). Overload resolution (13.3) takes place after name lookup has succeeded.
The access rules (Clause 11) are considered only once name lookup and function overload resolution (if
applicable) have succeeded.
Which means the steps are as follows for methods:
First collect all the matching names
Do overload resolution
Check for accessibility
For method, name lookup does not return after finding first match, rather it searches for all matching names. It is clear from the statement Name lookup may associate more than one declaration with a name if it finds the name to be a function name.