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

Files changed (1) hide show

tmp/tmpzl7z4uo_/{from.md → to.md} +87 -25

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

@@ -8,61 +8,123 @@ qualified-id:
 ``` bnf
 nested-name-specifier:
     '::'
     type-name '::'
     namespace-name '::'
- 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,

 ``` bnf
 nested-name-specifier:
     '::'
     type-name '::'
     namespace-name '::'
+ computed-type-specifier '::'
+    splice-scope-specifier '::'
     nested-name-specifier identifier '::'
     nested-name-specifier templateₒₚₜ simple-template-id '::'
 ```
+``` bnf
+splice-scope-specifier:
+    splice-specifier
+    templateₒₚₜ splice-specialization-specifier
+```
 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 *splice-specifier* or *splice-specialization-specifier* that is not
+followed by `::` is never interpreted as part of a
+*splice-scope-specifier*. The keyword `template` may only be omitted
+from the form `\opt{template} splice-specialization-specifier ::` when
+the *splice-specialization-specifier* is preceded by `typename`.
+[*Example 1*:
+``` cpp
+template<int V>
+struct TCls {
+  static constexpr int s = V;
+  using type = int;
+};
+int v1 = [:^^TCls<1>:]::s;
+int v2 = template [:^^TCls:]<2>::s;             // OK, template binds to splice-scope-specifier
+typename [:^^TCls:]<3>::type v3 = 3;            // OK, typename binds to the qualified name
+template [:^^TCls:]<3>::type v4 = 4;            // OK, template binds to the splice-scope-specifier
+typename template [:^^TCls:]<3>::type v5 = 5;   // OK, same as v3
+[:^^TCls:]<3>::type v6 = 6;                     // error: unexpected <
+```
+— *end example*]
 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
+*computed-type-specifier* or a *splice-scope-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 entity designated by a *nested-name-specifier* is determined as
+follows:
+- The *nested-name-specifier* `::` designates the global namespace.
+- A *nested-name-specifier* with a *computed-type-specifier* designates
+  the same type designated by the *computed-type-specifier*, which shall
+  be a class or enumeration type.
+- For a *nested-name-specifier* of the form `splice-specifier ::`, the
+  *splice-specifier* shall designate a class or enumeration type or a
+  namespace. The *nested-name-specifier* designates the same entity as
+  the *splice-specifier*.
+- For a *nested-name-specifier* of the form
+  `\opt{template} splice-specialization-specifier ::`, the
+  *splice-specifier* of the *splice-specialization-specifier* shall
+  designate a class template or an alias template T. Letting S be the
+  specialization of T corresponding to the template argument list of the
+  *splice-specialization-specifier*, S shall either be a class template
+  specialization or an alias template specialization that denotes a
+  class or enumeration type. The *nested-name-specifier* designates the
+  underlying entity of S.
+- 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 designates the primary template of
+    T; H shall be equivalent to the *template-head* of T
+    [[temp.over.link]].
+ - Otherwise, N designates 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* designates the entity denotes 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`ₒₚₜ  `~` *computed-type-specifier* nor of the form
+*computed-type-specifier* `::` `~` *type-name*.
 The result of a *qualified-id* Q is the entity it denotes
+[[basic.lookup.qual]].
+If Q 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 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`.
+Otherwise, 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,

Diff to HTML by rtfpessoa