Merge 2022-11 LWG Motion 8

P2704R0 C++ Standard Library Immediate Issues

Author: tkoeppe

source/containers.tex

@@ -7273,12 +7273,33 @@
 \indexlibrarymember{insert_after}{forward_list}%
 \begin{itemdecl}
 iterator insert_after(const_iterator position, const T& x);
+\end{itemdecl}
+
+\begin{itemdescr}
+\pnum
+\expects
+\tcode{T} is \oldconcept{CopyInsertable} into \tcode{forward_list}.
+\tcode{position} is \tcode{before_begin()} or is a dereferenceable
+iterator in the range \range{begin()}{end()}.
+
+\pnum
+\effects
+Inserts a copy of \tcode{x} after \tcode{position}.
+
+\pnum
+\returns
+An iterator pointing to the copy of \tcode{x}.
+\end{itemdescr}
+
+\indexlibrarymember{insert_after}{forward_list}%
+\begin{itemdecl}
 iterator insert_after(const_iterator position, T&& x);
 \end{itemdecl}
 
 \begin{itemdescr}
 \pnum
 \expects
+\tcode{T} is \oldconcept{MoveInsertable} into \tcode{forward_list}.
 \tcode{position} is \tcode{before_begin()} or is a dereferenceable
 iterator in the range \range{begin()}{end()}.
 
@@ -7299,6 +7320,7 @@
 \begin{itemdescr}
 \pnum
 \expects
+\tcode{T} is \oldconcept{CopyInsertable} into \tcode{forward_list}.
 \tcode{position} is \tcode{before_begin()} or is a dereferenceable
 iterator in the range \range{begin()}{end()}.
 
@@ -7308,7 +7330,8 @@
 
 \pnum
 \returns
-An iterator pointing to the last inserted copy of \tcode{x} or \tcode{position} if \tcode{n == 0}.
+An iterator pointing to the last inserted copy of \tcode{x}, or
+\tcode{position} if \tcode{n == 0} is \tcode{true}.
 \end{itemdescr}
 
 \indexlibrarymember{insert_after}{forward_list}%
@@ -7320,6 +7343,8 @@
 \begin{itemdescr}
 \pnum
 \expects
+\tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{forward_list}
+from \tcode{*first}.
 \tcode{position} is \tcode{before_begin()} or is a dereferenceable
 iterator in the range \range{begin()}{end()}.
 Neither \tcode{first} nor \tcode{last} are iterators in \tcode{*this}.
@@ -7330,7 +7355,8 @@
 
 \pnum
 \returns
-An iterator pointing to the last inserted element or \tcode{position} if \tcode{first == last}.
+An iterator pointing to the last inserted element, or
+\tcode{position} if \tcode{first == last} is \tcode{true}.
 \end{itemdescr}
 
 \indexlibrarymember{insert_range_after}{forward_list}%
@@ -7342,7 +7368,9 @@
 \begin{itemdescr}
 \pnum
 \expects
-\tcode{position} is \tcode{before_begin()} or
+\tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{forward_list}
+from \tcode{*ranges::begin(rg)}.
+\tcode{posi\-tion} is \tcode{before_begin()} or
 is a dereferenceable iterator in the range \range{begin()}{end()}.
 \tcode{rg} and \tcode{*this} do not overlap.
 
@@ -7364,11 +7392,7 @@
 \begin{itemdescr}
 \pnum
 \effects
-\tcode{insert_after(position, il.begin(), il.end())}.
-
-\pnum
-\returns
-An iterator pointing to the last inserted element or \tcode{position} if \tcode{il} is empty.
+Equivalent to: \tcode{return insert_after(position, il.begin(), il.end());}
 \end{itemdescr}
 
 
@@ -7381,13 +7405,15 @@
 \begin{itemdescr}
 \pnum
 \expects
+\tcode{T} is \oldconcept{EmplaceConstructible} into \tcode{forward_list}
+from \tcode{std::forward<Args>(\linebreak args)...}.
 \tcode{position} is \tcode{before_begin()} or is a dereferenceable
 iterator in the range \range{begin()}{end()}.
 
 \pnum
 \effects
