clang/test/Modules/Inputs/submodules-merge-defs/defs.h

   1 struct A { int a_member; };
   2 inline int use_a(A a) { return a.a_member; }
   3
   4 class B {
   5   struct Inner1 {};
   6 public:
   7   struct Inner2;
   8   struct Inner3;
   9   template<typename T> void f();
  10 };
  11 struct BFriend {
  12   friend class B::Inner3;
  13 private:
  14   struct Inner3Base {};
  15 };
  16 // Check that lookup and access checks are performed in the right context.
  17 struct B::Inner2 : Inner1 {};
  18 struct B::Inner3 : BFriend::Inner3Base {};
  19 template<typename T> void B::f() {}
  20 template<> inline void B::f<int>() {}
  21
  22 // Check that base-specifiers are correctly disambiguated.
  23 template<int N> struct C_Base { struct D { constexpr operator int() const { return 0; } }; };
  24 const int C_Const = 0;
  25 struct C1 : C_Base<C_Base<0>::D{}> {} extern c1;
  26 struct C2 : C_Base<C_Const<0>::D{} extern c2;
  27
  28 typedef struct { int a; void f(); struct X; } D;
  29 struct D::X { int dx; } extern dx;
  30 inline int use_dx(D::X dx) { return dx.dx; }
  31
  32 template<typename T> int E(T t) { return t; }
  33
  34 template<typename T> struct F {
  35   int f();
  36   template<typename U> int g();
  37   static int n;
  38 };
  39 template<typename T> int F<T>::f() { return 0; }
  40 template<typename T> template<typename U> int F<T>::g() { return 0; }
  41 template<typename T> int F<T>::n = 0;
  42 template<> inline int F<char>::f() { return 0; }
  43 template<> template<typename U> int F<char>::g() { return 0; }
  44 template<> struct F<void> { int h(); };
  45 inline int F<void>::h() { return 0; }
  46 template<typename T> struct F<T *> { int i(); };
  47 template<typename T> int F<T*>::i() { return 0; }
  48
  49 namespace G {
  50   enum A { a, b, c, d, e };
  51   enum { f, g, h };
  52   typedef enum { i, j } k;
  53   typedef enum {} l;
  54 }
  55
  56 template<typename T = int, int N = 3, template<typename> class K = F> int H(int a = 1);
  57 template<typename T = int, int N = 3, template<typename> class K = F> using I = decltype(H<T, N, K>());
  58 template<typename T = int, int N = 3, template<typename> class K = F> struct J {};
  59
  60 namespace NS {
  61   struct A {};
  62   template<typename T> struct B : A {};
  63   template<typename T> struct B<T*> : B<char> {};
  64   template<> struct B<int> : B<int*> {};
  65   inline void f() {}
  66 }
  67
  68 namespace StaticInline {
  69   struct X {};
  70   static inline void f(X);
  71   static inline void g(X x) { f(x); }
  72 }
  73
  74 namespace FriendDefArg {
  75   template<typename = int> struct A;
  76   template<int = 0> struct B;
  77   template<template<typename> class = A> struct C;
  78   template<typename = int, int = 0, template<typename> class = A> struct D {};
  79   template<typename U> struct Y {
  80     template<typename> friend struct A;
  81     template<int> friend struct B;
  82     template<template<typename> class> friend struct C;
  83     template<typename, int, template<typename> class> friend struct D;
  84   };
  85 }
  86
  87 namespace SeparateInline {
  88   inline void f();
  89   void f() {}
  90   constexpr int g() { return 0; }
  91 }
  92
  93 namespace TrailingAttributes {
  94   template<typename T> struct X {} __attribute__((aligned(8)));
  95 }
  96
  97 namespace MergeFunctionTemplateSpecializations {
  98   template<typename T> T f();
  99   template<typename T> struct X {
 100     template<typename U> using Q = decltype(f<T>() + U());
 101   };
 102   using xiq = X<int>::Q<int>;
 103 }
 104
 105 enum ScopedEnum : int;
 106 enum ScopedEnum : int { a, b, c };
 107
 108 namespace RedeclDifferentDeclKind {
 109   struct X {};
 110   typedef X X;
 111   using RedeclDifferentDeclKind::X;
 112 }
 113
 114 namespace Anon {
 115   struct X {
 116     union {
 117       int n;
 118     };
 119   };
 120 }
 121
 122 namespace ClassTemplatePartialSpec {
 123   template<typename T> struct F;
 124   template<template<int> class A, int B> struct F<A<B>> {
 125     template<typename C> F();
 126   };
 127   template<template<int> class A, int B> template<typename C> F<A<B>>::F() {}
 128
 129   template<typename A, int B> struct F<A[B]> {
 130     template<typename C> F();
 131   };
 132   template<typename A, int B> template<typename C> F<A[B]>::F() {}
 133 }
 134
 135 struct MemberClassTemplate {
 136   template<typename T> struct A;
 137 };
 138 template<typename T> struct MemberClassTemplate::A {};
 139 template<typename T> struct MemberClassTemplate::A<T*> {};
 140 template<> struct MemberClassTemplate::A<int> {};