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

Files changed (1) hide show

tmp/tmp863x3wte/{from.md → to.md} +60 -34

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

@@ -24,63 +24,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
@@ -113,10 +130,19 @@ void d() {
   void k(this int);
   operator int() const;
   void m(this const C& c) {
     c.k();              // OK
   }
 };
 ```
 — *end example*]
@@ -143,11 +169,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`

 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`

Diff to HTML by rtfpessoa