[expr.prim.id.unqual] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpyy1f0fws/{from.md → to.md} +147 -53

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

@@ -5,27 +5,24 @@ unqualified-id:
     identifier
     operator-function-id
     conversion-function-id
     literal-operator-id
     '~' type-name
-    '~' decltype-specifier
     template-id
 ```
 An *identifier* is only an *id-expression* if it has been suitably
-declared [[dcl.dcl]] or if it appears as part of a *declarator-id*
-[[dcl.decl]]. An *identifier* that names a coroutine parameter refers to
-the copy of the parameter [[dcl.fct.def.coroutine]].
 [*Note 1*: For *operator-function-id*s, see  [[over.oper]]; for
 *conversion-function-id*s, see  [[class.conv.fct]]; for
 *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.
@@ -36,46 +33,147 @@ several component names
 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;
@@ -102,23 +200,19 @@ void f() {
 }
 ```
 — *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*.

     identifier
     operator-function-id
     conversion-function-id
     literal-operator-id
     '~' type-name
+    '~' computed-type-specifier
     template-id
 ```
 An *identifier* is only an *id-expression* if it has been suitably
+declared [[dcl]] or if it appears as part of a *declarator-id*
+[[dcl.decl]].
 [*Note 1*: For *operator-function-id*s, see  [[over.oper]]; for
 *conversion-function-id*s, see  [[class.conv.fct]]; for
 *literal-operator-id*s, see  [[over.literal]]; for *template-id*s, see
+[[temp.names]]. A *type-name* or *computed-type-specifier* prefixed by
+`~` denotes the destructor of the type so named; see
+[[expr.prim.id.dtor]]. — *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.
 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,
+- the entity is a local entity [[basic.pre]] or a variable declared by
+  an *init-capture* [[expr.prim.lambda.capture]],
+- naming the entity within the *compound-statement* of the innermost
+  enclosing *lambda-expression* of P, but not in an unevaluated operand,
+ would refer to an entity captured by copy in some intervening
+ *lambda-expression*, and
+- P is in the function parameter scope, but not the
+ *parameter-declaration-clause*, of the innermost such
+  *lambda-expression* E,
+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 the *unqualified-id* names a coroutine parameter, the type
+of the expression is that of the copy of the parameter
+[[dcl.fct.def.coroutine]], and the result is that copy.
+Otherwise, if the *unqualified-id* names a result binding
+[[dcl.contract.res]] attached to a function with return type `U`,
+- if `U` is “reference to `T`”, then the type of the expression is
+  `const T`;
+- otherwise, the type of the expression is `const U`.
+Otherwise, if the *unqualified-id* appears in the predicate of a
+contract assertion C [[basic.contract]] and the entity is
+- a variable declared outside of C of object type `T`,
+- a variable or template parameter declared outside of C of type
+  “reference to `T`”, or
+- a structured binding of type `T` whose corresponding variable is
+  declared outside of C,
+then the type of the expression is `const` `T`.
+[*Example 1*:
+``` cpp
+int n = 0;
+struct X { bool m(); };
+struct Y {
+  int z = 0;
+  void f(int i, int* p, int& r, X x, X* px)
+    pre (++n)       // error: attempting to modify const lvalue
+    pre (++i)       // error: attempting to modify const lvalue
+    pre (++(*p))    // OK
+    pre (++r)       // error: attempting to modify const lvalue
+    pre (x.m())     // error: calling non-const member function
+    pre (px->m())   // OK
+    pre ([=,&i,*this] mutable {
+      ++n;          // error: attempting to modify const lvalue
+      ++i;          // error: attempting to modify const lvalue
+      ++p;          // OK, refers to member of closure type
+      ++r;          // OK, refers to non-reference member of closure type
+      ++this->z;    // OK, captured *this
+      ++z;          // OK, captured *this
+      int j = 17;
+      [&]{
+        int k = 34;
+        ++i;    // error: attempting to modify const lvalue
+        ++j;    // OK
+        ++k;    // OK
+      }();
+      return true;
+    }());
+  template <int N, int& R, int* P>
+  void g()
+    pre(++N)        // error: attempting to modify prvalue
+    pre(++R)        // error: attempting to modify const lvalue
+    pre(++(*P));    // OK
+  int h()
+    post(r : ++r)   // error: attempting to modify const lvalue
+    post(r: [=] mutable {
+       ++r;         // OK, refers to member of closure type
+       return true;
+     }());
+  int& k()
+    post(r : ++r);  // error: attempting to modify const lvalue
+};
+```
+— *end example*]
+Otherwise, 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`.
+In all other cases, the type of the expression is the type of the
+entity.
+[*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 xvalue if it is move-eligible (see below); an
 lvalue if the entity is a function, variable, structured binding
+[[dcl.struct.bind]], result binding [[dcl.contract.res]], data member,
+or template parameter object; and a prvalue otherwise [[basic.lval]]; it
+is a bit-field if the identifier designates a bit-field.
+If an *id-expression* E appears in the predicate of a function contract
+assertion attached to a function *f* and denotes a function parameter of
+*f* and the implementation introduces any temporary objects to hold the
+value of that parameter as specified in [[class.temporary]],
+- if the contract assertion is a precondition assertion and the
+  evaluation of the precondition assertion is sequenced before the
+  initialization of the parameter object, E refers to the most recently
+  initialized such temporary object, and
+- if the contract assertion is a postcondition assertion, it is
+  unspecified whether E refers to one of the temporary objects or the
+  parameter object; the choice is consistent within a single evaluation
+  of a postcondition assertion.
+If an *id-expression* E names a result binding in a postcondition
+assertion and the implementation introduces any temporary objects to
+hold the result object as specified in [[class.temporary]], and the
+postcondition assertion is sequenced before the initialization of the
+result object [[expr.call]], E refers to the most recently initialized
+such temporary object.
+[*Example 2*:
 ``` cpp
 void f() {
   float x, &r = x;
 }
 ```
 — *end example*]
+An *implicitly movable entity* is a variable with automatic storage
 duration that is either a non-volatile object or an rvalue reference to
+a non-volatile object type. An *id-expression* or *splice-expression*
+[[expr.prim.splice]] is *move-eligible* if
+- it designates an implicitly movable entity,
+- it is the (possibly parenthesized) operand of a `return`
+ [[stmt.return]] or `co_return` [[stmt.return.coroutine]] statement or
+ of a *throw-expression* [[expr.throw]], and
+- each intervening scope between the declaration of the entity and the
+  innermost enclosing scope of the expression is a block scope and, for
+ a *throw-expression*, is not the block scope of a *try-block* or
+ *function-try-block*.

Diff to HTML by rtfpessoa