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

Files changed (1) hide show

tmp/tmpyvc556an/{from.md → to.md} +109 -131

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

@@ -115,15 +115,19 @@ global module.
 is not introduced by any *module-declaration*. — *end note*]
 A *module* is either a named module or the global module. A declaration
 is *attached* to a module as follows:
-- If the declaration
- - is a replaceable global allocation or deallocation function (
-    [[new.delete.single]], [[new.delete.array]]), or
-  - is a *namespace-definition* with external linkage, or
- - appears within a *linkage-specification*,
   it is attached to the global module.
 - Otherwise, the declaration is attached to the module in whose purview
   it appears.
@@ -174,35 +178,38 @@ int &c = n;                     // OK
 ## Export declaration <a id="module.interface">[[module.interface]]</a>
 ``` bnf
 export-declaration:
-    export declaration
     export '{' declaration-seqₒₚₜ '}'
     export-keyword module-import-declaration
 ```
-An *export-declaration* shall appear only at namespace scope and only in
 the purview of a module interface unit. An *export-declaration* shall
 not appear directly or indirectly within an unnamed namespace or a
 *private-module-fragment*. An *export-declaration* has the declarative
-effects of its *declaration*, *declaration-seq* (if any), or
-*module-import-declaration*. An *export-declaration* does not establish
-a scope and its *declaration* or *declaration-seq* shall not contain an
-*export-declaration* or *module-import-declaration*.
-A declaration is *exported* if it is
-- a namespace-scope declaration declared within an *export-declaration*,
-  or
 - a *namespace-definition* that contains an exported declaration, or
 - a declaration within a header unit [[module.import]] that introduces
   at least one name.
-An exported declaration that is not a *module-import-declaration* shall
-declare at least one name. If the declaration is not within a header
-unit, it shall not declare a name with internal linkage.
 [*Example 1*:
 Source file \`"a.h"\`
@@ -215,27 +222,24 @@ Translation unit #1
 ``` cpp
 module;
 #include "a.h"                  // error: declaration of x is not in the
                                 // purview of a module interface unit
 export module M;
-export namespace {}             // error: does not introduce any names
-export namespace {
-  int a1;                       // error: export of name with internal linkage
-}
 namespace {
   export int a2;                // error: export of name with internal linkage
 }
 export static int b;            // error: b explicitly declared static
 export int f();                 // OK
 export namespace N { }          // OK
-export using namespace N;       // error: does not declare a name
 ```
 — *end example*]
-If the 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*:
@@ -276,11 +280,11 @@ namespace N {
 export using N::h;              // error: #1 has internal linkage
 ```
 — *end example*]
-[*Note 1*:
 These constraints do not apply to type names introduced by `typedef`
 declarations and *alias-declaration*s.
 [*Example 3*:
@@ -293,13 +297,13 @@ export using T = S;             // OK, exports name T denoting type S
 — *end example*]
 — *end note*]
-A redeclaration of an exported declaration of an entity is implicitly
-exported. An exported redeclaration of a non-exported declaration of an
-entity is ill-formed.
 [*Example 4*:
 ``` cpp
 export module M;
@@ -309,19 +313,16 @@ export typedef S S;             // OK, does not redeclare an entity
 export struct S;                // error: exported declaration follows non-exported declaration
 ```
 — *end example*]
-A name is *exported* by a module if it is introduced or redeclared by an
-exported declaration in the purview of that module.
-[*Note 2*: Exported names have either external linkage or no linkage;
-see [[basic.link]]. Namespace-scope names exported by a module are
-visible to name lookup in any translation unit importing that module;
-see [[basic.scope.namespace]]. Class and enumeration member names are
-visible to name lookup in any context in which a definition of the type
-is reachable. — *end note*]
 [*Example 5*:
 Interface unit of \`M\`
@@ -369,50 +370,24 @@ int main() {
 }
 ```
 — *end example*]
