1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2 
3 // Fun things you can do with inline namespaces:
4 
5 inline namespace X {
6   void f1(); // expected-note {{'f1' declared here}}
7 
8   inline namespace Y {
9     void f2();
10 
11     template <typename T> class C {};
12   }
13 
14   // Specialize and partially specialize somewhere else.
15   template <> class C<int> {};
16   template <typename T> class C<T*> {};
17 }
18 
19 // Qualified and unqualified lookup as if member of enclosing NS.
foo1()20 void foo1() {
21   f1();
22   ::f1();
23   X::f1();
24   Y::f1(); // expected-error {{no member named 'f1' in namespace 'X::Y'; did you mean simply 'f1'?}}
25 
26   f2();
27   ::f2();
28   X::f2();
29   Y::f2();
30 }
31 
32 template <> class C<float> {};
33 template <typename T> class C<T&> {};
34 
35 template class C<double>;
36 
37 
38 // As well as all the fun with ADL.
39 
40 namespace ADL {
41   struct Outer {};
42 
43   inline namespace IL {
44     struct Inner {};
45 
46     void fo(Outer);
47   }
48 
49   void fi(Inner);
50 
51   inline namespace IL2 {
52     void fi2(Inner);
53   }
54 }
55 
foo2()56 void foo2() {
57   ADL::Outer o;
58   ADL::Inner i;
59   fo(o);
60   fi(i);
61   fi2(i);
62 }
63 
64 // Let's not forget overload sets.
65 struct Distinct {};
66 inline namespace Over {
67   void over(Distinct);
68 }
69 void over(int);
70 
foo3()71 void foo3() {
72   Distinct d;
73   ::over(d);
74 }
75 
76 // Don't forget to do correct lookup for redeclarations.
77 namespace redecl { inline namespace n1 {
78 
79   template <class Tp> class allocator;
80 
81   template <>
82   class allocator<void>
83   {
84   public:
85       typedef const void* const_pointer;
86   };
87 
88   template <class Tp>
89   class allocator
90   {
91   public:
92       typedef Tp& reference;
93 
94       void allocate(allocator<void>::const_pointer = 0);
95   };
96 
97 } }
98 
99 // Normal redeclarations (not for explicit instantiations or
100 // specializations) are distinct in an inline namespace vs. not in an
101 // inline namespace.
102 namespace redecl2 {
103   inline namespace n1 {
f(int)104     void f(int) { }
105     struct X1 { };
f(T)106     template<typename T> void f(T) { }
107     template<typename T> struct X2 { };
108     int i = 71;
109     enum E { e };
110   }
111 
f(int)112   void f(int) { }
113   struct X1 { };
f(T)114   template<typename T> void f(T) { }
115   template<typename T> struct X2 { };
116   int i = 71;
117   enum E { e };
118 }
119