[basic.link] - C++20 → C++23

Files changed (1) hide show

tmp/tmpkbh053_l/{from.md → to.md} +92 -100

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

@@ -8,11 +8,11 @@ declarations.
 translation-unit:
     declaration-seqₒₚₜ
     global-module-fragmentₒₚₜ module-declaration declaration-seqₒₚₜ private-module-fragmentₒₚₜ
 ```
-A name is said to have *linkage* when it might denote the same object,
 reference, function, type, template, namespace or value as a name
 introduced by a declaration in another scope:
 - When a name has *external linkage*, the entity it denotes can be
   referred to by names from scopes of other translation units or from
@@ -24,30 +24,33 @@ introduced by a declaration in another scope:
 - When a name has *internal linkage*, the entity it denotes can be
   referred to by names from other scopes in the same translation unit.
 - When a name has *no linkage*, the entity it denotes cannot be referred
   to by names from other scopes.
-A name having namespace scope [[basic.scope.namespace]] has internal
-linkage if it is the name of
 - a variable, variable template, function, or function template that is
   explicitly declared `static`; or
 - a non-template variable of non-volatile const-qualified type, unless
   - it is explicitly declared `extern`, or
-  - it is inline or exported, or
   - it was previously declared and the prior declaration did not have
     internal linkage; or
 - a data member of an anonymous union.
 [*Note 1*: An instantiated variable template that has const-qualified
 type can have external or module linkage, even if not declared
 `extern`. — *end note*]
 An unnamed namespace or a namespace declared directly or indirectly
 within an unnamed namespace has internal linkage. All other namespaces
-have external linkage. A name having namespace scope that has not been
-given internal linkage above and that is the name of
 - a variable; or
 - a function; or
 - a named class [[class.pre]], or an unnamed class defined in a typedef
   declaration in which the class has the typedef name for linkage
@@ -66,112 +69,71 @@ has its linkage determined as follows:
 - otherwise, if the declaration of the name is attached to a named
   module [[module.unit]] and is not exported [[module.interface]], the
   name has module linkage;
 - otherwise, the name has external linkage.
-In addition, a member function, static data member, a named class or
-enumeration of class scope, or an unnamed class or enumeration defined
-in a class-scope typedef declaration such that the class or enumeration
-has the typedef name for linkage purposes [[dcl.typedef]], has the same
-linkage, if any, as the name of the class of which it is a member.
-The name of a function declared in block scope and the name of a
-variable declared by a block scope `extern` declaration have linkage. If
-such a declaration is attached to a named module, the program is
-ill-formed. If there is a visible declaration of an entity with linkage,
-ignoring entities declared outside the innermost enclosing namespace
-scope, such that the block scope declaration would be a (possibly
-ill-formed) redeclaration if the two declarations appeared in the same
-declarative region, the block scope declaration declares that same
-entity and receives the linkage of the previous declaration. If there is
-more than one such matching entity, the program is ill-formed.
-Otherwise, if no matching entity is found, the block scope entity
-receives external linkage. If, within a translation unit, the same
-entity is declared with both internal and external linkage, the program
-is ill-formed.
 [*Example 1*:
 ``` cpp
 static void f();
 extern "C" void h();
 static int i = 0;               // #1
