[everywhere] Consistently prevent linebreaks before a parenthesized \ref.

Author: zygoloid

source/algorithms.tex

@@ -3380,7 +3380,7 @@
 \tcode{Distance} shall be an integer type.
 \item
 \tcode{remove_reference_t<UniformRandomBitGenerator>}
-shall meet the requirements of a uniform random bit generator type (\ref{rand.req.urng})
+shall meet the requirements of a uniform random bit generator type~(\ref{rand.req.urng})
 whose return type is convertible to \tcode{Distance}.
 \item
 \tcode{out} shall not be in the range \range{first}{last}.

source/basic.tex

@@ -121,7 +121,7 @@
 \item
 \indextext{declaration!static member@\tcode{static} member}%
 it declares a non-inline static data member in a class
-definition (\ref{class.mem},~\ref{class.static}),
+definition~(\ref{class.mem}, \ref{class.static}),
 \item
 it declares a static data member outside a class definition
 and the variable was defined within the class with the \tcode{constexpr}
@@ -314,7 +314,7 @@
 \pnum
 A variable \tcode{x} whose name appears as a
 potentially-evaluated expression \tcode{ex} is \defn{odr-used} by \tcode{ex} unless
-applying the lvalue-to-rvalue conversion (\ref{conv.lval}) to \tcode{x} yields
+applying the lvalue-to-rvalue conversion~(\ref{conv.lval}) to \tcode{x} yields
 a constant expression~(\ref{expr.const}) that does not invoke any non-trivial
 functions
 and, if \tcode{x} is an object, \tcode{ex} is an element of
@@ -1091,7 +1091,7 @@
 \pnum
 The name lookup rules apply uniformly to all names (including
 \grammarterm{typedef-name}{s}~(\ref{dcl.typedef}),
-\grammarterm{namespace-name}{s} (\ref{basic.namespace}), and
+\grammarterm{namespace-name}{s}~(\ref{basic.namespace}), and
 \grammarterm{class-name}{s}~(\ref{class.name})) wherever the grammar allows
 such names in the context discussed by a particular rule. Name lookup
 associates the use of a name with a set of declarations~(\ref{basic.def}) of
@@ -2508,7 +2508,7 @@
 \indextext{termination!program}%
 Terminating the program
 without leaving the current block (e.g., by calling the function
-\tcode{std::exit(int)} (\ref{support.start.term})) does not destroy any
+\tcode{std::exit(int)}~(\ref{support.start.term})) does not destroy any
 objects with automatic storage duration~(\ref{class.dtor}). If
 \tcode{std::exit} is called to end a program during the destruction of
 an object with static or thread storage duration, the program has undefined
@@ -2673,7 +2673,7 @@
 \footnote{A non-local variable with static storage duration
 having initialization
 with side effects is initialized in this case,
-even if it is not itself odr-used (\ref{basic.def.odr},~\ref{basic.stc.static}).}
+even if it is not itself odr-used~(\ref{basic.def.odr}, \ref{basic.stc.static}).}
 It is \impldef{threads and program points at which deferred dynamic initialization is performed}
 in which threads and at which points in the program such deferred dynamic initialization occurs.
 \begin{note}
@@ -2804,7 +2804,7 @@
 \indexlibrary{\idxcode{atexit}}%
 If the completion of the initialization of an object with static storage
 duration strongly happens before a call to \tcode{std::atexit}~(see
-\tcode{<cstdlib>},~\ref{support.start.term}), the call to the function passed to
+\tcode{<cstdlib>}, \ref{support.start.term}), the call to the function passed to
 \tcode{std::atexit} is sequenced before the call to the destructor for the object. If a
 call to \tcode{std::atexit} strongly happens before the completion of the initialization of
 an object with static storage duration, the call to the destructor for the
