Clang Project

clang_source_code/test/Modules/Inputs/submodules-merge-defs/defs.h
1struct A { int a_member; };
2inline int use_a(A a) { return a.a_member; }
3
4class B {
5  struct Inner1 {};
6public:
7  struct Inner2;
8  struct Inner3;
9  template<typename T> void f();
10};
11struct BFriend {
12  friend class B::Inner3;
13private:
14  struct Inner3Base {};
15};
16// Check that lookup and access checks are performed in the right context.
17struct B::Inner2 : Inner1 {};
18struct B::Inner3 : BFriend::Inner3Base {};
19template<typename T> void B::f() {}
20template<> inline void B::f<int>() {}
21
22// Check that base-specifiers are correctly disambiguated.
23template<int N> struct C_Base { struct D { constexpr operator int() const { return 0; } }; };
24const int C_Const = 0;
25struct C1 : C_Base<C_Base<0>::D{}> {} extern c1;
26struct C2 : C_Base<C_Const<0>::D{} extern c2;
27
28typedef struct { int a; void f(); struct X; } D;
29struct D::X { int dx; } extern dx;
30inline int use_dx(D::X dx) { return dx.dx; }
31
32template<typename T> int E(T t) { return t; }
33
34template<typename T> struct F {
35  int f();
36  template<typename U> int g();
37  static int n;
38};
39template<typename T> int F<T>::f() { return 0; }
40template<typename T> template<typename U> int F<T>::g() { return 0; }
41template<typename T> int F<T>::n = 0;
42template<> inline int F<char>::f() { return 0; }
43template<> template<typename U> int F<char>::g() { return 0; }
44template<> struct F<void> { int h(); };
45inline int F<void>::h() { return 0; }
46template<typename T> struct F<T *> { int i(); };
47template<typename T> int F<T*>::i() { return 0; }
48
49namespace 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
56template<typename T = int, int N = 3, template<typename> class K = F> int H(int a = 1);
57template<typename T = int, int N = 3, template<typename> class K = F> using I = decltype(H<T, N, K>());
58template<typename T = int, int N = 3, template<typename> class K = F> struct J {};
59
60namespace 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
68namespace StaticInline {
69  struct X {};
70  static inline void f(X);
71  static inline void g(X x) { f(x); }
72}
73
74namespace 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
87namespace SeparateInline {
88  inline void f();
89  void f() {}
90  constexpr int g() { return 0; }
91}
92
93namespace TrailingAttributes {
94  template<typename T> struct X {} __attribute__((aligned(8)));
95}
96
97namespace 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
105enum ScopedEnum : int;
106enum ScopedEnum : int { a, b, c };
107
108namespace RedeclDifferentDeclKind {
109  struct X {};
110  typedef X X;
111  using RedeclDifferentDeclKind::X;
112}
113
114namespace Anon {
115  struct X {
116    union {
117      int n;
118    };
119  };
120}
121
122namespace 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
135struct MemberClassTemplate {
136  template<typename T> struct A;
137};
138template<typename T> struct MemberClassTemplate::A {};
139template<typename T> struct MemberClassTemplate::A<T*> {};
140template<> struct MemberClassTemplate::A<int> {};
141
CodeThinker, Enjoy your reading code