[basic.def.odr] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpzx25nqyl/{from.md → to.md} +134 -58

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

@@ -18,11 +18,12 @@ An expression or conversion is *potentially evaluated* unless it is an
 unevaluated operand [[expr.context]], a subexpression thereof, or a
 conversion in an initialization or conversion sequence in such a
 context. The set of *potential results* of an expression E is defined as
 follows:
-- If E is an *id-expression* [[expr.prim.id]], the set contains only E.
 - If E is a subscripting operation [[expr.sub]] with an array operand,
   the set contains the potential results of that operand.
 - If E is a class member access expression [[expr.ref]] of the form E₁
   `.` `template`ₒₚₜ  E₂ naming a non-static data member, the set
   contains the potential results of E₁.
@@ -39,24 +40,26 @@ follows:
   potential results of the right operand.
 - Otherwise, the set is empty.
 [*Note 1*:
-This set is a (possibly-empty) set of *id-expression*s, each of which is
-either E or a subexpression of E.
 [*Example 1*:
 In the following example, the set of potential results of the
 initializer of `n` contains the first `S::x` subexpression, but not the
-second `S::x` subexpression.
 ``` cpp
 struct S { static const int x = 0; };
 const int &f(const int &r);
 int n = b ? (1, S::x)           // S::x is not odr-used here
           : f(S::x);            // S::x is odr-used here, so a definition is required
 ```
 — *end example*]
 — *end note*]
@@ -65,13 +68,13 @@ A function is *named by* an expression or conversion as follows:
 - A function is named by an expression or conversion if it is the
   selected member of an overload set
   [[basic.lookup]], [[over.match]], [[over.over]] in an overload
   resolution performed as part of forming that expression or conversion,
