[module] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpoy2jv00_/{from.md → to.md} +91 -32

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

@@ -122,11 +122,13 @@ is *attached* to a module as follows:
   or *template-id* or that nominates a class other than with an
   *elaborated-type-specifier* with neither a *nested-name-specifier* nor
   a *simple-template-id*, it is attached to the module to which the
   friend is attached [[basic.link]].
 - Otherwise, if the declaration
-  - is a *namespace-definition* with external linkage or
   - appears within a *linkage-specification* [[dcl.link]]
   it is attached to the global module.
 - Otherwise, the declaration is attached to the module in whose purview
   it appears.
@@ -235,13 +237,13 @@ export using namespace N;       // OK
 ```
 — *end example*]
 If an exported declaration is a *using-declaration* [[namespace.udecl]]
-and is not within a header unit, all entities to which all of the
-*using-declarator*s ultimately refer (if any) shall have been introduced
-with a name having external linkage.
 [*Example 2*:
 Source file \`"b.h"\`
@@ -282,12 +284,12 @@ export using N::h;              // error: #1 has internal linkage
 — *end example*]
 [*Note 2*:
-These constraints do not apply to type names introduced by `typedef`
-declarations and *alias-declaration*s.
 [*Example 3*:
 ``` cpp
 export module M;
@@ -299,20 +301,26 @@ export using T = S;             // OK, exports name T denoting type S
 — *end note*]
 A redeclaration of an entity X is implicitly exported if X was
 introduced by an exported declaration; otherwise it shall not be
