[over.match.funcs] - C++23 → Trunk

Files changed (1) hide show

tmp/tmp85zwls5o/{from.md → to.md} +96 -66

tmp/tmp85zwls5o/{from.md → to.md} RENAMED Viewed

@@ -31,12 +31,12 @@ parameter is
 - “lvalue reference to cv `X`” for functions declared without a
   *ref-qualifier* or with the `&` *ref-qualifier*
 - “rvalue reference to cv `X`” for functions declared with the `&&`
   *ref-qualifier*
-where `X` is the class of which the function is a member and cv is the
-cv-qualification on the member function declaration.
 [*Example 1*: For a `const` member function of class `X`, the extra
 parameter is assumed to have type “lvalue reference to
 `const X`”. — *end example*]
@@ -188,63 +188,80 @@ If the function selected by overload resolution is an implicit object
 member function, the program is ill-formed.
 [*Note 2*: The resolution of the address of an overload set in other
 contexts is described in [[over.over]]. — *end note*]
-##### Call to named function <a id="over.call.func">[[over.call.func]]</a>
 Of interest in  [[over.call.func]] are only those function calls in
-which the *postfix-expression* ultimately contains an *id-expression*
-that denotes one or more functions. Such a *postfix-expression*, perhaps
-nested arbitrarily deep in parentheses, has one of the following forms:
 ``` bnf
 postfix-expression:
     postfix-expression '.' id-expression
     postfix-expression '->' id-expression
- primary-expression
 ```
 These represent two syntactic subcategories of function calls: qualified
 function calls and unqualified function calls.
-In qualified function calls, the function is named by an *id-expression*
-preceded by an `->` or `.` operator. Since the construct `A->B` is
-generally equivalent to `(*A).B`, the rest of [[over]] assumes, without
-loss of generality, that all member function calls have been normalized
-to the form that uses an object and the `.` operator. Furthermore,
-[[over]] assumes that the *postfix-expression* that is the left operand
-of the `.` operator has type “cv `T`” where `T` denotes a class.[^2]
-The function declarations found by name lookup [[class.member.lookup]]
-constitute the set of candidate functions. The argument list is the
-*expression-list* in the call augmented by the addition of the left
-operand of the `.` operator in the normalized member function call as
-the implied object argument [[over.match.funcs]].
-In unqualified function calls, the function is named by a
-*primary-expression*. The function declarations found by name lookup
-[[basic.lookup]] constitute the set of candidate functions. Because of
-the rules for name lookup, the set of candidate functions consists
-either entirely of non-member functions or entirely of member functions
-of some class `T`. In the former case or if the *primary-expression* is
-the address of an overload set, the argument list is the same as the
-*expression-list* in the call. Otherwise, the argument list is the
-*expression-list* in the call augmented by the addition of an implied
-object argument as in a qualified function call. If the current class
-is, or is derived from, `T`, and the keyword `this` [[expr.prim.this]]
-refers to it, then the implied object argument is `(*this)`. Otherwise,
-a contrived object of type `T` becomes the implied object argument;[^3]
-if overload resolution selects a non-static member function, the call is
-ill-formed.
 [*Example 1*:
 ``` cpp
 struct C {
- void a();
   void b() {
     a();                // OK, (*this).a()
   }
   void c(this const C&);    // #1
@@ -277,10 +294,19 @@ void d() {
   void k(this int);
   operator int() const;
   void m(this const C& c) {
     c.k();              // OK
   }
 };
 ```
 — *end example*]
@@ -307,11 +333,11 @@ returning `R`”, or the type “reference to function of (`P₁`, …, `Pₙ`)
 returning `R`”, a *surrogate call function* with the unique name
 *call-function* and having the form
 ``` bnf
 'R' *call-function* '(' conversion-type-id \ %
-'F, P₁ a₁, …, Pₙ aₙ)' '{ return F (a₁, …, aₙ); }'
 ```
 is also considered as a candidate function. Similarly, surrogate call
 functions are added to the set of candidate functions for each
 non-explicit conversion function declared in a base class of `T`
