blob: f1b3c814c4261a881f9d29121988f20abbbb9392 (
plain)
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
|
// RUN: %clang_cc1 -faccess-control -verify -emit-llvm-only %s
template <typename T> struct Num {
T value_;
public:
Num(T value) : value_(value) {}
T get() const { return value_; }
template <typename U> struct Rep {
U count_;
Rep(U count) : count_(count) {}
friend Num operator*(const Num &a, const Rep &n) {
Num x = 0;
for (U count = n.count_; count; --count)
x += a;
return x;
}
};
friend Num operator+(const Num &a, const Num &b) {
return a.value_ + b.value_;
}
Num& operator+=(const Num& b) {
value_ += b.value_;
return *this;
}
class Representation {};
friend class Representation;
};
class A {
template <typename T> friend bool iszero(const A &a) throw();
};
template <class T> class B_iterator;
template <class T> class B {
friend class B_iterator<T>;
};
int calc1() {
Num<int> left = -1;
Num<int> right = 1;
Num<int> result = left + right;
return result.get();
}
int calc2() {
Num<int> x = 3;
Num<int>::Rep<char> n = (char) 10;
Num<int> result = x * n;
return result.get();
}
// Reduced from GNU <locale>
namespace test1 {
class A {
bool b; // expected-note {{declared private here}}
template <typename T> friend bool has(const A&);
};
template <typename T> bool has(const A &x) {
return x.b;
}
template <typename T> bool hasnot(const A &x) {
return x.b; // expected-error {{'b' is a private member of 'test1::A'}}
}
}
namespace test2 {
class A {
bool b; // expected-note {{declared private here}}
template <typename T> friend class HasChecker;
};
template <typename T> class HasChecker {
bool check(A *a) {
return a->b;
}
};
template <typename T> class HasNotChecker {
bool check(A *a) {
return a->b; // expected-error {{'b' is a private member of 'test2::A'}}
}
};
}
|
