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