forked from OSchip/llvm-project
128 lines
2.8 KiB
C++
128 lines
2.8 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify %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}}
|
|
}
|
|
}
|
|
|
|
// FIXME: This should be OK. Both test2_f don't have language linkage since they
|
|
// have internal linkage.
|
|
extern "C" {
|
|
static void test2_f() { // expected-note {{previous definition is here}}
|
|
}
|
|
static void test2_f(int x) { // expected-error {{conflicting types for 'test2_f'}}
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
}
|