@@ -3117,7 +3117,7 @@
 \footnote{The global \tcode{operator delete(void*, std::size_t)}
 precludes use of an
 allocation function \tcode{void operator new(std::size_t, std::size_t)} as a placement
-allocation function (\ref{diff.cpp11.basic}).}; or
+allocation function~(\ref{diff.cpp11.basic}).}; or
 \item
 exactly three parameters,
 the type of the second being \tcode{std::size_t}
@@ -3182,7 +3182,7 @@
 value;
 
 \item the result of a well-defined pointer
-conversion~(\ref{conv.ptr},~\ref{expr.cast}) of a safely-derived pointer value;
+conversion~(\ref{conv.ptr}, \ref{expr.cast}) of a safely-derived pointer value;
 
 \item the result of a \tcode{reinterpret_cast} of a safely-derived pointer value;
 
@@ -3511,9 +3511,9 @@
 impose requirements on implementations regarding the representation
 of types.
 There are two kinds of types: fundamental types and compound types.
-Types describe objects (\ref{intro.object}),
-references (\ref{dcl.ref}),
-or functions (\ref{dcl.fct}).
+Types describe objects~(\ref{intro.object}),
+references~(\ref{dcl.ref}),
+or functions~(\ref{dcl.fct}).
 \end{note}
 
 \pnum
@@ -3952,19 +3952,19 @@
 \indextext{type!compound}%
 Compound types can be constructed in the following ways:
 \begin{itemize}
-\item \defnx{arrays}{type!array} of objects of a given type,~\ref{dcl.array};
+\item \defnx{arrays}{type!array} of objects of a given type, \ref{dcl.array};
 
 \item \defnx{functions}{type!function}, which have parameters of given types and return
-\tcode{void} or references or objects of a given type,~\ref{dcl.fct};
+\tcode{void} or references or objects of a given type, \ref{dcl.fct};
 
 \item \defnx{pointers}{type!pointer} to \cv{}~\tcode{void} or objects or functions (including
-static members of classes) of a given type,~\ref{dcl.ptr};
+static members of classes) of a given type, \ref{dcl.ptr};
 
 \item %
 \indextext{reference!lvalue}%
 \indextext{reference!rvalue}%
 \defnx{references}{reference} to objects or functions of a given
-type,~\ref{dcl.ref}. There are two types of references:
+type, \ref{dcl.ref}. There are two types of references:
 \begin{itemize}
 \item \defn{lvalue reference}
 \item \defn{rvalue reference}
@@ -3978,19 +3978,19 @@
 
 \item
 \defnx{unions}{\idxcode{union}}, which are classes capable of containing objects of
-different types at different times,~\ref{class.union};
+different types at different times, \ref{class.union};
 
 \item
 \defnx{enumerations}{\idxcode{enum}}, which comprise a set of named constant values.
 Each distinct enumeration constitutes a different
-\defnx{enumerated type}{type!enumerated},~\ref{dcl.enum};
+\defnx{enumerated type}{type!enumerated}, \ref{dcl.enum};
 
 \item \indextext{member pointer to|see{pointer to member}}%
 \defnx{pointers to non-static class members}{pointer to member},%
 \footnote{Static class members are objects or functions, and pointers to them are
 ordinary pointers to objects or functions.}
 which identify members of a given
-type within objects of a given class,~\ref{dcl.mptr}.
+type within objects of a given class, \ref{dcl.mptr}.
 \end{itemize}
 
 \pnum
@@ -4021,9 +4021,9 @@
 \item
 a \defn{pointer to} an object or function (the pointer is said to \defn{point} to the object or function), or
 \item
-a \defn{pointer past the end of} an object (\ref{expr.add}), or
+a \defn{pointer past the end of} an object~(\ref{expr.add}), or
 \item
-the \defn{null pointer value} (\ref{conv.ptr}) for that type, or
+the \defn{null pointer value}~(\ref{conv.ptr}) for that type, or
 \item
 an \defn{invalid pointer value}.
 \end{itemize}
@@ -4343,7 +4343,7 @@
 \rSec1[basic.align]{Alignment}
 
 \pnum
