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

Files changed (1) hide show

tmp/tmp38o69q1o/{from.md → to.md} +79 -38

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

@@ -1,12 +1,11 @@
 ##### 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
@@ -14,40 +13,82 @@ 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 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*]

Diff to HTML by rtfpessoa