Merge branch 'master' into b32

Author: zygoloid

source/basic.tex

@@ -54,7 +54,7 @@
 an object. The variable's name, if any, denotes the reference or object.
 
 \pnum
-A \defn{local entity} is a variable with
+A \defnadj{local}{entity} is a variable with
 automatic storage duration\iref{basic.stc.auto},
 a structured binding\iref{dcl.struct.bind}
 whose corresponding variable is such an entity,
@@ -216,7 +216,7 @@
 \begin{note}
 \indextext{implementation-generated}%
 In some circumstances, \Cpp{} implementations implicitly define the
-default constructor\iref{class.ctor},
+default constructor\iref{class.default.ctor},
 copy constructor, move constructor\iref{class.copy.ctor},
 copy assignment operator, move assignment operator\iref{class.copy.assign},
 or destructor\iref{class.dtor} member functions.
@@ -357,8 +357,9 @@
 A variable \tcode{x} whose name appears as a
 potentially-evaluated expression \tcode{ex} is \defnx{odr-used}{odr-use} by \tcode{ex} unless
 applying the lvalue-to-rvalue conversion\iref{conv.lval} to \tcode{x} yields
-a constant expression\iref{expr.const} that does not invoke any non-trivial
-functions
+a constant expression\iref{expr.const}
+that does not invoke a function
+other than a trivial special member function\iref{special}
 and, if \tcode{x} is an object, \tcode{ex} is an element of
 the set of potential results of an expression \tcode{e}, where either the lvalue-to-rvalue
 conversion\iref{conv.lval} is applied to \tcode{e}, or \tcode{e} is
@@ -412,8 +413,8 @@
 within the innermost enclosing class or non-lambda function definition scope),
 either:
 \begin{itemize}
-\item the declarative region is a block scope, or
-\item the declarative region is the function parameter scope of a \grammarterm{lambda-expression}
+\item the intervening declarative region is a block scope, or
+\item the intervening declarative region is the function parameter scope of a \grammarterm{lambda-expression}
 that has a \grammarterm{simple-capture} naming the entity or has a \grammarterm{capture-default}.
 \end{itemize}
 \end{itemize}
@@ -440,8 +441,8 @@
 outside of a discarded statement\iref{stmt.if}; no diagnostic required.
 The definition can appear explicitly in the program, it can be found in
 the standard or a user-defined library, or (when appropriate) it is
-implicitly defined (see~\ref{class.ctor}, \ref{class.dtor},
-\ref{class.copy.ctor}, and \ref{class.copy.assign}).
+implicitly defined (see~\ref{class.default.ctor}, \ref{class.copy.ctor},
+\ref{class.dtor}, and \ref{class.copy.assign}).
 An inline function or variable shall be defined in every
 translation unit in which it is odr-used outside of a discarded statement.
 
@@ -561,7 +562,8 @@
 and violation continuation mode; and
 
 \item if \tcode{D} is a class with an implicitly-declared
-constructor\iref{class.ctor}, it is as if the constructor was
+constructor (\ref{class.default.ctor}, \ref{class.copy.ctor}),
+it is as if the constructor was
 implicitly defined in every translation unit where it is odr-used, and the
 implicit definition in every translation unit shall call the same
 constructor for a subobject of \tcode{D}.
@@ -972,17 +974,14 @@
 namespace in a \grammarterm{using-directive}; see~\ref{namespace.qual}.
 
 \pnum
-\indextext{scope!global namespace}%
-\indextext{scope!global}%
 The outermost declarative region of a translation unit is also a
-namespace, called the \defn{global namespace}. A name declared in
-the global namespace has \defn{global namespace scope} (also called
-\defn{global scope}). The potential scope of such a name begins at
+namespace, called the \defnadj{global}{namespace}. A name declared in
+the global namespace has \defnadj{global}{namespace scope} (also called
+\defnadj{global}{scope}). The potential scope of such a name begins at
 its point of declaration\iref{basic.scope.pdecl} and ends at the end
 of the translation unit that is its declarative region.
-\indextext{name!global}%
 A name with global namespace scope is said to be a
-\defnx{global name}{global}.
+\defnadj{global}{name}.
 
 \rSec2[basic.scope.class]{Class scope}
 \indextext{scope!class}%
@@ -2588,7 +2587,7 @@
 width. \end{note}
 
 \pnum
