text: // RUN: %clang_cc1 -fsyntax-only -verify %s
  // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
  // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
  
  namespace A {
    class A {
      friend void func(A);
      friend A operator+(A,A);
    };
  }
  
  namespace B {
    class B {
      static void func(B);
    };
    B operator+(B,B);
  }
  
  namespace D {
    class D {};
  }
  
  namespace C {
    class C {}; // expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'B::B' to 'const C::C &' for 1st argument}}
  #if __cplusplus >= 201103L // C++11 or later
    // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'B::B' to 'C::C &&' for 1st argument}}
  #endif
    void func(C); // expected-note {{'C::func' declared here}} \
                  // expected-note {{passing argument to parameter here}}
    C operator+(C,C);
    D::D operator+(D::D,D::D);
  }
  
  namespace D {
    using namespace C;
  }
  
  namespace Test {
    void test() {
      func(A::A());
      // FIXME: namespace-aware typo correction causes an extra, misleading
      // message in this case; some form of backtracking, diagnostic message
      // delaying, or argument checking before emitting diagnostics is needed to
      // avoid accepting and printing out a typo correction that proves to be
      // incorrect once argument-dependent lookup resolution has occurred.
      func(B::B()); // expected-error {{use of undeclared identifier 'func'; did you mean 'C::func'?}} \
                    // expected-error {{no viable conversion from 'B::B' to 'C::C'}}
      func(C::C());
      A::A() + A::A();
      B::B() + B::B();
      C::C() + C::C();
      D::D() + D::D(); // expected-error {{invalid operands to binary expression ('D::D' and 'D::D')}}
    }
  }
  
  // PR6716
  namespace test1 {
    template <class T> class A {
      template <class U> friend void foo(A &, U); // expected-note {{not viable: 1st argument ('const A<int>') would lose const qualifier}}
  
    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}}
    }
  }
  