1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
| // Test C++ chained PCH functionality
// Without PCH
// RUN: %clang_cc1 -fsyntax-only -verify -include %s -include %s %s
// With PCH
// RUN: %clang_cc1 -fsyntax-only -verify %s -chain-include %s -chain-include %s
// With modules
// RUN: %clang_cc1 -fsyntax-only -verify -fmodules %s -chain-include %s -chain-include %s
// expected-no-diagnostics
#ifndef HEADER1
#define HEADER1
//===----------------------------------------------------------------------===//
// Primary header for C++ chained PCH test
void f();
// Name not appearing in dependent
void pf();
namespace ns {
void g();
void pg();
}
template <typename T>
struct S { typedef int G; };
// Partially specialize
template <typename T>
struct S<T *> { typedef int H; };
template <typename T> struct TS2;
typedef TS2<int> TS2int;
template <typename T> struct TestBaseSpecifiers { };
template<typename T> struct TestBaseSpecifiers2 : TestBaseSpecifiers<T> { };
template <typename T>
struct TS3 {
static const int value = 0;
static const int value2;
};
template <typename T>
const int TS3<T>::value;
template <typename T>
const int TS3<T>::value2 = 1;
// Instantiate struct, but not value.
struct instantiate : TS3<int> {};
// Typedef
typedef int Integer;
//===----------------------------------------------------------------------===//
#elif not defined(HEADER2)
#define HEADER2
#if !defined(HEADER1)
#error Header inclusion order messed up
#endif
//===----------------------------------------------------------------------===//
// Dependent header for C++ chained PCH test
// Overload function from primary
void f(int);
// Add function with different name
void f2();
// Reopen namespace
namespace ns {
// Overload function from primary
void g(int);
// Add different name
void g2();
}
// Specialize template from primary
template <>
struct S<int> { typedef int I; };
// Partially specialize
template <typename T>
struct S<T &> { typedef int J; };
// Specialize previous partial specialization
template <>
struct S<int *> { typedef int K; };
// Specialize the partial specialization from this file
template <>
struct S<int &> { typedef int L; };
template <typename T> struct TS2 { };
struct TestBaseSpecifiers3 { };
struct TestBaseSpecifiers4 : TestBaseSpecifiers3 { };
struct A { };
struct B : A { };
// Instantiate TS3's members.
static const int ts3m1 = TS3<int>::value;
extern int arr[TS3<int>::value2];
// Redefinition of typedef
typedef int Integer;
//===----------------------------------------------------------------------===//
#else
//===----------------------------------------------------------------------===//
void test() {
f();
f(1);
pf();
f2();
ns::g();
ns::g(1);
ns::pg();
ns::g2();
typedef S<double>::G T1;
typedef S<double *>::H T2;
typedef S<int>::I T3;
typedef S<double &>::J T4;
typedef S<int *>::K T5;
typedef S<int &>::L T6;
TS2int ts2;
B b;
Integer i = 17;
}
// Should have remembered that there is a definition.
static const int ts3m2 = TS3<int>::value;
int arr[TS3<int>::value2];
//===----------------------------------------------------------------------===//
#endif
|