-\begin{example} A structure declared as
+\begin{example} A class declared as
 
 \begin{codeblock}
 struct {
@@ -2840,8 +2839,8 @@
 \indextext{object lifetime|(}%
 The \defn{lifetime} of an object or reference is a runtime property of the
 object or reference.
-An object is said to have \defnx{non-vacuous initialization}{initialization!non-vacuous} if it is of a class or
-aggregate type and it or one of its subobjects is initialized by a constructor
+An object is said to have \defnadj{non-vacuous}{initialization} if it is of a class or
+array type and it or one of its subobjects is initialized by a constructor
 other than a trivial default constructor. \begin{note} Initialization by a
 trivial copy/move constructor is non-vacuous initialization. \end{note}
 The lifetime of an object of type \tcode{T} begins when:
@@ -3167,9 +3166,9 @@
 \rSec3[basic.stc.thread]{Thread storage duration}
 
 \pnum
-\indextext{storage duration!thread}%
-All variables declared with the \tcode{thread_local} keyword have \defn{thread
-storage duration}. The storage for these entities shall last for the duration of
+All variables declared with the \tcode{thread_local} keyword have
+\defnadj{thread}{storage duration}.
+The storage for these entities shall last for the duration of
 the thread in which they are created. There is a distinct object or reference
 per thread, and use of the declared name refers to the entity associated with
 the current thread.
@@ -3181,11 +3180,10 @@
 \rSec3[basic.stc.auto]{Automatic storage duration}
 
 \pnum
-\indextext{storage duration!automatic}%
 \indextext{storage duration!local object}%
 Block-scope variables
 not explicitly declared \tcode{static}, \tcode{thread_local}, or \tcode{extern} have
-\defn{automatic storage duration}. The storage
+\defnadj{automatic}{storage duration}. The storage
 for these entities lasts until the block in which they are created exits.
 
 \pnum
@@ -3365,7 +3363,7 @@
 
 \pnum
 A deallocation function
-is a \defn{destroying operator delete}
+is a \defnadj{destroying}{operator delete}
 if it has at least two parameters
 and its second parameter
 is of type \tcode{std::destroying_delete_t}.
@@ -3558,7 +3556,7 @@
 greater than \tcode{alignof(std::max_align_t)}. It is \impldef{support for extended alignments}
 whether any extended alignments are supported and the contexts in which they are
 supported\iref{dcl.align}. A type having an extended alignment
-requirement is an \defnx{over-aligned type}{type!over-aligned}. \begin{note}
+requirement is an \defnadj{over-aligned}{type}. \begin{note}
 Every over-aligned type is or contains a class type
 to which extended alignment applies (possibly through a non-static data member).
 \end{note}
@@ -3617,7 +3615,7 @@
 Temporary objects are created
 \begin{itemize}
 \item
-when a prvalue is materialized so that it can be used as a glvalue\iref{conv.rval},
+when a prvalue is converted to an xvalue\iref{conv.rval},
 \item
 when needed by the implementation to pass or return an object of trivially-copyable type (see below),
 and
@@ -3731,7 +3729,7 @@
 \indextext{temporary!destructor for}%
 \indextext{temporary!destruction of}%
 When an implementation introduces a temporary object of a class that has a
-non-trivial constructor~(\ref{class.ctor}, \ref{class.copy.ctor}),
+non-trivial constructor~(\ref{class.default.ctor}, \ref{class.copy.ctor}),
 it shall ensure that a constructor is called for the temporary object.
 Similarly, the destructor shall be called for a temporary with a non-trivial
 destructor\iref{class.dtor}.
@@ -4053,7 +4051,7 @@
 A class that has been declared but not defined, an enumeration type in certain
 contexts\iref{dcl.enum}, or an array of unknown
 bound or of incomplete element type, is an
-\defnx{incompletely-defined object type}{object type!incompletely-defined}.%
+\defnadj{incompletely-defined}{object type}.%
 \footnote{The size and layout of an instance of an incompletely-defined
 object type is unknown.}
 Incompletely-defined object types and \cv{}~\tcode{void} are
@@ -4123,7 +4121,7 @@
 cv-qualified\iref{basic.type.qualifier} versions of these
 types are collectively called
 \defnx{scalar types}{scalar type}.
-Cv-unqualified scalar types, trivially copyable class types\iref{class.prop},
+Scalar types, trivially copyable class types\iref{class.prop},
 arrays of such types, and cv-qualified versions of these
 types are collectively called \defn{trivially copyable types}.
 Scalar types, trivial class types\iref{class.prop},
@@ -4450,7 +4448,7 @@
 \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};
+\defnadj{enumerated}{type}, \ref{dcl.enum};
 
 \item \indextext{member pointer to|see{pointer to member}}%
 \defnx{pointers to non-static class members}{pointer to member},%
@@ -4579,7 +4577,7 @@
 \indextext{\idxcode{const}}%
 \indextext{\idxcode{volatile}}%
 A type mentioned in~\ref{basic.fundamental} and~\ref{basic.compound} is
-a \defnx{cv-unqualified type}{type!cv-unqualified}. Each type which is a
+a \defnadj{cv-unqualified}{type}. Each type which is a
 cv-unqualified complete or incomplete object type or is
 \tcode{void}\iref{basic.types} has three corresponding cv-qualified
 versions of its type: a \defn{const-qualified} version, a
@@ -4591,14 +4589,14 @@
 \grammarterm{type-id}\iref{dcl.name}, or
 \grammarterm{new-type-id}\iref{expr.new} when the object is created.
 \begin{itemize}
-\item A \defnx{const object}{object!const} is an object of type \tcode{const T} or a
+\item A \defnadj{const}{object} is an object of type \tcode{const T} or a
   non-mutable subobject of such an object.
 
-\item A \defnx{volatile object}{object!volatile} is an object of type
+\item A \defnadj{volatile}{object} is an object of type
   \tcode{volatile T}, a subobject of such an object, or a mutable
   subobject of a const volatile object.
 
-\item A \defnx{const volatile object}{object!const volatile} is an object of type
+\item A \defnadj{const volatile}{object} is an object of type
   \tcode{const volatile T}, a non-mutable subobject of such an object,
   a const subobject of a volatile object, or a non-mutable volatile
   subobject of a const object.
@@ -5212,7 +5210,7 @@
 \end{note}
 
 \pnum
-A \defnx{visible side effect}{side effects!visible} \placeholder{A} on a scalar object or bit-field \placeholder{M}
+A \defnadj{visible}{side effect} \placeholder{A} on a scalar object or bit-field \placeholder{M}
 with respect to a value computation \placeholder{B} of \placeholder{M} satisfies the
 conditions:
 \begin{itemize}