llvm-project/clang/test/SemaCXX/linkage2.cpp

// RUN: %clang_cc1 -fsyntax-only -verify -std=gnu++11 %s
// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions -Wno-local-type-template-args %s -std=gnu++98
// RUN: %clang_cc1 -fsyntax-only -verify -Wno-c++11-extensions -Wno-local-type-template-args -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);
  };
  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 {
  // Anonymous namespace implies internal linkage, so 'static' has no effect.
  namespace {
    void a(void);
    static void a(void) {}
  }
}

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;
    }
  }
}

namespace test17 {
  namespace {
    struct I {
    };
  }
  template <typename T1, typename T2> void foo() {}
  template <typename T, T x> void bar() {} // expected-note {{candidate function}}
  inline void *g() {
    struct L {
    };
    // foo<L, I>'s linkage should be the merge of UniqueExternalLinkage (or
    // InternalLinkage in c++11) and VisibleNoLinkage. The correct answer is
    // NoLinkage in both cases. This means that using foo<L, I> as a template
    // argument should fail.
    return reinterpret_cast<void*>(bar<typeof(foo<L, I>), foo<L, I> >); // expected-error {{reinterpret_cast cannot resolve overloaded function 'bar' to type 'void *}}
  }
  void h() {
    g();
  }
}

namespace test18 {
  template <typename T> struct foo {
    template <T *P> static void f() {}
    static void *g() { return (void *)f<&x>; }
    static T x;
  };
  template <typename T> T foo<T>::x;
  inline void *f() {
    struct S {
    };
    return foo<S>::g();
  }
  void *h() { return f(); }
}

extern "C" void pr16247_foo(int);
static void pr16247_foo(double);
void pr16247_foo(int) {}
void pr16247_foo(double) {}

namespace PR16247 {
  extern "C" void pr16247_bar(int);
  static void pr16247_bar(double);
  void pr16247_bar(int) {}
  void pr16247_bar(double) {}
}
namespace PR18964 {
  unsigned &*foo; //expected-error{{'foo' declared as a pointer to a reference of type}}
  extern struct {} *foo; // don't assert
}

namespace typedef_name_for_linkage {
  template<typename T> struct Use {};

  struct A { A(); A(const A&); ~A(); };

  typedef struct {
    A a;
  } B;

  struct C {
    typedef struct {
      A a;
    } D;
  };

  typedef struct {
    void f() { static int n; struct Inner {};}
  } E;

  // FIXME: Ideally this would be accepted in all modes. In C++98, we trigger a
  // linkage calculation to drive the "internal linkage type as template
  // argument" warning.
  typedef struct {
    void f() { struct Inner {}; Use<Inner> ui; }
  } F;
#if __cplusplus < 201103L
  // expected-error@-2 {{unsupported: typedef changes linkage of anonymous type, but linkage was already computed}}
  // expected-note@-5 {{use a tag name here}}
#endif
}