[expr.prim.id] - C++20 → C++23

Files changed (1) hide show

tmp/tmpozunzdzd/{from.md → to.md} +157 -84

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

@@ -1,7 +1,9 @@
 ### Names <a id="expr.prim.id">[[expr.prim.id]]</a>
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
 ```
@@ -9,63 +11,71 @@ id-expression:
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
-An *id-expression* that denotes a non-static data member or non-static
-member function of a class can only be used:
 - as part of a class member access [[expr.ref]] in which the object
   expression refers to the member’s class[^10] or a class derived from
   that class, or
 - to form a pointer to member [[expr.unary.op]], or
 - if that *id-expression* denotes a non-static data member and it
   appears in an unevaluated operand.
-  \[*Example 1*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
   ```
   — *end example*]
-A potentially-evaluated *id-expression* that denotes an immediate
-function [[dcl.constexpr]] shall appear only
-- as a subexpression of an immediate invocation, or
-- in an immediate function context [[expr.const]].
 For an *id-expression* that denotes an overload set, overload resolution
-is performed to select a unique function ([[over.match]],
-[[over.over]]).
-[*Note 2*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
-[*Example 2*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
-}
 void g() {
   A<int>::f(0);                         // error: cannot call f
   void (*p1)(int) = A<int>::f;          // error: cannot take the address of f
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
 declaration of `p2`, those constraints are required to be satisfied even
-though `f` is an unevaluated operand [[expr.prop]].
 — *end example*]
 — *end note*]
@@ -92,56 +102,109 @@ the copy of the parameter [[dcl.fct.def.coroutine]].
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
 [[temp.names]]. A *type-name* or *decltype-specifier* prefixed by `~`
 denotes the destructor of the type so named; see  [[expr.prim.id.dtor]].
 Within the definition of a non-static member function, an *identifier*
 that names a non-static member is transformed to a class member access
-expression ([[class.mfct.non-static]]). — *end note*]
-The result is the entity denoted by the identifier. If the entity is a
-local entity and naming it from outside of an unevaluated operand within
-the declarative region where the *unqualified-id* appears would result
-in some intervening *lambda-expression* capturing it by copy
-[[expr.prim.lambda.capture]], the type of the expression is the type of
-a class member access expression [[expr.ref]] naming the non-static data
-member that would be declared for such a capture in the closure object
-of the innermost such intervening *lambda-expression*.
-[*Note 2*: If that *lambda-expression* is not declared `mutable`, the
   type of such an identifier will typically be `const`
   qualified. — *end note*]
-The type of the expression is the type of the result.
-[*Note 3*: If the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
 `const T`. — *end note*]
