// RUN: %clang_cc1 -fsyntax-only -verify %s

namespace A {
  class X { }; // expected-note{{candidate found by name lookup is 'A::X'}}
               // expected-note@-1{{candidate found by name lookup is 'A::X'}}
}
namespace B {
  void X(int); // expected-note{{candidate found by name lookup is 'B::X'}}
               // expected-note@-1{{candidate found by name lookup is 'B::X'}}
}

// Using directive doesn't cause A::X to be hidden, so X is ambiguous.
namespace Test1a {
  using namespace A;
  using namespace B;

  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test1b {
  using namespace B;
  using namespace A;

  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

// The behaviour here should be the same as using namespaces A and B directly
namespace Test2a {
  namespace C {
    using A::X; // expected-note{{candidate found by name lookup is 'Test2a::C::X'}}
  }
  namespace D {
    using B::X; // expected-note{{candidate found by name lookup is 'Test2a::D::X'}}
  }
  using namespace C;
  using namespace D;

  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test2b {
  namespace C {
    using A::X; // expected-note{{candidate found by name lookup is 'Test2b::C::X'}}
  }
  namespace D {
    using B::X; // expected-note{{candidate found by name lookup is 'Test2b::D::X'}}
  }
  using namespace D;
  using namespace C;

  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

// Defining a function X inside C should hide using A::X in C but not D, so the result is ambiguous.
namespace Test3a {
  namespace C {
    using A::X;
    void X(int); // expected-note{{candidate found by name lookup is 'Test3a::C::X'}}
  }
  namespace D {
    using A::X; // expected-note{{candidate found by name lookup is 'Test3a::D::X'}}
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test3b {
  namespace C {
    using A::X;
    void X(int); // expected-note{{candidate found by name lookup is 'Test3b::C::X'}}
  }
  namespace D {
    using A::X; // expected-note{{candidate found by name lookup is 'Test3b::D::X'}}
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test3c {
  namespace C {
    void X(int); // expected-note{{candidate found by name lookup is 'Test3c::C::X'}}
    using A::X;
  }
  namespace D {
    using A::X; // expected-note{{candidate found by name lookup is 'Test3c::D::X'}}
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test3d {
  namespace C {
    void X(int); // expected-note{{candidate found by name lookup is 'Test3d::C::X'}}
    using A::X;
  }
  namespace D {
    using A::X; // expected-note{{candidate found by name lookup is 'Test3d::D::X'}}
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

// A::X hidden in both C and D by overloaded function, so the result is not ambiguous.
namespace Test4a {
  namespace C {
    using A::X;
    void X(int);
  }
  namespace D {
    using A::X;
    void X(int, int);
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1);
  }
}

namespace Test4b {
  namespace C {
    using A::X;
    void X(int);
  }
  namespace D {
    using A::X;
    void X(int, int);
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1);
  }
}

namespace Test4c {
  namespace C {
    void X(int);
    using A::X;
  }
  namespace D {
    void X(int, int);
    using A::X;
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1);
  }
}

namespace Test4d {
  namespace C {
    void X(int);
    using A::X;
  }
  namespace D {
    void X(int, int);
    using A::X;
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1);
  }
}

// B::X hides class X in C, so the the result is not ambiguous
namespace Test5a {
  namespace C {
    using B::X;
    class X { };
  }
  namespace D {
    using B::X;
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1);
  }
}

namespace Test5b {
  namespace C {
    using B::X;
    class X { };
  }
  namespace D {
    using B::X;
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1);
  }
}

namespace Test5c {
  namespace C {
    class X { };
    using B::X;
  }
  namespace D {
    using B::X;
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1);
  }
}

namespace Test5d {
  namespace C {
    class X { };
    using B::X;
  }
  namespace D {
    using B::X;
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1);
  }
}

// B::X hides class X declared in both C and D, so the result is not ambiguous.
namespace Test6a {
  namespace C {
    class X { };
    using B::X;
  }
  namespace D {
    class X { };
    using B::X;
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1);
  }
}

namespace Test6b {
  namespace C {
    class X { };
    using B::X;
  }
  namespace D {
    class X { };
    using B::X;
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1);
  }
}

namespace Test6c {
  namespace C {
    using B::X;
    class X { };
  }
  namespace D {
    using B::X;
    class X { };
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1);
  }
}

namespace Test6d {
  namespace C {
    using B::X;
    class X { };
  }
  namespace D {
    using B::X;
    class X { };
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1);
  }
}

// function X inside C should hide class X in C but not D.
namespace Test7a {
  namespace C {
    class X;
    void X(int); // expected-note{{candidate found by name lookup is 'Test7a::C::X'}}
  }
  namespace D {
    class X; // expected-note{{candidate found by name lookup is 'Test7a::D::X'}}
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test7b {
  namespace C {
    class X;
    void X(int); // expected-note{{candidate found by name lookup is 'Test7b::C::X'}}
  }
  namespace D {
    class X; // expected-note{{candidate found by name lookup is 'Test7b::D::X'}}
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test7c {
  namespace C {
    void X(int); // expected-note{{candidate found by name lookup is 'Test7c::C::X'}}
    class X;
  }
  namespace D {
    class X; // expected-note{{candidate found by name lookup is 'Test7c::D::X'}}
  }
  using namespace C;
  using namespace D;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}

namespace Test7d {
  namespace C {
    void X(int); // expected-note{{candidate found by name lookup is 'Test7d::C::X'}}
    class X;
  }
  namespace D {
    class X; // expected-note{{candidate found by name lookup is 'Test7d::D::X'}}
  }
  using namespace D;
  using namespace C;
  void f() {
    X(1); // expected-error{{reference to 'X' is ambiguous}}
  }
}