[libc++] Implement P1147R1 (Printing volatile T*)

[ldionne]

Summary

Implement P1147R1

[ldionne]

Thanks for the patch! Can you please go through the list at https://libcxx.llvm.org/Contributing.html and make sure you didn't forget anything?

[philnik]

Added synopsis and updated status

[ldionne]

LGTM except for the testing nitpick. Requesting changes so it shows up at the top once you update.

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp

62

Sorry for missing that in the first round of review, but the new tests should live in a new file like pointer.volatile.pass.cpp, and should show the correct synopsis for what we're testing. You can then mark it as // UNSUPPORTED: c++03, c++11, c++17, c++20.

[philnik]

Moved tests into new file

[philnik]

I don't have commit permissions, so someone else has to commit it for me. "Nikolas Klauser" <[e-mail]>

[ldionne]

Thanks for the patch!

[ldionne]

libcxx/include/ostream

58

Nitpick: add // C++23.

I'll do this when committing on your behalf.

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.volatile.pass.cpp

16 ↗

(On Diff #385820)

Nit: this is missing a return type. I'll fix that upon committing.

[• Quuxplusone]

LGTM as well.

libcxx/include/ostream

58

// since C++23 :)

215–217

These lines are misindented; should be 4 spaces.
Also consider s/__val/__p/g for consistency with line 213, but whatever.
Also consider linebreaking after _LIBCPP_HIDE_FROM_ABI.

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.volatile.pass.cpp

64 ↗

(On Diff #385820)

Style nit: Lines 51, 57, 64: IIUC, sb.str() returns something of type std::string already, so the cast-like direct-initialization syntax is unnecessary. std::string s3 = sb3.str(); would be fine.

[ldionne]

Commandeering to update.

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.volatile.pass.cpp

11 ↗

(On Diff #385820)

This is also missing c++14 from the list.

[ldionne]

Update nits.

libcxx/include/ostream

public:
     basic_ostream& operator<<(long n);
     basic_ostream& operator<<(unsigned long n);
     basic_ostream& operator<<(long long n);
     basic_ostream& operator<<(unsigned long long n);
     basic_ostream& operator<<(float f);
     basic_ostream& operator<<(double f);
     basic_ostream& operator<<(long double f);
     basic_ostream& operator<<(const void* p);
     basic_ostream& operator<<(basic_streambuf<char_type,traits>* sb);
     basic_ostream& operator<<(nullptr_t);
 
     // 27.7.2.7 Unformatted output:
     basic_ostream& put(char_type c);
     basic_ostream& write(const char_type* s, streamsize n);
     basic_ostream& flush();
 
     // 27.7.2.5 seeks:
public:
     basic_ostream& operator<<(long __n);
     basic_ostream& operator<<(unsigned long __n);
     basic_ostream& operator<<(long long __n);
     basic_ostream& operator<<(unsigned long long __n);
     basic_ostream& operator<<(float __f);
     basic_ostream& operator<<(double __f);
     basic_ostream& operator<<(long double __f);
     basic_ostream& operator<<(const void* __p);
+
+#if _LIBCPP_STD_VER > 20
+  _LIBCPP_HIDE_FROM_ABI basic_ostream& operator<<(const volatile void* __val) {
+    return operator<<(const_cast<const void*>(__val));
+  }
+#endif
+
     basic_ostream& operator<<(basic_streambuf<char_type, traits_type>* __sb);
 
     _LIBCPP_INLINE_VISIBILITY
     basic_ostream& operator<<(nullptr_t)
     { return *this << "nullptr"; }
 
     // 27.7.2.7 Unformatted output:
     basic_ostream& put(char_type __c);

libcxx/test/std/input.output/iostream.format/output.streams/ostream.formatted/ostream.inserters.arithmetic/pointer.pass.cpp

 {
     {
         std::ostream os((std::streambuf*)0);
         const void* n = 0;
         os << n;
         assert(os.bad());
         assert(os.fail());
     }
     {
         testbuf<char> sb1;
         std::ostream os1(&sb1);
         int n1;
         os1 << &n1;
         assert(os1.good());
         std::string s1(sb1.str());
 
+#if TEST_STD_VER > 20
+        testbuf<char> sb3;
+        std::ostream os3(&sb3);
+        os3 << static_cast<volatile void*>(&n1);
+        assert(os3.good());
+        std::string s3(sb3.str());
+#endif
+
         testbuf<char> sb2;
         std::ostream os2(&sb2);
         int n2;
         os2 << &n2;
         assert(os2.good());
         std::string s2(sb2.str());
 
+#if TEST_STD_VER > 20
+        testbuf<char> sb4;
+        std::ostream os4(&sb4);
+        os4 << static_cast<volatile void*>(&n2);
+        assert(os4.good());
+        std::string s4(sb4.str());
+#endif
+
         // %p is implementation defined. Instead of validating the
         // output, at least ensure that it does not generate an empty
         // string. Also make sure that given two distinct addresses, the
         // output of %p is different.
         assert(!s1.empty());
         assert(!s2.empty());
         assert(s1 != s2);
+
+#if TEST_STD_VER > 20
+        assert(!s3.empty());
+        assert(!s4.empty());
+        assert(s3 != s4);
+
+        assert(s1 == s3);
+        assert(s2 == s4);
+#endif
     }
     {
         testbuf<char> sb;
         std::ostream os(&sb);
         const void* n = &sb;
         os << n;
         assert(os.good());
     }
 
   return 0;
 }