-Object types have \defnx{alignment requirements}{alignment requirement!implementation-defined} (\ref{basic.fundamental},~\ref{basic.compound})
+Object types have \defnx{alignment requirements}{alignment requirement!implementation-defined}~(\ref{basic.fundamental}, \ref{basic.compound})
 which place restrictions on the addresses at which an object of that type
 may be allocated. An \defn{alignment} is an \impldef{alignment}
 integer value representing the number of bytes between successive addresses

source/classes.tex

@@ -526,7 +526,7 @@
 A \defn{data member} is a non-function member introduced by a
 \grammarterm{member-declarator}.
 A \defn{member function} is a member that is a function.
-Nested types are classes~(\ref{class.name},~\ref{class.nest}) and
+Nested types are classes~(\ref{class.name}, \ref{class.nest}) and
 enumerations~(\ref{dcl.enum}) declared in the class and arbitrary types
 declared as members by use of a typedef declaration~(\ref{dcl.typedef})
 or \grammarterm{alias-declaration}.
@@ -802,7 +802,7 @@
 \end{example}
 \begin{note}
 Reading a volatile object through a non-volatile glvalue has
-undefined behavior (\ref{dcl.type.cv}).
+undefined behavior~(\ref{dcl.type.cv}).
 \end{note}
 
 \pnum
@@ -930,9 +930,9 @@
 A non-static member function may be called for an object of
 its class type, or for an object of a class derived
 (Clause~\ref{class.derived}) from its class type, using the class member
-access syntax~(\ref{expr.ref},~\ref{over.match.call}). A non-static
+access syntax~(\ref{expr.ref}, \ref{over.match.call}). A non-static
 member function may also be called directly using the function call
-syntax~(\ref{expr.call},~\ref{over.match.call}) from within
+syntax~(\ref{expr.call}, \ref{over.match.call}) from within
 the body of a member function of its class or of a class derived from
 its class.
 
