Friend declaration and the entity it denotes - c++

Question

I have one question about friend functions/classes. Consider the following code:
#include <iostream>
struct A
{
private:
int a = 5;
friend int foo(A a);
};
int foo(A a)
{
return a.a;
}
int a = foo(A());
int main(){ std::cout << a << std::endl; }
DEMO
It works fine and both int foo() within class scope and global scope refer to the same entity. Although, the declaration of int foo() within the class scope didn't introduce a name into the global scope. If it were then we would recieve a linker-error intstead of compile-error in the code:
#include <iostream>
struct A
{
private:
int a = 5;
friend int foo();
};
int a = foo(); //undeclared foo
int main(){ std::cout << a << std::endl; }
DEMO
I can't find explanation about this in the Standard. What it says is N3797:11.3/6 [class.friend]:
A function can be defined in a friend declaration of a class if and
only if the class is a non-local class (9.8), the function name is
unqualified, and the function has namespace scope.
So, it explains why the following code works fine:
#include <iostream>
struct A
{
private:
int a = 5;
friend int foo(A a)
{
return a.a;
}
};
int a = foo(A());
int main(){ std::cout << a << std::endl; }
DEMO
We defined the function in the friend declaration and, as the Standard said it became the member of the global namespace. But the rule covers the defintion, not declaration. Obviously, that's not any declaration is definition. So we can't apply one to the first example.

Answer 1

In the last program
#include <iostream>
struct A
{
private:
int a = 5;
friend int foo(A a)
{
return a.a;
}
};
int a = foo(A());
int main(){ std::cout << a << std::endl; }
The compiler finds definition of function foo only due to the argument dependent lookup.
You should consider the following section of the C++ Standard
3.4.2 Argument-dependent name lookup
2 For each argument type T in the function call, there is a set of
zero or more associated namespaces and a set of zero or more
associated classes to be considered. The sets of namespaces and
classes is determined entirely by the types of the function
arguments (and the namespace of any template template argument).
Typedef names and using-declarations used to specify the types do not
contribute to this set.
Thus in this program the compiler searches the function in the scope of the class because the argument of the function has the class type. If you will change the function definition for example the following way then the compiler will not find the function.
#include <iostream>
struct A
{
public:
A( int x ) : a( 2 * x ) {}
private:
int a;
friend int foo( int x )
{
A a( x );
return a.a;
}
};
int a = foo( 10 );
int main()
{
std::cout << a << std::endl;
return 0;
}
But if you add a declaration of the function in the scope where the class is defined then the compiler will see the function
#include <iostream>
struct A
{
public:
A( int x ) : a( 2 * x ) {}
private:
int a;
friend int foo( int x )
{
A a( x );
return a.a;
}
};
int foo( int );
int a = foo( 10 );
int main()
{
std::cout << a << std::endl;
return 0;
}
Here the program output is
20