CWG1431 DR

"There are a number of places in the Standard that appear to assume
that exceptions are only thrown by throw-expressions. Various other
constructs, such as dynamic_casts, typeid, new-expressions, etc., can
also throw exceptions, so a more general term should be coined and
applied in place of throw-expression wherever necessary."

Author: Stefanus Du Toit

source/basic.tex

@@ -2933,8 +2933,8 @@
 \grammarterm{exception-specification}~(\ref{except.spec})
 fails to allocate storage, it shall return a null pointer. Any other
 allocation function that fails to allocate storage shall indicate
-failure only by throwing an exception of a type that would match a
-handler~(\ref{except.handle}) of type
+failure only by throwing an exception~(\ref{except.throw}) of a type
+that would match a handler~(\ref{except.handle}) of type
 \tcode{std::bad_alloc}~(\ref{bad.alloc}).
 
 \pnum

source/exceptions.tex

@@ -11,9 +11,8 @@
 Exception handling provides a way of transferring control and information
 from a point in the execution of a thread to an exception handler
 associated with a point previously passed by the execution.
-A handler will be invoked only by a
-\grammarterm{throw-expression}
-invoked in code executed in the handler's try block
+A handler will be invoked only by throwing an exception
+in code executed in the handler's try block
 or in functions called from the handler's try block .
 
 \indextext{\idxcode{try}}%
@@ -65,9 +64,7 @@
 \indextext{try block|see{exception handling, try block}}%
 \indextext{handler|see{exception handling, handler}}%
 A \grammarterm{try-block} is a \grammarterm{statement} (Clause~\ref{stmt.stmt}).
-A \grammarterm{throw-expression} is of type \tcode{void}. Code that executes a
-\grammarterm{throw-expression} is said to ``throw an exception;'' code that
-subsequently gets control is called a ``handler.'' \enternote Within this Clause
+A \grammarterm{throw-expression} is of type \tcode{void}. \enternote Within this Clause
 ``try block'' is taken to mean both \grammarterm{try-block} and
 \grammarterm{function-try-block}. \exitnote
 
@@ -199,6 +196,15 @@
 
 \pnum
 Throwing an exception transfers control to a handler.
+\enternote
+An exception can be thrown from one of the following contexts:
+\grammarterm{throw-expression} (see below), allocation
+functions~(\ref{basic.stc.dynamic.allocation}),
+\tcode{dynamic_cast}~(\ref{expr.dynamic.cast}),
+\tcode{typeid}~(\ref{expr.typeid}),
+\grammarterm{new-expression}~(\ref{expr.new}), and standard library
+functions~(\ref{structure.specifications}).
+\exitnote
 An object is passed and the type of that object determines which handlers
 can catch it.
 \enterexample
@@ -255,38 +261,23 @@
 keyword was most recently entered by the thread of control and not yet exited.
 
 \pnum
-A
-\grammarterm{throw-expression}
-copy-initializes~(\ref{dcl.init}) a temporary object,
+Throwing an exception
+copy-initializes~(\ref{dcl.init}, \ref{class.copy}) a temporary object,
 called the
-\indextext{exception handling!exception object}\term{exception object},
-the type of which
-is determined by removing any top-level
-\grammarterm{cv-qualifier}{s}
-from the static type of the operand of
-\tcode{throw}
-and adjusting the type from ``array of
-\tcode{T}''
-or ``function returning
-\tcode{T}''
-to ``pointer to
-\tcode{T}''
-or ``pointer to function
-returning
-\tcode{T}'',
-respectively.
+\indextext{exception handling!exception object}\term{exception object}.
 The temporary is an lvalue and is used to initialize the
 variable named in the matching
 \term{handler}~(\ref{except.handle}).
 If the type of the exception object would
 be an incomplete type or a pointer to an incomplete
 type other than (possibly cv-qualified)
 \tcode{void} the program is ill-formed.