-exported.
 [*Example 4*:
 ``` cpp
 export module M;
 struct S { int n; };
 typedef S S;
-export typedef S S;             // OK, does not redeclare an entity
 export struct S;                // error: exported declaration follows non-exported declaration
 ```
 — *end example*]
 [*Note 3*: Names introduced by exported declarations have either
@@ -431,13 +439,14 @@ A *module-import-declaration* that specifies a *header-name* `H` imports
 a synthesized *header unit*, which is a translation unit formed by
 applying phases 1 to 7 of translation [[lex.phases]] to the source file
 or header nominated by `H`, which shall not contain a
 *module-declaration*.
-[*Note 2*: All declarations within a header unit are implicitly
-exported [[module.interface]], and are attached to the global module
-[[module.unit]]. — *end note*]
 An *importable header* is a member of an *implementation-defined* set of
 headers that includes all importable C++ library headers [[headers]].
 `H` shall identify an importable header. Given two such
 *module-import-declaration*s:
@@ -561,11 +570,11 @@ A *global-module-fragment* specifies the contents of the *global module
 fragment* for a module unit. The global module fragment can be used to
 provide declarations that are attached to the global module and usable
 within the module unit.
 A declaration D is *decl-reachable* from a declaration S in the same
-translation unit if:
 - D does not declare a function or function template and S contains an
   *id-expression*, *namespace-name*, *type-name*, *template-name*, or
   *concept-name* naming D, or
 - D declares a function or function template that is named by an
@@ -583,23 +592,24 @@ translation unit if:
   [[over.over]] that contains D and for which the target type is
   dependent, or
 - there exists a declaration M that is not a *namespace-definition* for
   which M is decl-reachable from S and either
   - D is decl-reachable from M, or
-  - D redeclares the entity declared by M or M redeclares the entity
- declared by D, and D neither is a friend declaration nor inhabits a
-    block scope, or
   - D declares a namespace N and M is a member of N, or
-  - one of M and D declares a class or class template C and the other
     declares a member or friend of C, or
   - one of D and M declares an enumeration E and the other declares an
     enumerator of E, or
   - D declares a function or variable and M is declared in D,[^2] or
-  - one of M and D declares a template and the other declares a partial
     or explicit specialization or an implicit or explicit instantiation
     of that template, or
-  - one of M and D declares a class or enumeration type and the other
     introduces a typedef name for linkage purposes for that type.
 In this determination, it is unspecified
 - whether a reference to an *alias-declaration*, `typedef` declaration,
@@ -607,13 +617,18 @@ In this determination, it is unspecified
   the declarations they name prior to this determination,
 - whether a *simple-template-id* that does not denote a dependent type
   and whose *template-name* names an alias template is replaced by its
   denoted type prior to this determination,
 - whether a *decltype-specifier* that does not denote a dependent type
-  is replaced by its denoted type prior to this determination, and
 - whether a non-value-dependent constant expression is replaced by the
-  result of constant evaluation prior to this determination.
 A declaration `D` in a global module fragment of a module unit is
 *discarded* if `D` is not decl-reachable from any *declaration* in the
 *declaration-seq* of the *translation-unit*.
@@ -768,35 +783,49 @@ The *instantiation context* is a set of points within the program that
 determines which declarations are found by argument-dependent name
 lookup [[basic.lookup.argdep]] and which are reachable [[module.reach]]
 in the context of a particular declaration or template instantiation.
 During the implicit definition of a defaulted function
-[[special]], [[class.compare.default]], the instantiation context is the
-union of the instantiation context from the definition of the class and
-the instantiation context of the program construct that resulted in the
-implicit definition of the defaulted function.
 During the implicit instantiation of a template whose point of
 instantiation is specified as that of an enclosing specialization
-[[temp.point]], the instantiation context is the union of the
 instantiation context of the enclosing specialization and, if the
 template is defined in a module interface unit of a module M and the
 point of instantiation is not in a module interface unit of M, the point
 at the end of the *declaration-seq* of the primary module interface unit
 of M (prior to the *private-module-fragment*, if any).
 During the implicit instantiation of a template that is implicitly
 instantiated because it is referenced from within the implicit
-definition of a defaulted function, the instantiation context is the
-instantiation context of the defaulted function.
 During the instantiation of any other template specialization, the
-instantiation context comprises the point of instantiation of the
 template.
 In any other case, the instantiation context at a point within the
-program comprises that point.
 [*Example 1*:
 Translation unit #1
@@ -883,14 +912,40 @@ unspecified which are and under what circumstances.[^3]
 any additional translation units in programs intending to be
 portable. — *end note*]
 A declaration D is *reachable from* a point P if
   - D appears prior to P in the same translation unit, or
   - D is not discarded [[module.global.frag]], appears in a translation
     unit that is reachable from P, and does not appear within a
- *private-module-fragment*.
 A declaration is *reachable* if it is reachable from any point in the
 instantiation context [[module.context]].
 [*Note 3*: Whether a declaration is exported has no bearing on whether
@@ -906,11 +961,11 @@ These reachable semantic properties include type completeness, type
 definitions, initializers, default arguments of functions or template
 declarations, attributes, names bound, etc. Since default arguments are
 evaluated in the context of the call expression, the reachable semantic
 properties of the corresponding parameter types apply in that context.
-[*Example 1*:
 Translation unit #1
 ``` cpp
 export module M:A;
@@ -957,11 +1012,11 @@ void g() { f(); }               // error: no reachable definition of struct B
 — *end note*]
 [*Note 5*: Declarations of an entity can be reachable even where they
 cannot be found by name lookup. — *end note*]
-[*Example 2*:
 Translation unit #1
 ``` cpp
 export module A;
@@ -989,13 +1044,17 @@ X x;                // error: X not visible to unqualified lookup
 [cpp.include]: cpp.md#cpp.include
 [cpp.pre]: cpp.md#cpp.pre
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.link]: dcl.md#dcl.link
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
 [headers]: library.md#headers
 [lex.name]: lex.md#lex.name
 [lex.phases]: lex.md#lex.phases
 [module]: #module
 [module.context]: #module.context
 [module.global.frag]: #module.global.frag
 [module.import]: #module.import
 [module.interface]: #module.interface

   or *template-id* or that nominates a class other than with an
   *elaborated-type-specifier* with neither a *nested-name-specifier* nor
   a *simple-template-id*, it is attached to the module to which the
   friend is attached [[basic.link]].
 - Otherwise, if the declaration
+  - declares a namespace whose name has external linkage,
+  - declares a type alias,
+  - declares a namespace alias, or
   - appears within a *linkage-specification* [[dcl.link]]
   it is attached to the global module.
 - Otherwise, the declaration is attached to the module in whose purview
   it appears.
 ```
 — *end example*]
 If an exported declaration is a *using-declaration* [[namespace.udecl]]
+and is not within a header unit, all entities named by the
+*using-declarator*s (if any) shall either be a type alias or have been
+introduced with a name having external linkage.
 [*Example 2*:
 Source file \`"b.h"\`
 — *end example*]
 [*Note 2*:
+The underlying entity of an exported type alias need not have a name
+with external linkage.
 [*Example 3*:
 ``` cpp
 export module M;
 — *end note*]
 A redeclaration of an entity X is implicitly exported if X was
 introduced by an exported declaration; otherwise it shall not be
+exported unless it is a type alias, a namespace, or a namespace alias.
 [*Example 4*:
 ``` cpp
 export module M;
 struct S { int n; };
 typedef S S;
+export typedef S S;             // OK
 export struct S;                // error: exported declaration follows non-exported declaration
+namespace N {                   // external linkage, attached to global module, not exported
+  void f();
+}
+namespace N {                   // OK, exported namespace redeclaring non-exported namespace
+  export void g();
+}
 ```
 — *end example*]
 [*Note 3*: Names introduced by exported declarations have either
 a synthesized *header unit*, which is a translation unit formed by
 applying phases 1 to 7 of translation [[lex.phases]] to the source file
 or header nominated by `H`, which shall not contain a
 *module-declaration*.
+[*Note 2*: A header unit is a separate translation unit with an
+independent set of defined macros. All declarations within a header unit
+are implicitly exported [[module.interface]], and are attached to the
+global module [[module.unit]]. — *end note*]
 An *importable header* is a member of an *implementation-defined* set of
 headers that includes all importable C++ library headers [[headers]].
 `H` shall identify an importable header. Given two such
 *module-import-declaration*s:
 fragment* for a module unit. The global module fragment can be used to
 provide declarations that are attached to the global module and usable
 within the module unit.
 A declaration D is *decl-reachable* from a declaration S in the same
+translation unit if
 - D does not declare a function or function template and S contains an
   *id-expression*, *namespace-name*, *type-name*, *template-name*, or
   *concept-name* naming D, or
 - D declares a function or function template that is named by an
   [[over.over]] that contains D and for which the target type is
   dependent, or
 - there exists a declaration M that is not a *namespace-definition* for
   which M is decl-reachable from S and either
   - D is decl-reachable from M, or
+  - D and M declare the same entity, and D neither is a friend
+    declaration nor inhabits a block scope, or
   - D declares a namespace N and M is a member of N, or
+  - one of D and M declares a class or class template C and the other
     declares a member or friend of C, or
   - one of D and M declares an enumeration E and the other declares an
     enumerator of E, or
   - D declares a function or variable and M is declared in D,[^2] or
+  - one of D and M declares a template and the other declares a partial
     or explicit specialization or an implicit or explicit instantiation
     of that template, or
+  - M declares a class template and D is a deduction guide for that
+    template, or
+  - one of D and M declares a class or enumeration type and the other
     introduces a typedef name for linkage purposes for that type.
 In this determination, it is unspecified
 - whether a reference to an *alias-declaration*, `typedef` declaration,
   the declarations they name prior to this determination,
 - whether a *simple-template-id* that does not denote a dependent type
   and whose *template-name* names an alias template is replaced by its
   denoted type prior to this determination,
 - whether a *decltype-specifier* that does not denote a dependent type
+  is replaced by its denoted type prior to this determination,
 - whether a non-value-dependent constant expression is replaced by the
+  result of constant evaluation prior to this determination, and
+- whether a *splice-expression*, a *splice-type-specifier*, a
+  *splice-scope-specifier*, or any *splice-specifier* or
+  *splice-specialization-specifier* outside of the preceding is replaced
+  in any non-dependent context by the construct that it designates prior
+  to this determination.
 A declaration `D` in a global module fragment of a module unit is
 *discarded* if `D` is not decl-reachable from any *declaration* in the
 *declaration-seq* of the *translation-unit*.
 determines which declarations are found by argument-dependent name
 lookup [[basic.lookup.argdep]] and which are reachable [[module.reach]]
 in the context of a particular declaration or template instantiation.
 During the implicit definition of a defaulted function
+[[special]], [[class.compare.default]], the instantiation context
+contains each point in the instantiation context from the definition of
+the class and each point in the instantiation context of the program
+construct that resulted in the implicit definition of the defaulted
+function.
 During the implicit instantiation of a template whose point of
 instantiation is specified as that of an enclosing specialization
+[[temp.point]], the instantiation context contains each point in the
 instantiation context of the enclosing specialization and, if the
 template is defined in a module interface unit of a module M and the
 point of instantiation is not in a module interface unit of M, the point
 at the end of the *declaration-seq* of the primary module interface unit
 of M (prior to the *private-module-fragment*, if any).
 During the implicit instantiation of a template that is implicitly
 instantiated because it is referenced from within the implicit
+definition of a defaulted function, the instantiation context contains
+each point in the instantiation context of the defaulted function.
 During the instantiation of any other template specialization, the
+instantiation context contains the point of instantiation of the
 template.
+During the implicit instantiation of any construct that resulted from
+the evaluation of an expression as a core constant expression, the
+instantiation context contains each point in the evaluation context
+[[expr.const]].
+[*Note 1*: Implicit instantiations can result from invocations of
+library functions [[meta.reflection]]. The evaluation context can
+include synthesized points associated with injected declarations
+produced by `std::meta::define_aggregate`
+[[meta.reflection.define.aggregate]]. — *end note*]
 In any other case, the instantiation context at a point within the
+program contains that point.
+The instantiation context contains only the points specified above.
 [*Example 1*:
 Translation unit #1
 any additional translation units in programs intending to be
 portable. — *end note*]
 A declaration D is *reachable from* a point P if
+- P is a non-synthesized point and
   - D appears prior to P in the same translation unit, or
   - D is not discarded [[module.global.frag]], appears in a translation
     unit that is reachable from P, and does not appear within a
+ *private-module-fragment*; or
+- D is the injected declaration for which P is the corresponding
+  synthesized point.
+[*Example 1*:
+``` cpp
+class Incomplete;
+consteval {
+  int n = nonstatic_data_members_of(
+      define_aggregate(^^Incomplete, {data_member_spec(^^int, {.name="x"})}),
+      std::meta::access_context::current()
+    ).size();
+  Incomplete y;         // error: type of y is incomplete
+}
+/* P */
+```
+The value of `n` is 1. The member `Incomplete::x` members-of-precedes
+[[meta.reflection.member.queries]] the synthesized point P associated
+with the injected declaration produced by the call to
+`define_aggregate`.
+— *end example*]
 A declaration is *reachable* if it is reachable from any point in the
 instantiation context [[module.context]].
 [*Note 3*: Whether a declaration is exported has no bearing on whether
 definitions, initializers, default arguments of functions or template
 declarations, attributes, names bound, etc. Since default arguments are
 evaluated in the context of the call expression, the reachable semantic
 properties of the corresponding parameter types apply in that context.
+[*Example 2*:
 Translation unit #1
 ``` cpp
 export module M:A;
 — *end note*]
 [*Note 5*: Declarations of an entity can be reachable even where they
 cannot be found by name lookup. — *end note*]
+[*Example 3*:
 Translation unit #1
 ``` cpp
 export module A;
 [cpp.include]: cpp.md#cpp.include
 [cpp.pre]: cpp.md#cpp.pre
 [dcl.inline]: dcl.md#dcl.inline
 [dcl.link]: dcl.md#dcl.link
 [dcl.spec.auto]: dcl.md#dcl.spec.auto
+[expr.const]: expr.md#expr.const
 [headers]: library.md#headers
 [lex.name]: lex.md#lex.name
 [lex.phases]: lex.md#lex.phases
+[meta.reflection]: meta.md#meta.reflection
+[meta.reflection.define.aggregate]: meta.md#meta.reflection.define.aggregate
+[meta.reflection.member.queries]: meta.md#meta.reflection.member.queries
 [module]: #module
 [module.context]: #module.context
 [module.global.frag]: #module.global.frag
 [module.import]: #module.import
 [module.interface]: #module.interface

Diff to HTML by rtfpessoa