@@ -390,14 +416,14 @@ However, the operands are sequenced in the order prescribed for the
 built-in operator [[expr.compound]].
 **Table: Relationship between operator and function call notation** <a id="over.match.oper">[over.match.oper]</a>
 | Subclause       | Expression | As member function  | As non-member function |
-| ------------ | ---------- | ------------------- | ---------------------- |
 | (a)}            |
 | (a, b)}         |
-| [[over.ass]] | `a=b`      | `(a).operator= (b)` |                        |
 | [[over.sub]]    | `a[b]`     | `(a).operator[](b)` |                        |
 | [[over.ref]]    | `a->`      | `(a).operator->( )` |                        |
 | (a, 0)}         |
@@ -494,16 +520,12 @@ inline namespace N {
 bool d1 = 0 == D();             // OK, calls reversed #4; #5 does not forbid #4 as a rewrite target
 ```
 — *end example*]
-For the built-in assignment operators, conversions of the left operand
-are restricted as follows:
-- no temporaries are introduced to hold the left operand, and
-- no user-defined conversions are applied to the left operand to achieve
-  a type match with the left-most parameter of a built-in candidate.
 For all other operators, no such restrictions apply.
 The set of candidate functions for overload resolution for some operator
 `@` is the union of the member candidates, the non-member candidates,
@@ -612,17 +634,18 @@ void B::f() {
 When objects of class type are direct-initialized [[dcl.init]],
 copy-initialized from an expression of the same or a derived class type
 [[dcl.init]], or default-initialized [[dcl.init]], overload resolution
 selects the constructor. For direct-initialization or
-default-initialization that is not in the context of
-copy-initialization, the candidate functions are all the constructors of
-the class of the object being initialized. For copy-initialization
-(including default initialization in the context of
-copy-initialization), the candidate functions are all the converting
-constructors [[class.conv.ctor]] of that class. The argument list is the
-*expression-list* or *assignment-expression* of the *initializer*.
 #### Copy-initialization of class by user-defined conversion <a id="over.match.copy">[[over.match.copy]]</a>
 Under the conditions specified in  [[dcl.init]], as part of a
 copy-initialization of an object of class type, a user-defined
@@ -635,11 +658,11 @@ to a possibly cv-qualified class type is determined in terms of a
 corresponding non-reference copy-initialization. — *end note*]
 Assuming that “*cv1* `T`” is the type of the object being initialized,
 with `T` a class type, the candidate functions are selected as follows:
-- The converting constructors [[class.conv.ctor]] of `T` are candidate
   functions.
 - When the type of the initializer expression is a class type “cv `S`”,
   conversion functions are considered. The permissible types for
   non-explicit conversion functions are `T` and any class derived from
   `T`. When initializing a temporary object [[class.mem]] to be bound to
@@ -686,14 +709,13 @@ initializer expression. Overload resolution is used to select the
 conversion function to be invoked. Assuming that “reference to *cv1*
 `T`” is the type of the reference being initialized, the candidate
 functions are selected as follows:
 - Let R be a set of types including
-  - “lvalue reference to *cv2* `T2`” (when initializing an lvalue
-    reference or an rvalue reference to function) and
-  - “*cv2* `T2`” and “rvalue reference to *cv2* `T2`” (when initializing
-    an rvalue reference or an lvalue reference to function)
   for any `T2`. The permissible types for non-explicit conversion
   functions are the members of R where “*cv1* `T`” is
   reference-compatible [[dcl.init.ref]] with “*cv2* `T2`”. For
   direct-initialization, the permissible types for explicit conversion
@@ -726,40 +748,47 @@ resolution selects the constructor in two phases:
 In copy-list-initialization, if an explicit constructor is chosen, the
 initialization is ill-formed.
 [*Note 1*: This differs from other situations
-[[over.match.ctor]], [[over.match.copy]], where only converting
 constructors are considered for copy-initialization. This restriction
 only applies if this initialization is part of the final result of
 overload resolution. — *end note*]
 #### Class template argument deduction <a id="over.match.class.deduct">[[over.match.class.deduct]]</a>
 When resolving a placeholder for a deduced class type
-[[dcl.type.class.deduct]] where the *template-name* names a primary
-class template `C`, a set of functions and function templates, called
-the guides of `C`, is formed comprising:
 - If `C` is defined, for each constructor of `C`, a function template
   with the following properties:
   - The template parameters are the template parameters of `C` followed
     by the template parameters (including default template arguments) of
     the constructor, if any.
-  - The types of the function parameters are those of the constructor.
   - The return type is the class template specialization designated by
     `C` and template arguments corresponding to the template parameters
     of `C`.
 - If `C` is not defined or does not declare any constructors, an
   additional function template derived as above from a hypothetical
   constructor `C()`.
 - An additional function template derived as above from a hypothetical
   constructor `C(C)`, called the *copy deduction candidate*.
 - For each *deduction-guide*, a function or function template with the
   following properties:
-  - The template parameters, if any, and function parameters are those
-    of the *deduction-guide*.
   - The return type is the *simple-template-id* of the
     *deduction-guide*.
 In addition, if `C` is defined and its definition satisfies the
 conditions for an aggregate class [[dcl.init.aggr]] with the assumption
@@ -819,11 +848,11 @@ specialization whose template parameter list is that of `A` and whose
 template argument list is a specialization of `A` with the template
 argument list of `A` [[temp.dep.type]] having a member typedef `type`
 designating a template specialization with the template argument list of
 `A` but with `C` as the template.
-[*Note 1*: Equivalently, the template parameter list of the
 specialization is that of `C`, the template argument list of the
 specialization is `B`, and the member typedef names `C` with the
 template argument list of `C`. — *end note*]
 [*Example 1*:
@@ -876,12 +905,13 @@ J j = { "ghi" };    // error: cannot bind reference to array of unsigned char to
 ```
 — *end example*]
 When resolving a placeholder for a deduced class type
