blob: 3cfa98138babb3e4e0875cbadfd4617524d05b6d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: %clang_cc1 -fsyntax-only -verify -fmodules %s
namespace test1 {
int x; // expected-note {{previous definition is here}}
static int y;
void f() {} // expected-note {{previous definition is here}}
extern "C" {
extern int x; // expected-error {{declaration of 'x' has a different language linkage}}
extern int y; // OK, has internal linkage, so no language linkage.
void f(); // expected-error {{declaration of 'f' has a different language linkage}}
}
}
// This is OK. Both test2_f don't have language linkage since they have
// internal linkage.
extern "C" {
static void test2_f() {
}
static void test2_f(int x) {
}
}
namespace test3 {
extern "C" {
namespace {
extern int x2;
void f2();
}
}
namespace {
int x2;
void f2() {}
}
}
namespace test4 {
void dummy() {
void Bar();
class A {
friend void Bar();
};
}
}
namespace test5 {
static void g();
void f()
{
void g();
}
}
// pr14898
namespace test6 {
template <class _Rp>
class __attribute__ ((__visibility__("default"))) shared_future;
template <class _Rp>
class future {
template <class> friend class shared_future;
shared_future<_Rp> share();
};
template <class _Rp> future<_Rp>
get_future();
template <class _Rp>
struct shared_future<_Rp&> {
shared_future(future<_Rp&>&& __f); // expected-warning {{rvalue references are a C++11 extension}}
};
void f() {
typedef int T;
get_future<int>();
typedef int& U;
shared_future<int&> f1 = get_future<int&>();
}
}
// This is OK. The variables have internal linkage and therefore no language
// linkage.
extern "C" {
static int test7_x;
}
extern "C++" {
extern int test7_x;
}
extern "C++" {
static int test7_y;
}
extern "C" {
extern int test7_y;
}
extern "C" { typedef int test7_F(); static test7_F test7_f; }
extern "C++" { extern test7_F test7_f; }
// FIXME: This should be invalid. The function has no language linkage, but
// the function type has, so this is redeclaring the function with a different
// type.
extern "C++" {
static void test8_f();
}
extern "C" {
extern void test8_f();
}
extern "C" {
static void test8_g();
}
extern "C++" {
extern void test8_g();
}
extern "C" {
void __attribute__((overloadable)) test9_f(int c); // expected-note {{previous declaration is here}}
}
extern "C++" {
void __attribute__((overloadable)) test9_f(int c); // expected-error {{declaration of 'test9_f' has a different language linkage}}
}
extern "C" {
void __attribute__((overloadable)) test10_f(int);
void __attribute__((overloadable)) test10_f(double);
}
extern "C" {
void test11_f() {
void __attribute__((overloadable)) test11_g(int);
void __attribute__((overloadable)) test11_g(double);
}
}
namespace test12 {
const int n = 0;
extern const int n;
void f() {
extern const int n;
}
}
namespace test13 {
static void a(void);
extern void a();
static void a(void) {}
}
namespace test14 {
namespace {
void a(void); // expected-note {{previous declaration is here}}
static void a(void) {} // expected-error {{static declaration of 'a' follows non-static declaration}}
}
}
namespace test15 {
const int a = 5; // expected-note {{previous definition is here}}
static const int a; // expected-error {{redefinition of 'a'}}
}
namespace test16 {
extern "C" {
class Foo {
int x;
friend int bar(Foo *y);
};
int bar(Foo *y) {
return y->x;
}
}
}
|