-void g() {
   extern void f();              // internal linkage
   extern void h();              // C language linkage
   int i;                        // #2: i has no linkage
   {
     extern void f();            // internal linkage
-    extern int i;               // #3: external linkage, ill-formed
   }
 }
 ```
-Without the declaration at line \#2, the declaration at line \#3 would
-link with the declaration at line \#1. Because the declaration with
-internal linkage is hidden, however, \#3 is given external linkage,
-making the program ill-formed.
-— *end example*]
-When a block scope declaration of an entity with linkage is not found to
-refer to some other declaration, then that entity is a member of the
-innermost enclosing namespace. However such a declaration does not
-introduce the member name in its namespace scope.
-[*Example 2*:
-``` cpp
-namespace X {
-  void p() {
-    q();                        // error: q not yet declared
-    extern void q();            // q is a member of namespace X
-  }
-  void middle() {
-    q();                        // error: q not yet declared
-  }
-  void q() { ... }        // definition of X::q
-}
-void q() { ... }          // some other, unrelated q
-```
 — *end example*]
 Names not covered by these rules have no linkage. Moreover, except as
 noted, a name declared at block scope [[basic.scope.block]] has no
 linkage.
-Two names that are the same [[basic.pre]] and that are declared in
-different scopes shall denote the same variable, function, type,
-template or namespace if
-- both names have external or module linkage and are declared in
-  declarations attached to the same module, or else both names have
- internal linkage and are declared in the same translation unit; and
-- both names refer to members of the same namespace or to members, not
-  by inheritance, of the same class; and
-- when both names denote functions or function templates, the
-  signatures ([[defns.signature]], [[defns.signature.templ]]) are the
-  same.
-If multiple declarations of the same name with external linkage would
-declare the same entity except that they are attached to different
-modules, the program is ill-formed; no diagnostic is required.
-[*Note 2*: *using-declaration*s, typedef declarations, and
-*alias-declaration*s do not declare entities, but merely introduce
-synonyms. Similarly, *using-directive*s do not declare entities.
-Enumerators do not have linkage, but may serve as the name of an
-enumeration with linkage [[dcl.enum]]. — *end note*]
-If a declaration would redeclare a reachable declaration attached to a
-different module, the program is ill-formed.
-[*Example 3*:
 \`"decls.h"\`
 ``` cpp
 int f();            // #1, attached to the global module
@@ -182,11 +144,11 @@ Module interface of \`M\`
 ``` cpp
 module;
 #include "decls.h"
 export module M;
-export using ::f;   // OK: does not declare an entity, exports #1
 int g();            // error: matches #2, but attached to M
 export int h();     // #3
 export int k();     // #4
 ```
@@ -202,32 +164,62 @@ int k();            // error: matches #4
 As a consequence of these rules, all declarations of an entity are
 attached to the same module; the entity is said to be *attached* to that
 module.
-After all adjustments of types (during which typedefs [[dcl.typedef]]
-are replaced by their definitions), the types specified by all
-declarations referring to a given variable or function shall be
-identical, except that declarations for an array object can specify
-array types that differ by the presence or absence of a major array
-bound [[dcl.array]]. A violation of this rule on type identity does not
-require a diagnostic.
-[*Note 3*: Linkage to non-C++ declarations can be achieved using a
 *linkage-specification* [[dcl.link]]. — *end note*]
 A declaration D *names* an entity E if
 - D contains a *lambda-expression* whose closure type is E,
 - E is not a function or function template and D contains an
   *id-expression*, *type-specifier*, *nested-name-specifier*,
   *template-name*, or *concept-name* denoting E, or
 - E is a function or function template and D contains an expression that
   names E [[basic.def.odr]] or an *id-expression* that refers to a set
-  of overloads that contains E. \[*Note 4*: Non-dependent names in an
   instantiated declaration do not refer to a set of overloads
-  [[temp.nondep]]. — *end note*]
 A declaration is an *exposure* if it either names a TU-local entity
 (defined below), ignoring
 - the *function-body* for a non-inline function or function template
@@ -237,18 +229,18 @@ A declaration is an *exposure* if it either names a TU-local entity
 - the *initializer* for a variable or variable template (but not the
   variable’s type),
 - friend declarations in a class definition, and
 - any reference to a non-volatile const object or reference with
   internal or no linkage initialized with a constant expression that is
-  not an odr-use [[basic.def.odr]],
 or defines a constexpr variable initialized to a TU-local value (defined
 below).
-[*Note 5*: An inline function template can be an exposure even though
-explicit specializations of it might be usable in other translation
-units. — *end note*]
 An entity is *TU-local* if it is
 - a type, function, variable, or template that
   - has a name with internal linkage, or
@@ -259,17 +251,17 @@ An entity is *TU-local* if it is
   *defining-type-specifier* that is used to declare only TU-local
   entities,
 - a specialization of a TU-local template,
 - a specialization of a template with any TU-local template argument, or
 - a specialization of a template whose (possibly instantiated)
-  declaration is an exposure. \[*Note 6*: The specialization might have
- been implicitly or explicitly instantiated. — *end note*]
 A value or object is *TU-local* if either
 - it is, or is a pointer to, a TU-local function or the object
-  associated with a TU-local variable,
 - it is an object of class or array type and any of its subobjects or
   any of the objects or functions to which its non-static data members
   of reference type refer is TU-local and is usable in constant
   expressions.
@@ -315,11 +307,11 @@ namespace N {
   void adl(A);
   static void adl(int);
 }
 void adl(double);
-inline void h(auto x) { adl(x); }   // OK, but a specialization might be an exposure
 ```
 Translation unit #2
 ``` cpp

 translation-unit:
     declaration-seqₒₚₜ
     global-module-fragmentₒₚₜ module-declaration declaration-seqₒₚₜ private-module-fragmentₒₚₜ
 ```
