[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 ↗

(On Diff #385808)

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

17

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

[• Quuxplusone]

LGTM as well.

libcxx/include/ostream

58

// since C++23 :)

216–218

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

65

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

12

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

[ldionne]

Update nits.

libcxx/docs/Status/Cxx2bPapers.csv

 "`P1989R2 <https://wg21.link/P1989R2>`__","LWG","Range constructor for std::string_view","June 2021","",""
 "`P2136R3 <https://wg21.link/P2136R3>`__","LWG","invoke_r","June 2021","",""
 "`P2166R1 <https://wg21.link/P2166R1>`__","LWG","A Proposal to Prohibit std::basic_string and std::basic_string_view construction from nullptr","June 2021","|Complete|","13.0"
 "","","","","",""
 "`P0288R9 <https://wg21.link/P0288R9>`__","LWG","``any_invocable``","October 2021","",""
 "`P0798R8 <https://wg21.link/P0798R8>`__","LWG","Monadic operations for ``std::optional``","October 2021","",""
 "`P0849R8 <https://wg21.link/P0849R8>`__","LWG","``auto(x)``: ``DECAY_COPY`` in the language","October 2021","",""
 "`P1072R10 <https://wg21.link/P1072R10>`__","LWG","``basic_string::resize_and_overwrite``","October 2021","",""
-"`P1147R1 <https://wg21.link/P1147R1>`__","LWG","Printing ``volatile`` Pointers","October 2021","",""
+"`P1147R1 <https://wg21.link/P1147R1>`__","LWG","Printing ``volatile`` Pointers","October 2021","|Complete|","14.0"
 "`P1272R4 <https://wg21.link/P1272R4>`__","LWG","Byteswapping for fun&&nuf","October 2021","",""
 "`P1675R2 <https://wg21.link/P1675R2>`__","LWG","``rethrow_exception`` must be allowed to copy","October 2021","",""
 "`P2077R3 <https://wg21.link/P2077R3>`__","LWG","Heterogeneous erasure overloads for associative containers","October 2021","",""
 "`P2251R1 <https://wg21.link/P2251R1>`__","LWG","Require ``span`` & ``basic_string_view`` to be Trivially Copyable","October 2021","|Complete|","14.0"
 "`P2301R1 <https://wg21.link/P2301R1>`__","LWG","Add a ``pmr`` alias for ``std::stacktrace``","October 2021","",""
 "`P2321R2 <https://wg21.link/P2321R2>`__","LWG","``zip``","October 2021","",""
 "`P2340R1 <https://wg21.link/P2340R1>`__","LWG","Clarifying the status of the 'C headers'","October 2021","",""
 "`P2393R1 <https://wg21.link/P2393R1>`__","LWG","Cleaning up ``integer``-class types","October 2021","",""
 "`P2401R0 <https://wg21.link/P2401R0>`__","LWG","Add a conditional ``noexcept`` specification to ``std::exchange``","October 2021","|Complete|","14.0"
 "","","","","",""

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<<(const volatile void* val); // C++23
     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();
 
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* __p) {
+        return operator<<(const_cast<const void*>(__p));
+    }
+#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.volatile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <ostream>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+// template <class charT, class traits = char_traits<charT> >
+//   class basic_ostream;
+
+// basic_ostream& operator<<(const volatile void* val);
+
+#include <ostream>
+#include <cassert>
+
+template <class CharT>
+class testbuf : public std::basic_streambuf<CharT> {
+  typedef std::basic_streambuf<CharT> base;
+  std::basic_string<CharT> str_;
+
+public:
+  testbuf() {}
+
+  std::basic_string<CharT> str() const { return std::basic_string<CharT>(base::pbase(), base::pptr()); }
+
+protected:
+  virtual typename base::int_type overflow(typename base::int_type ch = base::traits_type::eof()) {
+    if (ch != base::traits_type::eof()) {
+      int n = static_cast<int>(str_.size());
+      str_.push_back(static_cast<CharT>(ch));
+      str_.resize(str_.capacity());
+      base::setp(const_cast<CharT*>(str_.data()), const_cast<CharT*>(str_.data() + str_.size()));
+      base::pbump(n + 1);
+    }
+    return ch;
+  }
+};
+
+int main(int, char**) {
+  testbuf<char> sb1;
+  std::ostream os1(&sb1);
+  int n1;
+  os1 << &n1;
+  assert(os1.good());
+  std::string s1 = sb1.str();
+
+  testbuf<char> sb2;
+  std::ostream os2(&sb2);
+  os2 << static_cast<volatile void*>(&n1);
+  assert(os2.good());
+  std::string s2 = sb2.str();
+
+  testbuf<char> sb3;
+  std::ostream os3(&sb3);
+  volatile int n3;
+  os3 << &n3;
+  assert(os3.good());
+  std::string s3 = sb3.str();
+
+  // %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);
+
+  assert(!s3.empty());
+  assert(s2 != s3);
+
+  return 0;
+}