@@ -1649,7 +1649,7 @@
 struct X { const int a; int b; };
 union Y { X x; int k; };
 void g() {
-  Y y = { { 1, 2 } };   // OK, \tcode{y.x} is active union member (\ref{class.mem})
+  Y y = { { 1, 2 } };   // OK, \tcode{y.x} is active union member~(\ref{class.mem})
   int n = y.x.a;
   y.k = 4;              // OK: ends lifetime of \tcode{y.x}, \tcode{y.k} is active member of union
   y.x.b = n;            // undefined behavior: \tcode{y.x.b} modified outside its lifetime,

source/compatibility.tex

@@ -1412,8 +1412,8 @@
 \ref{expr.cond}
 \change A conditional expression with a throw expression as its second or third
 operand keeps the type and value category of the other operand.
-\rationale Formerly mandated conversions (lvalue-to-rvalue (\ref{conv.lval}),
-array-to-pointer (\ref{conv.array}), and function-to-pointer (\ref{conv.func})
+\rationale Formerly mandated conversions (lvalue-to-rvalue~(\ref{conv.lval}),
+array-to-pointer~(\ref{conv.array}), and function-to-pointer~(\ref{conv.func})
 standard conversions), especially the creation of the temporary due to
 lvalue-to-rvalue conversion, were considered gratuitous and surprising.
 \effect Valid \CppXI code that relies on the conversions may behave differently
@@ -1818,7 +1818,7 @@
 The \tcode{requires} keyword is added
 to introduce constraints through a \grammarterm{requires-clause} or
 a \grammarterm{requires-expression}. The \tcode{concept} keyword is
-added to enable the definition of concepts (\ref{temp.concept}).
+added to enable the definition of concepts~(\ref{temp.concept}).
 \effect
 Valid ISO \CppXVII code using \tcode{concept} or \tcode{requires}
 as an identifier is not valid in this International Standard.
@@ -1848,8 +1848,8 @@
 nor are the C headers themselves part of \Cpp.
 
 \pnum
-The \Cpp headers \tcode{<ccomplex>}\indextext{\idxhdr{ccomplex}} (\ref{depr.ccomplex.syn})
-and \tcode{<ctgmath>}\indextext{\idxhdr{ctgmath}} (\ref{depr.ctgmath.syn}), as well
+The \Cpp headers \tcode{<ccomplex>}\indextext{\idxhdr{ccomplex}}~(\ref{depr.ccomplex.syn})
+and \tcode{<ctgmath>}\indextext{\idxhdr{ctgmath}}~(\ref{depr.ctgmath.syn}), as well
 as their corresponding C headers \tcode{<complex.h>}\indextext{\idxhdr{complex.h}}
 and \tcode{<tgmath.h>}\indextext{\idxhdr{tgmath.h}}, do not contain any of the
 content from the C standard library and instead merely include other headers
@@ -1869,7 +1869,7 @@
 The types \tcode{char16_t} and \tcode{char32_t}
 are distinct types rather than typedefs to existing integral types.
 The tokens \tcode{char16_t} and \tcode{char32_t}
-are keywords in this International Standard (\ref{lex.key}).
+are keywords in this International Standard~(\ref{lex.key}).
 They do not appear as macro names defined in
 \tcode{<cuchar>}\indexlibrary{\idxhdr{cuchar}}~(\ref{cuchar.syn}).
 
@@ -1879,7 +1879,7 @@
 The type \tcode{wchar_t} is a distinct type rather than a typedef to an
 existing integral type.
 The token \tcode{wchar_t}
-is a keyword in this International Standard (\ref{lex.key}).
+is a keyword in this International Standard~(\ref{lex.key}).
 It does not appear as a type name defined in any of
 \tcode{<cstddef>}~(\ref{cstddef.syn})\indexlibrary{\idxhdr{cstddef}},
 \tcode{<cstdlib>}~(\ref{cstdlib.syn})\indexlibrary{\idxhdr{cstdlib}},
@@ -1890,7 +1890,7 @@
 
 \pnum
 The token \tcode{static_assert} is a keyword in this International
-Standard (\ref{lex.key}). It does not appear as a macro name defined
+Standard~(\ref{lex.key}). It does not appear as a macro name defined
 in \tcode{<cassert>}\indexlibrary{\idxhdr{cassert}}~(\ref{cassert.syn}).
 
 \rSec3[diff.header.iso646.h]{Header \tcode{<iso646.h>}}
@@ -1911,7 +1911,7 @@
 and
 \tcode{xor_eq}
 are keywords in this International
-Standard (\ref{lex.key}).
+Standard~(\ref{lex.key}).
 They do not appear as macro names defined in
 \tcode{<ciso646>}.
 \indexlibrary{\idxhdr{ciso646}}%
@@ -1921,15 +1921,15 @@
 
 \pnum
 The token \tcode{alignas} is a keyword in this International
-Standard (\ref{lex.key}). It does not appear as a macro name defined
+Standard~(\ref{lex.key}). It does not appear as a macro name defined
 in \tcode{<cstdalign>}\indexlibrary{\idxhdr{cstdalign}}~(\ref{depr.cstdalign.syn}).
 
 \rSec3[diff.header.stdbool.h]{Header \tcode{<stdbool.h>}}
 \indexlibrary{\idxhdr{stdbool.h}}%
 
 \pnum
 The tokens \tcode{bool}, \tcode{true}, and \tcode{false}
-are keywords in this International Standard (\ref{lex.key}).
+are keywords in this International Standard~(\ref{lex.key}).
 They do not appear as macro names defined in
 \tcode{<cstdbool>}\indexlibrary{\idxhdr{cstdbool}}~(\ref{depr.cstdbool.syn}).
 
@@ -1942,12 +1942,12 @@
 \tcode{<clocale>}~(\ref{c.locales})\indexlibrary{\idxhdr{clocale}},
 \tcode{<cstddef>}~(\ref{cstddef.syn})\indexlibrary{\idxhdr{cstddef}},
 \tcode{<cstdio>}~(\ref{cstdio.syn})\indexlibrary{\idxhdr{cstdio}},
-\tcode{<cstdlib>} (\ref{cstdlib.syn})\indexlibrary{\idxhdr{cstdlib}},
+\tcode{<cstdlib>}~(\ref{cstdlib.syn})\indexlibrary{\idxhdr{cstdlib}},
 \tcode{<cstring>}~(\ref{cstring.syn})\indexlibrary{\idxhdr{cstring}},
 \tcode{<ctime>}~(\ref{ctime.syn})\indexlibrary{\idxhdr{ctime}},
 or \tcode{<cwchar>}~(\ref{cwchar.syn})\indexlibrary{\idxhdr{cwchar}},
 is an \impldef{definition of \tcode{NULL}} \Cpp null pointer constant in
-this International Standard (\ref{support.types}).
+this International Standard~(\ref{support.types}).
 
 \rSec2[diff.mods.to.declarations]{Modifications to declarations}
 

source/containers.tex

@@ -3372,7 +3372,7 @@
 A
 \indexlibrary{\idxcode{deque}}%
 \tcode{deque}
-is a sequence container that supports random access iterators (\ref{random.access.iterators}).
+is a sequence container that supports random access iterators~(\ref{random.access.iterators}).
 In addition, it supports constant time insert and erase operations at the beginning or the end;
 insert and erase in the middle take linear time.
 That is, a deque is especially optimized for pushing and popping elements at the beginning and end.

source/conversions.tex

@@ -54,7 +54,7 @@
 includes use as an argument in a function call and use as the expression
 in a \tcode{return} statement). The type of the entity being initialized
 is (generally) the destination type.
-See~\ref{dcl.init},~\ref{dcl.init.ref}.
+See~\ref{dcl.init}, \ref{dcl.init.ref}.
 \end{itemize}
 \end{note}
 
@@ -327,7 +327,7 @@
 \pnum
 \begin{note}
 Function types (including those used in pointer to member function
-types) are never cv-qualified (\ref{dcl.fct}).
+types) are never cv-qualified~(\ref{dcl.fct}).
 \end{note}
 \indextext{conversion!qualification|)}
 

