remove second constexpr if

Fixes NB US 113-173 (C++26 CD).

Author: JeffGarland

source/compatibility.tex

@@ -2996,10 +2996,7 @@
 \end{example}
 
 \howwide
-This is fairly widely used but it is good
-programming practice to add the cast when assigning pointer-to-void to pointer-to-object.
-Some C translators will give a warning
-if the cast is not used.
+Common.
 
 \diffref{expr.arith.conv}
 \change

source/containers.tex

@@ -6444,8 +6444,8 @@
   template<class T, class Allocator>
     constexpr bool operator==(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
   template<class T, class Allocator>
-    constexpr @\placeholder{synth-three-way-result}@<T> operator<=>(const deque<T, Allocator>& x,
-    @\itcorr@                                      const deque<T, Allocator>& y);
+    constexpr @\placeholder{synth-three-way-result}@<T>
+      operator<=>(const deque<T, Allocator>& x, const deque<T, Allocator>& y);
 
   template<class T, class Allocator>
     constexpr void swap(deque<T, Allocator>& x, deque<T, Allocator>& y)
@@ -6940,8 +6940,9 @@
     constexpr bool operator==(const forward_list<T, Allocator>& x,
                               const forward_list<T, Allocator>& y);
   template<class T, class Allocator>
-    constexpr @\placeholder{synth-three-way-result}@<T> operator<=>(const forward_list<T, Allocator>& x,
-    @\itcorr@                                            const forward_list<T, Allocator>& y);
+    constexpr @\placeholder{synth-three-way-result}@<T>
+      operator<=>(const forward_list<T, Allocator>& x,
+                  const forward_list<T, Allocator>& y);
 
   template<class T, class Allocator>
     constexpr void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
@@ -8994,8 +8995,8 @@
   template<class T, class Allocator>
     constexpr bool operator==(const list<T, Allocator>& x, const list<T, Allocator>& y);
   template<class T, class Allocator>
-    constexpr @\placeholder{synth-three-way-result}@<T> operator<=>(const list<T, Allocator>& x,
-    @\itcorr@                                      const list<T, Allocator>& y);
+    constexpr @\placeholder{synth-three-way-result}@<T>
+      operator<=>(const list<T, Allocator>& x, const list<T, Allocator>& y);
 
   template<class T, class Allocator>
     constexpr void swap(list<T, Allocator>& x, list<T, Allocator>& y)
@@ -9787,8 +9788,8 @@
   template<class T, class Allocator>
     constexpr bool operator==(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
   template<class T, class Allocator>
-    constexpr @\placeholder{synth-three-way-result}@<T> operator<=>(const vector<T, Allocator>& x,
-              @\itcorr@                                      const vector<T, Allocator>& y);
+    constexpr @\placeholder{synth-three-way-result}@<T>
+      operator<=>(const vector<T, Allocator>& x, const vector<T, Allocator>& y);
 
   template<class T, class Allocator>
     constexpr void swap(vector<T, Allocator>& x, vector<T, Allocator>& y)
@@ -10575,7 +10576,7 @@
 
 \pnum
 Unless described below, all operations have the same requirements and
-semantics as the primary \tcode{vector} template, except that operations
+semantics as the \tcode{vector} primary template, except that operations
 dealing with the \tcode{bool} value type map to bit values in the
 container storage and
 \tcode{allocator_traits::construct}\iref{allocator.traits.members}
@@ -12585,8 +12586,9 @@
     constexpr bool operator==(const set<Key, Compare, Allocator>& x,
                               const set<Key, Compare, Allocator>& y);
   template<class Key, class Compare, class Allocator>
-    constexpr @\placeholder{synth-three-way-result}@<Key> operator<=>(const set<Key, Compare, Allocator>& x,
-    @\itcorr@                                                const set<Key, Compare, Allocator>& y);
+    constexpr @\placeholder{synth-three-way-result}@<Key>
+      operator<=>(const set<Key, Compare, Allocator>& x,
+                  const set<Key, Compare, Allocator>& y);
 
   template<class Key, class Compare, class Allocator>
     constexpr void swap(set<Key, Compare, Allocator>& x,
@@ -13489,8 +13491,8 @@
 
     template<@\exposconcept{container-compatible-range}@<value_type> R>
       constexpr unordered_map(from_range_t, R&& rg, size_type n = @\seebelow@,
-        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
-        const allocator_type& a = allocator_type());
+                              const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+                              const allocator_type& a = allocator_type());
     constexpr unordered_map(const unordered_map&);
     constexpr unordered_map(unordered_map&&);
     constexpr explicit unordered_map(const Allocator&);
@@ -13510,7 +13512,7 @@
         : unordered_map(f, l, n, hasher(), key_equal(), a) { }
     template<class InputIterator>
       constexpr unordered_map(InputIterator f, InputIterator l, size_type n, const hasher& hf,
-                    const allocator_type& a)
+                              const allocator_type& a)
         : unordered_map(f, l, n, hf, key_equal(), a) { }
     template<@\exposconcept{container-compatible-range}@<value_type> R>
       constexpr unordered_map(from_range_t, R&& rg, size_type n, const allocator_type& a)
@@ -13523,7 +13525,7 @@
                             const allocator_type& a)
       : unordered_map(il, n, hasher(), key_equal(), a) { }
     constexpr unordered_map(initializer_list<value_type> il, size_type n, const hasher& hf,
-                  const allocator_type& a)
+                            const allocator_type& a)
       : unordered_map(il, n, hf, key_equal(), a) { }
     constexpr ~unordered_map();
     constexpr unordered_map& operator=(const unordered_map&);