-[*Note 3*:
-Redeclaring a name in an *export-declaration* cannot change the linkage
-of the name [[basic.link]].
-[*Example 6*:
-Interface unit of \`M\`
-``` cpp
-export module M;
-static int f();                 // #1
-export int f();                 // error: #1 gives internal linkage
-struct S;                       // #2
-export struct S;                // error: #2 gives module linkage
-namespace {
-  namespace N {
-    extern int x;               // #3
-  }
-}
-export int N::x;                // error: #3 gives internal linkage
-```
-— *end example*]
-— *end note*]
 [*Note 4*:
 Declarations in an exported *namespace-definition* or in an exported
 *linkage-specification* [[dcl.link]] are exported and subject to the
 rules of exported declarations.
-[*Example 7*:
 ``` cpp
 export module M;
 export namespace N {
   int x;                        // OK
- static_assert(1 == 1); // error: does not declare a name
 }
 ```
 — *end example*]
@@ -425,26 +400,26 @@ module-import-declaration:
     import-keyword module-name attribute-specifier-seqₒₚₜ ';'
     import-keyword module-partition attribute-specifier-seqₒₚₜ ';'
     import-keyword header-name attribute-specifier-seqₒₚₜ ';'
 ```
-A *module-import-declaration* shall only appear at global namespace
-scope. In a module unit, all *module-import-declaration*s and
 *export-declaration*s exporting *module-import-declaration*s shall
-precede all other *declaration*s in the *declaration-seq* of the
 *translation-unit* and of the *private-module-fragment* (if any). The
 optional *attribute-specifier-seq* appertains to the
 *module-import-declaration*.
 A *module-import-declaration* *imports* a set of translation units
 determined as described below.
-[*Note 1*: Namespace-scope names exported by the imported translation
-units become visible [[basic.scope.namespace]] in the importing
-translation unit and declarations within the imported translation units
-become reachable [[module.reach]] in the importing translation unit
-after the import declaration. — *end note*]
 A *module-import-declaration* that specifies a *module-name* `M` imports
 all module interface units of `M`.
 A *module-import-declaration* that specifies a *module-partition* shall
@@ -477,11 +452,12 @@ headers that includes all importable C++ library headers [[headers]].
   header. — *end note*]
 [*Note 4*: A *module-import-declaration* nominating a *header-name* is
 also recognized by the preprocessor, and results in macros defined at
 the end of phase 4 of translation of the header unit being made visible
-as described in [[cpp.import]]. — *end note*]
 A declaration of a name with internal linkage is permitted within a
 header unit despite all declarations being implicitly exported
 [[module.interface]].
@@ -495,12 +471,19 @@ When a *module-import-declaration* imports a translation unit T, it also
 imports all translation units imported by exported
 *module-import-declaration*s in T; such translation units are said to be
 *exported* by T. Additionally, when a *module-import-declaration* in a
 module unit of some module M imports another module unit U of M, it also
 imports all translation units imported by non-exported
-*module-import-declaration*s in the module unit purview of U.[^1] These
-rules may in turn lead to the importation of yet more translation units.
 A module implementation unit shall not be exported.
 [*Example 1*:
@@ -585,30 +568,28 @@ 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
   expression [[basic.def.odr]] appearing in S, or
-- S contains an expression `E` of the form
-  ``` bnf
- postfix-expression '(' expression-listₒₚₜ ')'
- ```
- whose *postfix-expression* denotes a dependent name, or for an
- operator expression whose operator denotes a dependent name, and D is
- found by name lookup for the corresponding name in an expression
- synthesized from `E` by replacing each type-dependent argument or
-  operand with a value of a placeholder type with no associated
- namespaces or entities, or
-- S contains an expression that takes the address of an overloaded
-  function [[over.over]] whose set of overloads 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 is neither a friend declaration nor a
-    block-scope declaration, 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
@@ -620,11 +601,11 @@ translation unit if:
     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,
-  *using-declaration*, or *namespace-alias-declaration* is replaced by
   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
@@ -634,11 +615,11 @@ In this determination, it is unspecified
 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*.
-[*Note 2*: A discarded declaration is neither reachable nor visible to
 name lookup outside the module unit, nor in template instantiations
 whose points of instantiation [[temp.point]] are outside the module
 unit, even when the instantiation context [[module.context]] includes
 the module unit. — *end note*]
@@ -739,18 +720,18 @@ unit that can affect the behavior of other translation units. A
 *private-module-fragment* allows a module to be represented as a single
 translation unit without making all of the contents of the module
 reachable to importers. The presence of a *private-module-fragment*
 affects:
-- the point by which the definition of an exported inline function is
   required [[dcl.inline]],
 - the point by which the definition of an exported function with a
   placeholder return type is required [[dcl.spec.auto]],
 - whether a declaration is required not to be an exposure
   [[basic.link]],
-- where definitions for inline functions and templates must appear (
-  [[basic.def.odr]], [[dcl.inline]], [[temp.pre]]),
 - the instantiation contexts of templates instantiated before it
   [[module.context]], and
 - the reachability of declarations within it [[module.reach]].
 — *end note*]
@@ -759,16 +740,15 @@ affects:
 ``` cpp
 export module A;
 export inline void fn_e();      // error: exported inline function fn_e not defined
                                 // before private module fragment
-inline void fn_m();             // OK, module-linkage inline function
 static void fn_s();
 export struct X;
 export void g(X *x) {
   fn_s();                       // OK, call to static function in same translation unit
-  fn_m();                       // OK, call to module-linkage inline function
 }
 export X *factory();            // OK
 module :private;
 struct X {};                    // definition not reachable from importers of A
@@ -783,19 +763,18 @@ void fn_s() {}
 — *end example*]
 ## Instantiation context <a id="module.context">[[module.context]]</a>
 The *instantiation context* is a set of points within the program that
-determines which names are visible to argument-dependent name lookup
-[[basic.lookup.argdep]] and which declarations 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
@@ -867,11 +846,11 @@ comprises
 - the point at the end of translation unit \#1,
 - the point at the end of translation unit \#2, and
 - the point of the call to `f(0)`,
-so the definition of `X` is reachable ([[module.reach]]).
 It is unspecified whether the call to `g(0)` is valid: the instantiation
 context of `bar<int, X>` comprises
 - the point at the end of translation unit \#1,
@@ -886,34 +865,36 @@ so the definition of `X` need not be reachable, as described in
 ## Reachability <a id="module.reach">[[module.reach]]</a>
 A translation unit U is *necessarily reachable* from a point P if U is a
 module interface unit on which the translation unit containing P has an
 interface dependency, or the translation unit containing P imports U, in
-either case prior to P ([[module.import]]).
 [*Note 1*: While module interface units are reachable even when they
 are only transitively imported via a non-exported import declaration,
-namespace-scope names from such module interface units are not visible
-to name lookup [[basic.scope.namespace]]. — *end note*]
-All translation units that are necessarily reachable are *reachable*. It
-is unspecified whether additional translation units on which the point
-within the program has an interface dependency are considered reachable,
-and under what circumstances. [^3]
 [*Note 2*: It is advisable to avoid depending on the reachability of
 any additional translation units in programs intending to be
 portable. — *end note*]
-A declaration D is *reachable* if, for any point P in the instantiation
-context [[module.context]],
 - 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*.
 [*Note 3*: Whether a declaration is exported has no bearing on whether
 it is reachable. — *end note*]
 The accumulated properties of all reachable declarations of an entity
 within a context determine the behavior of the entity within that
@@ -921,14 +902,13 @@ context.
 [*Note 4*:
 These reachable semantic properties include type completeness, type
 definitions, initializers, default arguments of functions or template
-declarations, attributes, visibility of class or enumeration member
-names to ordinary lookup, 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
@@ -965,22 +945,21 @@ export void f(B b = B());
 ```
 Translation unit #5
 ``` cpp
-module X;
 import M;
 B b3;                           // error: no reachable definition of struct B
 void g() { f(); }               // error: no reachable definition of struct B
 ```
 — *end example*]
 — *end note*]
