[libc++] Restore `basic_ios`'s implicit conversion to `bool` in C++03 mode.

[• Quuxplusone]

Summary

@efriedma noted that my D104682 broke this test case, reduced from SPEC2006.

    
#include <istream>
bool a(std::istream a) {
    return a.getline(0,0) == 0;
}

We can unbreak it by restoring the conversion to something-convertible-to-bool. I chose const void* to match libstdc++ (which uses non-const void*). We could of course just choose bool itself, but that would break some existing libc++ tests which assert basic_ios is NOT convertible to int.

I'm not at all sure that we want this patch; it might be better to say that in the year 2021 we no longer support a benchmark from 2006 written in a language from 2003, and those people should just fix their code already. But if we want it, then I think this is what we want. @efriedma, what are your thoughts re: the appropriate libc++ action here?

[efriedma]

This codepath is only used if someone is explicitly building with -std=c++98. If someone is explicitly requesting -std=c++98, they're presumably dealing with ancient code they can't update for some reason. The only downside I can think of is a minor risk of ODR violations if you mix -std=c++98 and -std=c++11 code.

And yes, SPEC2006 is still relevant for various companies.

libcxx/include/ios

614

The ancient standards actually specify operator void*, not operator const void*, but that probably doesn't matter.

[ldionne]

LGTM with my suggested change applied. Let's also cherry-pick this onto release/13.x to avoid breaking people.

libcxx/include/ios

614

Yeah, let's make this operator void* to match the C++03 spec.

[ldionne]

@tstellar Is it fine to cherry-pick this bugfix onto release/13.x? If it bit @efriedma, it may bite other users, so I'd rather cherry-pick it if that's possible.

[tstellar]

@ldionne Yes, go ahead.

[• Quuxplusone]

Convert to void* instead of const void*. (This requires casting away const.)
Poke buildkite to make sure this last change didn't break anything in the test suite.

[• Quuxplusone]

Welp, obviously that broke the existing test that tests !std::is_convertible<std::istream&, void*>.
So I propose we change the test, on the theory that "match libstdc++'s behavior exactly" is more important than "match libc++'s old behavior in some but not all obscure corner cases" (which is what I was trying to achieve with operator const void* in the original version of this PR). @ldionne, does this still seem reasonable to you?

[ldionne]

In D107663#2938517, @Quuxplusone wrote:

Welp, obviously that broke the existing test that tests !std::is_convertible<std::istream&, void*>.
So I propose we change the test, on the theory that "match libstdc++'s behavior exactly" is more important than "match libc++'s old behavior in some but not all obscure corner cases" (which is what I was trying to achieve with operator const void* in the original version of this PR). @ldionne, does this still seem reasonable to you?

Yes, that seems reasonable.

libcxx/include/ios

public:
 
     typedef typename traits_type::int_type int_type;
     typedef typename traits_type::pos_type pos_type;
     typedef typename traits_type::off_type off_type;
 
     static_assert((is_same<_CharT, typename traits_type::char_type>::value),
                   "traits_type::char_type must be the same type as CharT");
 
+#ifdef _LIBCPP_CXX03_LANG
+    // Preserve the ability to compare with literal 0,
+    // and implicitly convert to bool, but not implicitly convert to int.
+    _LIBCPP_INLINE_VISIBILITY
+    operator void*() const {return fail() ? nullptr : (void*)this;}
+#else
     _LIBCPP_INLINE_VISIBILITY
     explicit operator bool() const {return !fail();}
+#endif
 
     _LIBCPP_INLINE_VISIBILITY bool operator!() const    {return  fail();}
     _LIBCPP_INLINE_VISIBILITY iostate rdstate() const   {return ios_base::rdstate();}
     _LIBCPP_INLINE_VISIBILITY void clear(iostate __state = goodbit) {ios_base::clear(__state);}
     _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state) {ios_base::setstate(__state);}
     _LIBCPP_INLINE_VISIBILITY bool good() const {return ios_base::good();}
     _LIBCPP_INLINE_VISIBILITY bool eof() const  {return ios_base::eof();}
     _LIBCPP_INLINE_VISIBILITY bool fail() const {return ios_base::fail();}

libcxx/test/std/input.output/iostreams.base/ios/iostate.flags/bool.pass.cpp

 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::ios ios(0);
     assert(static_cast<bool>(ios) == !ios.fail());
     ios.setstate(std::ios::failbit);
     assert(static_cast<bool>(ios) == !ios.fail());
-    static_assert((!std::is_convertible<std::ios, void*>::value), "");
     static_assert((!std::is_convertible<std::ios, int>::value), "");
     static_assert((!std::is_convertible<std::ios const&, int>::value), "");
-    static_assert((!std::is_convertible<std::ios, bool>::value), "");
+#if TEST_STD_VER >= 11
+    static_assert(!std::is_convertible<std::ios, void*>::value, "");
+    static_assert(!std::is_convertible<std::ios, bool>::value, "");
+#else
+    static_assert(std::is_convertible<std::ios, void*>::value, "");
+    static_assert(std::is_convertible<std::ios, bool>::value, "");
+    (void)(ios == 0);  // SPEC2006 apparently relies on this to compile
+#endif
 
   return 0;
 }