-Inserts an object of type \tcode{value_type} constructed with
-\tcode{value_type(std::forward<Args>(\brk{}args)...)} after \tcode{position}.
+Inserts an object of type \tcode{value_type} direct-non-list-initialized with
+\tcode{std::forward<Args>(\linebreak args)...} after \tcode{position}.
 
 \pnum
 \returns
@@ -14621,10 +14647,12 @@
 \end{note}
 
 \pnum
-Any sequence container\iref{sequence.reqmts} \tcode{C}
-supporting \oldconcept{RandomAccessIterator} can be used
-to instantiate \tcode{flat_map},
-as long as invocations of
+Any type \tcode{C}
+that meets the sequence container requirements\iref{sequence.reqmts}
+can be used to instantiate \tcode{flat_map},
+as long as
+\tcode{C::iterator} meets the \oldconcept{RandomAccessIterator} requirements and
+invocations of
 member functions \tcode{C::size} and \tcode{C::max_size} do not exit via an exception.
 In particular, \tcode{vector}\iref{vector} and \tcode{deque}\iref{deque}
 can be used.
@@ -15763,10 +15791,12 @@
 \end{note}
 
 \pnum
-Any sequence container\iref{sequence.reqmts} \tcode{C}
-supporting \oldconcept{RandomAccessIterator} can be used to
-instantiate \tcode{flat_multimap},
-as long as invocations of
+Any type \tcode{C}
+that meets the sequence container requirements\iref{sequence.reqmts}
+can be used to instantiate \tcode{flat_multimap},
+as long as
+\tcode{C::iterator} meets the \oldconcept{RandomAccessIterator} requirements and
+invocations of
 member functions \tcode{C::size} and \tcode{C::max_size} do not exit via an exception.
 In particular,
 \tcode{vector}\iref{vector} and \tcode{deque}\iref{deque} can be used.

source/diagnostics.tex

@@ -1752,13 +1752,9 @@
   template<class Allocator>
     string to_string(const basic_stacktrace<Allocator>& st);
 
