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

Files changed (1) hide show

tmp/tmpv07cw_tf/{from.md → to.md} +98 -55

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

@@ -1,7 +1,9 @@
 #### Function call syntax <a id="over.match.call">[[over.match.call]]</a>
 In a function call [[expr.call]]
 ``` bnf
 postfix-expression '(' expression-listₒₚₜ ')'
 ```
@@ -11,24 +13,27 @@ template, overload resolution is applied as specified in
 [[over.call.func]]. If the *postfix-expression* denotes an object of
 class type, overload resolution is applied as specified in
 [[over.call.object]].
 If the *postfix-expression* is the address of an overload set, overload
-resolution is applied using that set as described above. If the function
-selected by overload resolution is a non-static member function, the
-program is ill-formed.
-[*Note 1*: 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 a name that denotes
-one or more functions that might be called. 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
@@ -36,52 +41,94 @@ postfix-expression:
 ```
 These represent two syntactic subcategories of function calls: qualified
 function calls and unqualified function calls.
-In qualified function calls, the name to be resolved is an
-*id-expression* and is 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.[^3] Under this assumption, the *id-expression* in the
-call is looked up as a member function of `T` following the rules for
-looking up names in classes [[class.member.lookup]]. The function
-declarations found by that 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 name is not qualified by an `->` or
-`.` operator and has the more general form of a *primary-expression*.
-The name is looked up in the context of the function call following the
-normal rules for name lookup in expressions [[basic.lookup]]. The
-function declarations found by that lookup constitute the set of
-candidate functions. Because of the rules for name lookup, the set of
-candidate functions consists (1) entirely of non-member functions or (2)
-entirely of member functions of some class `T`. In case (1), the
-argument list is the same as the *expression-list* in the call. In case
-(2), 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 keyword `this` [[class.this]] is in scope and refers to
-class `T`, or a derived class of `T`, then the implied object argument
-is `(*this)`. If the keyword `this` is not in scope or refers to another
-class, then a contrived object of type `T` becomes the implied object
-argument.[^4] If the argument list is augmented by a contrived object
-and overload resolution selects one of the non-static member functions
-of `T`, the call is ill-formed.
 ##### Call to object of class type <a id="over.call.object">[[over.call.object]]</a>
 If the *postfix-expression* `E` in the function call syntax evaluates to
 a class object of type “cv `T`”, then the set of candidate functions
 includes at least the function call operators of `T`. The function call
-operators of `T` are obtained by ordinary lookup of the name
-`operator()` in the context of `(E).operator()`.
 In addition, for each non-explicit conversion function declared in `T`
 of the form
 ``` bnf
@@ -103,27 +150,23 @@ returning `R`”, a *surrogate call function* with the unique name
 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`
 provided the function is not hidden within `T` by another intervening
-declaration.[^5]
 The argument list submitted to overload resolution consists of the
 argument expressions present in the function call syntax preceded by the
 implied object argument `(E)`.
-[*Note 2*: When comparing the call against the function call operators,
-the implied object argument is compared against the implicit object
-parameter of the function call operator. When comparing the call against
-a surrogate call function, the implied object argument is compared
-against the first parameter of the surrogate call function. The
-conversion function from which the surrogate call function was derived
-will be used in the conversion sequence for that parameter since it
-converts the implied object argument to the appropriate function pointer
-or reference required by that first parameter. — *end note*]
-[*Example 1*:
 ``` cpp
 int f1(int);
 int f2(float);
 typedef int (*fp1)(int);

 #### Function call syntax <a id="over.match.call">[[over.match.call]]</a>
+##### General <a id="over.match.call.general">[[over.match.call.general]]</a>
 In a function call [[expr.call]]
 ``` bnf
 postfix-expression '(' expression-listₒₚₜ ')'
 ```
 [[over.call.func]]. If the *postfix-expression* denotes an object of
 class type, overload resolution is applied as specified in
 [[over.call.object]].
 If the *postfix-expression* is the address of an overload set, overload
+resolution is applied using that set as described above.
+[*Note 1*: No implied object argument is added in this
+case. — *end note*]
+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
 ```
 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
+void c()&;                  // #2
+static void c(int = 0);     // #3
+void d() {
+  c();                  // error: ambiguous between #2 and #3
+  (C::c)();             // error: as above
+  (&(C::c))();          // error: cannot resolve address of overloaded this->C::c[over.over]
+  (&C::c)(C{});         // selects #1
+  (&C::c)(*this);       // error: selects #2, and is ill-formed[over.match.call.general]
+  (&C::c)();            // selects #3
+}
+  void f(this const C&);
+  void g() const {
+    f();                // OK, (*this).f()
+    f(*this);           // error: no viable candidate for (*this).f(*this)
+    this->f();          // OK
+  }
+  static void h() {
+    f();                // error: contrived object argument, but overload resolution
+                        // picked a non-static member function
+    f(C{});             // error: no viable candidate
+    C{}.f();            // OK
+  }
+  void k(this int);
+  operator int() const;
+  void m(this const C& c) {
+    c.k();              // OK
+  }
+};
+```
+— *end example*]
 ##### Call to object of class type <a id="over.call.object">[[over.call.object]]</a>
 If the *postfix-expression* `E` in the function call syntax evaluates to
 a class object of type “cv `T`”, then the set of candidate functions
 includes at least the function call operators of `T`. The function call
+operators of `T` are the results of a search for the name `operator()`
+in the scope of `T`.
 In addition, for each non-explicit conversion function declared in `T`
 of the form
 ``` bnf
 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`
 provided the function is not hidden within `T` by another intervening
+declaration.[^4]
 The argument list submitted to overload resolution consists of the
 argument expressions present in the function call syntax preceded by the
 implied object argument `(E)`.
+[*Note 3*: When comparing the call against the function call operators,
+the implied object argument is compared against the object parameter of
+the function call operator. When comparing the call against a surrogate
+call function, the implied object argument is compared against the first
+parameter of the surrogate call function. — *end note*]
+[*Example 2*:
 ``` cpp
 int f1(int);
 int f2(float);
 typedef int (*fp1)(int);

Diff to HTML by rtfpessoa