N4533: Make exception specifications be part of the type system, version 3

Introduction

The exception specification of a function was never considered a part of its type. Instead, 15.4 [except.spec] paragraphs 5 and 6 only restrict assignments and initializations of pointers and references to (member) functions. This leads to odd holes in the type system that have resulted in a number of core issues.

    void (*p)() throw(int);
    void (**pp)() throw() = &p;   // not currently an error

This issue was closed as NAD in February 2014, because "EWG determined that no action should be taken on this issue" (quote from the core issues list). Little technical argument seems to have been presented; closing the issue was rather seen as warding off work.

Core issue 1946 "exception-specifications vs pointer dereference" highlighted that clarifications for determining potential exceptions of an expression brought forward for core issue 1351 caused this example to be ill-formed, which was arguably well-formed under the earlier imprecise wording:

  void (*p)() throw(int);
  void (&r)() throw(int) = *p;  // ill-formed

  template<typename T> T& f(T* p);
  void (*p)() throw(int);
  void (&r)() throw(int) = f(p);  // ill-formed

Core issue 2010 "exception-specifications and conversion operators" adds these examples:

  struct S { typedef void (*p)(); operator p(); };
  void (*q)() noexcept = S();

  void (*r)() noexcept = []() noexcept {};

The recent work on a specification for transactional memory support (see N4265 "Transactional Memory Support for C++: Wording (revision 3)") required integrating the transaction_safe specifier into the types of functions, among other things considering it for implicit conversions and overload resolution. This paper clones that approach to integrate the presence or absence of a non-throwing exception-specification (called noexcept) into the types of functions, too.

The predecessor paper N4518 was presented to the WG21 plenary in Lenexa, but straw polls were postponed to the following meeting to give all interested parties a chance to review the effects, in particular on existing code.

Changes compared to N4518

• Fix 14.8.2.3 [temp.deduct.conv] and consider pointer to member function, too (thanks to Stephan T. Lavavej)

Changes compared to N4320

• Review by the Evolution and Core Working Groups during the Lenexa meeting of WG21 (May 2015)

Feature-test macro

Wording

Clause 4 [conv]

An lvalue of function type T can be converted to a prvalue of type "pointer to T". The result is a pointer to the function. [ Footnote: ... ]

4.12 [conv.fctptr] Function pointer conversions

A prvalue of type "pointer to noexcept function" can be converted to a prvalue of type "pointer to function". The result is a pointer to the function. A prvalue of type "pointer to member of type noexcept function" can be converted to a prvalue of type "pointer to member of type function". The result points to the member function.

[ Example:

  void (*p)() throw(int);
  void (**pp)() throw() = &p;   // error

  struct S { typedef void (*p)(); operator p(); };
  void (*q)() noexcept = S();   // error

-- end example ]

Clause 5 [expr] Expressions

[ Note: ... ] The composite pointer type of two operands p1 and p2 having types T1 and T2, respectively, where at least one is a pointer or pointer to member type or std::nullptr_t, is:

• ...
• if T1 or T2 is "pointer to cv1 void" and the other type is "pointer to cv2 T", "pointer to cv12 void", where cv12 is the union of cv1 and cv2 ;
• if T1 or T2 is "pointer to noexcept function" and the other type is "pointer to function", where the function types are otherwise the same, "pointer to function";
• ...

The closure type for a non-generic lambda-expression with no lambda-capture has a public non-virtual non-explicit const conversion function to pointer to function with C++ language linkage (7.5 [dcl.link]) having the same parameter and return types as the closure type's function call operator. That pointer type is "pointer to noexcept function" if the function call operator has a non-throwing exception specification.

The inverse of any standard conversion sequence (Clause 4 [conv]) not containing an lvalue-to-rvalue (4.1 [conv.lval]), array-to-pointer (4.2 [conv.array]), function-to-pointer (4.3), null pointer (4.10), null member pointer (4.11), or boolean (4.12), or function pointer (4.12 [conv.fctptr]) conversion, can be performed explicitly using static_cast. ...

If at least one of the operands is a pointer, pointer conversions (4.10 [conv.ptr]), function pointer conversions (4.12 [conv.fctptr]), and qualification conversions (4.4 [conv.qual]) are performed on both operands to bring them to their composite pointer type (clause 5 [expr]).

• One or both of the second and third operands have pointer type; pointer conversions (4.10 [conv.ptr]), function pointer conversions (4.12 [conv.fctptr]), and qualification conversions (4.4 [conv.qual]) are performed to bring them to their composite pointer type (5 [expr]). ...
• ...

Evaluating a throw-expression with an operand throws an exception (15.1 [except.throw]); the type of the exception object is determined by removing any top-level cv-qualifiers from the static type of the operand and adjusting the type from "array of T" or "function returning T" function type T to "pointer to T" or "pointer to "function returning T," respectively.

... A converted constant expression of type T is an expression, implicitly converted to a prvalue of type T, where the converted expression is a core constant expression and the implicit conversion sequence contains only user-defined conversions, lvalue-to-rvalue conversions (4.1 [conv.lval]), integral promotions (4.5 [conv.prom]), and integral conversions (4.7 [conv.integral]) other than narrowing conversions (8.5.4 [dcl.init.list]), and function pointer conversions (4.12 [conv.fctptr]). [ Note: ... ]

Section 8 [dcl.decl] Declarators

In a declaration T D where D has the form

    D1 ( parameter-declaration-clause ) cv-qualifier-seqopt
         ref-qualifieropt exception-specificationopt attribute-specifier-seqopt