-[[dcl.type.simple]] where the *template-name* names an alias template
-`A`, the *defining-type-id* of `A` must be of the form
 ``` bnf
 typenameₒₚₜ nested-name-specifierₒₚₜ templateₒₚₜ simple-template-id
 ```

 - “lvalue reference to cv `X`” for functions declared without a
   *ref-qualifier* or with the `&` *ref-qualifier*
 - “rvalue reference to cv `X`” for functions declared with the `&&`
   *ref-qualifier*
+where `X` is the class of which the function is a direct member and cv
+is the cv-qualification on the member function declaration.
 [*Example 1*: For a `const` member function of class `X`, the extra
 parameter is assumed to have type “lvalue reference to
 `const X`”. — *end example*]
 member function, the program is ill-formed.
 [*Note 2*: The resolution of the address of an overload set in other
 contexts is described in [[over.over]]. — *end note*]
+##### Call to designated function <a id="over.call.func">[[over.call.func]]</a>
 Of interest in  [[over.call.func]] are only those function calls in
+which the *postfix-expression* ultimately contains an *id-expression* or
+*splice-expression* that designates one or more functions. Such a
+*postfix-expression*, perhaps nested arbitrarily deep in parentheses,
+has one of the following forms:
 ``` bnf
 postfix-expression:
     postfix-expression '.' id-expression
+    postfix-expression '.' splice-expression
     postfix-expression '->' id-expression
+ postfix-expression '->' splice-expression
+    id-expression
+    splice-expression
 ```
 These represent two syntactic subcategories of function calls: qualified
 function calls and unqualified function calls.
