[Sema] Add more tests for the behavior of argument-dependent name lookup

[riccibruno]

Summary

The goal here is to exercise each rule in [basic.lookup.argdep] at least once. These new tests expose what I believe are 2 issues:

1. CWG 1691 needs to be implemented (p2: [...] Its associated namespaces are the innermost enclosing namespaces of its associated classes [...]) The corresponding tests are adl_class_type::X2 and adl_class_type::X5.

2. The end of paragraph 2 ([...] Additionally, if the aforementioned set of overloaded functions is named with a template-id, its associated classes and namespaces also include those of its type template-arguments and its template template-arguments.) is not implemented. Closely related, the restriction on non-dependent parameter types in this same paragraph needs to be removed. The corresponding tests are in adl_overload_set. (both issues are from CWG 997).

[riccibruno]

Also test for inline namespaces.

[• Quuxplusone]

test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-associated-namespaces-classes.cpp

304 ↗

(On Diff #194763)

I see how g3 matches the example in CWG997
http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#997
However, I don't see how CWG997's resolution actually affected this example in the slightest. The wording inserted for CWG997 was, "Additionally, if the aforementioned set of overloaded functions is named with a template-id, its associated classes and namespaces are those of its type template-arguments and its template template-arguments." That makes e.g.

f(g3<N::S>)

consider N::f, because N::S is a "type template-argument" of the template-id g3<N::S> which names the set of overloaded functions. But it doesn't do anything at all to f(g3) because g3 is not a template-id and doesn't have any template-arguments.

This piece of ADL is implemented only by GCC (not EDG, Clang, or MSVC), and personally I would very much like to keep it that way. We know there's no real-world code that expects or relies on CWG997 — because such code would never work in practice except on GCC. Let's keep it that way! As soon as you implement a crazy arcane rule, such that code _could_ portably rely on it, code _will start_ relying on it... and then we'll never be able to simplify the language.
Case in point: the piece of ADL described in this blog post --
https://quuxplusone.github.io/blog/2019/04/09/adl-insanity-round-2/
As soon as the above-described arcane ADL rule was implemented in GCC and Clang, Boost.Hana started relying on it; and now the rule is "locked in" to the paper standard because there's real-world code relying on it.
Personally I'd like to _keep_ real-world code from relying on CWG997, until someone figures out what CWG was thinking when they added it.

[riccibruno]

test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-associated-namespaces-classes.cpp

304 ↗

(On Diff #194763)

I think that the relevant part of CWG 997 is the removal of the restriction on non-dependent parameter types. Sure, g3 is not a template-id, but it refers to an overload set which contains the second g3, and one of the parameter of this second g3 is N::Q<T>.

I don't think this is a surprising rule. It matches the general intuition that for function types ADL is done based on the function parameter types and return type. Not having this rule introduces a difference between function templates and functions in overload sets. Consider https://godbolt.org/z/UXHqm2 :

namespace N {
    struct S1 {};
    template <typename> struct S2 {};

    void f(void (*g)());
}

void g1();          // #1
void g1(N::S1);     // #2

void g2();                                  // #3
template <typename T> void g2(N::S2<T>);    // #4

void test() {
    f(g1); // ok, g1 is #1
    f(g2); // should be ok, g2 is #3
}

[• Quuxplusone]

test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-associated-namespaces-classes.cpp

77 ↗

(On Diff #194763)

Do you also have a test somewhere to verify that the parameter and return types of a lambda's operator() do not contribute to the associated types of the lambda type itself? That is,

// https://godbolt.org/z/g_oMOA
namespace N {
    struct A {};
    template<class T> constexpr int f(T) { return 1; }
}

constexpr int f(N::A (*)()) { return 2; }
constexpr int f(void (*)(N::A)) { return 3; }

void test() {
    constexpr auto lambda = []() -> N::A { return {}; };
    static_assert(f(lambda) == 2);

    constexpr auto lambda2 = [](N::A) {};
    static_assert(f(lambda2) == 3);
}

Clang does handle this correctly; I'm just asking for it to be tested, if it's not already. (I might have overlooked an existing test.)

144 ↗

(On Diff #194763)

I think for completeness there should be a "negative test" for non-type template arguments:

namespace X4 {
  template <auto NT> struct C {};
  namespace N {
    struct Z {
        enum E { E0 };
        void X4_f(C<E::E0>);
    };
    enum E { E0 };
    void X4_g(C<E::E0>);
  }
}
void test4() {
  X4::C<X4::N::E::E0> c1;
  X4::C<X4::N::Z::E::E0> c2;
  X4_f(c1); // expected-error{{undeclared identifier 'X4_f'}}
  X4_g(c2); // expected-error{{undeclared identifier 'X4_g'}}
}

In C++2a, user-defined NTTPs will become possible, so we'll want another test for something like

// https://godbolt.org/z/MfWG8C
namespace X4 {
  template<auto NT> struct C {};
  namespace N {
    struct Z {
      int i;
      constexpr Z(int i): i(i) {}
      auto operator<=>(const Z&) const = default;
    };
    void X4_f(C<Z(0)>);
  }
}
void test4() {
  X4::C<X4::N::Z(0)> c1;
  X4_f(c1); // expected-error{{undeclared identifier 'X4_f'}}
}

304 ↗

(On Diff #194763)

I think that the relevant part of CWG 997 is the removal of the restriction on non-dependent parameter types.

Ah, I had missed the removal of the word (non-dependent) in my reading of CWG997. So just that one-word removal is what fixed their example, and is what you're testing with g3.

I still object to g2 — I would like that FIXME to say PLEASEDONTFIXME or something. :)

test/CXX/basic/basic.lookup/basic.lookup.argdep/p3.cpp

50 ↗

(On Diff #194763)

...But if you put the using M::f; _after_ the extern void f(char);, then GCC believes it's okay. https://godbolt.org/z/DghSTM
You should definitely have a test for the using-after-extern case, just to make sure it doesn't ICE or anything.

test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp

96 ↗

(On Diff #194763)

Nit: 80-column lines here and above would be nice. :)

[• Quuxplusone]

As you're making tests for ADL corner cases, you might also consider testing the interactions between ADL and defaulted function parameters, e.g. https://godbolt.org/z/vHnyFl
It looks like everyone (except MSVC) already gets that stuff right (or at least portable-between-the-big-three). I bet the behavior naturally falls out of some other rules; you might say "there's no way that could possibly break, so we don't need to test it," and I'd accept that.

[riccibruno]

In D60570#1465478, @Quuxplusone wrote:

As you're making tests for ADL corner cases, you might also consider testing the interactions between ADL and defaulted function parameters, e.g. https://godbolt.org/z/vHnyFl
It looks like everyone (except MSVC) already gets that stuff right (or at least portable-between-the-big-three). I bet the behavior naturally falls out of some other rules; you might say "there's no way that could possibly break, so we don't need to test it," and I'd accept that.

I think that as you say this falls out of the other rules.

test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-associated-namespaces-classes.cpp

77 ↗

(On Diff #194763)

I am not sure, but I see no harm in adding it here.

144 ↗

(On Diff #194763)

Isn't that already covered by the test in adl_class_template_specialization_type::X1 ? I agree that a test for class type NTTP will be needed in C++2a, but for now this feature is not yet implemented.

304 ↗

(On Diff #194763)

I don't understand your objection to the template-id rule of CWG 997 (which is what f(g2<N::S>) tests). It seems to me that the following should be well-formed (https://godbolt.org/z/J5uhQ-) :

namespace N {
    template <typename T> void f(T &&);
    struct S {};
}

template <typename T> struct C {};
template <typename T> void g();

void test() {
    f(C<N::S>{}); // ok
    f(g<N::S>);   // should be ok (and is ok according to the spec)
}

test/CXX/basic/basic.lookup/basic.lookup.argdep/p3.cpp

50 ↗

(On Diff #194763)

Hmm... I am not sure what gcc is thinking here. The order should not matter according to the beginning of [basic.lookup.argdep]p3.

test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp

96 ↗

(On Diff #194763)

I am usually a little bit more flexible on the 80-columns rule in tests, but you are right. Fixed.

[riccibruno]

Also test that typedef-names and using-declarations are not considered.

[• Quuxplusone]

test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-associated-namespaces-classes.cpp

304 ↗

(On Diff #194763)

I admit that your comparison makes the rule look reasonable. :) But here are some comparisons designed to make the rule look UNreasonable.
https://godbolt.org/z/n5kvUE

namespace N {
    void foo(void(*)());

    class T {};
    using A = int;
    template<class> class TT {};
    template<class> using AT = int;
    void F();
    void (*V)();
}

template<class> void ft_t();
template<class> void (*vt_t)();
template<auto&> void ft_nt();
template<auto&> void (*vt_nt)();
template<template<class> class> void ft_tt();
template<template<class> class> void (*vt_tt)();

void test() {
    foo(ft_t<N::T>);  // OK: ADL considers N::foo (nobody but GCC implements this)
    foo(vt_t<N::T>);  // Error: ADL does not consider N::foo
    foo(ft_t<N::A>);  // Error: ADL does not consider N::foo
    foo(vt_t<N::A>);  // Error: ADL does not consider N::foo

    foo(ft_nt<N::V>);  // Error: ADL does not consider N::foo
    foo(vt_nt<N::V>);  // Error: ADL does not consider N::foo
    foo(vt_nt<N::F>);  // Error: ADL does not consider N::foo

    foo(ft_tt<N::TT>);  // OK: ADL considers N::foo (nobody but GCC implements this)
    foo(vt_tt<N::TT>);  // Error: ADL does not consider N::foo
    foo(ft_tt<N::AT>);  // OK: ADL considers N::foo (nobody but GCC implements this)

    foo( (ft_t<N::T>) );  // OK??: ADL considers N::foo (nobody but GCC implements this)
    foo( &ft_t<N::T>  );  // OK??: ADL considers N::foo (nobody but GCC implements this)
    foo( (ft_tt<N::TT>) );  // OK??: ADL considers N::foo (nobody but GCC implements this)
    foo( &ft_tt<N::TT>  );  // OK??: ADL considers N::foo (nobody but GCC implements this)
    foo( (ft_tt<N::AT>) );  // OK??: ADL considers N::foo (nobody but GCC implements this)
    foo( &ft_tt<N::AT>  );  // OK??: ADL considers N::foo (nobody but GCC implements this)
}

In all of these cases there is no ADL, on any of the Big 4 compilers, except for GCC in some of the cases. So it would be really nice IMO to just say "okay, let's just strike those corner cases from C++2b, eliminate these cases of ADL from GCC, the world gets a little bit simpler, no code breaks, everyone is happy." If Clang moves closer to GCC (and further from EDG/MSVC), then the happy path actually becomes harder to sell.

(I'm pretty sure the cases I marked OK?? are indeed OK according to the paper standard; I think that's why [basic.lookup.argdep] says "...if the argument is the name or address of a set of overloaded functions...")

[riccibruno]

(I have numbered your examples to make the discussion easier, and moved to a non-inline comment to have more space)

foo(ft_t<N::T>);  // OK: ADL considers N::foo (nobody but GCC implements this) #1
foo(vt_t<N::T>);  // Error: ADL does not consider N::foo #2
foo(ft_t<N::A>);  // Error: ADL does not consider N::foo #3
foo(vt_t<N::A>);  // Error: ADL does not consider N::foo #4

foo(ft_nt<N::V>);  // Error: ADL does not consider N::foo #5
foo(vt_nt<N::V>);  // Error: ADL does not consider N::foo #6
foo(vt_nt<N::F>);  // Error: ADL does not consider N::foo #7

foo(ft_tt<N::TT>);  // OK: ADL considers N::foo (nobody but GCC implements this) #8
foo(vt_tt<N::TT>);  // Error: ADL does not consider N::foo #9
foo(ft_tt<N::AT>);  // OK: ADL considers N::foo (nobody but GCC implements this) #10

foo( (ft_t<N::T>) );  // OK??: ADL considers N::foo (nobody but GCC implements this) #11
foo( &ft_t<N::T>  );  // OK??: ADL considers N::foo (nobody but GCC implements this) #12
foo( (ft_tt<N::TT>) );  // OK??: ADL considers N::foo (nobody but GCC implements this) #13
foo( &ft_tt<N::TT>  );  // OK??: ADL considers N::foo (nobody but GCC implements this) #14
foo( (ft_tt<N::AT>) );  // OK??: ADL considers N::foo (nobody but GCC implements this) #15
foo( &ft_tt<N::AT>  );  // OK??: ADL considers N::foo (nobody but GCC implements this) #16

I am sympathetic to your concerns about having consistent rules for ADL in these examples. However I am not sure that the conclusion here is to ban them.

First I believe that the examples #11-#16 are just variations of the previous examples because of [over.over]p1: The overloaded function name can be preceded by the & operator. [...].

The examples involving a variable template are currently not supported, but it may be just because it is omitted from the list of ADL rules ? It might be worth filing an issue asking for clarification about this case. WDYT ? (In general I have noticed that variable templates are rarely mentioned in the standard).

The examples #3, #4 are a consequence of the fact that builtin types have no associated namespaces and classes. But this is something that is consistent; just use a class type instead if ADL is intended to be used. Similarly the examples #5. #6, and #7 are consistent; for now, don't rely on ADL with NTTPs (similarly perhaps this case should also be included in the ADL rules since C++20 will allow class types as NTTPs ? I did not see any discussion about this issue in P0732r2.)

[riccibruno]

@rsmith @aaron.ballman Do you have any opinion on whether the ADL rules from CWG 997 should be implemented ? The issue here as I understand it is that these rules expand ADL, but no one apart from GCC implement them. By implementing these rules, the argument to remove them in the future becomes weaker since real code might actually start to depend on them.

[riccibruno]

@Quuxplusone Do you have other objections apart from the template-id issue ? If not, since D60573 depends on this patch, I would like to commit this with a comment explaining the issue instead of the FIXME.

[• Quuxplusone]

@Quuxplusone Do you have other objections apart from the template-id issue ? If not, since D60573 depends on this patch, I would like to commit this with a comment explaining the issue instead of the FIXME.

Sure, go for it!

[riccibruno]

In D60570#1473873, @Quuxplusone wrote:

@Quuxplusone Do you have other objections apart from the template-id issue ? If not, since D60573 depends on this patch, I would like to commit this with a comment explaining the issue instead of the FIXME.

Sure, go for it!

Thanks a lot for your insightful comments and for your time, I really appreciate it!

cfe/trunk/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-associated-namespaces-classes.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s
+
+// Attempt to test each rule for forming associated namespaces
+// and classes as described in [basic.lookup.argdep]p2.
+
+// fundamental type: no associated namespace and no associated class
+namespace adl_fundamental_type {
+  constexpr int g(char) { return 1; } // #1
+  template <typename T> constexpr int foo(T t) { return g(t); }
+  constexpr int g(int) { return 2; } // #2 not found
+  void test() {
+    static_assert(foo(0) == 1); // ok, #1
+  }
+}
+
+// class type:
+//   associated classes: itself, the class of which it is a member (if any),
+//                       direct and indirect base classes
+//   associated namespaces: innermost enclosing namespaces of associated classes
+namespace adl_class_type {
+  // associated class: itself, simple case
+  namespace X1 {
+    namespace N {
+      struct S {};
+      void f(S); // found
+    }
+    void g(N::S); // not found
+  };
+  void test1() {
+    f(X1::N::S{}); // ok
+    g(X1::N::S{}); // expected-error {{use of undeclared identifier}}
+  }
+
+  // associated class: itself, local type
+  namespace X2 {
+    auto foo() {
+      struct S {} s;
+      return s;
+    }
+    using S = decltype(foo());
+    void f(S); // expected-note {{'X2::f' declared here}}
+  }
+  void test2() {
+    f(X2::S{}); // FIXME: This is well-formed; X2 is the innermost enclosing namespace
+                // of the local struct S.
+                // expected-error@-2 {{use of undeclared identifier 'f'}}
+  }
+
+  // associated class: the parent class
+  namespace X3 {
+    struct S {
+      struct T {};
+      friend void f(T);
+    };
+  }
+  void test3() {
+    f(X3::S::T{}); // ok
+  }
+
+  // associated class: direct and indirect base classes
+  namespace X4 {
+    namespace IndirectBaseNamespace {
+      struct IndirectBase {};
+      void f(IndirectBase); // #1
+    }
+    namespace DirectBaseNamespace {
+      struct DirectBase : IndirectBaseNamespace::IndirectBase {};
+      void g(DirectBase); // #2
+    }
+    struct S : DirectBaseNamespace::DirectBase {};
+  }
+  void test4() {
+    f(X4::S{}); // ok, #1
+    g(X4::S{}); // ok, #2
+  }
+
+  // associated class: itself, lambda
+  namespace X5 {
+    namespace N {
+      auto get_lambda() { return [](){}; }
+      void f(decltype(get_lambda()));
+    }
+
+    void test5() {
+      auto lambda = N::get_lambda();
+      f(lambda); // FIXME: This is well-formed. expected-error {{use of undeclared}}
+    }
+  }
+
+  // The parameter types and return type of a lambda's operator() do not
+  // contribute to the associated namespaces and classes of the lambda itself.
+  namespace X6 {
+    namespace N {
+      struct A {};
+      template<class T> constexpr int f(T) { return 1; }
+    }
+
+    constexpr int f(N::A (*)()) { return 2; }
+    constexpr int f(void (*)(N::A)) { return 3; }
+
+    void test() {
+      constexpr auto lambda = []() -> N::A { return {}; };
+      static_assert(f(lambda) == 2);
+
+      constexpr auto lambda2 = [](N::A) {};
+      static_assert(f(lambda2) == 3);
+    }
+  }
+} // namespace adl_class_type
+
+// class template specialization: as for class type plus
+//   for non-type template arguments:
+//    - nothing
+//   for type template arguments:
+//    - associated namespaces and classes of the type template arguments
+//   for template template arguments:
+//    - namespaces of which template template arguments are member of
+//    - classes of which member template used as template template arguments
+//      are member of
+namespace adl_class_template_specialization_type {
+  // non-type template argument
+  namespace X1 {
+    namespace BaseNamespace { struct Base {}; }
+    namespace N { struct S : BaseNamespace::Base {}; }
+    template <N::S *> struct C {};
+    namespace N {
+      template <S *p> void X1_f(C<p>); // #1
+    }
+    namespace BaseNamespace {
+      template <N::S *p> void X1_g(C<p>); // #2
+    }
+    template <N::S *p> void X1_h(C<p>); // #3
+  }
+  void test1() {
+    constexpr X1::N::S *p = nullptr;
+    X1::C<p> c;
+    X1_f(c); // N is not added to the set of associated namespaces
+             // and #1 is not found...
+             // expected-error@-2 {{use of undeclared identifier}}
+    X1_g(c); // ... nor is #2 ...
+             // expected-error@-1 {{use of undeclared identifier}}
+    X1_h(c); // ... but the namespace X1 is added and #3 is found.
+  }
+
+  // type template argument
+  namespace X2 {
+    template <typename T> struct C {};
+    namespace BaseNamespace { struct Base {}; }
+    namespace N { struct S : BaseNamespace::Base {}; }
+    namespace N {
+      template <typename T> void X2_f(C<T>); // #1
+    }
+    namespace BaseNamespace {
+      template <typename T> void X2_g(C<T>); // #2
+    }
+    template <typename T> void X2_h(C<T>); // #2
+  }
+  void test2() {
+    X2::C<X2::N::S> c;
+    X2_f(c); // N is added to the set of associated namespaces and #1 is found.
+    X2_g(c); // Similarly BaseNamespace is added and #2 is found.
+    X2_h(c); // As before, X2 is also added and #3 is found.
+  }
+
+  // template template argument
+  namespace X3 {
+    template <template <typename> class TT> struct C {};
+    namespace N {
+      template <typename T> struct Z {};
+      void X3_f(C<Z>); // #1
+    }
+    struct M {
+      template <typename T> struct Z {};
+      friend void X3_g(C<Z>); // #2
+    };
+  }
+  void test3() {
+    X3::C<X3::N::Z> c1;
+    X3::C<X3::M::Z> c2;
+    X3_f(c1); // ok, namespace N is added, #1
+    X3_g(c2); // ok, struct M is added, #2
+  }
+}
+
+// enumeration type:
+//  associated namespace: innermost enclosing namespace of its declaration.
+//  associated class: if the enumeration is a class member, the member's class.
+namespace adl_enumeration_type {
+  namespace N {
+    enum E : int;
+    void f(E);
+    struct S {
+      enum F : int;
+      friend void g(F);
+    };
+  }
+
+  void test() {
+    N::E e;
+    f(e); // ok
+    N::S::F f;
+    g(f); // ok
+  }
+}
+
+// pointer and reference type:
+//  associated namespaces and classes of the pointee type
+// array type:
+//  associated namespaces and classes of the base type
+namespace adl_point_array_reference_type {
+  namespace N {
+    struct S {};
+    void f(S *);
+    void f(S &);
+  }
+
+  void test() {
+    N::S *p;
+    f(p); // ok
+    extern N::S &r;
+    f(r); // ok
+    N::S a[2];
+    f(a); // ok
+  }
+}
+
+// function type:
+//  associated namespaces and classes of the function parameter types
+//  and the return type.
+namespace adl_function_type {
+  namespace M { struct T; }
+  namespace N {
+    struct S {};
+    void f(S (*)(M::T));
+  };
+  namespace M {
+    struct T {};
+    void g(N::S (*)(T));
+  }
+
+  void test() {
+    extern N::S x(M::T);
+    f(x); // ok
+    g(x); // ok
+  }
+}
+
+// pointer to member function:
+//  associated namespaces and classes of the class, parameter types
+//  and return type.
+namespace adl_pointer_to_member_function {
+  namespace M { struct C; }
+  namespace L { struct T; }
+  namespace N {
+    struct S {};
+    void f(N::S (M::C::*)(L::T));
+  }
+  namespace L {
+    struct T {};
+    void g(N::S (M::C::*)(L::T));
+  }
+  namespace M {
+    struct C {};
+    void h(N::S (M::C::*)(L::T));
+  }
+
+  void test() {
+    N::S (M::C::*p)(L::T);
+    f(p); // ok
+    g(p); // ok
+    h(p); // ok
+  }
+}
+
+// pointer to member:
+//  associated namespaces and classes of the class and of the member type.
+namespace adl_pointer_to_member {
+  namespace M { struct C; }
+  namespace N {
+    struct S {};
+    void f(N::S (M::C::*));
+  }
+  namespace M {
+    struct C {};
+    void g(N::S (M::C::*));
+  }
+
+  void test() {
+    N::S (M::C::*p);
+    f(p); // ok
+    g(p); // ok
+  }
+}
+
+// [...] if the argument is the name or address of a set of overloaded
+// functions and/or function templates, its associated classes and namespaces
+// are the union of those associated with each of the members of the set,
+// i.e., the classes and namespaces associated with its parameter types and
+// return type.
+//
+// Additionally, if the aforementioned set of overloaded functions is named
+// with a template-id, its associated classes and namespaces also include
+// those of its type template-arguments and its template template-arguments.
+//
+// CWG 33 for the union rule. CWG 997 for the template-id rule.
+namespace adl_overload_set {
+  namespace N {
+    struct S {};
+    constexpr int f(int (*g)()) { return g(); }
+    // expected-note@-1 2{{'N::f' declared here}}
+    template <typename T> struct Q;
+  }
+
+  constexpr int g1() { return 1; }
+  constexpr int g1(N::S) { return 2; }
+
+  template <typename T> constexpr int g2() { return 3; }
+
+  // Inspired from CWG 997.
+  constexpr int g3() { return 4; }
+  template <typename T> constexpr int g3(T, N::Q<T>) { return 5; }
+
+  void test() {
+    static_assert(f(g1) == 1, "");        // Well-formed from the union rule above
+    static_assert(f(g2<N::S>) == 3, "");  // FIXME: Well-formed from the template-id rule above.
+                                          // expected-error@-1 {{use of undeclared}}
+
+    // A objection was raised during review against implementing the
+    // template-id rule. Currently only GCC implements it. Implementing
+    // it would weaken the argument to remove it in the future since
+    // actual real code might start to depend on it.
+
+    static_assert(f(g3) == 4, "");        // FIXME: Also well-formed from the union rule.
+                                          // expected-error@-1 {{use of undeclared}}
+  }
+}

cfe/trunk/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2-inline-namespace.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+// C++11 [basic.lookup.argdep]p2
+//
+// [...] If an associated namespace is an inline namespace (10.3.1), its
+// enclosing namespace is also included in the set. If an associated
+// namespace directly contains inline namespaces, those inline namespaces
+// are also included in the set.
+
+namespace test1 {
+  namespace L {
+    namespace M {
+      inline namespace N {
+        inline namespace O {
+          struct S {};
+          void f1(S);
+        }
+        void f2(S);
+      }
+      void f3(S);
+    }
+    void f4(M::S); // expected-note {{declared here}}
+  }
+
+  void test() {
+    L::M::S s;
+    f1(s); // ok
+    f2(s); // ok
+    f3(s); // ok
+    f4(s); // expected-error {{use of undeclared}}
+  }
+}
+
+namespace test2 {
+  namespace L {
+    struct S {};
+    inline namespace M {
+      inline namespace N {
+        inline namespace O {
+          void f1(S);
+        }
+        void f2(S);
+      }
+      void f3(S);
+    }
+    void f4(S);
+  }
+
+  void test() {
+    L::S s;
+    f1(s); // ok
+    f2(s); // ok
+    f3(s); // ok
+    f4(s); // ok
+  }
+}

cfe/trunk/test/CXX/basic/basic.lookup/basic.lookup.argdep/p2.cpp

 namespace test8 {
   template <class T> class B;
   void test8_function(B<int> &);
 
   void test(B<int> &ref) {
     test8_function(ref);
   }
 }
+
+
+
+// [...] Typedef names and using-declarations used to specify the types
+// do not contribute to this set.
+namespace typedef_names_and_using_declarations {
+  namespace N { struct S {}; void f(S); }
+  namespace M { typedef N::S S; void g1(S); } // expected-note {{declared here}}
+  namespace L { using N::S; void g2(S); } // expected-note {{declared here}}
+  void test() {
+    M::S s;
+    f(s);    // ok
+    g1(s);   // expected-error {{use of undeclared}}
+    g2(s);   // expected-error {{use of undeclared}}
+  }
+}

cfe/trunk/test/CXX/basic/basic.lookup/basic.lookup.argdep/p3.cpp

namespace test0 {
   class Test {
     enum E { foo = 0 };
 
     void test() {
       foo(A::Foo()); // expected-error {{not a function}}
     }
   };
 }
+
+// If X contains [...] then Y is empty.
+// - a declaration of a class member
+namespace test_adl_suppression_by_class_member {
+  namespace N {
+    struct T {};
+    void f(T); // expected-note {{declared here}}
+  }
+  struct S {
+    void f();
+    void test() {
+      N::T t;
+      f(t); // expected-error {{too many arguments}}
+    }
+  };
+}
+
+// - a block-scope function declaration that is not a using-declaration
+namespace test_adl_suppression_by_block_scope {
+  namespace N {
+    struct S {};
+    void f(S);
+  }
+  namespace M { void f(int); } // expected-note 2{{candidate}}
+  void test1() {
+    N::S s;
+    using M::f;
+    f(s); // ok
+  }
+
+  void test2() {
+    N::S s;
+    extern void f(char); // expected-note {{passing argument to parameter here}}
+    f(s); // expected-error {{no viable conversion from 'N::S' to 'char'}}
+  }
+
+  void test3() {
+    N::S s;
+    extern void f(char); // expected-note {{candidate}}
+    using M::f;
+    f(s); // expected-error {{no matching function}}
+  }
+
+  void test4() {
+    N::S s;
+    using M::f;
+    extern void f(char); // expected-note {{candidate}}
+    f(s); // expected-error {{no matching function}}
+  }
+
+}
+
+// - a declaration that is neither a function nor a function template
+namespace test_adl_suppression_by_non_function {
+  namespace N {
+    struct S {};
+    void f(S);
+  }
+  void test() {
+    extern void (*f)();
+    N::S s;
+    f(s); // expected-error {{too many arguments}}
+  }
+}

cfe/trunk/test/CXX/basic/basic.lookup/basic.lookup.argdep/p4.cpp

public:
     A();
   };
 
   void test() {
     const A<int> a;
     foo(a, 10); // expected-error {{no matching function for call to 'foo'}}
   }
 }
+
+
+// Check the rules described in p4:
+//  When considering an associated namespace, the lookup is the same as the lookup
+//  performed when the associated namespace is used as a qualifier (6.4.3.2) except that:
+
+//  - Any using-directives in the associated namespace are ignored.
+namespace test_using_directives {
+  namespace M { struct S; }
+  namespace N {
+    void f(M::S); // expected-note {{declared here}}
+  }
+  namespace M {
+    using namespace N;
+    struct S {};
+  }
+  void test() {
+    M::S s;
+    f(s); // expected-error {{use of undeclared}}
+    M::f(s); // ok
+  }
+}
+
+//  - Any namespace-scope friend functions or friend function templates declared in
+//    associated classes are visible within their respective namespaces even if
+//    they are not visible during an ordinary lookup
+// (Note: For the friend declaration to be visible, the corresponding class must be
+//  included in the set of associated classes. Merely including the namespace in
+//  the set of associated namespaces is not enough.)
+namespace test_friend1 {
+  namespace N {
+    struct S;
+    struct T {
+      friend void f(S); // #1
+    };
+    struct S { S(); S(T); };
+  }
+
+  void test() {
+    N::S s;
+    N::T t;
+    f(s); // expected-error {{use of undeclared}}
+    f(t); // ok, #1
+  }
+}
+
+// credit: Arthur O’Dwyer
+namespace test_friend2 {
+  struct A {
+    struct B {
+        struct C {};
+    };
+    friend void foo(...); // #1
+  };
+
+  struct D {
+    friend void foo(...); // #2
+  };
+  template<class> struct E {
+    struct F {};
+  };
+
+  template<class> struct G {};
+  template<class> struct H {};
+  template<class> struct I {};
+  struct J { friend void foo(...) {} }; // #3
+
+  void test() {
+    A::B::C c;
+    foo(c); // #1 is not visible since A is not an associated class
+            // expected-error@-1 {{use of undeclared}}
+    E<D>::F f;
+    foo(f); // #2 is not visible since D is not an associated class
+            // expected-error@-1 {{use of undeclared}}
+    G<H<I<J> > > j;
+    foo(j);  // ok, #3.
+  }
+}
+
+//  - All names except those of (possibly overloaded) functions and
+//    function templates are ignored.
+namespace test_other_names {
+  namespace N {
+    struct S {};
+    struct Callable { void operator()(S); };
+    static struct Callable Callable;
+  }
+
+  void test() {
+    N::S s;
+    Callable(s); // expected-error {{use of undeclared}}
+  }
+}