expr.* (rest)

Author: jensmaurer

source/expressions.tex

@@ -3066,7 +3066,7 @@
 \end{codeblock}
 \end{example}
 If the function is a non-static member
-function, the \tcode{this} parameter of the function\iref{class.this}
+function, the \tcode{this} parameter of the function\iref{expr.prim.this}
 is initialized with a pointer to the object of the call, converted
 as if by an explicit type conversion\iref{expr.cast}.
 \begin{note}
@@ -3093,7 +3093,7 @@
 The access of the constructor, conversion functions or destructor is
 checked at the point of call in the calling function. If a constructor
 or destructor for a function parameter throws an exception, the search
-for a handler starts in the scope of the calling function; in
+for a handler starts in the calling function; in
 particular, if the function called has a \grammarterm{function-try-block}\iref{except.pre}
 with a handler that could handle the exception,
 this handler is not considered.
@@ -3287,7 +3287,7 @@
 \indextext{arrow operator|see{operator, class member access}}%
 A postfix expression followed by a dot \tcode{.} or an arrow \tcode{->},
 optionally followed by the keyword
-\keyword{template}\iref{temp.names}, and then followed by an
+\keyword{template}, and then followed by an
 \grammarterm{id-expression}, is a postfix expression. The postfix
 expression before the dot or arrow is evaluated;
 \begin{footnote}
@@ -3300,6 +3300,13 @@
 the result of that evaluation, together with the
 \grammarterm{id-expression}, determines the result of the entire postfix
 expression.
+\begin{note}
+If the keyword \keyword{template} is used,
+the following unqualified name
+is considered to refer to a template\iref{temp.names}.
+If a \grammarterm{simple-template-id} results and is followed by a \tcode{::},
+the \grammarterm{id-expression} is a \grammarterm{qualified-id}.
+\end{note}
 
 \pnum
 \indextext{type!incomplete}%
@@ -3332,16 +3339,8 @@
 The class type shall be complete
 unless the class member access appears in the definition of that class.
 \begin{note}
-If the class is incomplete,
-lookup in the complete class type is required to refer
-to the same declaration\iref{basic.scope.class}.
-\end{note}
-The \grammarterm{id-expression} shall name a member of the class or of one of
-its base classes.
-\begin{note}
-Because the name of a class is inserted in its class scope\iref{class},
-the name of a class is also considered a nested
-member of that class.
+The program is ill-formed if the result differs from that
+when the class is complete\iref{class.member.lookup}.
 \end{note}
 \begin{note}
 \ref{basic.lookup.qual} describes how names are looked up after the
@@ -3384,7 +3383,7 @@
 \tcode{mutable} member, then the type of \tcode{E1.E2} is
 ``\cvqual{cq12} \cvqual{vq12} \tcode{T}''.
 
-\item If \tcode{E2} is a (possibly overloaded) member function,
+\item If \tcode{E2} is an overload set,
 function overload resolution\iref{over.match}
 is used to select the function to which \tcode{E2} refers.
 The type of \tcode{E1.E2} is the type of \tcode{E2}
@@ -4360,9 +4359,9 @@
 \pnum
 \indextext{overloaded function!address of}%
 \begin{note}
-The address of an overloaded function\iref{over} can be taken
-only in a context that uniquely determines which version of the
-overloaded function is referred to (see~\ref{over.over}).
+The address of an overload set\iref{over} can be taken
+only in a context that uniquely determines
+which function is referred to (see~\ref{over.over}).
 Since the context might determine whether the operand is a static or
 non-static member function, the context can also affect whether the
 expression has type ``pointer to function'' or ``pointer to member
@@ -4474,7 +4473,7 @@
 An \grammarterm{await-expression} shall not appear in a
 default argument\iref{dcl.fct.default}.
 An \grammarterm{await-expression} shall not appear in the initializer of
-a block-scope variable with static or thread storage duration.
+a block variable with static or thread storage duration.
 A context within a function where an \grammarterm{await-expression} can appear
 is called a \term{suspension context} of the function.
 
@@ -4488,14 +4487,14 @@
 object\iref{dcl.fct.def.coroutine}
 of the enclosing coroutine and \tcode{P} is the type of that object.
 
-\item \placeholder{a} is the \grammarterm{cast-expression} if
+\item Unless
 the \grammarterm{await-expression} was implicitly produced by a
 \grammarterm{yield-expression}\iref{expr.yield}, an initial suspend point,
-or a final suspend point\iref{dcl.fct.def.coroutine}.
-Otherwise, the \grammarterm{unqualified-id} \tcode{await_transform} is
-looked up within the scope of \tcode{P} by class member access
-lookup\iref{basic.lookup.qual},
-and if this lookup finds at least one declaration, then \placeholder{a} is
+or a final suspend point\iref{dcl.fct.def.coroutine},
+a search is performed for the name \tcode{await_transform}
+in the scope of \tcode{P} \iref{class.member.lookup}.
+If this search is performed and finds at least one declaration,
+then \placeholder{a} is
 \mbox{\placeholder{p}\tcode{.await_transform(}\grammarterm{cast-expression}\tcode{)}};
 otherwise, \placeholder{a} is the  \grammarterm{cast-expression}.
 
@@ -5040,13 +5039,14 @@
 
 \pnum
 \indextext{operator!scope resolution}%