source/iostreams.tex

@@ -14727,7 +14727,7 @@
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{format("\{\}", *this)}.
+\tcode{std::format("\{\}", *this)}.
 \begin{note}
 The returned string is suitable for use with formatting\iref{format.functions}
 and print functions\iref{print.fun}.
@@ -14801,7 +14801,7 @@
 \begin{itemdescr}
 \pnum
 \returns
-\tcode{format("\{:g\}", *this)}.
+\tcode{std::format("\{:g\}", *this)}.
 \begin{note}
 The returned string is suitable for use with formatting\iref{format.functions}
 and print functions\iref{print.fun}.

source/lex.tex

@@ -586,6 +586,9 @@
 or an operator or punctuator.
 
 \pnum
+\indexgrammar{\idxgram{import-keyword}}%
+\indexgrammar{\idxgram{module-keyword}}%
+\indexgrammar{\idxgram{export-keyword}}%
 The \grammarterm{import-keyword} is produced
 by processing an \keyword{import} directive\iref{cpp.import},
 the \grammarterm{module-keyword} is produced

source/meta.tex

@@ -5222,7 +5222,7 @@
 \end{itemdescr}
 
 \begin{itemdecl}
-static consteval access_context @\libmember{via}{access_context}@(info cls) const;
+consteval access_context @\libmember{via}{access_context}@(info cls) const;
 \end{itemdecl}
 
 \begin{itemdescr}
@@ -6281,7 +6281,7 @@
   initialized with \tcode{\{[:$V$:]...\}}.
 \item
   Otherwise, the template parameter object
-  of type \tcode{array<T, 0>}
+  of type \tcode{const array<T, 0>}
   initialized with \tcode{\{\}}.
 \end{itemize}
 

source/numerics.tex

@@ -12793,8 +12793,9 @@
     using offset_policy = conjugated_accessor<NestedAccessor::offset_policy>;
 
     constexpr conjugated_accessor() = default;
+    constexpr conjugated_accessor(const NestedAccessor& acc);
     template<class OtherNestedAccessor>
-      explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>>)
+      explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>)
       constexpr conjugated_accessor(const conjugated_accessor<OtherNestedAccessor>& other);
 
     constexpr reference access(data_handle_type p, size_t i) const;
@@ -12838,7 +12839,7 @@
 \indexlibraryctor{conjugated_accessor}%
 \begin{itemdecl}
 template<class OtherNestedAccessor>
-  explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>>)
+  explicit(!is_convertible_v<OtherNestedAccessor, NestedAccessor>)
     constexpr conjugated_accessor(const conjugated_accessor<OtherNestedAccessor>& other);
 \end{itemdecl}
 

source/threads.tex

@@ -534,10 +534,10 @@
   class stop_source;
 
   // no-shared-stop-state indicator
-  struct nostopstate_t {
+  struct @\libglobal{nostopstate_t}@ {
     explicit nostopstate_t() = default;
   };
-  inline constexpr nostopstate_t nostopstate{};
+  inline constexpr nostopstate_t @\libglobal{nostopstate}@{};
 
   // \ref{stopcallback}, class template \tcode{stop_callback}
   template<class Callback>
@@ -557,7 +557,7 @@
     class inplace_stop_callback;
 
   template<class T, class CallbackFn>
-    using stop_callback_for_t = T::template callback_type<CallbackFn>;
+    using @\libglobal{stop_callback_for_t}@ = T::template callback_type<CallbackFn>;
 }
 \end{codeblock}
 