-  template<class charT, class traits>
-    basic_ostream<charT, traits>&
-      operator<<(basic_ostream<charT, traits>& os, const stacktrace_entry& f);
-
-  template<class charT, class traits, class Allocator>
-    basic_ostream<charT, traits>&
-      operator<<(basic_ostream<charT, traits>& os, const basic_stacktrace<Allocator>& st);
+  ostream& operator<<(ostream& os, const stacktrace_entry& f);
+  template<class Allocator>
+    ostream& operator<<(ostream& os, const basic_stacktrace<Allocator>& st);
 
   namespace pmr {
     using stacktrace = basic_stacktrace<polymorphic_allocator<stacktrace_entry>>;
@@ -2391,9 +2387,7 @@
 
 \indexlibrarymember{operator<<}{stacktrace_entry}%
 \begin{itemdecl}
-template<class charT, class traits>
-basic_ostream<charT, traits>&
-  operator<<(basic_ostream<charT, traits>& os, const stacktrace_entry& f);
+ostream& operator<<(ostream& os, const stacktrace_entry& f);
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -2404,9 +2398,8 @@
 
 \indexlibrarymember{operator<<}{basic_stacktrace}%
 \begin{itemdecl}
-template<class charT, class traits, class Allocator>
-basic_ostream<charT, traits>&
-  operator<<(basic_ostream<charT, traits>& os, const basic_stacktrace<Allocator>& st);
+template<class Allocator>
+  ostream& operator<<(ostream& os, const basic_stacktrace<Allocator>& st);
 \end{itemdecl}
 
 \begin{itemdescr}

source/iostreams.tex

@@ -18327,12 +18327,6 @@
 \pnum
 \throws
 As specified in~\ref{fs.err.report}.
-
-\pnum
-\remarks
-Implementations should
-  avoid unnecessary normalization such as
-  when \tcode{canonical} has already been called on the entirety of \tcode{p}.
 \end{itemdescr}
 
 \rSec1[c.files]{C library files}

source/lib-intro.tex

@@ -478,13 +478,14 @@
 implementation-defined types\iref{type.descriptions},
 and member functions\iref{functions.within.classes}.
 
-\rSec3[expos.only.func]{Exposition-only functions}
+\rSec3[expos.only.entity]{Exposition-only entities, etc.}
 
 \pnum
-Several function templates
+Several entities and \grammarterm{typedef-name}{s}
 defined in \ref{\firstlibchapter} through \ref{\lastlibchapter} and \ref{depr}
 are only defined for the purpose of exposition.
-The declaration of such a function is followed by a comment ending in \expos.
+The declaration of such an entity or \grammarterm{typedef-name}
+is followed by a comment ending in \expos.
 
 \pnum
 The following are defined for exposition only
@@ -546,22 +547,6 @@
 \indextext{types!implementation-defined}%
 They are based on other types, but with added constraints.
 
-\rSec4[expos.only.types]{Exposition-only types}
-
-\pnum
-Several types defined in \ref{\firstlibchapter} through \ref{\lastlibchapter}
-and \ref{depr} are defined for the purpose of exposition.
-The declaration of such a type is followed by a comment ending in \expos.
-\begin{example}
-\begin{codeblock}
-namespace std {
-  extern "C" using @\placeholdernc{some-handler}@ = int(int, void*, double);  // \expos
-}
-\end{codeblock}
-The type placeholder \tcode{\placeholder{some-handler}} can now be used to specify a function
-that takes a callback parameter with C language linkage.
-\end{example}
-
 \rSec4[enumerated.types]{Enumerated types}
 
 \pnum
@@ -914,52 +899,70 @@
 \pnum
 An implementation may use any technique that provides equivalent observable behavior.
 
-\rSec3[freestanding.entity]{Freestanding entities}
+\rSec3[freestanding.item]{Freestanding items}
 
 \pnum
-\indextext{entity!freestanding|see{freestanding entity}}%
-A \defn{freestanding entity} is a declaration or macro definition
-that is present in a freestanding implementation and a hosted implementation.
+\indextext{item!freestanding|see{freestanding item}}%
+A \defn{freestanding item} is
+a declaration, entity, \grammarterm{typedef-name}, or macro
+that is required to be present in
+a freestanding implementation and a hosted implementation.
 
 \pnum
 Unless otherwise specified,
-the requirements on freestanding entities on a freestanding implementation
-are the same as the corresponding requirements in a hosted implementation.
+the requirements on freestanding items for a freestanding implementation
+are the same as the corresponding requirements for a hosted implementation,
+except that not all of the members of the namespaces are required to be present.
+\begin{note}
+This implies that freestanding item enumerations have the same enumerators on
+freestanding implementations and hosted implementations.
+Furthermore, class types have the same members and
+class templates have the same deduction guides
+on freestanding implementations and hosted implementations.
+\end{note}
+
+\pnum
+\indextext{declaration!freestanding item}%
+A declaration in a header synopsis is a freestanding item if
+\begin{itemize}
+\item it is followed by a comment that includes \textit{freestanding}, or
+\item the header synopsis begins with a comment that includes \textit{all freestanding}.
+\end{itemize}
+
+\pnum
+\indextext{entity!freestanding item}%
+\indextext{\idxgram{typedef-name}!freestanding item}%
+An entity or \grammarterm{typedef-name} is a freestanding item if it is:
+\begin{itemize}
+\item introduced by a declaration that is a freestanding item,
+\item an enclosing namespace of a freestanding item,
+\item a friend of a freestanding item,
+\item denoted by a \grammarterm{typedef-name} that is a freestanding item, or
+\item denoted by an alias template that is a freestanding item.
+\end{itemize}
+
+\pnum
+\indextext{macro!freestanding item}%
+A macro is a freestanding item if it is defined in a header synopsis and
+\begin{itemize}
+\item the definition is followed by a comment that includes \textit{freestanding}, or
+\item the header synopsis begins with a comment that includes \textit{all freestanding}.
+\end{itemize}
 
 \pnum
-In a header synopsis, entities followed with a comment
-that includes \textit{freestanding} are freestanding entities.
 \begin{example}
 \begin{codeblock}
 #define NULL @\seebelow@      // freestanding
 \end{codeblock}
 \end{example}
 
-\pnum
-If a header synopsis begins with a comment
-that includes \textit{all freestanding},
-then all of the declarations and macro definitions in the header synopsis
-are freestanding entities.
 \begin{example}
 \begin{codeblock}
 // all freestanding
 namespace std {
 \end{codeblock}
 \end{example}
 
-\pnum
-Deduction guides for freestanding entity class templates are freestanding entities.
-
-\pnum
-Enclosing namespaces of freestanding entities are freestanding entities.
-
-\pnum
-Friends of freestanding entities are freestanding entities.
-
-\pnum
-Entities denoted by freestanding entity \grammarterm{typedef-name}{s} and
-freestanding entity alias templates are freestanding entities.
-
 \rSec1[requirements]{Library-wide requirements}
 
 \rSec2[requirements.general]{General}
@@ -1480,7 +1483,7 @@
 \pnum
 For each of the headers listed in \tref{headers.cpp.fs},
 a freestanding implementation provides at least
-the freestanding entities\iref{freestanding.entity} declared in the header.
+the freestanding items\iref{freestanding.item} declared in the header.
 \indextext{implementation!freestanding|)}%
 
 \pnum

source/memory.tex

@@ -86,21 +86,22 @@
 
   // \ref{obj.lifetime}, explicit lifetime management
   template<class T>
-    T* start_lifetime_as(void* p) noexcept;
+    T* start_lifetime_as(void* p) noexcept;                                         // freestanding
   template<class T>
-    const T* start_lifetime_as(const void* p) noexcept;
+    const T* start_lifetime_as(const void* p) noexcept;                             // freestanding
   template<class T>
-    volatile T* start_lifetime_as(volatile void* p) noexcept;
+    volatile T* start_lifetime_as(volatile void* p) noexcept;                       // freestanding
   template<class T>
-    const volatile T* start_lifetime_as(const volatile void* p) noexcept;
+    const volatile T* start_lifetime_as(const volatile void* p) noexcept;           // freestanding
   template<class T>
-    T* start_lifetime_as_array(void* p, size_t n) noexcept;
+    T* start_lifetime_as_array(void* p, size_t n) noexcept;                         // freestanding
   template<class T>
-    const T* start_lifetime_as_array(const void* p, size_t n) noexcept;
+    const T* start_lifetime_as_array(const void* p, size_t n) noexcept;             // freestanding
   template<class T>
-    volatile T* start_lifetime_as_array(volatile void* p, size_t n) noexcept;
+    volatile T* start_lifetime_as_array(volatile void* p, size_t n) noexcept;       // freestanding
   template<class T>
-    const volatile T* start_lifetime_as_array(const volatile void* p, size_t n) noexcept;
+    const volatile T* start_lifetime_as_array(const volatile void* p,               // freestanding
+	                                      size_t n) noexcept;
 
   // \ref{allocator.tag}, allocator argument tag
   struct allocator_arg_t {                                                          // freestanding

source/meta.tex

@@ -881,7 +881,7 @@
 \tcode{template<class T>}\br
   \tcode{struct is_aggregate;}           &
  \tcode{T} is an aggregate type\iref{dcl.init.aggr} &
- \tcode{remove_all_extents_t<T>} shall be a complete type or \cv~\keyword{void}.              \\ \rowsep
+ \tcode{T} shall be an array type, a complete type, or \cv~\keyword{void}.              \\ \rowsep
 
 \indexlibrary{\idxcode{is_signed}!class}%
 \tcode{template<class T>}\br