- unless it is a pure virtual function and either the expression is not
- an *id-expression* naming the function with an explicitly qualified
- name or the expression forms a pointer to member [[expr.unary.op]].
   \[*Note 2*: This covers taking the address of functions
   [[conv.func]], [[expr.unary.op]], calls to named functions
   [[expr.call]], operator overloading [[over]], user-defined conversions
   [[class.conv.fct]], allocation functions for *new-expression*s
   [[expr.new]], as well as non-default initialization [[dcl.init]]. A
@@ -86,31 +89,64 @@ A function is *named by* an expression or conversion as follows:
 - A deallocation function for a class is named by a *delete-expression*
   if it is the selected usual deallocation function as specified in
   [[expr.delete]] and  [[class.free]].
 A variable is named by an expression if the expression is an
-*id-expression* that denotes it. A variable `x` that is named by a
-potentially-evaluated expression E is *odr-used* by E unless
-- `x` is a reference that is usable in constant expressions
-  [[expr.const]], or
-- `x` is a variable of non-reference type that is usable in constant
- expressions and has no mutable subobjects, and E is an element of the
- set of potential results of an expression of non-volatile-qualified
-  non-class type to which the lvalue-to-rvalue conversion [[conv.lval]]
-  is applied, or
-- `x` is a variable of non-reference type, and E is an element of the
-  set of potential results of a discarded-value expression
-  [[expr.context]] to which the lvalue-to-rvalue conversion is not
-  applied.
-A structured binding is odr-used if it appears as a
 potentially-evaluated expression.
 `*this` is odr-used if `this` appears as a potentially-evaluated
-expression (including as the result of the implicit transformation in
-the body of a non-static member function [[class.mfct.non.static]]).
 A virtual member function is odr-used if it is not pure. A function is
 odr-used if it is named by a potentially-evaluated expression or
 conversion. A non-placement allocation or deallocation function for a
 class is odr-used by the definition of a constructor of that class. A
@@ -118,36 +154,40 @@ non-placement deallocation function for a class is odr-used by the
 definition of the destructor of that class, or by being selected by the
 lookup at the point of definition of a virtual destructor
 [[class.dtor]].[^2]
 An assignment operator function in a class is odr-used by an
-implicitly-defined copy-assignment or move-assignment function for
 another class as specified in  [[class.copy.assign]]. A constructor for
 a class is odr-used as specified in  [[dcl.init]]. A destructor for a
 class is odr-used if it is potentially invoked [[class.dtor]].
 A local entity [[basic.pre]] is *odr-usable* in a scope
-[[basic.scope.scope]] if:
 - either the local entity is not `*this`, or an enclosing class or
   non-lambda function parameter scope exists and, if the innermost such
   scope is a function parameter scope, it corresponds to a non-static
   member function, and
 - for each intervening scope [[basic.scope.scope]] between the point at
   which the entity is introduced and the scope (where `*this` is
   considered to be introduced within the innermost enclosing class or
-  non-lambda function definition scope), either:
-  - the intervening scope is a block scope, or
   - the intervening scope is the function parameter scope of a
-    *lambda-expression* that has a *simple-capture* naming the entity or
-    has a *capture-default*, and the block scope of the
-    *lambda-expression* is also an intervening scope.
 If a local entity is odr-used in a scope in which it is not odr-usable,
 the program is ill-formed.
-[*Example 2*:
 ``` cpp
 void f(int n) {
   [] { n = 1; };                // error: n is not odr-usable due to intervening lambda-expression
   struct A {
@@ -160,19 +200,41 @@ void f(int n) {
 }
 ```
 — *end example*]
 Every program shall contain at least one definition of every function or
 variable that is odr-used in that program outside of a discarded
 statement [[stmt.if]]; no diagnostic required. The definition can appear
 explicitly in the program, it can be found in the standard or a
 user-defined library, or (when appropriate) it is implicitly defined
 (see  [[class.default.ctor]], [[class.copy.ctor]], [[class.dtor]], and
 [[class.copy.assign]]).
-[*Example 3*:
 ``` cpp
 auto f() {
   struct A {};
   return A{};
@@ -195,11 +257,11 @@ end of every definition domain in which it is odr-used outside of a
 discarded statement.
 A definition of a class shall be reachable in every context in which the
 class is used in a way that requires the class type to be complete.
-[*Example 4*:
 The following complete translation unit is well-formed, even though it
 never defines `X`:
 ``` cpp
@@ -211,11 +273,11 @@ X* x2;                          // use X in pointer formation
 — *end example*]
 [*Note 3*:
 The rules for declarations and expressions describe in which contexts
-complete class types are required. A class type `T` must be complete if:
 - an object of type `T` is defined [[basic.def]], or
 - a non-static class data member of type `T` is declared [[class.mem]],
   or
 - `T` is used as the allocated type or array element type in a
@@ -235,20 +297,27 @@ complete class types are required. A class type `T` must be complete if:
 - the `typeid` operator [[expr.typeid]] or the `sizeof` operator
   [[expr.sizeof]] is applied to an operand of type `T`, or
 - a function with a return type or argument type of type `T` is defined
   [[basic.def]] or called [[expr.call]], or
 - a class with a base class of type `T` is defined [[class.derived]], or
-- an lvalue of type `T` is assigned to [[expr.ass]], or
 - the type `T` is the subject of an `alignof` expression
   [[expr.alignof]], or
 - an *exception-declaration* has type `T`, reference to `T`, or pointer
   to `T` [[except.handle]].
 — *end note*]
-For any definable item `D` with definitions in multiple translation
-units,
 - if `D` is a non-inline non-templated function or variable, or
 - if the definitions in different translation units do not satisfy the
   following requirements,
@@ -263,24 +332,25 @@ point, the following requirements shall be satisfied.
   [[module.unit]].
 - Each such definition shall consist of the same sequence of tokens,
   where the definition of a closure type is considered to consist of the
   sequence of tokens of the corresponding *lambda-expression*.
 - In each such definition, corresponding names, looked up according to
-  [[basic.lookup]], shall refer to the same entity, after overload
   resolution [[over.match]] and after matching of partial template
- specialization [[temp.over]], except that a name can refer to
   - a non-volatile const object with internal or no linkage if the
     object
     - has the same literal type in all definitions of `D`,
     - is initialized with a constant expression [[expr.const]],
     - is not odr-used in any definition of `D`, and
     - has the same value in all definitions of `D`,
     or
   - a reference with internal or no linkage initialized with a constant
-    expression such that the reference refers to the same entity in all
-    definitions of `D`.
 - In each such definition, except within the default arguments and
   default template arguments of `D`, corresponding *lambda-expression*s
   shall have the same closure type (see below).
 - In each such definition, corresponding entities shall have the same
   language linkage.
@@ -294,20 +364,26 @@ point, the following requirements shall be satisfied.
   implicit calls to conversion functions, constructors, operator new
   functions and operator delete functions, shall refer to the same
   function.
 - In each such definition, a default argument used by an (implicit or
   explicit) function call or a default template argument used by an
-  (implicit or explicit) *template-id* or *simple-template-id* is
-  treated as if its token sequence were present in the definition of
-  `D`; that is, the default argument or default template argument is
-  subject to the requirements described in this paragraph (recursively).
 - If `D` is a class with an implicitly-declared constructor
   [[class.default.ctor]], [[class.copy.ctor]], it is as if the
   constructor was implicitly defined in every translation unit where it
   is odr-used, and the implicit definition in every translation unit
   shall call the same constructor for a subobject of `D`.
-  \[*Example 5*:
   ``` cpp
   // translation unit 1:
   struct X {
     X(int, int);
     X(int, int, int);
@@ -335,31 +411,31 @@ point, the following requirements shall be satisfied.
 - If `D` is a class with a defaulted three-way comparison operator
   function [[class.spaceship]], it is as if the operator was implicitly
   defined in every translation unit where it is odr-used, and the
   implicit definition in every translation unit shall call the same
   comparison operators for each subobject of `D`.
-If `D` is a template and is defined in more than one translation unit,
-then the preceding requirements shall apply both to names from the
-template’s enclosing scope used in the template definition, and also to
-dependent names at the point of instantiation [[temp.dep]]. These
-requirements also apply to corresponding entities defined within each
-definition of `D` (including the closure types of *lambda-expression*s,
-but excluding entities defined within default arguments or default
-template arguments of either `D` or an entity not defined within `D`).
-For each such entity and for `D` itself, the behavior is as if there is
-a single entity with a single definition, including in the application
-of these requirements to other entities.
 [*Note 4*: The entity is still declared in multiple translation units,
 and [[basic.link]] still applies to these declarations. In particular,
 *lambda-expression*s [[expr.prim.lambda]] appearing in the type of `D`
 can result in the different declarations having distinct types, and
 *lambda-expression*s appearing in a default argument of `D` might still
 denote different types in different translation units. — *end note*]
-[*Example 6*:
 ``` cpp
 inline void f(bool cond, void (*p)()) {
   if (cond) f(false, []{});
 }

 unevaluated operand [[expr.context]], a subexpression thereof, or a
 conversion in an initialization or conversion sequence in such a
 context. The set of *potential results* of an expression E is defined as
 follows:
+- If E is an *id-expression* [[expr.prim.id]] or a *splice-expression*
+  [[expr.prim.splice]], the set contains only E.
 - If E is a subscripting operation [[expr.sub]] with an array operand,
   the set contains the potential results of that operand.
 - If E is a class member access expression [[expr.ref]] of the form E₁
   `.` `template`ₒₚₜ  E₂ naming a non-static data member, the set
   contains the potential results of E₁.
   potential results of the right operand.
 - Otherwise, the set is empty.
 [*Note 1*:
+This set is a (possibly-empty) set of *id-expression*s and
+*splice-expression*s, each of which is either E or a subexpression of E.
 [*Example 1*:
 In the following example, the set of potential results of the
 initializer of `n` contains the first `S::x` subexpression, but not the
+second `S::x` subexpression. The set of potential results of the
+initializer of `o` contains the subexpression `[:^^ S::x:]`.
 ``` cpp
 struct S { static const int x = 0; };
 const int &f(const int &r);
 int n = b ? (1, S::x)           // S::x is not odr-used here
           : f(S::x);            // S::x is odr-used here, so a definition is required
+int o = [:^^S::x:];
 ```
 — *end example*]
 — *end note*]
 - A function is named by an expression or conversion if it is the
   selected member of an overload set
   [[basic.lookup]], [[over.match]], [[over.over]] in an overload
   resolution performed as part of forming that expression or conversion,
+ and either it is not a pure virtual function or the expression is an
+  *id-expression* naming the function with an explicitly qualified name
+ that does not form a pointer to member [[expr.unary.op]].
   \[*Note 2*: This covers taking the address of functions
   [[conv.func]], [[expr.unary.op]], calls to named functions
   [[expr.call]], operator overloading [[over]], user-defined conversions
   [[class.conv.fct]], allocation functions for *new-expression*s
   [[expr.new]], as well as non-default initialization [[dcl.init]]. A
 - A deallocation function for a class is named by a *delete-expression*
   if it is the selected usual deallocation function as specified in
   [[expr.delete]] and  [[class.free]].
 A variable is named by an expression if the expression is an
+*id-expression* or *splice-expression* [[expr.prim.splice]] that
+designates it. A variable `x` that is named by a potentially-evaluated
+expression N that appears at a point P is *odr-used* by N unless
+- `x` is a reference that is usable in constant expressions at P
+  [[expr.const]] or
+- N is an element of the set of potential results of an expression E,
+ where
+ - E is a discarded-value expression [[expr.context]] to which the
+ lvalue-to-rvalue conversion is not applied or
+ - `x` is a non-volatile object that is usable in constant expressions
+    at P and has no mutable subobjects and
+    - E is a class member access expression [[expr.ref]] naming a
+      non-static data member of reference type and whose object
+      expression has non-volatile-qualified type or
+    - the lvalue-to-rvalue conversion [[conv.lval]] is applied to E and
+      E has non-volatile-qualified non-class type
+[*Example 2*:
+``` cpp
+int f(int);
+int g(int&);
+struct A {
+  int x;
+};
+struct B {
+  int& r;
+};
+int h(bool cond) {
+  constexpr A a = {1};
+  constexpr const volatile A& r = a;    // odr-uses a
+  int _ = f(cond ? a.x : r.x);          // does not odr-use a or r
+  int x, y;
+  constexpr B b1 = {x}, b2 = {y};       // odr-uses x and y
+  int _ = g(cond ? b1.r : b2.r);        // does not odr-use b1 or b2
+  int _ = ((cond ? x : y), 0);          // does not odr-use x or y
+  return [] {
+    return b1.r;                        // error: b1 is odr-used here because the object
+                                        // referred to by b1.r is not constexpr-referenceable here
+  }();
+}
+```
+— *end example*]
+A structured binding is named by an expression if that expression is
+either an *id-expression* or a *splice-expression* that designates that
+structured binding. A structured binding is odr-used if it is named by a
 potentially-evaluated expression.
 `*this` is odr-used if `this` appears as a potentially-evaluated
+expression (including as the result of any implicit transformation to a
+class member access expression [[expr.prim.id.general]]).
 A virtual member function is odr-used if it is not pure. A function is
 odr-used if it is named by a potentially-evaluated expression or
 conversion. A non-placement allocation or deallocation function for a
 class is odr-used by the definition of a constructor of that class. A
 definition of the destructor of that class, or by being selected by the
 lookup at the point of definition of a virtual destructor
 [[class.dtor]].[^2]
 An assignment operator function in a class is odr-used by an
+implicitly-defined copy assignment or move assignment function for
 another class as specified in  [[class.copy.assign]]. A constructor for
 a class is odr-used as specified in  [[dcl.init]]. A destructor for a
 class is odr-used if it is potentially invoked [[class.dtor]].
 A local entity [[basic.pre]] is *odr-usable* in a scope
+[[basic.scope.scope]] if
 - either the local entity is not `*this`, or an enclosing class or
   non-lambda function parameter scope exists and, if the innermost such
   scope is a function parameter scope, it corresponds to a non-static
   member function, and
 - for each intervening scope [[basic.scope.scope]] between the point at
   which the entity is introduced and the scope (where `*this` is
   considered to be introduced within the innermost enclosing class or
+  non-lambda function definition scope), either
+  - the intervening scope is a block scope,
+  - the intervening scope is a contract-assertion scope
+    [[basic.scope.contract]],
   - the intervening scope is the function parameter scope of a
+    *lambda-expression* or *requires-expression*, or
+  - the intervening scope is the lambda scope of a *lambda-expression*
+ that has a *simple-capture* naming the entity or has a
+    *capture-default*, and the block scope of the *lambda-expression* is
+    also an intervening scope.
 If a local entity is odr-used in a scope in which it is not odr-usable,
 the program is ill-formed.
+[*Example 3*:
 ``` cpp
 void f(int n) {
   [] { n = 1; };                // error: n is not odr-usable due to intervening lambda-expression
   struct A {
 }
 ```
 — *end example*]
+[*Example 4*:
+``` cpp
+void g() {
+  constexpr int x = 1;
+  auto lambda = [] <typename T, int = ((T)x, 0)> {};    // OK
+  lambda.operator()<int, 1>();          // OK, does not consider x at all
+  lambda.operator()<int>();             // OK, does not odr-use x
+  lambda.operator()<const int&>();      // error: odr-uses x from a context where x is not odr-usable
+}
+void h() {
+  constexpr int x = 1;
+  auto lambda = [] <typename T> { (T)x; };      // OK
+  lambda.operator()<int>();             // OK, does not odr-use x
+  lambda.operator()<void>();            // OK, does not odr-use x
+  lambda.operator()<const int&>();      // error: odr-uses x from a context where x is not odr-usable
+}
+```
+— *end example*]
 Every program shall contain at least one definition of every function or
 variable that is odr-used in that program outside of a discarded
 statement [[stmt.if]]; no diagnostic required. The definition can appear
 explicitly in the program, it can be found in the standard or a
 user-defined library, or (when appropriate) it is implicitly defined
 (see  [[class.default.ctor]], [[class.copy.ctor]], [[class.dtor]], and
 [[class.copy.assign]]).
+[*Example 5*:
 ``` cpp
 auto f() {
   struct A {};
   return A{};
 discarded statement.
 A definition of a class shall be reachable in every context in which the
 class is used in a way that requires the class type to be complete.
+[*Example 6*:
 The following complete translation unit is well-formed, even though it
 never defines `X`:
 ``` cpp
 — *end example*]
 [*Note 3*:
 The rules for declarations and expressions describe in which contexts
+complete class types are required. A class type `T` must be complete if
 - an object of type `T` is defined [[basic.def]], or
 - a non-static class data member of type `T` is declared [[class.mem]],
   or
 - `T` is used as the allocated type or array element type in a
 - the `typeid` operator [[expr.typeid]] or the `sizeof` operator
   [[expr.sizeof]] is applied to an operand of type `T`, or
 - a function with a return type or argument type of type `T` is defined
   [[basic.def]] or called [[expr.call]], or
 - a class with a base class of type `T` is defined [[class.derived]], or
+- an lvalue of type `T` is assigned to [[expr.assign]], or
 - the type `T` is the subject of an `alignof` expression
   [[expr.alignof]], or
 - an *exception-declaration* has type `T`, reference to `T`, or pointer
   to `T` [[except.handle]].
 — *end note*]
+If a definable item `D` is defined in a translation unit by an injected
+declaration X [[expr.const]] and another translation unit contains a
+definition of `D`, that definition shall be an injected declaration
+having the same characteristic sequence as X; a diagnostic is required
+only if `D` is attached to a named module and a prior definition is
+reachable at the point where a later definition occurs.
+For any other definable item `D` with definitions in multiple
+translation units,
 - if `D` is a non-inline non-templated function or variable, or
 - if the definitions in different translation units do not satisfy the
   following requirements,
   [[module.unit]].
 - Each such definition shall consist of the same sequence of tokens,
   where the definition of a closure type is considered to consist of the
   sequence of tokens of the corresponding *lambda-expression*.
 - In each such definition, corresponding names, looked up according to
+  [[basic.lookup]], shall denote the same entity, after overload
   resolution [[over.match]] and after matching of partial template
+ specializations [[temp.spec.partial.match]], except that a name can
+  refer to
   - a non-volatile const object with internal or no linkage if the
     object
     - has the same literal type in all definitions of `D`,
     - is initialized with a constant expression [[expr.const]],
     - is not odr-used in any definition of `D`, and
     - has the same value in all definitions of `D`,
     or
   - a reference with internal or no linkage initialized with a constant
+    expression such that the reference refers to the same object or
+ function in all definitions of `D`.
 - In each such definition, except within the default arguments and
   default template arguments of `D`, corresponding *lambda-expression*s
   shall have the same closure type (see below).
 - In each such definition, corresponding entities shall have the same
   language linkage.
   implicit calls to conversion functions, constructors, operator new
   functions and operator delete functions, shall refer to the same
   function.
 - In each such definition, a default argument used by an (implicit or
   explicit) function call or a default template argument used by an
+  (implicit or explicit) *template-id*, *simple-template-id*, or
+ *splice-specialization-specifier* is treated as if its token sequence
+ were present in the definition of `D`; that is, the default argument
+ or default template argument is subject to the requirements described
+  in this paragraph (recursively).
+- In each such definition, corresponding *reflect-expression*s
+  [[expr.reflect]] compute equivalent values [[expr.eq]].
+For the purposes of the preceding requirements:
 - If `D` is a class with an implicitly-declared constructor
   [[class.default.ctor]], [[class.copy.ctor]], it is as if the
   constructor was implicitly defined in every translation unit where it
   is odr-used, and the implicit definition in every translation unit
   shall call the same constructor for a subobject of `D`.
+  \[*Example 7*:
   ``` cpp
   // translation unit 1:
   struct X {
     X(int, int);
     X(int, int, int);
 - If `D` is a class with a defaulted three-way comparison operator
   function [[class.spaceship]], it is as if the operator was implicitly
   defined in every translation unit where it is odr-used, and the
   implicit definition in every translation unit shall call the same
   comparison operators for each subobject of `D`.
+- If `D` is a template and is defined in more than one translation unit,
+  the requirements apply both to names from the template’s enclosing
+  scope used in the template definition, and also to dependent names at
+  the point of instantiation [[temp.dep]].
+These requirements also apply to corresponding entities defined within
+each definition of `D` (including the closure types of
+*lambda-expression*s, but excluding entities defined within default
+arguments or default template arguments of either `D` or an entity not
+defined within `D`). For each such entity and for `D` itself, the
+behavior is as if there is a single entity with a single definition,
+including in the application of these requirements to other entities.
 [*Note 4*: The entity is still declared in multiple translation units,
 and [[basic.link]] still applies to these declarations. In particular,
 *lambda-expression*s [[expr.prim.lambda]] appearing in the type of `D`
 can result in the different declarations having distinct types, and
 *lambda-expression*s appearing in a default argument of `D` might still
 denote different types in different translation units. — *end note*]
+[*Example 8*:
 ``` cpp
 inline void f(bool cond, void (*p)()) {
   if (cond) f(false, []{});
 }

Diff to HTML by rtfpessoa