[enum] - C++20 → C++23

Files changed (1) hide show

tmp/tmp1kys2_sb/{from.md → to.md} +47 -60

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

@@ -85,11 +85,13 @@ struct S {
 — *end example*]
 — *end note*]
-If the *enum-head-name* of an *opaque-enum-declaration* contains a
 *nested-name-specifier*, the declaration shall be an explicit
 specialization [[temp.expl.spec]].
 The enumeration type declared with an *enum-key* of only `enum` is an
 *unscoped enumeration*, and its *enumerator*s are *unscoped
@@ -100,16 +102,18 @@ enumerators*. The optional *enum-head-name* shall not be omitted in the
 declaration of a scoped enumeration. The *type-specifier-seq* of an
 *enum-base* shall name an integral type; any cv-qualification is
 ignored. An *opaque-enum-declaration* declaring an unscoped enumeration
 shall not omit the *enum-base*. The identifiers in an *enumerator-list*
 are declared as constants, and can appear wherever constants are
-required. An *enumerator-definition* with `=` gives the associated
-*enumerator* the value indicated by the *constant-expression*. If the
-first *enumerator* has no *initializer*, the value of the corresponding
-constant is zero. An *enumerator-definition* without an *initializer*
-gives the *enumerator* the value obtained by increasing the value of the
-previous *enumerator* by one.
 [*Example 2*:
 ``` cpp
 enum { a, b, c=0 };
@@ -135,19 +139,17 @@ can be provided in a later redeclaration with an
 A scoped enumeration shall not be later redeclared as unscoped or with a
 different underlying type. An unscoped enumeration shall not be later
 redeclared as scoped and each redeclaration shall include an *enum-base*
 specifying the same underlying type as in the original declaration.
-If an *enum-head-name* contains a *nested-name-specifier*, it shall not
-begin with a *decltype-specifier* and the enclosing *enum-specifier* or
-*opaque-enum-declaration* shall refer to an enumeration that was
-previously declared directly in the class or namespace to which the
-*nested-name-specifier* refers, or in an element of the inline namespace
-set [[namespace.def]] of that namespace (i.e., neither inherited nor
-introduced by a *using-declaration*), and the *enum-specifier* or
-*opaque-enum-declaration* shall appear in a namespace enclosing the
-previous declaration.
 Each enumeration defines a type that is different from all other types.
 Each enumeration also has an *underlying type*. The underlying type can
 be explicitly specified using an *enum-base*. For a scoped enumeration
 type, the underlying type is `int` if it is not explicitly specified. In
@@ -171,16 +173,15 @@ the closing brace is determined as follows:
   preceding enumerator unless the incremented value is not representable
   in that type, in which case the type is an unspecified integral type
   sufficient to contain the incremented value. If no such type exists,
   the program is ill-formed.
-An enumeration whose underlying type is fixed is an incomplete type from
-its point of declaration [[basic.scope.pdecl]] to immediately after its
-*enum-base* (if any), at which point it becomes a complete type. An
-enumeration whose underlying type is not fixed is an incomplete type
-from its point of declaration to immediately after the closing `}` of
-its *enum-specifier*, at which point it becomes a complete type.
 For an enumeration whose underlying type is not fixed, the underlying
 type is an integral type that can represent all the enumerator values
 defined in the enumeration. If no integral type can represent all the
 enumerator values, the enumeration is ill-formed. It is
@@ -198,10 +199,15 @@ represented. The width of the smallest bit-field large enough to hold
 all the values of the enumeration type is M. It is possible to define an
 enumeration that has values not defined by any of its enumerators. If
 the *enumerator-list* is empty, the values of the enumeration are as if
 the enumeration had a single enumerator with value 0.[^9]
 Two enumeration types are *layout-compatible enumerations* if they have
 the same underlying type.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion [[conv.prom]].
@@ -222,11 +228,11 @@ type. The possible values of an object of type `color` are `red`,
 values `0`, `1`, `20`, and `21`. Since enumerations are distinct types,
 objects of type `color` can be assigned only values of type `color`.
 ``` cpp
 color c = 1;                    // error: type mismatch, no conversion from int to color
