1 // RUN: %clang_cc1 -fsyntax-only -verify -std=gnu++11 %s
2 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions -Wno-local-type-template-args %s
3 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions -Wno-local-type-template-args -fmodules %s
4 
5 namespace test1 {
6   int x; // expected-note {{previous definition is here}}
7   static int y;
f()8   void f() {} // expected-note {{previous definition is here}}
9 
10   extern "C" {
11     extern int x; // expected-error {{declaration of 'x' has a different language linkage}}
12     extern int y; // OK, has internal linkage, so no language linkage.
13     void f(); // expected-error {{declaration of 'f' has a different language linkage}}
14   }
15 }
16 
17 // This is OK. Both test2_f don't have language linkage since they have
18 // internal linkage.
19 extern "C" {
test2_f()20   static void test2_f() {
21   }
test2_f(int x)22   static void test2_f(int x) {
23   }
24 }
25 
26 namespace test3 {
27   extern "C" {
28     namespace {
29       extern int x2;
30       void f2();
31     }
32   }
33   namespace {
34     int x2;
f2()35     void f2() {}
36   }
37 }
38 
39 namespace test4 {
dummy()40   void dummy() {
41     void Bar();
42     class A {
43       friend void Bar();
44     };
45   }
46 }
47 
48 namespace test5 {
49   static void g();
f()50   void f()
51   {
52     void g();
53   }
54 }
55 
56 // pr14898
57 namespace test6 {
58   template <class _Rp>
59   class __attribute__ ((__visibility__("default"))) shared_future;
60   template <class _Rp>
61   class future {
62     template <class> friend class shared_future;
63     shared_future<_Rp> share();
64   };
65   template <class _Rp> future<_Rp>
66   get_future();
67   template <class _Rp>
68   struct shared_future<_Rp&> {
69     shared_future(future<_Rp&>&& __f);
70   };
f()71   void f() {
72     typedef int T;
73     get_future<int>();
74     typedef int& U;
75     shared_future<int&> f1 = get_future<int&>();
76   }
77 }
78 
79 // This is OK. The variables have internal linkage and therefore no language
80 // linkage.
81 extern "C" {
82   static int test7_x;
83 }
84 extern "C++" {
85   extern int test7_x;
86 }
87 extern "C++" {
88   static int test7_y;
89 }
90 extern "C" {
91   extern int test7_y;
92 }
93 extern "C" { typedef int test7_F(); static test7_F test7_f; }
94 extern "C++" { extern test7_F test7_f; }
95 
96 // FIXME: This should be invalid. The function has no language linkage, but
97 // the function type has, so this is redeclaring the function with a different
98 // type.
99 extern "C++" {
100   static void test8_f();
101 }
102 extern "C" {
103   extern void test8_f();
104 }
105 extern "C" {
106   static void test8_g();
107 }
108 extern "C++" {
109   extern void test8_g();
110 }
111 
112 extern "C" {
113   void __attribute__((overloadable)) test9_f(int c); // expected-note {{previous declaration is here}}
114 }
115 extern "C++" {
116   void __attribute__((overloadable)) test9_f(int c); // expected-error {{declaration of 'test9_f' has a different language linkage}}
117 }
118 
119 extern "C" {
120   void __attribute__((overloadable)) test10_f(int);
121   void __attribute__((overloadable)) test10_f(double);
122 }
123 
124 extern "C" {
test11_f()125   void test11_f() {
126     void  __attribute__((overloadable)) test11_g(int);
127     void  __attribute__((overloadable)) test11_g(double);
128   }
129 }
130 
131 namespace test12 {
132   const int n = 0;
133   extern const int n;
f()134   void f() {
135     extern const int n;
136   }
137 }
138 
139 namespace test13 {
140   static void a(void);
141   extern void a();
a(void)142   static void a(void) {}
143 }
144 
145 namespace test14 {
146   namespace {
147     void a(void); // expected-note {{previous declaration is here}}
a(void)148     static void a(void) {} // expected-error {{static declaration of 'a' follows non-static declaration}}
149   }
150 }
151 
152 namespace test15 {
153   const int a = 5; // expected-note {{previous definition is here}}
154   static const int a; // expected-error {{redefinition of 'a'}}
155 }
156 
157 namespace test16 {
158   extern "C" {
159     class Foo {
160       int x;
161       friend int bar(Foo *y);
162     };
bar(Foo * y)163     int bar(Foo *y) {
164       return y->x;
165     }
166   }
167 }
168 
169 namespace test17 {
170   namespace {
171     struct I {
172     };
173   }
foo()174   template <typename T1, typename T2> void foo() {}
bar()175   template <typename T, T x> void bar() {} // expected-note {{candidate function}}
g()176   inline void *g() {
177     struct L {
178     };
179     // foo<L, I>'s linkage should be the merge of UniqueExternalLinkage (or
180     // InternalLinkage in c++11) and VisibleNoLinkage. The correct answer is
181     // NoLinkage in both cases. This means that using foo<L, I> as a template
182     // argument should fail.
183     return reinterpret_cast<void*>(bar<typeof(foo<L, I>), foo<L, I> >); // expected-error {{reinterpret_cast cannot resolve overloaded function 'bar' to type 'void *}}
184   }
h()185   void h() {
186     g();
187   }
188 }
189 
190 namespace test18 {
191   template <typename T> struct foo {
ftest18::foo192     template <T *P> static void f() {}
gtest18::foo193     static void *g() { return (void *)f<&x>; }
194     static T x;
195   };
196   template <typename T> T foo<T>::x;
f()197   inline void *f() {
198     struct S {
199     };
200     return foo<S>::g();
201   }
h()202   void *h() { return f(); }
203 }
204 
205 extern "C" void pr16247_foo(int);
206 static void pr16247_foo(double);
pr16247_foo(int)207 void pr16247_foo(int) {}
pr16247_foo(double)208 void pr16247_foo(double) {}
209 
210 namespace PR16247 {
211   extern "C" void pr16247_bar(int);
212   static void pr16247_bar(double);
pr16247_bar(int)213   void pr16247_bar(int) {}
pr16247_bar(double)214   void pr16247_bar(double) {}
215 }
216 namespace PR18964 {
217   unsigned &*foo; //expected-error{{'foo' declared as a pointer to a reference of type}}
218   extern struct {} *foo; // don't assert
219 }
220