-[*Note 5*: An entity can have reachable declarations even if it is not
-visible to name lookup. — *end note*]
 [*Example 2*:
 Translation unit #1
@@ -991,23 +970,22 @@ export using Y = X;
 ```
 Translation unit #2
 ``` cpp
-module B;
 import A;
 Y y;                // OK, definition of X is reachable
 X x;                // error: X not visible to unqualified lookup
 ```
 — *end example*]
 <!-- Link reference definitions -->
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.link]: basic.md#basic.link
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
-[basic.scope.namespace]: basic.md#basic.scope.namespace
 [class.compare.default]: class.md#class.compare.default
 [cpp.import]: cpp.md#cpp.import
 [cpp.include]: cpp.md#cpp.include
 [cpp.pre]: cpp.md#cpp.pre
 [dcl.inline]: dcl.md#dcl.inline
@@ -1023,19 +1001,19 @@ X x;                // error: X not visible to unqualified lookup
 [module.interface]: #module.interface
 [module.private.frag]: #module.private.frag
 [module.reach]: #module.reach
 [module.unit]: #module.unit
 [namespace.udecl]: dcl.md#namespace.udecl
-[new.delete.array]: support.md#new.delete.array
-[new.delete.single]: support.md#new.delete.single
 [over.over]: over.md#over.over
 [special]: class.md#special
 [temp.point]: temp.md#temp.point
 [temp.pre]: temp.md#temp.pre
-[^1]: This is consistent with the rules for visibility of imported names
-    [[basic.scope.namespace]].
 [^2]: A declaration can appear within a *lambda-expression* in the
     initializer of a variable.
 [^3]: Implementations are therefore not required to prevent the semantic

 is not introduced by any *module-declaration*. — *end note*]
 A *module* is either a named module or the global module. A declaration
 is *attached* to a module as follows:
+- If the declaration is a non-dependent friend declaration that
+ nominates a function with a *declarator-id* that is a *qualified-id*
+  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.
 ## Export declaration <a id="module.interface">[[module.interface]]</a>
 ``` bnf
 export-declaration:
+    export name-declaration
     export '{' declaration-seqₒₚₜ '}'
     export-keyword module-import-declaration
 ```
+An *export-declaration* shall inhabit a namespace scope and appear in
 the purview of a module interface unit. An *export-declaration* shall
 not appear directly or indirectly within an unnamed namespace or a
 *private-module-fragment*. An *export-declaration* has the declarative
+effects of its *name-declaration*, *declaration-seq* (if any), or
+*module-import-declaration*. The *name-declaration* of an
+*export-declaration* shall not declare a partial specialization
+[[temp.decls.general]]. The *declaration-seq* of an *export-declaration*
+shall not contain an *export-declaration* or
+*module-import-declaration*.
+[*Note 1*: An *export-declaration* does not establish a
+scope. — *end note*]
+A declaration is *exported* if it is declared within an
+*export-declaration* and inhabits a namespace scope or it is
 - a *namespace-definition* that contains an exported declaration, or
 - a declaration within a header unit [[module.import]] that introduces
   at least one name.
+If an exported declaration is not within a header unit, it shall not
+declare a name with internal linkage.
 [*Example 1*:
 Source file \`"a.h"\`
 ``` cpp
 module;
 #include "a.h"                  // error: declaration of x is not in the
                                 // purview of a module interface unit
 export module M;
+export namespace {}             // error: namespace has internal linkage
 namespace {
   export int a2;                // error: export of name with internal linkage
 }
 export static int b;            // error: b explicitly declared static
 export int f();                 // OK
 export namespace N { }          // OK
+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*:
 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*:
 — *end example*]
 — *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;
 export struct S;                // error: exported declaration follows non-exported declaration
 ```
 — *end example*]
+[*Note 3*: Names introduced by exported declarations have either
+external linkage or no linkage; see [[basic.link]]. Namespace-scope
+declarations exported by a module can be found by name lookup in any
+translation unit importing that module [[basic.lookup]]. Class and
+enumeration member names can be found by name lookup in any context in
+which a definition of the type is reachable. — *end note*]
 [*Example 5*:
 Interface unit of \`M\`
 }
 ```
 — *end example*]
 [*Note 4*:
 Declarations in an exported *namespace-definition* or in an exported
 *linkage-specification* [[dcl.link]] are exported and subject to the
 rules of exported declarations.
+[*Example 6*:
 ``` cpp
 export module M;
+int g;
 export namespace N {
   int x;                        // OK
+ using ::g; // error: ::g has module linkage
 }
 ```
 — *end example*]
     import-keyword module-name attribute-specifier-seqₒₚₜ ';'
     import-keyword module-partition attribute-specifier-seqₒₚₜ ';'
     import-keyword header-name attribute-specifier-seqₒₚₜ ';'
 ```
+A *module-import-declaration* shall inhabit the global namespace scope.
+In a module unit, all *module-import-declaration*s and
 *export-declaration*s exporting *module-import-declaration*s shall
+appear before all other *declaration*s in the *declaration-seq* of the
 *translation-unit* and of the *private-module-fragment* (if any). The
 optional *attribute-specifier-seq* appertains to the
 *module-import-declaration*.
 A *module-import-declaration* *imports* a set of translation units
 determined as described below.
+[*Note 1*: Namespace-scope declarations exported by the imported
+translation units can be found by name lookup [[basic.lookup]] in the
+importing translation unit and declarations within the imported
+translation units become reachable [[module.reach]] in the importing
+translation unit after the import declaration. — *end note*]
 A *module-import-declaration* that specifies a *module-name* `M` imports
 all module interface units of `M`.
 A *module-import-declaration* that specifies a *module-partition* shall
   header. — *end note*]
 [*Note 4*: A *module-import-declaration* nominating a *header-name* is
 also recognized by the preprocessor, and results in macros defined at
 the end of phase 4 of translation of the header unit being made visible
+as described in [[cpp.import]]. Any other *module-import-declaration*
+does not make macros visible. — *end note*]
 A declaration of a name with internal linkage is permitted within a
 header unit despite all declarations being implicitly exported
 [[module.interface]].
 imports all translation units imported by exported
 *module-import-declaration*s in T; such translation units are said to be
 *exported* by T. Additionally, when a *module-import-declaration* in a
 module unit of some module M imports another module unit U of M, it also
 imports all translation units imported by non-exported
+*module-import-declaration*s in the module unit purview of U.[^1]
+These rules can in turn lead to the importation of yet more translation
+units.
+[*Note 6*: Such indirect importation does not make macros available,
+because a translation unit is a sequence of tokens in translation phase
+7 [[lex.phases]]. Macros can be made available by directly importing
+header units as described in [[cpp.import]]. — *end note*]
 A module implementation unit shall not be exported.
 [*Example 1*:
 - 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
   expression [[basic.def.odr]] appearing in S, or
+- S contains a dependent call `E` [[temp.dep]] and D is found by any
+ name lookup performed for an expression synthesized from `E` by
+ replacing each type-dependent argument or operand with a value of a
+ placeholder type with no associated namespaces or entities, or
+  \[*Note 2*: This includes the lookup for `operator==` performed when
+ considering rewriting an `!=` expression, the lookup for `operator<=>`
+ performed when considering rewriting a relational comparison, and the
+  lookup for `operator!=` when considering whether an `operator==` is a
+ rewrite target. — *end note*]
+- S contains an expression that takes the address of an overload set
+ [[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
     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,
+  *using-declaration*, or *namespace-alias-definition* is replaced by
   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
 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*.
+[*Note 3*: A discarded declaration is neither reachable nor visible to
 name lookup outside the module unit, nor in template instantiations
 whose points of instantiation [[temp.point]] are outside the module
 unit, even when the instantiation context [[module.context]] includes
 the module unit. — *end note*]
 *private-module-fragment* allows a module to be represented as a single
 translation unit without making all of the contents of the module
 reachable to importers. The presence of a *private-module-fragment*
 affects:
+- the point by which the definition of an inline function or variable is
   required [[dcl.inline]],
 - the point by which the definition of an exported function with a
   placeholder return type is required [[dcl.spec.auto]],
 - whether a declaration is required not to be an exposure
   [[basic.link]],
+- where definitions for inline functions and templates must appear
+  [[basic.def.odr]], [[dcl.inline]], [[temp.pre]],
 - the instantiation contexts of templates instantiated before it
   [[module.context]], and
 - the reachability of declarations within it [[module.reach]].
 — *end note*]
 ``` cpp
 export module A;
 export inline void fn_e();      // error: exported inline function fn_e not defined
                                 // before private module fragment
+inline void fn_m();             // error: non-exported inline function fn_m not defined
 static void fn_s();
 export struct X;
 export void g(X *x) {
   fn_s();                       // OK, call to static function in same translation unit
 }
 export X *factory();            // OK
 module :private;
 struct X {};                    // definition not reachable from importers of A
 — *end example*]
 ## Instantiation context <a id="module.context">[[module.context]]</a>
 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
 - the point at the end of translation unit \#1,
 - the point at the end of translation unit \#2, and
 - the point of the call to `f(0)`,