-int i = yellow;                 // OK: yellow converted to integral value 1, integral promotion
 ```
 Note that this implicit `enum` to `int` conversion is not provided for a
 scoped enumeration:
@@ -237,19 +243,17 @@ Col y = Col::red;
 if (y) { }                      // error: no Col to bool conversion
 ```
 — *end example*]
-Each *enum-name* and each unscoped *enumerator* is declared in the scope
-that immediately contains the *enum-specifier*. Each scoped *enumerator*
-is declared in the scope of the enumeration. An unnamed enumeration that
 does not have a typedef name for linkage purposes [[dcl.typedef]] and
 that has a first enumerator is denoted, for linkage purposes
 [[basic.link]], by its underlying type and its first enumerator; such an
 enumeration is said to have an enumerator as a name for linkage
-purposes. These names obey the scope rules defined for all names in
-[[basic.scope]] and  [[basic.lookup]].
 [*Note 3*: Each unnamed enumeration with no enumerators is a distinct
 type. — *end note*]
 [*Example 4*:
@@ -272,52 +276,35 @@ void h()  {
 }
 ```
 — *end example*]
-An enumerator declared in class scope can be referred to using the class
-member access operators (`::`, `.` (dot) and `->` (arrow)), see
-[[expr.ref]].
-[*Example 5*:
-``` cpp
-struct X {
-  enum direction { left='l', right='r' };
-  int f(int i) { return i==left ? 0 : i==right ? 1 : 2; }
-};
-void g(X* p) {
-  direction d;                  // error: direction not in scope
-  int i;
-  i = p->f(left);               // error: left not in scope
-  i = p->f(X::right);           // OK
-  i = p->f(p->left);            // OK
-  // ...
-}
-```
-— *end example*]
 ### The `using enum` declaration <a id="enum.udecl">[[enum.udecl]]</a>
 ``` bnf
 using-enum-declaration:
- 'using' elaborated-enum-specifier ';'
 ```
-The *elaborated-enum-specifier* shall not name a dependent type and the
-type shall have a reachable *enum-specifier*.
-A *using-enum-declaration* introduces the enumerator names of the named
-enumeration as if by a *using-declaration* for each enumerator.
 [*Note 1*:
-A *using-enum-declaration* in class scope adds the enumerators of the
-named enumeration as members to the scope. This means they are
-accessible for member lookup.
 [*Example 1*:
 ``` cpp
 enum class fruit { orange, apple };

 — *end example*]
 — *end note*]
+The *identifier* in an *enum-head-name* is not looked up and is
+introduced by the *enum-specifier* or *opaque-enum-declaration*. If the
+*enum-head-name* of an *opaque-enum-declaration* contains a
 *nested-name-specifier*, the declaration shall be an explicit
 specialization [[temp.expl.spec]].
 The enumeration type declared with an *enum-key* of only `enum` is an
 *unscoped enumeration*, and its *enumerator*s are *unscoped
 declaration of a scoped enumeration. The *type-specifier-seq* of an
 *enum-base* shall name an integral type; any cv-qualification is
 ignored. An *opaque-enum-declaration* declaring an unscoped enumeration
 shall not omit the *enum-base*. The identifiers in an *enumerator-list*
 are declared as constants, and can appear wherever constants are