source/declarations.tex

@@ -235,7 +235,7 @@
 \begin{note}
 A \grammarterm{nodeclspec-function-declaration} can only be used in a
 \grammarterm{template-declaration}~(Clause~\ref{temp}),
-\grammarterm{explicit-instantiation} (\ref{temp.explicit}), or
+\grammarterm{explicit-instantiation}~(\ref{temp.explicit}), or
 \grammarterm{explicit-specialization}~(\ref{temp.expl.spec}).
 \end{note}
 
@@ -970,7 +970,7 @@
 \pnum
 \indextext{specifier!\idxcode{inline}}%
 \indextext{inline function}%
-A function declaration~(\ref{dcl.fct},~\ref{class.mfct},
+A function declaration~(\ref{dcl.fct}, \ref{class.mfct},
 \ref{class.friend}) with an \tcode{inline} specifier declares an
 \term{inline function}. The inline specifier indicates to
 the implementation that inline substitution of the function body at the
@@ -1546,9 +1546,9 @@
 from an initializer. The \tcode{auto}
 \grammarterm{type-specifier} is also used to
 introduce a function type having a \grammarterm{trailing-return-type} or to
-signify that a lambda is a generic lambda (\ref{expr.prim.lambda}).
+signify that a lambda is a generic lambda~(\ref{expr.prim.lambda}).
 The \tcode{auto} \grammarterm{type-specifier} is also used to introduce a
-structured binding declaration (\ref{dcl.struct.bind}).
+structured binding declaration~(\ref{dcl.struct.bind}).
 
 \pnum
 The placeholder type can appear with a function declarator in the