1 struct A { int a_member; };
use_a(A a)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 {};
f()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;
use_dx(D::X dx)30 inline int use_dx(D::X dx) { return dx.dx; }
31
E(T t)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 };
f()39 template<typename T> int F<T>::f() { return 0; }
g()40 template<typename T> template<typename U> int F<T>::g() { return 0; }
41 template<typename T> int F<T>::n = 0;
f()42 template<> inline int F<char>::f() { return 0; }
g()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> {};
141