+A name is said to have *linkage* when it can denote the same object,
 reference, function, type, template, namespace or value as a name
 introduced by a declaration in another scope:
 - When a name has *external linkage*, the entity it denotes can be
   referred to by names from scopes of other translation units or from
 - When a name has *internal linkage*, the entity it denotes can be
   referred to by names from other scopes in the same translation unit.
 - When a name has *no linkage*, the entity it denotes cannot be referred
   to by names from other scopes.
+The name of an entity that belongs to a namespace scope
+[[basic.scope.namespace]] has internal linkage if it is the name of
 - a variable, variable template, function, or function template that is
   explicitly declared `static`; or
 - a non-template variable of non-volatile const-qualified type, unless
+  - it is declared in the purview of a module interface unit (outside
+    the *private-module-fragment*, if any) or module partition, or
   - it is explicitly declared `extern`, or
+  - it is inline, or
   - it was previously declared and the prior declaration did not have
     internal linkage; or
 - a data member of an anonymous union.
 [*Note 1*: An instantiated variable template that has const-qualified
 type can have external or module linkage, even if not declared
 `extern`. — *end note*]
 An unnamed namespace or a namespace declared directly or indirectly
 within an unnamed namespace has internal linkage. All other namespaces
+have external linkage. The name of an entity that belongs to a namespace
+scope that has not been given internal linkage above and that is the
+name of
 - a variable; or
 - a function; or
 - a named class [[class.pre]], or an unnamed class defined in a typedef
   declaration in which the class has the typedef name for linkage
 - otherwise, if the declaration of the name is attached to a named
   module [[module.unit]] and is not exported [[module.interface]], the
   name has module linkage;
 - otherwise, the name has external linkage.
+In addition, a member function, a static data member, a named class or
+enumeration that inhabits a class scope, or an unnamed class or
+enumeration defined in a typedef declaration that inhabits a class scope
+such that the class or enumeration has the typedef name for linkage
+purposes [[dcl.typedef]], has the same linkage, if any, as the name of
+the class of which it is a member.
 [*Example 1*:
 ``` cpp
 static void f();
 extern "C" void h();
 static int i = 0;               // #1
+void q() {
   extern void f();              // internal linkage
+  extern void g();              // ::g, external linkage
   extern void h();              // C language linkage
   int i;                        // #2: i has no linkage
   {
     extern void f();            // internal linkage
+    extern int i;               // #3: internal linkage
   }
 }
 ```
+Even though the declaration at line \#2 hides the declaration at line
+\#1, the declaration at line \#3 still redeclares \#1 and receives
+internal linkage.
 — *end example*]
 Names not covered by these rules have no linkage. Moreover, except as
 noted, a name declared at block scope [[basic.scope.block]] has no
 linkage.
