259 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -verify -Wno-non-c-typedef-for-linkage -std=gnu++11 %s2// RUN: %clang_cc1 -fsyntax-only -verify -Wno-non-c-typedef-for-linkage -Wno-c++11-extensions -Wno-local-type-template-args %s -std=gnu++983// RUN: %clang_cc1 -fsyntax-only -verify -Wno-non-c-typedef-for-linkage -Wno-c++11-extensions -Wno-local-type-template-args -fmodules %s4 5namespace test1 {6 int x; // expected-note {{previous definition is here}}7 static int y;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 have18// internal linkage.19extern "C" {20 static void test2_f() {21 }22 static void test2_f(int x) {23 }24}25 26namespace test3 {27 extern "C" {28 namespace {29 extern int x2;30 void f2();31 }32 }33 namespace {34 int x2;35 void f2() {}36 }37}38 39namespace test4 {40 void dummy() {41 void Bar();42 class A {43 friend void Bar();44 };45 }46}47 48namespace test5 {49 static void g();50 void f()51 {52 void g();53 }54}55 56// pr1489857namespace 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 };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 language80// linkage.81extern "C" {82 static int test7_x;83}84extern "C++" {85 extern int test7_x;86}87extern "C++" {88 static int test7_y;89}90extern "C" {91 extern int test7_y;92}93extern "C" { typedef int test7_F(); static test7_F test7_f; }94extern "C++" { extern test7_F test7_f; }95 96// FIXME: This should be invalid. The function has no language linkage, but97// the function type has, so this is redeclaring the function with a different98// type.99extern "C++" {100 static void test8_f();101}102extern "C" {103 extern void test8_f();104}105extern "C" {106 static void test8_g();107}108extern "C++" {109 extern void test8_g();110}111 112extern "C" {113 void __attribute__((overloadable)) test9_f(int c); // expected-note {{previous declaration is here}}114}115extern "C++" {116 void __attribute__((overloadable)) test9_f(int c); // expected-error {{declaration of 'test9_f' has a different language linkage}}117}118 119extern "C" {120 void __attribute__((overloadable)) test10_f(int);121 void __attribute__((overloadable)) test10_f(double);122}123 124extern "C" {125 void test11_f() {126 void __attribute__((overloadable)) test11_g(int);127 void __attribute__((overloadable)) test11_g(double);128 }129}130 131namespace test12 {132 const int n = 0;133 extern const int n;134 void f() {135 extern const int n;136 }137}138 139namespace test13 {140 static void a(void);141 extern void a();142 static void a(void) {}143}144 145namespace test14 {146 // Anonymous namespace implies internal linkage, so 'static' has no effect.147 namespace {148 void a(void);149 static void a(void) {}150 }151}152 153namespace test15 {154 const int a = 5; // expected-note {{previous definition is here}}155 static const int a; // expected-error {{redefinition of 'a'}}156}157 158namespace test16 {159 extern "C" {160 class Foo {161 int x;162 friend int bar(Foo *y);163 };164 int bar(Foo *y) {165 return y->x;166 }167 }168}169 170namespace test17 {171 namespace {172 struct I {173 };174 }175 template <typename T1, typename T2> void foo() {}176 template <typename T, T x> void bar() {}177#if __cplusplus < 201703L178 // expected-note@-2 {{candidate function}}179#endif180 inline void *g() {181 struct L {182 };183 // foo<L, I>'s linkage should be the merge of UniqueExternalLinkage (or184 // InternalLinkage in c++11) and VisibleNoLinkage. The correct answer is185 // NoLinkage in both cases. This means that using foo<L, I> as a template186 // argument should fail.187 return reinterpret_cast<void*>(bar<typeof(foo<L, I>), foo<L, I> >);188#if __cplusplus < 201703L189 // expected-error@-2 {{reinterpret_cast cannot resolve overloaded function 'bar' to type 'void *}}190#endif191 }192 void h() {193 g();194 }195}196 197namespace test18 {198 template <typename T> struct foo {199 template <T *P> static void f() {}200 static void *g() { return (void *)f<&x>; }201 static T x;202 };203 template <typename T> T foo<T>::x;204 inline void *f() {205 struct S {206 };207 return foo<S>::g();208 }209 void *h() { return f(); }210}211 212extern "C" void pr16247_foo(int);213static void pr16247_foo(double);214void pr16247_foo(int) {}215void pr16247_foo(double) {}216 217namespace PR16247 {218 extern "C" void pr16247_bar(int);219 static void pr16247_bar(double);220 void pr16247_bar(int) {}221 void pr16247_bar(double) {}222}223namespace PR18964 {224 unsigned &*foo; //expected-error{{'foo' declared as a pointer to a reference of type}}225 extern struct {} *foo; // don't assert226}227 228namespace typedef_name_for_linkage {229 template<typename T> struct Use {};230 231 struct A { A(); A(const A&); ~A(); };232 233 typedef struct {234 A a;235 } B;236 237 struct C {238 typedef struct {239 A a;240 } D;241 };242 243 typedef struct {244 void f() { static int n; struct Inner {};}245 } E;246 247 // FIXME: Ideally this would be accepted in all modes. In C++98, we trigger a248 // linkage calculation to drive the "internal linkage type as template249 // argument" warning.250 typedef struct {251 void f() { struct Inner {}; Use<Inner> ui; }252 } F;253#if __cplusplus < 201103L254 // expected-error@-4 {{given name for linkage purposes by typedef declaration after its linkage was computed}}255 // expected-note@-4 {{due to this member}}256 // expected-note@-4 {{by this typedef}}257#endif258}259