-If the \grammarterm{new-expression} begins with a unary \tcode{::}
-operator, the allocation function's name is looked up in the global
-scope. Otherwise, if the allocated type is a class type \tcode{T} or
-array thereof, the allocation function's name is looked up in the scope
-of \tcode{T}. If this lookup fails to find the name, or if the allocated
-type is not a class type, the allocation function's name is looked up in
-the global scope.
+If the \grammarterm{new-expression}
+does not begin with a unary \tcode{::} operator and
+the allocated type is a class type \tcode{T} or array thereof,
+a search is performed for the allocation function's name in the scope
+of \tcode{T}\iref{class.member.lookup}.
+Otherwise, or if nothing is found,
+the allocation function's name is looked up by
+searching for it in the global scope.
 
 \pnum
 An implementation is allowed to omit a call to a replaceable global allocation
@@ -5280,7 +5280,7 @@
 \pnum
 If the \grammarterm{new-expression} creates an object or an array of
 objects of class type, access and ambiguity control are done for the
-allocation function, the deallocation function\iref{class.free}, and
+allocation function, the deallocation function\iref{basic.stc.dynamic.deallocation}, and
 the constructor\iref{class.ctor} selected for the initialization (if any).
 If the \grammarterm{new-expression}
 creates an array of objects of class type, the destructor is potentially
@@ -5307,13 +5307,14 @@
 \end{note}
 
 \pnum
-If the \grammarterm{new-expression} begins with a unary \tcode{::}
-operator, the deallocation function's name is looked up in the global
-scope. Otherwise, if the allocated type is a class type \tcode{T} or an
-array thereof, the deallocation function's name is looked up in the
-scope of \tcode{T}. If this lookup fails to find the name, or if the
-allocated type is not a class type or array thereof, the deallocation
-function's name is looked up in the global scope.
+If the \grammarterm{new-expression} does not begin with
+a unary \tcode{::} operator and
+the allocated type is a class type \tcode{T} or an array thereof,
+a search is performed for the deallocation function's name
+in the scope of \tcode{T}.
+Otherwise, or if nothing is found,
+the deallocation function's name is looked up by
+searching for it in the global scope.
 
 \pnum
 A declaration of a placement deallocation function matches the
@@ -5502,27 +5503,45 @@
 called as described above.
 
 \pnum
+If a deallocation function is called,
+it is \tcode{operator delete} for a single-object delete expression or
+\tcode{operator delete[]} for an array delete expression.
 \begin{note}
-An implementation provides default definitions of the global
-deallocation functions \tcode{operator delete} for
-non-arrays\iref{new.delete.single} and
 \indextext{\idxcode{operator delete}}%
-\tcode{operator delete[]} for arrays\iref{new.delete.array}. A \Cpp{}
-program can provide alternative definitions of these
+An implementation provides default definitions of the global
+deallocation functions (\ref{new.delete.single}, \ref{new.delete.array}).
+A \Cpp{} program can provide alternative definitions of these
 functions\iref{replacement.functions}, and/or class-specific
 versions\iref{class.free}.
 \end{note}
 
 \pnum
-When the keyword \tcode{delete} in a \grammarterm{delete-expression} is
-preceded by the unary \tcode{::} operator, the deallocation function's name is looked
-up in global scope. Otherwise, the lookup considers class-specific deallocation
-functions\iref{class.free}. If no class-specific deallocation function is found,
-the deallocation function's name is looked up in global scope.
+If the keyword \tcode{delete} in a \grammarterm{delete-expression}
+is not preceded by the unary \tcode{::} operator and the type of the operand is
+a pointer to a (possibly cv-qualified) class type \tcode{T}:
+\begin{itemize}
+\item
+If \tcode{T} has a virtual destructor,
+the deallocation function is the one selected at the point of definition of
+the dynamic type's virtual destructor\iref{class.dtor}.
+\item
+Otherwise,
+a search is performed for the deallocation function's name
+in the scope of \tcode{T}.
+\end{itemize}
+Otherwise, or if nothing is found,
+the deallocation function's name is looked up by
+searching for it in the global scope.
+In any case, any declarations
+other than of usual deallocation functions\iref{basic.stc.dynamic.deallocation}
+are discarded.
+\begin{note}
+If only a placement deallocation function is found in a class,
+the program is ill-formed because the lookup set is empty\iref{basic.lookup}.
+\end{note}
 
 \pnum
-If deallocation function lookup finds more than one usual
-deallocation function,
+If more than one deallocation function is found,
 the function to be called is selected as follows:
 \begin{itemize}
 \item
@@ -5539,7 +5558,7 @@
 If exactly one function remains,
 that function is selected and the selection process terminates.
 \item
-If the deallocation functions have class scope,
+If the deallocation functions belong to a class scope,
 the one without a parameter of type \tcode{std::size_t} is selected.
 \item
 If the type is complete
@@ -7433,7 +7452,7 @@
 \pnum
 An expression or conversion is in an \defn{immediate function context}
 if it is potentially evaluated and
-its innermost non-block scope is
+its innermost enclosing non-block scope is
 a function parameter scope of an immediate function.
 An expression or conversion is an \defn{immediate invocation}
 if it is a potentially-evaluated explicit or implicit invocation of
@@ -7525,7 +7544,7 @@
 that is potentially constant evaluated, or
 
 \item
-a variable whose name appears as a potentially constant evaluated expression
+a variable named by a potentially constant evaluated expression
 that is either a constexpr variable or
 is of non-volatile const-qualified integral type or of reference type.
 \end{itemize}