clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify %s
   2
   3 struct Opaque0 {};
   4 struct Opaque1 {};
   5
   6 // Redeclarations are okay in a namespace.
   7 namespace test0 {
   8   namespace ns {
   9     void foo(Opaque0); // expected-note 2 {{candidate function}}
  10   }
  11
  12   using ns::foo;
  13   using ns::foo;
  14
  15   void test0() {
  16     foo(Opaque1()); // expected-error {{no matching function for call}}
  17   }
  18
  19   namespace ns {
  20     void foo(Opaque1);
  21   }
  22
  23   void test1() {
  24     foo(Opaque1()); // expected-error {{no matching function for call}}
  25   }
  26
  27   using ns::foo;
  28
  29   void test2() {
  30     foo(Opaque1());
  31   }
  32
  33   using ns::foo;
  34 }
  35
  36 // Make sure we handle transparent contexts the same way.
  37 namespace test1 {
  38   namespace ns {
  39     void foo(Opaque0); // expected-note 2 {{candidate function}}
  40   }
  41
  42   extern "C++" {
  43     using ns::foo;
  44   }
  45
  46   void test0() {
  47     foo(Opaque1()); // expected-error {{no matching function for call}}
  48   }
  49
  50   namespace ns {
  51     void foo(Opaque1);
  52   }
  53
  54   void test1() {
  55     foo(Opaque1()); // expected-error {{no matching function for call}}
  56   }
  57
  58   extern "C++" {
  59     using ns::foo;
  60   }
  61
  62   void test2() {
  63     foo(Opaque1());
  64   }
  65 }
  66
  67 // Make sure we detect invalid redeclarations that can't be detected
  68 // until template instantiation.
  69 namespace test2 {
  70   template <class T> struct Base {
  71     typedef Base type;
  72     void foo();
  73   };
  74
  75   template <class T> struct Derived : Base<T> {
  76     // These are invalid redeclarations, detectable only after
  77     // instantiation.
  78     using Base<T>::foo; // expected-note {{previous using decl}}
  79     using Base<T>::type::foo; //expected-error {{redeclaration of using decl}}
  80   };
  81
  82   template struct Derived<int>; // expected-note {{in instantiation of template class}}
  83 }
  84
  85 // Redeclarations are okay in a function.
  86 namespace test3 {
  87   namespace N {
  88     int f(int);
  89     typedef int type;
  90   }
  91
  92   void g() {
  93     using N::f;
  94     using N::f;
  95     using N::type;
  96     using N::type;
  97   }
  98 }