+so the definition of `X` is reachable [[module.reach]].
 It is unspecified whether the call to `g(0)` is valid: the instantiation
 context of `bar<int, X>` comprises
 - the point at the end of translation unit \#1,
 ## Reachability <a id="module.reach">[[module.reach]]</a>
 A translation unit U is *necessarily reachable* from a point P if U is a
 module interface unit on which the translation unit containing P has an
 interface dependency, or the translation unit containing P imports U, in
+either case prior to P [[module.import]].
 [*Note 1*: While module interface units are reachable even when they
 are only transitively imported via a non-exported import declaration,
+namespace-scope names from such module interface units are not found by
+name lookup [[basic.lookup]]. — *end note*]
+All translation units that are necessarily reachable are *reachable*.
+Additional translation units on which the point within the program has
+an interface dependency may be considered reachable, but it is
+unspecified which are and under what circumstances.[^3]
 [*Note 2*: It is advisable to avoid depending on the reachability of
 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
 it is reachable. — *end note*]
 The accumulated properties of all reachable declarations of an entity
 within a context determine the behavior of the entity within that
 [*Note 4*:
 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
 ```
 Translation unit #5
 ``` cpp
 import M;
 B b3;                           // error: no reachable definition of struct B
 void g() { f(); }               // error: no reachable definition of struct B
 ```
 — *end example*]
 — *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
 ```
 Translation unit #2
 ``` cpp
 import A;
 Y y;                // OK, definition of X is reachable
 X x;                // error: X not visible to unqualified lookup
 ```
 — *end example*]
 <!-- Link reference definitions -->
 [basic.def.odr]: basic.md#basic.def.odr
 [basic.link]: basic.md#basic.link
+[basic.lookup]: basic.md#basic.lookup
 [basic.lookup.argdep]: basic.md#basic.lookup.argdep
 [class.compare.default]: class.md#class.compare.default
 [cpp.import]: cpp.md#cpp.import
 [cpp.include]: cpp.md#cpp.include
 [cpp.pre]: cpp.md#cpp.pre
 [dcl.inline]: dcl.md#dcl.inline
 [module.interface]: #module.interface
 [module.private.frag]: #module.private.frag
 [module.reach]: #module.reach
 [module.unit]: #module.unit
 [namespace.udecl]: dcl.md#namespace.udecl
 [over.over]: over.md#over.over
 [special]: class.md#special
+[temp.decls.general]: temp.md#temp.decls.general
+[temp.dep]: temp.md#temp.dep
 [temp.point]: temp.md#temp.point
 [temp.pre]: temp.md#temp.pre
+[^1]: This is consistent with the lookup rules for imported names
+    [[basic.lookup]].
 [^2]: A declaration can appear within a *lambda-expression* in the
     initializer of a variable.
 [^3]: Implementations are therefore not required to prevent the semantic

Diff to HTML by rtfpessoa