+required. The same identifier shall not appear as the name of multiple
+enumerators in an *enumerator-list*. An *enumerator-definition* with `=`
+gives the associated *enumerator* the value indicated by the
+*constant-expression*. If the first *enumerator* has no *initializer*,
+the value of the corresponding constant is zero. An
+*enumerator-definition* without an *initializer* gives the *enumerator*
+the value obtained by increasing the value of the previous *enumerator*
+by one.
 [*Example 2*:
 ``` cpp
 enum { a, b, c=0 };
 A scoped enumeration shall not be later redeclared as unscoped or with a
 different underlying type. An unscoped enumeration shall not be later
 redeclared as scoped and each redeclaration shall include an *enum-base*
 specifying the same underlying type as in the original declaration.
+If an *enum-head-name* contains a *nested-name-specifier*, the enclosing
+*enum-specifier* or *opaque-enum-declaration* D shall not inhabit a
+class scope and shall correspond to one or more declarations nominable
+in the class, class template, or namespace to which the
+*nested-name-specifier* refers [[basic.scope.scope]]. All those
+declarations shall have the same target scope; the target scope of D is
+that scope.
 Each enumeration defines a type that is different from all other types.
 Each enumeration also has an *underlying type*. The underlying type can
 be explicitly specified using an *enum-base*. For a scoped enumeration
 type, the underlying type is `int` if it is not explicitly specified. In
   preceding enumerator unless the incremented value is not representable
   in that type, in which case the type is an unspecified integral type
   sufficient to contain the incremented value. If no such type exists,
   the program is ill-formed.
+An enumeration whose underlying type is fixed is an incomplete type
+until immediately after its *enum-base* (if any), at which point it
+becomes a complete type. An enumeration whose underlying type is not
+fixed is an incomplete type until the closing `}` of its
+*enum-specifier*, at which point it becomes a complete type.
 For an enumeration whose underlying type is not fixed, the underlying
 type is an integral type that can represent all the enumerator values
 defined in the enumeration. If no integral type can represent all the
 enumerator values, the enumeration is ill-formed. It is
 all the values of the enumeration type is M. It is possible to define an
 enumeration that has values not defined by any of its enumerators. If
 the *enumerator-list* is empty, the values of the enumeration are as if
 the enumeration had a single enumerator with value 0.[^9]
+An enumeration has the same size, value representation, and alignment
+requirements [[basic.align]] as its underlying type. Furthermore, each
+value of an enumeration has the same representation as the corresponding
+value of the underlying type.
 Two enumeration types are *layout-compatible enumerations* if they have
 the same underlying type.
 The value of an enumerator or an object of an unscoped enumeration type
 is converted to an integer by integral promotion [[conv.prom]].
 values `0`, `1`, `20`, and `21`. Since enumerations are distinct types,
 objects of type `color` can be assigned only values of type `color`.
 ``` cpp
 color c = 1;                    // error: type mismatch, no conversion from int to color
+int i = yellow;                 // OK, yellow converted to integral value 1, integral promotion
 ```
 Note that this implicit `enum` to `int` conversion is not provided for a
 scoped enumeration:
 if (y) { }                      // error: no Col to bool conversion
 ```
 — *end example*]
+The name of each unscoped enumerator is also bound in the scope that
+immediately contains the *enum-specifier*. An unnamed enumeration that
 does not have a typedef name for linkage purposes [[dcl.typedef]] and
 that has a first enumerator is denoted, for linkage purposes
 [[basic.link]], by its underlying type and its first enumerator; such an
 enumeration is said to have an enumerator as a name for linkage
+purposes.
 [*Note 3*: Each unnamed enumeration with no enumerators is a distinct
 type. — *end note*]
 [*Example 4*:
 }
 ```
 — *end example*]
 ### The `using enum` declaration <a id="enum.udecl">[[enum.udecl]]</a>
 ``` bnf
 using-enum-declaration:
+    using enum using-enum-declarator ';'
 ```
+``` bnf
+using-enum-declarator:
+    nested-name-specifierₒₚₜ identifier
+    nested-name-specifierₒₚₜ simple-template-id
+```
+A *using-enum-declarator* names the set of declarations found by lookup
+[[basic.lookup.unqual]], [[basic.lookup.qual]] for the
+*using-enum-declarator*. The *using-enum-declarator* shall designate a
+non-dependent type with a reachable *enum-specifier*.
+A *using-enum-declaration* is equivalent to a *using-declaration* for
+each enumerator.
 [*Note 1*:
+A *using-enum-declaration* in class scope makes the enumerators of the
+named enumeration available via member lookup.
 [*Example 1*:
 ``` cpp
 enum class fruit { orange, apple };

Diff to HTML by rtfpessoa