@@ -835,7 +835,7 @@
   class stop_token {
   public:
     template<class CallbackFn>
-      using callback_type = stop_callback<CallbackFn>;
+      using @\libmember{callback_type}{stop_token}@ = stop_callback<CallbackFn>;
 
     stop_token() noexcept = default;
 
@@ -1043,7 +1043,7 @@
   template<class CallbackFn>
   class stop_callback {
   public:
-    using callback_type = CallbackFn;
+    using @\libmember{callback_type}{stop_callback}@ = CallbackFn;
 
     // \ref{stopcallback.cons}, constructors and destructor
     template<class Initializer>
@@ -1133,6 +1133,7 @@
 It provides a stop token interface,
 but also provides static information
 that a stop is never possible nor requested.
+\indexlibraryglobal{never_stop_token}%
 \begin{codeblock}
 namespace std {
   class never_stop_token {
@@ -1141,10 +1142,10 @@
     };
   public:
     template<class>
-      using callback_type = @\exposid{callback-type}@;
+      using @\libmember{callback_type}{never_stop_token}@ = @\exposid{callback-type}@;
 
-    static constexpr bool stop_requested() noexcept { return false; }
-    static constexpr bool stop_possible() noexcept { return false; }
+    static constexpr bool @\libmember{stop_requested}{never_stop_token}@() noexcept { return false; }
+    static constexpr bool @\libmember{stop_possible}{never_stop_token}@() noexcept { return false; }
 
     bool operator==(const never_stop_token&) const = default;
   };
@@ -1161,12 +1162,13 @@
 It references the stop state of
 its associated \tcode{inplace_stop_source} object\iref{stopsource.inplace},
 if any.
+\indexlibraryglobal{inplace_stop_token}%
 \begin{codeblock}
 namespace std {
   class inplace_stop_token {
   public:
     template<class CallbackFn>
-      using callback_type = inplace_stop_callback<CallbackFn>;
+      using @\libmember{callback_type}{inplace_stop_token}@ = inplace_stop_callback<CallbackFn>;
 
     inplace_stop_token() = default;
     bool operator==(const inplace_stop_token&) const = default;
@@ -1184,6 +1186,7 @@
 
 \rSec3[stoptoken.inplace.mem]{Member functions}
 
+\indexlibrarymember{swap}{inplace_stop_token}%
 \begin{itemdecl}
 void swap(inplace_stop_token& rhs) noexcept;
 \end{itemdecl}
@@ -1194,6 +1197,7 @@
 Exchanges the values of \exposid{stop-source} and \tcode{rhs.\exposid{stop-source}}.
 \end{itemdescr}
 
+\indexlibrarymember{stop_requested}{inplace_stop_token}%
 \begin{itemdecl}
 bool stop_requested() const noexcept;
 \end{itemdecl}
@@ -1215,6 +1219,7 @@
 \end{note}
 \end{itemdescr}
 
+\indexlibrarymember{stop_possible}{inplace_stop_token}%
 \begin{itemdecl}
 stop_possible() const noexcept;
 \end{itemdecl}
@@ -1241,6 +1246,7 @@
 \pnum
 The class \tcode{inplace_stop_source} models \exposconcept{stoppable-source}.
 
+\indexlibraryglobal{inplace_stop_source}%
 \begin{codeblock}
 namespace std {
   class inplace_stop_source {
@@ -1256,7 +1262,7 @@
 
     // \ref{stopsource.inplace.mem}, stop handling
     constexpr inplace_stop_token get_token() const noexcept;
-    static constexpr bool stop_possible() noexcept { return true; }
+    static constexpr bool @\libmember{stop_possible}{inplace_stop_source}@() noexcept { return true; }
     bool stop_requested() const noexcept;
     bool request_stop() noexcept;
   };
@@ -1265,6 +1271,7 @@
 
 \rSec3[stopsource.inplace.cons]{Constructors}
 
+\indexlibraryctor{inplace_stop_source}%
 \begin{itemdecl}
 constexpr inplace_stop_source() noexcept;
 \end{itemdecl}
@@ -1281,6 +1288,7 @@
 
 \rSec3[stopsource.inplace.mem]{Member functions}
 
+\indexlibrarymember{get_token}{inplace_stop_source}%
 \begin{itemdecl}
 constexpr inplace_stop_token get_token() const noexcept;
 \end{itemdecl}
@@ -1292,6 +1300,7 @@
 whose \exposid{stop-source} member is equal to \tcode{this}.
 \end{itemdescr}
 
+\indexlibrarymember{stop_requested}{inplace_stop_source}%
 \begin{itemdecl}
 bool stop_requested() const noexcept;
 \end{itemdecl}
@@ -1303,6 +1312,7 @@
 has received a stop request; otherwise, \tcode{false}.
 \end{itemdescr}
 
+\indexlibrarymember{request_stop}{inplace_stop_source}%
 \begin{itemdecl}
 bool request_stop() noexcept;
 \end{itemdecl}
@@ -1321,12 +1331,13 @@
 
 \rSec3[stopcallback.inplace.general]{General}
 
+\indexlibraryglobal{inplace_stop_callback}%
 \begin{codeblock}
 namespace std {
   template<class CallbackFn>
   class inplace_stop_callback {
   public:
-    using callback_type = CallbackFn;
+    using @\libmember{callback_type}{inplace_stop_callback}@ = CallbackFn;
 
     // \ref{stopcallback.inplace.cons}, constructors and destructor
     template<class Initializer>
@@ -1371,6 +1382,7 @@
 
 \rSec3[stopcallback.inplace.cons]{Constructors and destructor}
 
+\indexlibraryctor{inplace_stop_callback}%
 \begin{itemdecl}
 template<class Initializer>
   explicit inplace_stop_callback(inplace_stop_token st, Initializer&& init)
@@ -1388,6 +1400,7 @@
 and executes a stoppable callback registration\iref{stoptoken.concepts}.
 \end{itemdescr}
 
+\indexlibrarydtor{inplace_stop_callback}%
 \begin{itemdecl}
 ~inplace_stop_callback();
 \end{itemdecl}