Debian Codegraph @

clang-tools-extra/test/clang-tidy/checkers/performance/move-constructor-init.cpp

raw
1 // RUN: %check_clang_tidy %s performance-move-constructor-init,modernize-pass-by-value %t -- \
2 // RUN: -config='{CheckOptions: \
3 // RUN: {modernize-pass-by-value.ValuesOnly: true}}' \
4 // RUN: -- -isystem %clang_tidy_headers
5
6 #include <s.h>
7
8 // CHECK-FIXES: #include <utility>
9
10 template <class T> struct remove_reference {typedef T type;};
11 template <class T> struct remove_reference<T&> {typedef T type;};
12 template <class T> struct remove_reference<T&&> {typedef T type;};
13
14 template <typename T>
15 typename remove_reference<T>::type&& move(T&& arg) {
16 return static_cast<typename remove_reference<T>::type&&>(arg);
17 }
18
19 struct C {
20 C() = default;
21 C(const C&) = default;
22 };
23
24 struct B {
25 B() {}
26 B(const B&) {}
27 B(B &&) {}
28 };
29
30 struct D : B {
31 D() : B() {}
32 D(const D &RHS) : B(RHS) {}
33 // CHECK-NOTES: :[[@LINE+3]]:16: warning: move constructor initializes base class by calling a copy constructor [performance-move-constructor-init]
34 // CHECK-NOTES: 26:3: note: copy constructor being called
35 // CHECK-NOTES: 27:3: note: candidate move constructor here
36 D(D &&RHS) : B(RHS) {}
37 };
38
39 struct E : B {
40 E() : B() {}
41 E(const E &RHS) : B(RHS) {}
42 E(E &&RHS) : B(move(RHS)) {} // ok
43 };
44
45 struct F {
46 C M;
47
48 F(F &&) : M(C()) {} // ok
49 };
50
51 struct G {
52 G() = default;
53 G(const G&) = default;
54 G(G&&) = delete;
55 };
56
57 struct H : G {
58 H() = default;
59 H(const H&) = default;
60 H(H &&RHS) : G(RHS) {} // ok
61 };
62
63 struct I {
64 I(const I &) = default; // suppresses move constructor creation
65 };
66
67 struct J : I {
68 J(J &&RHS) : I(RHS) {} // ok
69 };
70
71 struct K {}; // Has implicit copy and move constructors, is trivially copyable
72 struct L : K {
73 L(L &&RHS) : K(RHS) {} // ok
74 };
75
76 struct M {
77 B Mem;
78 // CHECK-NOTES: :[[@LINE+1]]:16: warning: move constructor initializes class member by calling a copy constructor [performance-move-constructor-init]
79 M(M &&RHS) : Mem(RHS.Mem) {}
80 // CHECK-NOTES: 26:3: note: copy constructor being called
81 // CHECK-NOTES: 27:3: note: candidate move constructor here
82 };
83
84 struct N {
85 B Mem;
86 N(N &&RHS) : Mem(move(RHS.Mem)) {}
87 };
88
89 struct O {
90 O(O&& other) : b(other.b) {} // ok
91 const B b;
92 };
93
94 struct P {
95 P(O&& other) : b(other.b) {} // ok
96 B b;
97 };
98
99 struct Movable {
100 Movable(Movable &&) = default;
101 Movable(const Movable &) = default;
102 Movable &operator=(const Movable &) = default;
103 ~Movable() {}
104 };
105
106 struct TriviallyCopyable {
107 TriviallyCopyable() = default;
108 TriviallyCopyable(TriviallyCopyable &&) = default;
109 TriviallyCopyable(const TriviallyCopyable &) = default;
110 };
111
112 struct Positive {
113 Positive(Movable M) : M_(M) {}
114 // CHECK-NOTES: [[@LINE-1]]:12: warning: pass by value and use std::move [modernize-pass-by-value]
115 // CHECK-FIXES: Positive(Movable M) : M_(std::move(M)) {}
116 Movable M_;
117 };
118
119 struct NegativeMultipleInitializerReferences {
120 NegativeMultipleInitializerReferences(Movable M) : M_(M), n_(M) {}
121 Movable M_;
122 Movable n_;
123 };
124
125 struct NegativeReferencedInConstructorBody {
126 NegativeReferencedInConstructorBody(Movable M) : M_(M) { M_ = M; }
127 Movable M_;
128 };
129
130 struct NegativeParamTriviallyCopyable {
131 NegativeParamTriviallyCopyable(TriviallyCopyable T) : T_(T) {}
132 NegativeParamTriviallyCopyable(int I) : I_(I) {}
133
134 TriviallyCopyable T_;
135 int I_;
136 };
137
138 struct NegativeNotPassedByValue {
139 // This const ref constructor isn't warned about because the ValuesOnly option is set.
140 NegativeNotPassedByValue(const Movable &M) : M_(M) {}
141 NegativeNotPassedByValue(const Movable M) : M_(M) {}
142 NegativeNotPassedByValue(Movable &M) : M_(M) {}
143 NegativeNotPassedByValue(Movable *M) : M_(*M) {}
144 NegativeNotPassedByValue(const Movable *M) : M_(*M) {}
145 Movable M_;
146 };
147
148 struct Immovable {
149 Immovable(const Immovable &) = default;
150 Immovable(Immovable &&) = delete;
151 };
152
153 struct NegativeImmovableParameter {
154 NegativeImmovableParameter(Immovable I) : I_(I) {}
155 Immovable I_;
156 };