and the type of the contained declarator-id in the declaration T D1 is "derived-declarator-type-list T", the type of the declarator-id in D is "derived-declarator-type-list noexcept_opt function of (parameter-declaration-clause) cv-qualifier-seq_opt ref-qualifier_opt returning T", where the optional noexcept is present if and only if the exception-specification is non-throwing. The optional attribute-specifier-seq appertains to the function type.

In a declaration T D where D has the form

    D1 ( parameter-declaration-clause ) cv-qualifier-seqopt
         ref-qualifieropt exception-specificationopt attribute-specifier-seqopt trailing-return-type

and the type of the contained declarator-id in the declaration T D1 is "derived-declarator-type-list T", T shall be the single type-specifier auto. The type of the declarator-id in D is "derived-declarator-type-list noexcept_opt function of (parameter-declaration-clause) cv-qualifier-seq_opt ref-qualifier_opt returning trailing-return-type", where the optional noexcept is present if and only if the exception-specification is non-throwing. The optional attribute-specifier-seq appertains to the function type.

... After determining the type of each parameter, any parameter of type "array of T" or "function returning T" of function type T is adjusted to be "pointer to T" or "pointer to function returning T," respectively. ...

... The return type, the parameter-type-list, the ref-qualifier, and the cv-qualifier-seq, and whether the function has a non-throwing exception-specification, but not the default arguments (8.3.6 [dcl.fct.default]) or the exception specification (15.4 [except.spec]), are part of the function type. ...

The declarator in a function-definition shall have the form

         D1 ( parameter-declaration-clause ) cv-qualifier-seqopt
               ref-qualifieropt exception-specificationopt attribute-specifier-seqopt 
               parameters-and-qualifiers trailing-return-typeopt

[ Drafting note: This is intended to reduce the grammar redundancies around function declarators. ]

Clause 13 [over] Overloading

Certain function declarations cannot be overloaded:

• Function declarations that differ only in the return type and/or the exception specification (15.4 [except.spec]) cannot be overloaded.
• ...

• Conversion: Function pointer conversion
• Category: Lvalue transformation
• Rank: Exact Match
• Subclause: 4.12 [conv.fctptr]

... The function selected is the one whose type is identical to the function type of the target type required in the context. A function with type F is selected for the function type FT of the target type required in the context if F (after possibly applying the function pointer conversion (4.12 [conv.fctptr])) is identical to FT. [ Note: ... ]

[ Note: There are no standard conversions (Clause 4) of one pointer-to-function type into another. In particular, even Even if B is a public base of D, we have

D* f();
B* (*p1)() = &f;     // error
void g(D*);
void (*p2)(B*) = &g; // error

]

Clause 14 [temp] Templates

A non-type template-parameter of type "array of T" or "function returning T" of function type T is adjusted to be of type "pointer to T" or "pointer to function returning T", respectively. [ Example: ... ]

... However, there are three cases that allow a difference:

• ...
• The transformed A can be another pointer or pointer to member type that can be converted to the deduced A via a qualification conversion (4.4 [conv.qual]) or a function pointer conversion (4.12 [conv.fctptr]).
• ...

In general, the deduction process attempts to find template argument values that will make the deduced A identical to A. However, there are two four cases that allow a difference:

• If the original A is a reference type, A can be more cv-qualified than the deduced A (i.e., the type referred to by the reference).
• If the original A is a pointer to function type, A can be "pointer to function" even if the deduced A is "pointer to noexcept function".
• If the original A is a pointer to member function type, A can be "pointer to member of type function" even if the deduced A is "pointer to member of type noexcept function".
• ...

Clause 15 [except] Exception handling

A handler is a match for an exception object of type E if

• ...
• the handler is of type cv T or const T& where T is a pointer type and E is a pointer type that can be converted to T by either or both of one or more of
  • a standard pointer conversion (4.10 [conv.ptr]) not involving conversions to pointers to private or protected or ambiguous classes
  • a qualification conversion (4.4 [conv.qual])
  • a function pointer conversion (4.12 [conv.fctptr])
• ...

A function declaration declarator lists exceptions that its function might directly or indirectly throw by using an exception-specification as a suffix of its declarator.

An exception-specification shall appear only on a function declarator for a function type, pointer to function type, reference to function type, or pointer to member function type that is the top-level type of a declaration or definition, or on such a type appearing as a parameter or return type in a function declarator. An exception-specification shall not appear in a typedef declaration or alias-declaration. [ Example: ... ] ...

[ Example: ... ] A similar restriction applies to assignment to and initialization of pointers to functions, pointers to member functions, and references to functions: the target entity shall allow at least the exceptions allowed by the source value in the assignment or initialization. [ Example: ... ]

In such an assignment or initialization, exception-specifications on return types and parameter types shall be compatible. In other assignments or initializations, exception-specifications shall be compatible.

A function with an implied non-throwing exception specification, where the function's type is declared to be T, is instead considered to be of type "noexcept T".

C.4.2 Clause 8: Declarators [diff.cpp14.decl]
8.3.5 [dcl.fct]

Change: Make exception specifications be part of the type system.
Rationale: Improve type-safety.
Effect on original feature: Valid C++2014 code may fail to compile or change meaning in this International Standard:

  void g1() noexcept;
  void g2();
  template<class T> int f(T *, T *);
  int x = f(g1, g2);    // ill-formed; previously well-formed