+In qualified function calls, the function is designated by an
+*id-expression* or *splice-expression* E preceded by an `->` or `.`
+operator. Since the construct `A->B` is generally equivalent to
+`(*A).B`, the rest of [[over]] assumes, without loss of generality, that
+all member function calls have been normalized to the form that uses an
+object and the `.` operator. Furthermore, [[over]] assumes that the
+*postfix-expression* that is the left operand of the `.` operator has
+type “cv `T`” where `T` denotes a class.[^2]
+The set of candidate functions either is the set found by name lookup
+[[class.member.lookup]] if E is an *id-expression* or is the set
+determined as specified in  [[expr.prim.splice]] if E is a
+*splice-expression*. The argument list is the *expression-list* in the
+call augmented by the addition of the left operand of the `.` operator
+in the normalized member function call as the implied object argument
+[[over.match.funcs]].
+In unqualified function calls, the function is designated by an
+*id-expression* or a *splice-expression* E. The set of candidate
+functions either is the set found by name lookup [[basic.lookup]] if E
+is an *id-expression* or is the set determined as specified in
+[[expr.prim.splice]] if E is a *splice-expression*. The set of candidate
+functions consists either entirely of non-member functions or entirely
+of member functions of some class `T`. In the former case or if E is
+either a *splice-expression* or the address of an overload set, the
+argument list is the same as the *expression-list* in the call.
+Otherwise, the argument list is the *expression-list* in the call
+augmented by the addition of an implied object argument as in a
+qualified function call. If the current class is, or is derived from,
+`T`, and the keyword `this` [[expr.prim.this]] refers to it,
+- if the unqualified function call appears in a precondition assertion
+  of a constructor or a postcondition assertion of a destructor and
+  overload resolution selects a non-static member function, the call is
+  ill-formed;
+- otherwise, the implied object argument is `(*this)`.
+Otherwise,
+- if overload resolution selects a non-static member function, the call
+  is ill-formed;
+- otherwise, a contrived object of type `T` becomes the implied object
+  argument.[^3]
 [*Example 1*:
 ``` cpp
 struct C {
+ bool a();
   void b() {
     a();                // OK, (*this).a()
   }
   void c(this const C&);    // #1
   void k(this int);
   operator int() const;
   void m(this const C& c) {
     c.k();              // OK
   }
+  C()
+    pre(a())            // error: implied this in constructor precondition
+    pre(this->a())      // OK
+    post(a());          // OK
+  ~C()
+    pre(a())            // OK
+    post(a())           // error: implied this in destructor postcondition
+    post(this->a());    // OK
 };
 ```
 — *end example*]
 returning `R`”, a *surrogate call function* with the unique name
 *call-function* and having the form
 ``` bnf
 'R' *call-function* '(' conversion-type-id \ %
+'F, P₁ a₁, …, Pₙ aₙ)' '{' return 'F (a₁, …, aₙ); }'
 ```
 is also considered as a candidate function. Similarly, surrogate call
 functions are added to the set of candidate functions for each
 non-explicit conversion function declared in a base class of `T`
 built-in operator [[expr.compound]].
 **Table: Relationship between operator and function call notation** <a id="over.match.oper">[over.match.oper]</a>
 | Subclause       | Expression | As member function  | As non-member function |
+| --------------- | ---------- | ------------------- | ---------------------- |
 | (a)}            |
 | (a, b)}         |
