[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

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

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

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

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/language.support/support.types/byteops/and.assign.pass.cpp

 
 
 int main () {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
     constexpr std::byte b9{static_cast<std::byte>(9)};
 
-    static_assert(noexcept(b &= b), "" );
+    static_assert(noexcept(b &= (std::byte &)b), "" );
 
     static_assert(std::to_integer<int>(test(b1, b8)) == 0, "");
     static_assert(std::to_integer<int>(test(b1, b9)) == 1, "");
     static_assert(std::to_integer<int>(test(b8, b9)) == 8, "");
 
     static_assert(std::to_integer<int>(test(b8, b1)) == 0, "");
     static_assert(std::to_integer<int>(test(b9, b1)) == 1, "");
     static_assert(std::to_integer<int>(test(b9, b8)) == 8, "");
 }

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

 
 
 int main () {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b2{static_cast<std::byte>(2)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
 
-    static_assert(noexcept(b |= b), "" );
+    static_assert(noexcept(b |= (std::byte &)b), "" );
 
     static_assert(std::to_integer<int>(test(b1, b2)) ==  3, "");
     static_assert(std::to_integer<int>(test(b1, b8)) ==  9, "");
     static_assert(std::to_integer<int>(test(b2, b8)) == 10, "");
 
     static_assert(std::to_integer<int>(test(b2, b1)) ==  3, "");
     static_assert(std::to_integer<int>(test(b8, b1)) ==  9, "");
     static_assert(std::to_integer<int>(test(b8, b2)) == 10, "");
 
 }

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

 
 
 int main () {
     std::byte b;  // not constexpr, just used in noexcept check
     constexpr std::byte b1{static_cast<std::byte>(1)};
     constexpr std::byte b8{static_cast<std::byte>(8)};
     constexpr std::byte b9{static_cast<std::byte>(9)};
 
-    static_assert(noexcept(b ^= b), "" );
+    static_assert(noexcept(b ^= (std::byte &)b), "" );
 
     static_assert(std::to_integer<int>(test(b1, b8)) == 9, "");
     static_assert(std::to_integer<int>(test(b1, b9)) == 8, "");
     static_assert(std::to_integer<int>(test(b8, b9)) == 1, "");
 
     static_assert(std::to_integer<int>(test(b8, b1)) == 9, "");
     static_assert(std::to_integer<int>(test(b9, b1)) == 8, "");
     static_assert(std::to_integer<int>(test(b9, b8)) == 1, "");
 }

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);