Debian Codegraph @

clang-tools-extra/test/clang-tidy/checkers/performance/move-const-arg.cpp

raw
1 // RUN: %check_clang_tidy %s performance-move-const-arg %t
2
3 namespace std {
4 template <typename>
5 struct remove_reference;
6
7 template <typename _Tp>
8 struct remove_reference {
9 typedef _Tp type;
10 };
11
12 template <typename _Tp>
13 struct remove_reference<_Tp &> {
14 typedef _Tp type;
15 };
16
17 template <typename _Tp>
18 struct remove_reference<_Tp &&> {
19 typedef _Tp type;
20 };
21
22 template <typename _Tp>
23 constexpr typename std::remove_reference<_Tp>::type &&move(_Tp &&__t) {
24 return static_cast<typename std::remove_reference<_Tp>::type &&>(__t);
25 }
26
27 template <typename _Tp>
28 constexpr _Tp &&
29 forward(typename remove_reference<_Tp>::type &__t) noexcept {
30 return static_cast<_Tp &&>(__t);
31 }
32
33 } // namespace std
34
35 class A {
36 public:
37 A() {}
38 A(const A &rhs) {}
39 A(A &&rhs) {}
40 };
41
42 using AlsoA = A;
43
44 struct TriviallyCopyable {
45 int i;
46 };
47
48 using TrivialAlias = TriviallyCopyable;
49
50 void f(TriviallyCopyable) {}
51
52 void g() {
53 TriviallyCopyable obj;
54 f(std::move(obj));
55 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable' has no effect; remove std::move() [performance-move-const-arg]
56 // CHECK-FIXES: f(obj);
57
58 TrivialAlias obj2;
59 f(std::move(obj2));
60 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: std::move of the variable 'obj2' of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect; remove std::move() [performance-move-const-arg]
61 // CHECK-FIXES: f(obj2);
62 }
63
64 int f1() {
65 return std::move(42);
66 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the expression of the trivially-copyable type 'int' has no effect; remove std::move() [performance-move-const-arg]
67 // CHECK-FIXES: return 42;
68 }
69
70 int f2(int x2) {
71 return std::move(x2);
72 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'x2' of the trivially-copyable type 'int'
73 // CHECK-FIXES: return x2;
74 }
75
76 int *f3(int *x3) {
77 return std::move(x3);
78 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'x3' of the trivially-copyable type 'int *'
79 // CHECK-FIXES: return x3;
80 }
81
82 A f4(A x4) { return std::move(x4); }
83
84 AlsoA f4_a(AlsoA x4) { return std::move(x4); }
85
86 A f5(const A x5) {
87 return std::move(x5);
88 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the const variable 'x5' has no effect; remove std::move() or make the variable non-const [performance-move-const-arg]
89 // CHECK-FIXES: return x5;
90 }
91
92 AlsoA f5_a(const AlsoA x5) {
93 return std::move(x5);
94 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the const variable 'x5' has no effect; remove std::move() or make the variable non-const [performance-move-const-arg]
95 // CHECK-FIXES: return x5;
96 }
97
98 template <typename T>
99 T f6(const T x6) {
100 return std::move(x6);
101 }
102
103 void f7() { int a = f6(10); }
104
105 #define M1(x) x
106 void f8() {
107 const A a;
108 M1(A b = std::move(a);)
109 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: std::move of the const variable 'a' has no effect; remove std::move() or make the variable non-const
110 // CHECK-FIXES: M1(A b = a;)
111 }
112
113 #define M2(x) std::move(x)
114 int f9() { return M2(1); }
115
116 template <typename T>
117 T f_unknown_target(const int x10) {
118 return std::move(x10);
119 }
120
121 void f11() {
122 f_unknown_target<int>(1);
123 f_unknown_target<double>(1);
124 }
125
126 A&& f_return_right_ref() {
127 static A a{};
128 return std::move(a);
129 }
130
131 class NoMoveSemantics {
132 public:
133 NoMoveSemantics();
134 NoMoveSemantics(const NoMoveSemantics &);
135
136 NoMoveSemantics &operator=(const NoMoveSemantics &);
137 };
138
139 using NoMoveSemanticsAlias = NoMoveSemantics;
140
141 void callByConstRef(const NoMoveSemantics &);
142 void callByConstRef(int i, const NoMoveSemantics &);
143
144 void moveToConstReferencePositives() {
145 NoMoveSemantics obj;
146
147 // Basic case.
148 callByConstRef(std::move(obj));
149 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as
150 // CHECK-FIXES: callByConstRef(obj);
151
152 // Also works for second argument.
153 callByConstRef(1, std::move(obj));
154 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: passing result of std::move() as
155 // CHECK-FIXES: callByConstRef(1, obj);
156
157 // Works if std::move() applied to a temporary.
158 callByConstRef(std::move(NoMoveSemantics()));
159 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as
160 // CHECK-FIXES: callByConstRef(NoMoveSemantics());
161
162 // Works if calling a copy constructor.
163 NoMoveSemantics other(std::move(obj));
164 // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: passing result of std::move() as
165 // CHECK-FIXES: NoMoveSemantics other(obj);
166
167 // Works if calling assignment operator.
168 other = std::move(obj);
169 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: passing result of std::move() as
170 // CHECK-FIXES: other = obj;
171 }
172
173 void moveToConstReferencePositivesAlias() {
174 NoMoveSemanticsAlias obj;
175
176 // Basic case.
177 callByConstRef(std::move(obj));
178 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
179 // CHECK-FIXES: callByConstRef(obj);
180
181 // Also works for second argument.
182 callByConstRef(1, std::move(obj));
183 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
184 // CHECK-FIXES: callByConstRef(1, obj);
185
186 // Works if std::move() applied to a temporary.
187 callByConstRef(std::move(NoMoveSemanticsAlias()));
188 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
189 // CHECK-FIXES: callByConstRef(NoMoveSemanticsAlias());
190
191 // Works if calling a copy constructor.
192 NoMoveSemanticsAlias other(std::move(obj));
193 // CHECK-MESSAGES: :[[@LINE-1]]:30: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
194 // CHECK-FIXES: NoMoveSemanticsAlias other(obj);
195
196 // Works if calling assignment operator.
197 other = std::move(obj);
198 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
199 // CHECK-FIXES: other = obj;
200 }
201
202 class MoveSemantics {
203 public:
204 MoveSemantics();
205 MoveSemantics(MoveSemantics &&);
206
207 MoveSemantics &operator=(MoveSemantics &&);
208 };
209
210 using MoveSemanticsAlias = MoveSemantics;
211
212 void callByValue(MoveSemantics);
213
214 void callByRValueRef(MoveSemantics &&);
215
216 template <class T>
217 void templateFunction(T obj) {
218 T other = std::move(obj);
219 }
220
221 #define M3(T, obj) \
222 do { \
223 T other = std::move(obj); \
224 } while (true)
225
226 #define CALL(func) (func)()
227
228 void moveToConstReferenceNegatives() {
229 // No warning when actual move takes place.
230 MoveSemantics move_semantics;
231 callByValue(std::move(move_semantics));
232 callByRValueRef(std::move(move_semantics));
233 MoveSemantics other(std::move(move_semantics));
234 other = std::move(move_semantics);
235
236 // No warning if std::move() not used.
237 NoMoveSemantics no_move_semantics;
238 callByConstRef(no_move_semantics);
239
240 // No warning if instantiating a template.
241 templateFunction(no_move_semantics);
242
243 // No warning inside of macro expansions.
244 M3(NoMoveSemantics, no_move_semantics);
245
246 // No warning inside of macro expansion, even if the macro expansion is inside
247 // a lambda that is, in turn, an argument to a macro.
248 CALL([no_move_semantics] { M3(NoMoveSemantics, no_move_semantics); });
249
250 auto lambda = [] {};
251 auto lambda2 = std::move(lambda);
252 }
253
254 void moveToConstReferenceNegativesAlias() {
255 // No warning when actual move takes place.
256 MoveSemanticsAlias move_semantics;
257 callByValue(std::move(move_semantics));
258 callByRValueRef(std::move(move_semantics));
259 MoveSemanticsAlias other(std::move(move_semantics));
260 other = std::move(move_semantics);
261
262 // No warning if std::move() not used.
263 NoMoveSemanticsAlias no_move_semantics;
264 callByConstRef(no_move_semantics);
265
266 // No warning if instantiating a template.
267 templateFunction(no_move_semantics);
268
269 // No warning inside of macro expansions.
270 M3(NoMoveSemanticsAlias, no_move_semantics);
271
272 // No warning inside of macro expansion, even if the macro expansion is inside
273 // a lambda that is, in turn, an argument to a macro.
274 CALL([no_move_semantics] { M3(NoMoveSemanticsAlias, no_move_semantics); });
275
276 auto lambda = [] {};
277 auto lambda2 = std::move(lambda);
278 }
279
280 class MoveOnly {
281 public:
282 MoveOnly(const MoveOnly &other) = delete;
283 MoveOnly &operator=(const MoveOnly &other) = delete;
284 MoveOnly(MoveOnly &&other) = default;
285 MoveOnly &operator=(MoveOnly &&other) = default;
286 };
287 template <class T>
288 void Q(T);
289 void moveOnlyNegatives(MoveOnly val) {
290 Q(std::move(val));
291 }
292
293 using MoveOnlyAlias = MoveOnly;
294
295 void fmovable(MoveSemantics);
296
297 void lambda1() {
298 auto f = [](MoveSemantics m) {
299 fmovable(std::move(m));
300 };
301 f(MoveSemantics());
302 }
303
304 template<class T> struct function {};
305
306 template<typename Result, typename... Args>
307 class function<Result(Args...)> {
308 public:
309 function() = default;
310 void operator()(Args... args) const {
311 fmovable(std::forward<Args>(args)...);
312 }
313 };
314
315 void functionInvocation() {
316 function<void(MoveSemantics)> callback;
317 MoveSemantics m;
318 callback(std::move(m));
319 }
320
321 void functionInvocationAlias() {
322 function<void(MoveSemanticsAlias)> callback;
323 MoveSemanticsAlias m;
324 callback(std::move(m));
325 }
326
327 void lambda2() {
328 function<void(MoveSemantics)> callback;
329
330 auto f = [callback = std::move(callback)](MoveSemantics m) mutable {
331 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: std::move of the variable 'callback' of the trivially-copyable type 'function<void (MoveSemantics)>' has no effect; remove std::move()
332 // CHECK-FIXES: auto f = [callback = callback](MoveSemantics m) mutable {
333 callback(std::move(m));
334 };
335 f(MoveSemantics());
336 }
337
338 void lambda2Alias() {
339 function<void(MoveSemanticsAlias)> callback;
340
341 auto f = [callback = std::move(callback)](MoveSemanticsAlias m) mutable {
342 // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: std::move of the variable 'callback' of the trivially-copyable type 'function<void (MoveSemanticsAlias)>' (aka 'function<void (MoveSemantics)>') has no effect; remove std::move() [performance-move-const-arg]
343 // CHECK-FIXES: auto f = [callback = callback](MoveSemanticsAlias m) mutable {
344 callback(std::move(m));
345 };
346 f(MoveSemanticsAlias());
347 }
348
349 void showInt(int &&v);
350 void showInt(int v1, int &&v2);
351 void showPointer(const char *&&s);
352 void showPointer2(const char *const &&s);
353 void showTriviallyCopyable(TriviallyCopyable &&obj);
354 void showTriviallyCopyablePointer(const TriviallyCopyable *&&obj);
355 void testFunctions() {
356 int a = 10;
357 showInt(std::move(a));
358 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
359 // CHECK-MESSAGES: :[[@LINE-10]]:20: note: consider changing the 1st parameter of 'showInt' from 'int &&' to 'const int &'
360 showInt(int());
361 showInt(a, std::move(a));
362 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
363 // CHECK-MESSAGES: :[[@LINE-13]]:28: note: consider changing the 2nd parameter of 'showInt' from 'int &&' to 'const int &'
364 const char* s = "";
365 showPointer(std::move(s));
366 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
367 // CHECK-MESSAGES: :[[@LINE-16]]:32: note: consider changing the 1st parameter of 'showPointer' from 'const char *&&' to 'const char *'
368 showPointer2(std::move(s));
369 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
370 // CHECK-MESSAGES: :[[@LINE-18]]:39: note: consider changing the 1st parameter of 'showPointer2' from 'const char *const &&' to 'const char *const'
371 TriviallyCopyable *obj = new TriviallyCopyable();
372 showTriviallyCopyable(std::move(*obj));
373 // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
374 // CHECK-MESSAGES: :[[@LINE-21]]:48: note: consider changing the 1st parameter of 'showTriviallyCopyable' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
375 showTriviallyCopyablePointer(std::move(obj));
376 // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable *' has no effect [performance-move-const-arg]
377 // CHECK-MESSAGES: :[[@LINE-23]]:62: note: consider changing the 1st parameter of 'showTriviallyCopyablePointer' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
378 TrivialAlias* obj2 = new TrivialAlias();
379 showTriviallyCopyable(std::move(*obj));
380 // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
381 // CHECK-MESSAGES: :[[@LINE-28]]:48: note: consider changing the 1st parameter of 'showTriviallyCopyable' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
382 showTriviallyCopyablePointer(std::move(obj));
383 // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable *' has no effect [performance-move-const-arg]
384 // CHECK-MESSAGES: :[[@LINE-30]]:62: note: consider changing the 1st parameter of 'showTriviallyCopyablePointer' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
385 }
386 template <class T>
387 void forwardToShowInt(T && t) {
388 showInt(static_cast<T &&>(t));
389 }
390 void testTemplate() {
391 int a = 10;
392 forwardToShowInt(std::move(a));
393 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
394 }
395
396 struct Tmp {
397 Tmp();
398 Tmp(int &&a);
399 Tmp(int v1, int &&a);
400 Tmp(const char *&&s);
401 Tmp(TriviallyCopyable&& obj);
402 Tmp(const TriviallyCopyable *&&obj);
403 void showTmp(TriviallyCopyable&& t);
404 static void showTmpStatic(TriviallyCopyable&& t);
405 };
406 using TmpAlias = Tmp;
407
408 void testMethods() {
409 Tmp t;
410 int a = 10;
411 Tmp t1(std::move(a));
412 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
413 // CHECK-MESSAGES: :[[@LINE-15]]:13: note: consider changing the 1st parameter of 'Tmp' from 'int &&' to 'const int &'
414 Tmp t2(a, std::move(a));
415 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
416 // CHECK-MESSAGES: :[[@LINE-17]]:21: note: consider changing the 2nd parameter of 'Tmp' from 'int &&' to 'const int &'
417 const char* s = "";
418 Tmp t3(std::move(s));
419 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
420 // CHECK-MESSAGES: :[[@LINE-20]]:21: note: consider changing the 1st parameter of 'Tmp' from 'const char *&&' to 'const char *'
421 TriviallyCopyable *obj = new TriviallyCopyable();
422 Tmp t4(std::move(*obj));
423 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
424 // CHECK-MESSAGES: :[[@LINE-23]]:27: note: consider changing the 1st parameter of 'Tmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
425 Tmp t5(std::move(obj));
426 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'obj' of the trivially-copyable type 'TriviallyCopyable *' has no effect [performance-move-const-arg]
427 // CHECK-MESSAGES: :[[@LINE-25]]:34: note: consider changing the 1st parameter of 'Tmp' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
428 t.showTmp(std::move(*obj));
429 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
430 // CHECK-MESSAGES: :[[@LINE-27]]:36: note: consider changing the 1st parameter of 'showTmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
431 Tmp::showTmpStatic(std::move(*obj));
432 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: std::move of the expression of the trivially-copyable type 'TriviallyCopyable' has no effect [performance-move-const-arg]
433 // CHECK-MESSAGES: :[[@LINE-29]]:49: note: consider changing the 1st parameter of 'showTmpStatic' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
434 }
435
436 void testMethodsAlias() {
437 TmpAlias t;
438 int a = 10;
439 TmpAlias t1(std::move(a));
440 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
441 // CHECK-MESSAGES: :[[@LINE-43]]:13: note: consider changing the 1st parameter of 'Tmp' from 'int &&' to 'const int &'
442 TmpAlias t2(a, std::move(a));
443 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
444 // CHECK-MESSAGES: :[[@LINE-45]]:21: note: consider changing the 2nd parameter of 'Tmp' from 'int &&' to 'const int &'
445 const char* s = "";
446 TmpAlias t3(std::move(s));
447 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 's' of the trivially-copyable type 'const char *' has no effect [performance-move-const-arg]
448 // CHECK-MESSAGES: :[[@LINE-48]]:21: note: consider changing the 1st parameter of 'Tmp' from 'const char *&&' to 'const char *'
449 TrivialAlias *obj = new TrivialAlias();
450 TmpAlias t4(std::move(*obj));
451 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the expression of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect [performance-move-const-arg]
452 // CHECK-MESSAGES: :[[@LINE-51]]:27: note: consider changing the 1st parameter of 'Tmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
453 TmpAlias t5(std::move(obj));
454 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: std::move of the variable 'obj' of the trivially-copyable type 'TrivialAlias *' (aka 'TriviallyCopyable *') has no effect [performance-move-const-arg]
455 // CHECK-MESSAGES: :[[@LINE-53]]:34: note: consider changing the 1st parameter of 'Tmp' from 'const TriviallyCopyable *&&' to 'const TriviallyCopyable *'
456 t.showTmp(std::move(*obj));
457 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: std::move of the expression of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect [performance-move-const-arg]
458 // CHECK-MESSAGES: :[[@LINE-55]]:36: note: consider changing the 1st parameter of 'showTmp' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
459 TmpAlias::showTmpStatic(std::move(*obj));
460 // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: std::move of the expression of the trivially-copyable type 'TrivialAlias' (aka 'TriviallyCopyable') has no effect [performance-move-const-arg]
461 // CHECK-MESSAGES: :[[@LINE-57]]:49: note: consider changing the 1st parameter of 'showTmpStatic' from 'TriviallyCopyable &&' to 'const TriviallyCopyable &'
462 }
463
464 void showA(A &&v) {}
465 void testA() {
466 A a;
467 showA(std::move(a));
468 }
469
470 void testAAlias() {
471 AlsoA a;
472 showA(std::move(a));
473 }
474
475 void testFuncPointer() {
476 int a = 10;
477 void (*choice)(int, int &&);
478 choice = showInt;
479 choice(std::move(a), std::move(a));
480 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect; remove std::move() [performance-move-const-arg]
481 // CHECK-FIXES: choice(a, std::move(a));
482 // CHECK-MESSAGES: :[[@LINE-3]]:24: warning: std::move of the variable 'a' of the trivially-copyable type 'int' has no effect [performance-move-const-arg]
483 }
484
485 namespace issue_62550 {
486
487 struct NonMoveConstructable {
488 NonMoveConstructable();
489 NonMoveConstructable(const NonMoveConstructable&);
490 NonMoveConstructable& operator=(const NonMoveConstructable&);
491 NonMoveConstructable& operator=(NonMoveConstructable&&);
492 };
493
494 void testNonMoveConstructible() {
495 NonMoveConstructable t1;
496 NonMoveConstructable t2{std::move(t1)};
497 // CHECK-MESSAGES: :[[@LINE-1]]:27: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
498 // CHECK-MESSAGES: :[[@LINE-11]]:8: note: 'NonMoveConstructable' is not move constructible
499 }
500
501 struct NonMoveAssignable {
502 NonMoveAssignable();
503 NonMoveAssignable(const NonMoveAssignable&);
504 NonMoveAssignable(NonMoveAssignable&&);
505
506 NonMoveAssignable& operator=(const NonMoveAssignable&);
507 };
508
509 void testNonMoveAssignable() {
510 NonMoveAssignable t1;
511 NonMoveAssignable t2;
512
513 t2 = std::move(t1);
514 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
515 // CHECK-MESSAGES: :[[@LINE-14]]:8: note: 'NonMoveAssignable' is not move assignable
516 }
517
518 struct NonMoveable {
519 NonMoveable();
520 NonMoveable(const NonMoveable&);
521 NonMoveable& operator=(const NonMoveable&);
522 };
523
524 void testNonMoveable() {
525 NonMoveable t1;
526 NonMoveable t2{std::move(t1)};
527 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
528 // CHECK-MESSAGES: :[[@LINE-10]]:8: note: 'NonMoveable' is not move assignable/constructible
529
530 t1 = std::move(t2);
531 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
532 // CHECK-MESSAGES: :[[@LINE-14]]:8: note: 'NonMoveable' is not move assignable/constructible
533 }
534
535 using AlsoNonMoveable = NonMoveable;
536
537 void testAlsoNonMoveable() {
538 AlsoNonMoveable t1;
539 AlsoNonMoveable t2{std::move(t1)};
540 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
541 // CHECK-MESSAGES: :[[@LINE-23]]:8: note: 'NonMoveable' is not move assignable/constructible
542
543 t1 = std::move(t2);
544 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: passing result of std::move() as a const reference argument; no move will actually happen [performance-move-const-arg]
545 // CHECK-MESSAGES: :[[@LINE-27]]:8: note: 'NonMoveable' is not move assignable/constructible
546 }
547
548 } // namespace issue_62550