[libcxx][test] Silence -Wself-assign diagnostics

[lebedev.ri]

Summary

D44883 extends -Wself-assign to also work on C++ classes.
These new warnings pop up in the test suite, so they have to be silenced.

Please refer to the D45082 for disscussion on whether this is the right way to solve this.

Testing: ninja check-libcxx check-libcxxabi in stage-2 build.

[EricWF]

test/std/language.support/support.types/byteops/and.assign.pass.cpp

30 ↗

(On Diff #140553)

Should Clang really be warning when the expression is in an unevaluated context?

[lebedev.ri]

test/std/language.support/support.types/byteops/and.assign.pass.cpp

30 ↗

(On Diff #140553)

At least that is what it currently already does:
https://godbolt.org/g/RpcgBi

[• Quuxplusone]

test/std/language.support/support.types/byteops/and.assign.pass.cpp

30 ↗

(On Diff #140553)

Clang already warns on noexcept(b = b) that "expression with side effects has no effect in an unevaluated context [-Wunevaluated-expression]", so adding one more warning should be acceptable, I think.
Both warnings are (IMO correctly) disabled if the expression b = b is dependently typed, e.g. in a template, where expressions like noexcept(b = b) are practically unavoidable.

Personally I think the warnings are acceptable, but these proposed fixes (inserting C-style casts to T&) are not good. The cast hides the intent of the code (especially in the self-assignment tests for function and any). We shouldn't be encouraging that particular workaround in user code. And besides, a good static analyzer (or even Clang itself) should be able to see that "casting a to the type of a" doesn't change the object referred to, and so the self-assignment is still happening, regardless.

How do the std::byte tests avoid the existing warning for -Wunevaluated-expression? Could we use the same mechanism to avoid the new warning for -Wself-assign?

Could we reuse that mechanism in the tests for byte's -= and /= and %= and ^= operators, which may one day start complaining as loudly as &= and |= when you have the same thing on the left and right hand sides?

Could we reuse that mechanism in the tests for function and any?

[lebedev.ri]

test/std/language.support/support.types/byteops/and.assign.pass.cpp

30 ↗

(On Diff #140553)

but these proposed fixes (inserting C-style casts to T&) are not good. The cast hides the intent of the code (especially in the self-assignment tests for function and any). We shouldn't be encouraging that particular workaround in user code.

Please refer to the D45082 for disscussion on that, and on whether or not to add a more fine-grained sub-flag to -Wself-assign.

And besides, a good static analyzer (or even Clang itself) should be able to see that "casting a to the type of a" doesn't change the object referred to, and so the self-assignment is still happening, regardless.

Absolutely, but static analyzer, not compiler diagnostic.

Could we use the same mechanism to avoid the new warning for -Wself-assign?

Not unless you want to completely disable -Wself-assign (as in, not just the new part from D44883) for tests, no.

[lebedev.ri]

The diagnostic was adjusted not to warn in an unevaluated context.
The remaining diff will have to remain, unless you want to disable -Wself-assign altogether for tests...

If there are remaining problems with this diff, please let me know; otherwise it would be really great to get this accepted!

[EricWF]

LGTM. Perhaps we could add a comment for the first such occurrence of the cast in each file explaining it.

test/std/utilities/any/any.class/any.assign/copy.pass.cpp

void test_copy_assign_empty() {
     }
     assert(LHS::count == 0);
 }
 
 void test_copy_assign_self() {
     // empty
     {
         any a;
-        a = a;
+        a = (any &)a;
         assertEmpty(a);
         assert(globalMemCounter.checkOutstandingNewEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
     // small
     {
         any a((small(1)));
         assert(small::count == 1);
 
-        a = a;
+        a = (any &)a;
 
         assert(small::count == 1);
         assertContains<small>(a, 1);
         assert(globalMemCounter.checkOutstandingNewEq(0));
     }
     assert(small::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
     // large
     {
         any a(large(1));
         assert(large::count == 1);
 
-        a = a;
+        a = (any &)a;
 
         assert(large::count == 1);
         assertContains<large>(a, 1);
         assert(globalMemCounter.checkOutstandingNewEq(1));
     }
     assert(large::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }

test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp

assert(globalMemCounter.checkOutstandingNewEq(0));
     f2 = f;
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(f2.target<int (*)(int)>() == 0);
     assert(f2.target<A>() == 0);
   }
   {
     typedef std::function<int()> Func;
     Func f = g0;
-    Func& fr = (f = f);
+    Func& fr = (f = (Func &)f);
     assert(&fr == &f);
     assert(*f.target<int(*)()>() == g0);
   }
   {
     typedef std::function<int(int)> Func;
     Func f = g;
-    Func& fr = (f = f);
+    Func& fr = (f = (Func &)f);
     assert(&fr == &f);
     assert(*f.target<int(*)(int)>() == g);
   }
   {
     typedef std::function<int(int, int)> Func;
     Func f = g2;
-    Func& fr = (f = f);
+    Func& fr = (f = (Func &)f);
     assert(&fr == &f);
     assert(*f.target<int(*)(int, int)>() == g2);
   }
   {
     typedef std::function<int(int, int, int)> Func;
     Func f = g3;
-    Func& fr = (f = f);
+    Func& fr = (f = (Func &)f);
     assert(&fr == &f);
     assert(*f.target<int(*)(int, int, int)>() == g3);
   }
 #if TEST_STD_VER >= 11
   assert(globalMemCounter.checkOutstandingNewEq(0));
   {
     std::function<int(int)> f = A();
     assert(A::count == 1);