+| [[over.assign]] | `a=b`      | `(a).operator= (b)` |                        |
 | [[over.sub]]    | `a[b]`     | `(a).operator[](b)` |                        |
 | [[over.ref]]    | `a->`      | `(a).operator->( )` |                        |
 | (a, 0)}         |
 bool d1 = 0 == D();             // OK, calls reversed #4; #5 does not forbid #4 as a rewrite target
 ```
 — *end example*]
+For the first parameter of the built-in assignment operators, only
+standard conversion sequences [[over.ics.scs]] are considered.
 For all other operators, no such restrictions apply.
 The set of candidate functions for overload resolution for some operator
 `@` is the union of the member candidates, the non-member candidates,
 When objects of class type are direct-initialized [[dcl.init]],
 copy-initialized from an expression of the same or a derived class type
 [[dcl.init]], or default-initialized [[dcl.init]], overload resolution
 selects the constructor. For direct-initialization or
+default-initialization (including default-initialization in the context
+of copy-list-initialization), the candidate functions are all the
+constructors of the class of the object being initialized. Otherwise,
+the candidate functions are all the non-explicit constructors
+[[class.conv.ctor]] of that class. The argument list is the
+*expression-list* or *assignment-expression* of the *initializer*. For
+default-initialization in the context of copy-list-initialization, if an
+explicit constructor is chosen, the initialization is ill-formed.
 #### Copy-initialization of class by user-defined conversion <a id="over.match.copy">[[over.match.copy]]</a>
 Under the conditions specified in  [[dcl.init]], as part of a
 copy-initialization of an object of class type, a user-defined
 corresponding non-reference copy-initialization. — *end note*]
 Assuming that “*cv1* `T`” is the type of the object being initialized,
 with `T` a class type, the candidate functions are selected as follows:
+- The non-explicit constructors [[class.conv.ctor]] of `T` are candidate
   functions.
 - When the type of the initializer expression is a class type “cv `S`”,
   conversion functions are considered. The permissible types for
   non-explicit conversion functions are `T` and any class derived from
   `T`. When initializing a temporary object [[class.mem]] to be bound to
 conversion function to be invoked. Assuming that “reference to *cv1*
 `T`” is the type of the reference being initialized, the candidate
 functions are selected as follows:
 - Let R be a set of types including
+  - “lvalue reference to *cv2* `T2`” (when converting to an lvalue) and
+  - “*cv2* `T2`” and “rvalue reference to *cv2* `T2`” (when converting
+    to an rvalue or an lvalue of function type)
   for any `T2`. The permissible types for non-explicit conversion
   functions are the members of R where “*cv1* `T`” is
   reference-compatible [[dcl.init.ref]] with “*cv2* `T2`”. For
   direct-initialization, the permissible types for explicit conversion
 In copy-list-initialization, if an explicit constructor is chosen, the
 initialization is ill-formed.
 [*Note 1*: This differs from other situations
+[[over.match.ctor]], [[over.match.copy]], where only non-explicit
 constructors are considered for copy-initialization. This restriction
 only applies if this initialization is part of the final result of
 overload resolution. — *end note*]
 #### Class template argument deduction <a id="over.match.class.deduct">[[over.match.class.deduct]]</a>
 When resolving a placeholder for a deduced class type
+[[dcl.type.class.deduct]] where the *template-name* or
+*splice-type-specifier* designates a primary class template `C`, a set
+of functions and function templates, called the guides of `C`, is formed
+comprising:
 - If `C` is defined, for each constructor of `C`, a function template
   with the following properties:
   - The template parameters are the template parameters of `C` followed
     by the template parameters (including default template arguments) of
     the constructor, if any.
+  - The associated constraints [[temp.constr.decl]] are the conjunction
+    of the associated constraints of `C` and the associated constraints
+    of the constructor, if any. \[*Note 1*: A *constraint-expression* in
+    the *template-head* of `C` is checked for satisfaction before any
+    constraints from the *template-head* or trailing *requires-clause*
+    of the constructor. — *end note*]
+  - The *parameter-declaration-clause* is that of the constructor.
   - The return type is the class template specialization designated by
     `C` and template arguments corresponding to the template parameters
     of `C`.
 - If `C` is not defined or does not declare any constructors, an
   additional function template derived as above from a hypothetical
   constructor `C()`.
 - An additional function template derived as above from a hypothetical
   constructor `C(C)`, called the *copy deduction candidate*.
 - For each *deduction-guide*, a function or function template with the
   following properties:
+  - The *template-head*, if any, and *parameter-declaration-clause* are
+ those of the *deduction-guide*.
   - The return type is the *simple-template-id* of the
     *deduction-guide*.
 In addition, if `C` is defined and its definition satisfies the
 conditions for an aggregate class [[dcl.init.aggr]] with the assumption
 template argument list is a specialization of `A` with the template
 argument list of `A` [[temp.dep.type]] having a member typedef `type`
 designating a template specialization with the template argument list of
 `A` but with `C` as the template.
+[*Note 2*: Equivalently, the template parameter list of the
 specialization is that of `C`, the template argument list of the
 specialization is `B`, and the member typedef names `C` with the
 template argument list of `C`. — *end note*]
 [*Example 1*:
 ```
 — *end example*]
 When resolving a placeholder for a deduced class type
+[[dcl.type.simple]] where the *template-name* or *splice-type-specifier*
+designates an alias template `A`, the *defining-type-id* of `A` must be
+of the form
 ``` bnf
 typenameₒₚₜ nested-name-specifierₒₚₜ templateₒₚₜ simple-template-id
 ```

Diff to HTML by rtfpessoa