[thread] Fix and add cross-references in header synopses

Author: jensmaurer

source/threads.tex

@@ -1106,13 +1106,15 @@
 #include <compare>              // see \ref{compare.syn}
 
 namespace std {
+  // \ref{thread.thread.class}, class \tcode{thread}
   class thread;
 
   void swap(thread& x, thread& y) noexcept;
 
-  // \ref{thread.jthread.class} class \tcode{jthread}
+  // \ref{thread.jthread.class}, class \tcode{jthread}
   class jthread;
 
+  // \ref{thread.thread.this}, namespace \tcode{this_thread}
   namespace this_thread {
     thread::id get_id() noexcept;
 
@@ -1149,7 +1151,7 @@
 namespace std {
   class thread {
   public:
-    // types
+    // \ref{thread.thread.id}, class \tcode{thread::id}
     class id;
     using native_handle_type = @\impdefnc@;         // see~\ref{thread.req.native}
 
@@ -1162,7 +1164,7 @@
     thread& operator=(const thread&) = delete;
     thread& operator=(thread&&) noexcept;
 
-    // members
+    // \ref{thread.thread.member}, members
     void swap(thread&) noexcept;
     bool joinable() const noexcept;
     void join();
@@ -2044,9 +2046,13 @@
 \indexheader{mutex}%
 \begin{codeblock}
 namespace std {
+  // \ref{thread.mutex.class}, class \tcode{mutex}
   class mutex;
+  // \ref{thread.mutex.recursive}, class \tcode{recursive_mutex}
   class recursive_mutex;
+  // \ref{thread.timedmutex.class} class \tcode{timed_mutex}
   class timed_mutex;
+  // \ref{thread.timedmutex.recursive}, class \tcode{recursive_timed_mutex}
   class recursive_timed_mutex;
 
   struct defer_lock_t { explicit defer_lock_t() = default; };
@@ -2057,13 +2063,15 @@
   inline constexpr try_to_lock_t try_to_lock { };
   inline constexpr adopt_lock_t  adopt_lock { };
 
+  // \ref{thread.lock}, locks
   template<class Mutex> class lock_guard;
   template<class... MutexTypes> class scoped_lock;
   template<class Mutex> class unique_lock;
 
   template<class Mutex>
     void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
 
+  // \ref{thread.lock.algorithm}, generic locking algorithms
   template<class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
   template<class L1, class L2, class... L3> void lock(L1&, L2&, L3&...);
 
@@ -2079,8 +2087,11 @@
 \indexheader{shared_mutex}%
 \begin{codeblock}
 namespace std {
+  // \ref{thread.sharedmutex.class}, class \tcode{shared_mutex}
   class shared_mutex;
+  // \ref{thread.sharedtimedmutex.class}, class \tcode{shared_timed_mutex}
   class shared_timed_mutex;
+  // \ref{thread.lock.shared}, class template \tcode{shared_lock}
   template<class Mutex> class shared_lock;
   template<class Mutex>
     void swap(shared_lock<Mutex>& x, shared_lock<Mutex>& y) noexcept;
@@ -4313,9 +4324,12 @@
 \indexlibraryglobal{cv_status}%
 \begin{codeblock}
 namespace std {
+  // \ref{thread.condition.condvar}, class \tcode{condition_variable}
   class condition_variable;
+  // \ref{thread.condition.condvarany}, class \tcode{condition_variable_any}
   class condition_variable_any;
 
+  // \ref{thread.condition.nonmember}, non-member functions
   void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
 
   enum class cv_status { no_timeout, timeout };
@@ -5246,6 +5260,7 @@
 \indexheader{semaphore}%
 \begin{codeblock}
 namespace std {
+  // \ref{thread.sema.cnt}, class template \tcode{counting_semaphore}
   template<ptrdiff_t least_max_value = @\impdef@>
     class counting_semaphore;
 
@@ -5955,14 +5970,17 @@
     deferred
   };
 
+  // \ref{futures.errors}, error handling
   template<> struct is_error_code_enum<future_errc> : public true_type { };
   error_code make_error_code(future_errc e) noexcept;
   error_condition make_error_condition(future_errc e) noexcept;
 
   const error_category& future_category() noexcept;
 
+  // \ref{futures.future.error}, class \tcode{future_error}
   class future_error;
 
+  // \ref{futures.promise}, class template \tcode{promise}
   template<class R> class promise;
   template<class R> class promise<R&>;
   template<> class promise<void>;
@@ -5973,21 +5991,25 @@
   template<class R, class Alloc>
     struct uses_allocator<promise<R>, Alloc>;
 
+  // \ref{futures.unique.future}, class template \tcode{future}
   template<class R> class future;
   template<class R> class future<R&>;
   template<> class future<void>;
 
+  // \ref{futures.shared.future}, class template \tcode{shared_future}
   template<class R> class shared_future;
   template<class R> class shared_future<R&>;
   template<> class shared_future<void>;
 
+  // \ref{futures.task}, class template \tcode{packaged_task}
   template<class> class packaged_task;  // \notdef
   template<class R, class... ArgTypes>
     class packaged_task<R(ArgTypes...)>;
 
   template<class R, class... ArgTypes>
     void swap(packaged_task<R(ArgTypes...)>&, packaged_task<R(ArgTypes...)>&) noexcept;
 
+  // \ref{futures.async}, function template \tcode{async}
   template<class F, class... Args>
     [[nodiscard]] future<invoke_result_t<decay_t<F>, decay_t<Args>...>>
       async(F&& f, Args&&... args);