blob: c9646765d07dc8075502b9e85b70ecafd54ff8c1 (
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
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
|
// RUN: $(dirname %s)/check_clang_tidy.sh %s google-explicit-constructor %t
// REQUIRES: shell
namespace std {
typedef decltype(sizeof(int)) size_t;
// libc++'s implementation
template <class _E>
class initializer_list
{
const _E* __begin_;
size_t __size_;
initializer_list(const _E* __b, size_t __s)
: __begin_(__b),
__size_(__s)
{}
public:
typedef _E value_type;
typedef const _E& reference;
typedef const _E& const_reference;
typedef size_t size_type;
typedef const _E* iterator;
typedef const _E* const_iterator;
initializer_list() : __begin_(nullptr), __size_(0) {}
size_t size() const {return __size_;}
const _E* begin() const {return __begin_;}
const _E* end() const {return __begin_ + __size_;}
};
}
struct A {
A() {}
A(int x, int y) {}
explicit A(void *x) {}
explicit A(void *x, void *y) {}
explicit A(const A& a) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: copy constructor should not be declared explicit [google-explicit-constructor]
// CHECK-FIXES: {{^ }}A(const A& a) {}
A(int x1) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors must be explicit [google-explicit-constructor]
// CHECK-FIXES: {{^ }}explicit A(int x1) {}
A(double x2, double y = 3.14) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors
// CHECK-FIXES: {{^ }}explicit A(double x2, double y = 3.14) {}
};
struct B {
B(std::initializer_list<int> list1) {}
B(const std::initializer_list<unsigned> &list2) {}
B(std::initializer_list<unsigned> &&list3) {}
explicit B(::std::initializer_list<double> list4) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor should not be declared explicit [google-explicit-constructor]
// CHECK-FIXES: {{^ }}B(::std::initializer_list<double> list4) {}
explicit B(const ::std::initializer_list<char> &list5) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor
// CHECK-FIXES: {{^ }}B(const ::std::initializer_list<char> &list5) {}
explicit B(::std::initializer_list<char> &&list6) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor
// CHECK-FIXES: {{^ }}B(::std::initializer_list<char> &&list6) {}
};
using namespace std;
struct C {
C(initializer_list<int> list1) {}
C(const initializer_list<unsigned> &list2) {}
C(initializer_list<unsigned> &&list3) {}
};
template <typename T>
struct C2 {
C2(initializer_list<int> list1) {}
C2(const initializer_list<unsigned> &list2) {}
C2(initializer_list<unsigned> &&list3) {}
explicit C2(initializer_list<double> list4) {}
// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: initializer-list constructor
// CHECK-FIXES: {{^ }}C2(initializer_list<double> list4) {}
};
template <typename T>
struct C3 {
C3(initializer_list<T> list1) {}
C3(const std::initializer_list<T*> &list2) {}
C3(::std::initializer_list<T**> &&list3) {}
template <typename U>
C3(initializer_list<U> list3) {}
};
struct D {
template <typename T>
explicit D(T t) {}
};
template <typename T>
struct E {
E(T *pt) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors
// CHECK-FIXES: {{^ }}explicit E(T *pt) {}
template <typename U>
E(U *pu) {}
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: single-argument constructors
// CHECK-FIXES: {{^ }}explicit E(U *pu) {}
explicit E(T t) {}
template <typename U>
explicit E(U u) {}
};
void f(std::initializer_list<int> list) {
D d(list);
E<decltype(list)> e(list);
E<int> e2(list);
}
|