-Except for these restrictions and the restrictions on type matching mentioned
-in~\ref{except.handle}, the operand of
-\tcode{throw}
-is treated exactly as a function argument in a call~(\ref{expr.call}) or the operand
-of a return statement.
+Evaluating a \grammarterm{throw-expression} with an operand throws an
+exception; the type of the exception object is determined by removing
+any top-level \grammarterm{cv-qualifiers} from the static type of the
+operand and adjusting the type from ``array of \tcode{T}'' or ``function
+returning \tcode{T}'' to ``pointer to \tcode{T}'' or ``pointer to function returning
+\tcode{T},'' respectively.
 
 \pnum
 \indextext{exception handling!memory}%
@@ -308,7 +299,7 @@
 The implementation may then
 deallocate the memory for the exception object; any such deallocation
 is done in an unspecified way.
-\enternote an exception thrown by a \grammarterm{throw-expression} does not
+\enternote a thrown exception does not
 propagate to other threads unless caught, stored, and rethrown using
 appropriate library functions; see~\ref{propagation} and~\ref{futures}. \exitnote
 
@@ -358,8 +349,8 @@
 A
 \grammarterm{throw-expression}
 with no operand rethrows the currently handled exception~(\ref{except.handle}).
-The exception is reactivated with the existing temporary;
-no new temporary exception object is created.
+The exception is reactivated with the existing exception object;
+no new exception object is created.
 The exception
 is no longer considered to be caught; therefore, the value
 of
@@ -398,8 +389,7 @@
 \indextext{destructor!exception~handling|see{exception handling, constructors and destructors}}
 
 \pnum
-As control passes from a
-\grammarterm{throw-expression}
+As control passes from the point where an exception is thrown
 to a handler,
 destructors are invoked for all automatic objects constructed since the
 try block was entered.
@@ -427,8 +417,7 @@
 \pnum
 \indextext{unwinding!stack}%
 The process of calling destructors for automatic objects constructed on the
-path from a try block to a
-\grammarterm{throw-expression}
+path from a try block to the point where an exception is thrown
 is called
 ``\term{stack unwinding}.''
 If a destructor called during stack unwinding exits with an exception,
@@ -712,15 +701,11 @@
 within the handler.
 
 \pnum
-When the handler declares a non-constant object,
-any changes to that object will not affect the temporary object
-that was initialized by execution of the
-\grammarterm{throw-expression}.
-When the handler declares a reference to a non-constant object,
+When the handler declares an object,
+any changes to that object will not affect the exception object.
+When the handler declares a reference to an object,
 any changes to the referenced object are changes to the
-temporary object initialized when the
-\grammarterm{throw-expression}
-was executed and will have effect should that object be rethrown.%
+exception object and will have effect should that object be rethrown.%
 \indextext{exception handling!handler!match|)}%
 \indextext{exception handling!handler|)}
 

source/expressions.tex

@@ -1547,7 +1547,8 @@
 \pnum
 The value of a failed cast to pointer type is the null pointer value of
 the required result type. A failed cast to reference type throws
-\tcode{std::bad_cast}~(\ref{bad.cast}).
+an exception~(\ref{except.throw}) of a type that would match a
+handler~(\ref{except.handle}) of type \tcode{std::bad_cast}~(\ref{bad.cast}).
 
 \indextext{\idxcode{bad_cast}}%
 \indexlibrary{\idxcode{bad_cast}}%
@@ -2661,7 +2662,7 @@
 which the number of \grammarterm{initializer-clause}{s} exceeds the number of
 elements to initialize,
 no storage is obtained and the
-\grammarterm{new-expression} terminates by throwing an exception of a type that would
+\grammarterm{new-expression} throws an exception~(\ref{except.throw}) of a type that would
 match a handler~(\ref{except.handle}) of type
 \tcode{std::bad_array_new_length}~(\ref{new.badlength}).
 

source/support.tex

@@ -2755,7 +2755,7 @@
 \remarks
 Called by the implementation when exception
 handling must be abandoned for any of several reasons~(\ref{except.terminate}),
-in effect immediately after evaluating the \grammarterm{throw-expression}~(\ref{terminate.handler}).
+in effect immediately after throwing the exception.
 May also be called directly by the program.
 
 \pnum