Lines Matching full:a
39 // RUN: -analyzer-config cplusplus.Move:WarnOn="a bunch of things" \
72 class A {
78 A(int ii = 42, double dd = 1.0) : d(dd), i(ii), b(B()) {}
79 void moveconstruct(A &&other) {
85 static A get() {
86 A v(12, 13);
89 A(A *a) {
90 moveconstruct(std::move(*a));
92 A(const A &other) : i(other.i), d(other.d), b(other.b) {}
93 A(A &&other) : i(other.i), d(other.d), b(std::move(other.b)) { // aggressive-note{{Object 'b' is moved}}
95 A(A &&other, char *k) {
98 void operator=(const A &other) {
104 void operator=(A &&other) {
115 void assign(const A &);
121 A a;
122 A b = std::move(a);
123 a.i = 1;
124 a.foo(); // no-warning
127 A a;
128 A b = std::move(a);
129 a.d = 1.0;
130 a.foo(); // no-warning
136 void moveInsideFunctionCall(A a) {
137 A b = std::move(a);
139 void leftRefCall(A &a) {
140 a.foo();
142 void rightRefCall(A &&a) {
143 a.foo();
145 void constCopyOrMoveCall(const A a) {
146 a.foo();
149 void copyOrMoveCall(A a) {
150 a.foo();
155 A a;
156 A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
164 // CHECK: "a: moved",
170 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
171 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
174 A a;
175 A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
176 b = a; // peaceful-warning {{Moved-from object 'a' is copied}}
177 // peaceful-note@-1 {{Moved-from object 'a' is copied}}
180 A a;
181 A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
182 b = std::move(a); // peaceful-warning {{Moved-from object 'a' is moved}}
183 // peaceful-note@-1 {{Moved-from object 'a' is moved}}
189 A a;
190 A b;
191 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
192 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
193 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
196 A a;
197 A b;
198 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
199 A c(a); // peaceful-warning {{Moved-from object 'a' is copied}}
200 // peaceful-note@-1 {{Moved-from object 'a' is copied}}
203 A a;
204 A b;
205 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
206 A c(std::move(a)); // peaceful-warning {{Moved-from object 'a' is moved}}
207 // peaceful-note@-1 {{Moved-from object 'a' is moved}}
213 A a;
215 A a;
216 S s{std::move(a)}; // peaceful-note {{Object 'a' is moved}}
217 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
218 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
221 // Don't report a bug if the variable was assigned to in the meantime.
224 A a;
225 A b;
226 b = std::move(a);
227 a = A();
228 a.foo();
231 A a;
234 A b;
235 b = std::move(a);
236 a = A();
240 a.foo(); // no-warning
244 A a;
247 (void)std::move(a);
251 a = A();
252 a.foo();
255 // The built-in assignment operator should also be recognized as a
262 // A std::move() after the assignment makes the variable invalid again.
264 A a;
265 A b;
266 b = std::move(a);
267 a = A();
268 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
269 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
270 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
272 // If a path exist where we not reinitialize the variable we report a bug.
274 A a;
275 A b;
276 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
279 a = A();
283 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
284 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
289 // Using decltype on an expression is not a use.
291 A a;
292 // A b(std::move(a));
293 decltype(a) other_a; // no-warning
298 A a;
301 rightRefCall(std::move(a)); // no-warning
305 A a;
309 rightRefCall(std::move(a)); // no-warning
313 A a;
315 leftRefCall(a); // no-warning
319 A a;
323 leftRefCall(a); // no-warning
327 A a;
329 constCopyOrMoveCall(a); // no-warning
333 A a;
337 constCopyOrMoveCall(a); // no-warning
341 A a;
343 moveInsideFunctionCall(a); // no-warning
347 A a;
351 moveInsideFunctionCall(a); // no-warning
355 A a;
357 copyOrMoveCall(a); // no-warning
361 A a;
365 copyOrMoveCall(a); // no-warning
369 A a;
372 constCopyOrMoveCall(std::move(a)); // peaceful-note {{Object 'a' is moved}}
373 // peaceful-warning@-1 {{Moved-from object 'a' is moved}}
374 // peaceful-note@-2 {{Moved-from object 'a' is moved}}
380 A a;
382 a.bar();
383 if (a.foo() > 0) {
384 A b;
385 b = std::move(a); // no-warning
392 // Report a usage of a moved-from object only at the first use.
394 A a(42, 42.0);
395 A b;
396 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
400 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
401 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
404 a.bar(); // no-warning
407 a.bar(); // no-warning
411 A a;
412 A a1 = std::move(a); // peaceful-note {{Object 'a' is moved}}
413 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
414 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
416 A a2 = std::move(a); // no-warning
417 a.foo(); // no-warning
423 A a;
424 A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
425 a.empty(); // no-warning
426 a.isEmpty(); // no-warning
427 (void)a; // no-warning
428 (bool)a; // expected-warning {{expression result unused}}
429 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
430 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
435 A a;
436 A b = std::move(a);
437 a.reset(); // no-warning
438 a.foo(); // no-warning
440 a.b.foo(); // no-warning
443 A a;
444 A b = std::move(a);
445 a.destroy(); // no-warning
446 a.foo(); // no-warning
449 A a;
450 A b = std::move(a);
451 a.clear(); // no-warning
452 a.foo(); // no-warning
453 a.b.foo(); // no-warning
456 A a;
457 A b = std::move(a);
458 a.resize(0); // no-warning
459 a.foo(); // no-warning
460 a.b.foo(); // no-warning
463 A a;
464 A b = std::move(a);
465 a.assign(A()); // no-warning
466 a.foo(); // no-warning
467 a.b.foo(); // no-warning
475 void foo(A a);
479 void functionTemplate(A a);
483 // A pattern like this occurs in the EXPECT_EQ and ASSERT_EQ macros in
485 A a;
486 ClassTemplate<sizeof(A(std::move(a)))>().foo(std::move(a)); // no-warning
489 A a;
490 functionTemplate<sizeof(A(std::move(a)))>(std::move(a)); // no-warning
495 A global_a;
503 A a;
504 static A static_a;
507 A b;
508 b = std::move(a); // aggressive-note {{Object 'a' is moved}}
510 a.foo(); // aggressive-warning {{Method called on moved-from object 'a'}}
511 // aggressive-note@-1 {{Method called on moved-from object 'a'}}
520 A *Ptr = new A(1, 1.5);
521 A Arr[10];
540 A a;
542 A b;
543 b = std::move(a);
546 a.bar(); // no-warning
551 // Don't warn if the use is in a different branch from the move.
553 A a;
556 A b;
557 b = std::move(a);
559 a.foo(); // no-warning
562 // Same thing, but with a ternary operator.
564 A a, b;
565 i > 0 ? (void)(b = std::move(a)) : a.bar(); // no-warning
569 // A variation on the theme above.
571 A a;
572 a.foo() > 0 ? a.foo() : A(std::move(a)).foo();
576 // Same thing, but with a switch statement.
578 A a, b;
581 b = std::move(a); // no-warning
585 a.foo(); // no-warning
589 // However, if there's a fallthrough, we do warn.
591 A a, b;
594 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
596 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
597 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
604 A a = A::get();
605 A::get().foo(); // no-warning
607 A::get().foo(); // no-warning
612 A&& a = A{};
613 A b = std::move(a); // peaceful-note {{Object is moved}}
615 a.foo(); // peaceful-warning {{Method called on moved-from object}}
619 void interFunTest1(A &a) {
620 a.bar(); // peaceful-warning {{Method called on moved-from object 'a'}}
621 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
625 A a;
626 A b;
627 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
628 interFunTest1(a); // peaceful-note {{Calling 'interFunTest1'}}
631 void foobar(A a, int i);
632 void foobar(int i, A a);
635 A a;
636 foobar(std::move(a), a.getI()); // peaceful-note {{Object 'a' is moved}}
637 // peaceful-warning@-1 {{Method called on moved-from object 'a'}}
638 // peaceful-note@-2 {{Method called on moved-from object 'a'}}
641 foobar(a.getI(), std::move(a)); //no-warning
644 void not_known_pass_by_ref(A &a);
645 void not_known_pass_by_const_ref(const A &a);
646 void not_known_pass_by_rvalue_ref(A &&a);
647 void not_known_pass_by_ptr(A *a);
648 void not_known_pass_by_const_ptr(const A *a);
652 A a;
653 A b;
654 b = std::move(a);
655 not_known_pass_by_ref(a);
656 a.foo(); // no-warning
659 A a;
660 A b;
661 b = std::move(a); // peaceful-note{{Object 'a' is moved}}
662 not_known_pass_by_const_ref(a);
663 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
664 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
667 A a;
668 A b;
669 b = std::move(a);
670 not_known_pass_by_rvalue_ref(std::move(a));
671 a.foo(); // no-warning
674 A a;
675 A b;
676 b = std::move(a);
677 not_known_pass_by_ptr(&a);
678 a.foo(); // no-warning
681 A a;
682 A b;
683 b = std::move(a); // peaceful-note {{Object 'a' is moved}}
684 not_known_pass_by_const_ptr(&a);
685 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
686 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
690 // A declaration statement containing multiple declarations sequences the
694 A a;
695 A a1 = a, a2 = std::move(a); // no-warning
698 A a;
699 A a1 = std::move(a), a2 = a; // peaceful-note {{Object 'a' is moved}}
700 // peaceful-warning@-1 {{Moved-from object 'a' is copied}}
701 // peaceful-note@-2 {{Moved-from object 'a' is copied}}
708 A a;
709 if (a.foo() > 0 && A(std::move(a)).foo() > 0) { // peaceful-note {{Assuming the condition is false}}
716 A().bar();
719 // A variation: Negate the result of the && (which pushes the && further down
722 A a;
723 if (!(a.foo() > 0 && A(std::move(a)).foo() > 0)) { // peaceful-note {{Assuming the condition is false}}
730 A().bar();
734 A a;
735 if (A(std::move(a)).foo() > 0 && a.foo() > 0) { // peaceful-note {{Object 'a' is moved}}
738 // peaceful-warning@-3 {{Method called on moved-from object 'a'}}
739 // peaceful-note@-4 {{Method called on moved-from object 'a'}}
744 A().bar();
748 A a;
749 if (a.foo() > 0 || A(std::move(a)).foo() > 0) { // peaceful-note {{Assuming the condition is true}}
752 A().bar();
756 A a;
757 if (A(std::move(a)).foo() > 0 || a.foo() > 0) { // peaceful-note {{Object 'a' is moved}}
760 // peaceful-warning@-3 {{Method called on moved-from object 'a'}}
761 // peaceful-note@-4 {{Method called on moved-from object 'a'}}
762 A().bar();
767 // A range-based for sequences the loop variable declaration before the body.
769 A v[2] = {A(), A()};
770 for (A &a : v) {
771 A b;
772 b = std::move(a); // no-warning
776 // If a variable is declared in an if statement, the declaration of the variable
777 // (which is treated like a reinitialization by the check) is sequenced before
778 // the evaluation of the condition (which constitutes a use).
781 if (A a = A()) {
782 A b;
783 b = std::move(a); // no-warning
788 struct C : public A {
794 A a;
795 B b = std::move(a.b); // aggressive-note {{Object 'b' is moved}}
796 a.b.foo(); // aggressive-warning {{Method called on moved-from object 'b'}}
800 A a;
801 A a1 = std::move(a); // aggressive-note {{Calling move constructor for 'A'}}
802 // aggressive-note@-1 {{Returning from move constructor for 'A'}}
803 a.b.foo(); // aggressive-warning{{Method called on moved-from object 'b'}}
806 // Don't report a misuse if any SuperRegion is already reported.
808 A a;
809 A a1 = std::move(a); // peaceful-note {{Object 'a' is moved}}
810 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
811 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
812 a.b.foo(); // no-warning
908 // implicit). While this is not a desired code behavior, it is
909 // not the use-after-move checker's responsibility to issue such a warning.
912 B a = std::move(*b);
917 B a, b;
918 new (&a) B(reinterpret_cast<B &&>(b));
923 B a = std::move(b);
945 std::vector<int> W = std::move(V); // expected-note {{Object 'V' of type 'std::vector' is left in a valid but unspecified state after move}}
952 // unique_ptr remains in a well-defined state after move.
969 void localRValueMove(A &&a) {
970 A b = std::move(a); // peaceful-note {{Object 'a' is moved}}
971 a.foo(); // peaceful-warning {{Method called on moved-from object 'a'}}
972 // peaceful-note@-1 {{Method called on moved-from object 'a'}}
977 // reusing a local variable this way usually indicates a bug.
983 void localUniquePtrWithArrow(std::unique_ptr<A> P) {
984 std::unique_ptr<A> Q = std::move(P); // expected-note{{Smart pointer 'P' of type 'std::unique_ptr' is reset to null when moved from}}
989 void getAfterMove(std::unique_ptr<A> P) {
990 std::unique_ptr<A> Q = std::move(P); // peaceful-note {{Object 'P' is moved}}
996 A *a = P.get(); // peaceful-warning {{Method called on moved-from object 'P'}}
999 // TODO: Warn on a null dereference here.
1000 a->foo();