+Two declarations of entities declare the same entity if, considering
+declarations of unnamed types to introduce their names for linkage
+purposes, if any [[dcl.typedef]], [[dcl.enum]], they correspond
+[[basic.scope.scope]], have the same target scope that is not a function
+or template parameter scope, and either
+- they appear in the same translation unit, or
+- they both declare names with module linkage and are attached to the
+  same module, or
+- they both declare names with external linkage.
+[*Note 2*: There are other circumstances in which declarations declare
+the same entity
+[[dcl.link]], [[temp.type]], [[temp.spec.partial]]. — *end note*]
+If a declaration H that declares a name with internal linkage precedes a
+declaration D in another translation unit U and would declare the same
+entity as D if it appeared in U, the program is ill-formed.
+[*Note 3*: Such an H can appear only in a header unit. — *end note*]
+If two declarations of an entity are attached to different modules, the
+program is ill-formed; no diagnostic is required if neither is reachable
+from the other.
+[*Example 2*:
 \`"decls.h"\`
 ``` cpp
 int f();            // #1, attached to the global module
 ``` cpp
 module;
 #include "decls.h"
 export module M;
+export using ::f;   // OK, does not declare an entity, exports #1
 int g();            // error: matches #2, but attached to M
 export int h();     // #3
 export int k();     // #4
 ```
 As a consequence of these rules, all declarations of an entity are
 attached to the same module; the entity is said to be *attached* to that
 module.
+For any two declarations of an entity E:
+- If one declares E to be a variable or function, the other shall
+  declare E as one of the same type.
+- If one declares E to be an enumerator, the other shall do so.
+- If one declares E to be a namespace, the other shall do so.
+- If one declares E to be a type, the other shall declare E to be a type
+  of the same kind [[dcl.type.elab]].
+- If one declares E to be a class template, the other shall do so with
+  the same kind and an equivalent *template-head* [[temp.over.link]].
+  \[*Note 4*: The declarations can supply different default template
+  arguments. — *end note*]
+- If one declares E to be a function template or a (partial
+  specialization of a) variable template, the other shall declare E to
+  be one with an equivalent *template-head* and type.
+- If one declares E to be an alias template, the other shall declare E
+  to be one with an equivalent *template-head* and *defining-type-id*.
+- If one declares E to be a concept, the other shall do so.
+Types are compared after all adjustments of types (during which typedefs
+[[dcl.typedef]] are replaced by their definitions); declarations for an
+array object can specify array types that differ by the presence or
+absence of a major array bound [[dcl.array]]. No diagnostic is required
+if neither declaration is reachable from the other.
+[*Example 3*:
+``` cpp
+int f(int x, int x);    // error: different entities for x
+void g();               // #1
+void g(int);            // OK, different entity from #1
+int g();                // error: same entity as #1 with different type
+void h();               // #2
+namespace h {}          // error: same entity as #2, but not a function
+```
+— *end example*]
+[*Note 5*: Linkage to non-C++ declarations can be achieved using a
 *linkage-specification* [[dcl.link]]. — *end note*]
 A declaration D *names* an entity E if
 - D contains a *lambda-expression* whose closure type is E,
 - E is not a function or function template and D contains an
   *id-expression*, *type-specifier*, *nested-name-specifier*,
   *template-name*, or *concept-name* denoting E, or
 - E is a function or function template and D contains an expression that
   names E [[basic.def.odr]] or an *id-expression* that refers to a set
+  of overloads that contains E. \[*Note 6*: Non-dependent names in an
   instantiated declaration do not refer to a set of overloads
+  [[temp.res]]. — *end note*]
 A declaration is an *exposure* if it either names a TU-local entity
 (defined below), ignoring
 - the *function-body* for a non-inline function or function template
 - the *initializer* for a variable or variable template (but not the
   variable’s type),
 - friend declarations in a class definition, and
 - any reference to a non-volatile const object or reference with
   internal or no linkage initialized with a constant expression that is
+  not an odr-use [[term.odr.use]],
 or defines a constexpr variable initialized to a TU-local value (defined
 below).
+[*Note 7*: An inline function template can be an exposure even though
+certain explicit specializations of it would be usable in other
+translation units. — *end note*]
 An entity is *TU-local* if it is
 - a type, function, variable, or template that
   - has a name with internal linkage, or
   *defining-type-specifier* that is used to declare only TU-local
   entities,
 - a specialization of a TU-local template,
 - a specialization of a template with any TU-local template argument, or
 - a specialization of a template whose (possibly instantiated)
+  declaration is an exposure. \[*Note 8*: A specialization can be
+ produced by implicit or explicit instantiation. — *end note*]
 A value or object is *TU-local* if either
 - it is, or is a pointer to, a TU-local function or the object
+  associated with a TU-local variable, or
 - it is an object of class or array type and any of its subobjects or
   any of the objects or functions to which its non-static data members
   of reference type refer is TU-local and is usable in constant
   expressions.
   void adl(A);
   static void adl(int);
 }
 void adl(double);
+inline void h(auto x) { adl(x); }   // OK, but certain specializations are exposures
 ```
 Translation unit #2
 ``` cpp

Diff to HTML by rtfpessoa