-[*Note 4*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
-The expression is an lvalue if the entity is a function, variable,
-structured binding [[dcl.struct.bind]], data member, or template
-parameter object and a prvalue otherwise [[basic.lval]]; it is a
-bit-field if the identifier designates a bit-field.
 [*Example 1*:
 ``` cpp
 void f() {
   float x, &r = x;
-  [=] {
     decltype(x) y1;             // y1 has type float
-    decltype((x)) y2 = y1;      // y2 has type float const& because this lambda
-                                // is not mutable and x is an lvalue
     decltype(r) r1 = y1;        // r1 has type float&
     decltype((r)) r2 = y2;      // r2 has type float const&
   };
 }
 ```
 — *end example*]
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
     nested-name-specifier templateₒₚₜ unqualified-id
@@ -155,56 +218,66 @@ nested-name-specifier:
     decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
-The type denoted by a *decltype-specifier* in a *nested-name-specifier*
-shall be a class or enumeration type.
-A *nested-name-specifier* that denotes a class, optionally followed by
-the keyword `template` [[temp.names]], and then followed by the name of
-a member of either that class [[class.mem]] or one of its base classes
-[[class.derived]], is a *qualified-id*;  [[class.qual]] describes name
-lookup for class members that appear in *qualified-id*s. The result is
-the member. The type of the result is the type of the member. The result
-is an lvalue if the member is a static member function or a data member
 and a prvalue otherwise.
-[*Note 1*: A class member can be referred to using a *qualified-id* at
-any point in its potential scope [[basic.scope.class]]. — *end note*]
-Where *type-name* `::~` *type-name* is used, the two *type-name*s shall
-refer to the same type (ignoring cv-qualifications); this notation
-denotes the destructor of the type so named [[expr.prim.id.dtor]]. The
-*unqualified-id* in a *qualified-id* shall not be of the form
-`~`*decltype-specifier*.
-The *nested-name-specifier* `::` names the global namespace. A
-*nested-name-specifier* that names a namespace [[basic.namespace]],
-optionally followed by the keyword `template` [[temp.names]], and then
-followed by the name of a member of that namespace (or the name of a
-member of a namespace made visible by a *using-directive*), is a
-*qualified-id*;  [[namespace.qual]] describes name lookup for namespace
-members that appear in *qualified-id*s. The result is the member. The
-type of the result is the type of the member. The result is an lvalue if
-the member is a function, a variable, or a structured binding
-[[dcl.struct.bind]] and a prvalue otherwise.
-A *nested-name-specifier* that denotes an enumeration [[dcl.enum]],
-followed by the name of an enumerator of that enumeration, is a
-*qualified-id* that refers to the enumerator. The result is the
-enumerator. The type of the result is the type of the enumeration. The
-result is a prvalue.
-In a *qualified-id*, if the *unqualified-id* is a
-*conversion-function-id*, its *conversion-type-id* is first looked up in
-the class denoted by the *nested-name-specifier* of the *qualified-id*
-and the name, if found, is used. Otherwise, it is looked up in the
-context in which the entire *qualified-id* occurs. In each of these
-lookups, only names that denote types or templates whose specializations
-are types are considered.
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
@@ -212,12 +285,12 @@ destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 If the *id-expression* names a pseudo-destructor, `T` shall be a scalar
 type and the *id-expression* shall appear as the right operand of a
 class member access [[expr.ref]] that forms the *postfix-expression* of
 a function call [[expr.call]].
-[*Note 1*: Such a call ends the lifetime of the object ([[expr.call]],
-[[basic.life]]). — *end note*]
 [*Example 1*:
 ``` cpp
 struct C { };

 ### Names <a id="expr.prim.id">[[expr.prim.id]]</a>
+#### General <a id="expr.prim.id.general">[[expr.prim.id.general]]</a>
 ``` bnf
 id-expression:
     unqualified-id
     qualified-id
 ```
 An *id-expression* is a restricted form of a *primary-expression*.
 [*Note 1*: An *id-expression* can appear after `.` and `->` operators
 [[expr.ref]]. — *end note*]
+If an *id-expression* E denotes a member M of an anonymous union
+[[class.union.anon]] U:
+- If U is a non-static data member, E refers to M as a member of the
+  lookup context of the terminal name of E (after any transformation to
+  a class member access expression [[class.mfct.non.static]]).
+  \[*Example 1*: `o.x` is interpreted as `o.u.x`, where u names the
+  anonymous union member. — *end example*]
+- Otherwise, E is interpreted as a class member access [[expr.ref]] that
+  designates the member subobject M of the anonymous union variable for
+  U. \[*Note 2*: Under this interpretation, E no longer denotes a
+  non-static data member. — *end note*] \[*Example 2*: `N::x` is
+  interpreted as `N::u.x`, where u names the anonymous union
+  variable. — *end example*]
+An *id-expression* that denotes a non-static data member or implicit
+object member function of a class can only be used:
 - as part of a class member access [[expr.ref]] in which the object
   expression refers to the member’s class[^10] or a class derived from
   that class, or
 - to form a pointer to member [[expr.unary.op]], or
 - if that *id-expression* denotes a non-static data member and it
   appears in an unevaluated operand.
+  \[*Example 3*:
   ``` cpp
   struct S {
     int m;
   };
   int i = sizeof(S::m);           // OK
   int j = sizeof(S::m + 42);      // OK
   ```
   — *end example*]
 For an *id-expression* that denotes an overload set, overload resolution
+is performed to select a unique function [[over.match]], [[over.over]].
+[*Note 3*:
 A program cannot refer to a function with a trailing *requires-clause*
 whose *constraint-expression* is not satisfied, because such functions
 are never selected by overload resolution.
+[*Example 4*:
 ``` cpp
 template<typename T> struct A {
   static void f(int) requires false;
+};
 void g() {
   A<int>::f(0);                         // error: cannot call f
   void (*p1)(int) = A<int>::f;          // error: cannot take the address of f
   decltype(A<int>::f)* p2 = nullptr;    // error: the type decltype(A<int>::f) is invalid
 }
 ```
 In each case, the constraints of `f` are not satisfied. In the
 declaration of `p2`, those constraints are required to be satisfied even
+though `f` is an unevaluated operand [[term.unevaluated.operand]].
 — *end example*]
 — *end note*]
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
 [[temp.names]]. A *type-name* or *decltype-specifier* prefixed by `~`
 denotes the destructor of the type so named; see  [[expr.prim.id.dtor]].
 Within the definition of a non-static member function, an *identifier*
 that names a non-static member is transformed to a class member access
+expression [[class.mfct.non.static]]. — *end note*]
+A *component name* of an *unqualified-id* U is
+- U if it is a name or
+- the component name of the *template-id* or *type-name* of U, if any.
+[*Note 2*: Other constructs that contain names to look up can have
+several component names
+[[expr.prim.id.qual]], [[dcl.type.simple]], [[dcl.type.elab]], [[dcl.mptr]], [[namespace.udecl]], [[temp.param]], [[temp.names]], [[temp.res]]. — *end note*]
+The *terminal name* of a construct is the component name of that
+construct that appears lexically last.
+The result is the entity denoted by the *unqualified-id*
+[[basic.lookup.unqual]]. If the *unqualified-id* appears in a
+*lambda-expression* at program point P and the entity is a local entity
+[[basic.pre]] or a variable declared by an *init-capture*
+[[expr.prim.lambda.capture]], then let S be the *compound-statement* of
+the innermost enclosing *lambda-expression* of P. If naming the entity
+from outside of an unevaluated operand within S would refer to an entity
+captured by copy in some intervening *lambda-expression*, then let E be
+the innermost such *lambda-expression*.
+- If there is such a *lambda-expression* and if P is in E’s function
+  parameter scope but not its *parameter-declaration-clause*, then the
+  type of the expression is the type of a class member access expression
+  [[expr.ref]] naming the non-static data member that would be declared
+  for such a capture in the object parameter [[dcl.fct]] of the function
+  call operator of E. \[*Note 3*: If E is not declared `mutable`, the
   type of such an identifier will typically be `const`
   qualified. — *end note*]
+- Otherwise (if there is no such *lambda-expression* or if P either
+  precedes E’s function parameter scope or is in E’s
+  *parameter-declaration-clause*), the type of the expression is the
+  type of the result.
+[*Note 4*: If the entity is a template parameter object for a template
 parameter of type `T` [[temp.param]], the type of the expression is
 `const T`. — *end note*]
+[*Note 5*: The type will be adjusted as described in [[expr.type]] if
 it is cv-qualified or is a reference type. — *end note*]
+The expression is an xvalue if it is move-eligible (see below); an
+lvalue if the entity is a function, variable, structured binding
+[[dcl.struct.bind]], data member, or template parameter object; and a
+prvalue otherwise [[basic.lval]]; it is a bit-field if the identifier
+designates a bit-field.
 [*Example 1*:
 ``` cpp
 void f() {
   float x, &r = x;
+  [=]() -> decltype((x)) {      // lambda returns float const& because this lambda is not mutable and
+                                // x is an lvalue
     decltype(x) y1;             // y1 has type float
+    decltype((x)) y2 = y1;      // y2 has type float const&
     decltype(r) r1 = y1;        // r1 has type float&
     decltype((r)) r2 = y2;      // r2 has type float const&
+    return y2;
+  };
+  [=](decltype((x)) y) {
+    decltype((x)) z = x;        // OK, y has type float&, z has type float const&
+  };
+  [=] {
+    [](decltype((x)) y) {};     // OK, lambda takes a parameter of type float const&
+    [x=1](decltype((x)) y) {
+      decltype((x)) z = x;      // OK, y has type int&, z has type int const&
+    };
   };
 }
 ```
 — *end example*]
+An *implicitly movable entity* is a variable of automatic storage
+duration that is either a non-volatile object or an rvalue reference to
+a non-volatile object type. In the following contexts, an
+*id-expression* is *move-eligible*:
+- If the *id-expression* (possibly parenthesized) is the operand of a
+  `return` [[stmt.return]] or `co_return` [[stmt.return.coroutine]]
+  statement, and names an implicitly movable entity declared in the body
+  or *parameter-declaration-clause* of the innermost enclosing function
+  or *lambda-expression*, or
+- if the *id-expression* (possibly parenthesized) is the operand of a
+  *throw-expression* [[expr.throw]], and names an implicitly movable
+  entity that belongs to a scope that does not contain the
+  *compound-statement* of the innermost *lambda-expression*,
+  *try-block*, or *function-try-block* (if any) whose
+  *compound-statement* or *ctor-initializer* contains the
+  *throw-expression*.
 #### Qualified names <a id="expr.prim.id.qual">[[expr.prim.id.qual]]</a>
 ``` bnf
 qualified-id:
     nested-name-specifier templateₒₚₜ unqualified-id
     decltype-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
+The component names of a *qualified-id* are those of its
+*nested-name-specifier* and *unqualified-id*. The component names of a
+*nested-name-specifier* are its *identifier* (if any) and those of its
+*type-name*, *namespace-name*, *simple-template-id*, and/or
+*nested-name-specifier*.
+A *nested-name-specifier* is *declarative* if it is part of
+- a *class-head-name*,
+- an *enum-head-name*,
+- a *qualified-id* that is the *id-expression* of a *declarator-id*, or
+- a declarative *nested-name-specifier*.
+A declarative *nested-name-specifier* shall not have a
+*decltype-specifier*. A declaration that uses a declarative
+*nested-name-specifier* shall be a friend declaration or inhabit a scope
+that contains the entity being redeclared or specialized.
+The *nested-name-specifier* `::` nominates the global namespace. A
+*nested-name-specifier* with a *decltype-specifier* nominates the type
+denoted by the *decltype-specifier*, which shall be a class or
+enumeration type. If a *nested-name-specifier* N is declarative and has
+a *simple-template-id* with a template argument list A that involves a
+template parameter, let T be the template nominated by N without A. T
+shall be a class template.
+- If A is the template argument list [[temp.arg]] of the corresponding
+  *template-head* H [[temp.mem]], N nominates the primary template of T;
+  H shall be equivalent to the *template-head* of T [[temp.over.link]].
+- Otherwise, N nominates the partial specialization
+  [[temp.spec.partial]] of T whose template argument list is equivalent
+  to A [[temp.over.link]]; the program is ill-formed if no such partial
+  specialization exists.
+Any other *nested-name-specifier* nominates the entity denoted by its
+*type-name*, *namespace-name*, *identifier*, or *simple-template-id*. If
+the *nested-name-specifier* is not declarative, the entity shall not be
+a template.
+A *qualified-id* shall not be of the form *nested-name-specifier*
+`template`ₒₚₜ  `~` *decltype-specifier* nor of the form
+*decltype-specifier* `::` `~` *type-name*.
+The result of a *qualified-id* Q is the entity it denotes
+[[basic.lookup.qual]]. The type of the expression is the type of the
+result. The result is an lvalue if the member is
+- a function other than a non-static member function,
+- a non-static member function if Q is the operand of a unary `&`
+  operator,
+- a variable,
+- a structured binding [[dcl.struct.bind]], or
+- a data member,
 and a prvalue otherwise.
 #### Destruction <a id="expr.prim.id.dtor">[[expr.prim.id.dtor]]</a>
 An *id-expression* that denotes the destructor of a type `T` names the
 destructor of `T` if `T` is a class type [[class.dtor]], otherwise the
 *id-expression* is said to name a *pseudo-destructor*.
 If the *id-expression* names a pseudo-destructor, `T` shall be a scalar
 type and the *id-expression* shall appear as the right operand of a
 class member access [[expr.ref]] that forms the *postfix-expression* of
 a function call [[expr.call]].
+[*Note 1*: Such a call ends the lifetime of the object
+[[expr.call]], [[basic.life]]. — *end note*]
 [*Example 1*:
 ``` cpp
 struct C { };

Diff to HTML by rtfpessoa