Argument-dependent Nachschlag unerwartet auf Typen aliased aus einem anderen Namespace

Question

ich gerade lief in einige interessante Verhalten mit dem Argument abhängigen Lookup verhalten, die ich nicht ganz verstehen:

#include <iostream> 

namespace a { 
struct Foo { 
    Foo(int v1, int v2) : v1(v1), v2(v2) { } 
    int v1,v2; 
}; 
} 

namespace b { 
template <typename T> 
struct Baz : T { 
    using T::T; 
}; 
} 

namespace c { 
using Foo = ::b::Baz< ::a::Foo>; 

// (1) NOT FOUND BY ADL 
// std::ostream& operator << (std::ostream& os, const Foo& foo) 
// { 
// return os << foo.v1 << "," << foo.v2; 
// } 
} 

namespace b { 

// (2) FOUND BY ADL 
std::ostream& operator << (std::ostream& os, const ::c::Foo& foo) 
{ 
    return os << foo.v1 << "," << foo.v2; 
} 

} 

int main() 
{ 
    c::Foo foo(1,2); 
    // Variant (1): ADL fails: should it not find 
    // c::operator<<(std::ostream&, const Foo&) ? 
    // Variant (2) compiles 
    std::cout << "foo: " << foo << std::endl; 
} 

ich, dass c::Foo tatsächlich b::Baz<...> ist, also macht es etwas Sinn, dass ADL den Operator findet, wenn ich ihn innerhalb namespace b definiere. Aber es scheint der Intuition zu widersprechen, dass das Definieren des Operators innerhalb von namespace c nicht funktioniert, da c::Foo (IMHO) dem Compiler erlauben sollte, ADL innerhalb namespace c auch durchzuführen.

Warum ist das nicht der Fall? Was ist der Grund dafür?

Answer 1

[basic.lookup.argdep]/2:

Typedef Namen und mit Deklaration s verwendet, um die Typen zu spezifizieren nicht zu diesem Set beitragen.

Weder typedef-Namen noch using-declarations gehören zu dem Typ, den sie bezeichnen. Wenn sie das wären (was eigentlich kontraintuitiv wäre, IMO), würden die Dinge sehr leicht brechen; nur weil ich eine Klasse typedef'd, werden alle Anrufe nun Funktionen unter Berücksichtigung in der Nähe des typedef gegeben, die praktisch nie gewünscht:

#include <string> 

namespace A { 
    using str = std::string; 
    int stoi(str); // This will be a candidate in e.g. stoi(std::string{"0.4"}), 
        // leading to potentially different behavior or ambiguity 

namespace B { 
    int stoi(std::string); // This is no candidate, because...? 
}