[basic.scope] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpz883t1hg/{from.md → to.md} +92 -34

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

@@ -3,17 +3,17 @@
 ### General <a id="basic.scope.scope">[[basic.scope.scope]]</a>
 The declarations in a program appear in a number of *scopes* that are in
 general discontiguous. The *global scope* contains the entire program;
 every other scope S is introduced by a declaration,
-*parameter-declaration-clause*, *statement*, or *handler* (as described
-in the following subclauses of [[basic.scope]]) appearing in another
-scope which thereby contains S. An *enclosing scope* at a program point
-is any scope that contains it; the smallest such scope is said to be the
-*immediate scope* at that point. A scope *intervenes* between a program
-point P and a scope S (that does not contain P) if it is or contains S
-but does not contain P.
 Unless otherwise specified:
 - The smallest scope that contains a scope S is the *parent scope* of S.
 - No two declarations (re)introduce the same entity.
@@ -21,12 +21,13 @@ Unless otherwise specified:
   [[basic.scope.pdecl]].
 - A declaration’s *target scope* is the scope it inhabits.
 - Any names (re)introduced by a declaration are *bound* to it in its
   target scope.
-An entity *belongs* to a scope S if S is the target scope of a
-declaration of the entity.
 [*Note 1*:
 Special cases include that:
@@ -34,35 +35,36 @@ Special cases include that:
   scopes [[basic.scope.temp]].
 - Corresponding declarations with appropriate linkage declare the same
   entity [[basic.link]].
 - The declaration in a *template-declaration* inhabits the same scope as
   the *template-declaration*.
-- Friend declarations and declarations of qualified names and template
- specializations do not bind names [[dcl.meaning]]; those with
- qualified names target a specified scope, and other friend
- declarations and certain *elaborated-type-specifier*s
- [[dcl.type.elab]] target a larger enclosing scope.
-- Block-scope extern declarations target a larger enclosing scope but
-  bind a name in their immediate scope.
 - The names of unscoped enumerators are bound in the two innermost
   enclosing scopes [[dcl.enum]].
 - A class’s name is also bound in its own scope [[class.pre]].
 - The names of the members of an anonymous union are bound in the
   union’s parent scope [[class.union.anon]].
 — *end note*]
 Two non-static member functions have *corresponding object parameters*
-if:
 - exactly one is an implicit object member function with no
   *ref-qualifier* and the types of their object parameters [[dcl.fct]],
-  after removing top-level references, are the same, or
 - their object parameters have the same type.
 Two non-static member function templates have *corresponding object
-parameters* if:
 - exactly one is an implicit object member function with no
   *ref-qualifier* and the types of their object parameters, after
   removing any references, are equivalent, or
 - the types of their object parameters are equivalent.
@@ -75,22 +77,26 @@ are non-static members, they have corresponding object parameters.
 Two declarations *correspond* if they (re)introduce the same name, both
 declare constructors, or both declare destructors, unless
 - either is a *using-declarator*, or
-- one declares a type (not a *typedef-name*) and the other declares a
   variable, non-static data member other than of an anonymous union
   [[class.union.anon]], enumerator, function, or function template, or
-- each declares a function or function template, except when
 - both declare functions with the same
   non-object-parameter-type-list,[^3] equivalent [[temp.over.link]]
   trailing *requires-clause*s (if any, except as specified in
   [[temp.friend]]), and, if both are non-static members, they have
   corresponding object parameters, or
 - both declare function templates with corresponding signatures and
- equivalent *template-head*s and trailing *requires-clause*s (if
-    any).
 [*Note 2*:
 Declarations can correspond even if neither binds a name.
@@ -134,17 +140,34 @@ struct X {
 };
 ```
 — *end example*]
 Two declarations *potentially conflict* if they correspond and cause
 their shared name to denote different entities [[basic.link]]. The
 program is ill-formed if, in any scope, a name is bound to two
-declarations that potentially conflict and one precedes the other
-[[basic.lookup]].
-[*Note 3*: Overload resolution can consider potentially conflicting
 declarations found in multiple scopes (e.g., via *using-directive*s or
 for operator functions), in which case it is often
 ambiguous. — *end note*]
 [*Example 3*:
@@ -160,10 +183,22 @@ namespace A {}
 namespace B = A;
 namespace B = A;        // OK, no effect
 namespace B = B;        // OK, no effect
 namespace A = B;        // OK, no effect
 namespace B {}          // error: different entity for B
 ```
 — *end example*]
 A declaration is *nominable* in a class, class template, or namespace E
@@ -286,11 +321,13 @@ variable [[dcl.fct.def.general]] is immediately before the
 The locus of the declaration of a structured binding [[dcl.struct.bind]]
 is immediately after the *identifier-list* of the structured binding
 declaration.
 The locus of a *for-range-declaration* of a range-based `for` statement
-[[stmt.ranged]] is immediately after the *for-range-initializer*.
 The locus of a *template-parameter* is immediately after it.
 [*Example 5*:
@@ -302,12 +339,15 @@ template<class T
     N = 0> struct A { };
 ```
 — *end example*]
 The locus of a *concept-definition* is immediately after its
-concept-name [[temp.concept]].
 [*Note 3*: The *constraint-expression* cannot use the
 *concept-name*. — *end note*]
 The locus of a *namespace-definition* with an *identifier* is
@@ -328,11 +368,12 @@ but they do not bind names in it. — *end note*]
 ### Block scope <a id="basic.scope.block">[[basic.scope.block]]</a>
 Each
-- selection or iteration statement [[stmt.select]], [[stmt.iter]],
 - substatement of such a statement,
 - *handler* [[except.pre]], or
 - compound statement [[stmt.block]] that is not the *compound-statement*
   of a *handler*
@@ -355,11 +396,12 @@ for (int i = 0; i < 10; i++)
 int j = i;          // j = 42
 ```
 — *end example*]
-If a declaration whose target scope is the block scope S of a
 - *compound-statement* of a *lambda-expression*, *function-body*, or
   *function-try-block*,
 - substatement of a selection or iteration statement that is not itself
   a selection or iteration statement, or
@@ -401,11 +443,11 @@ A *parameter-declaration-clause* P introduces a
   parameter scope is nested within its class’s scope. — *end note*]
 - If P is associated with a *lambda-declarator*, its scope extends to
   the end of the *compound-statement* in the *lambda-expression*.
 - If P is associated with a *requirement-parameter-list*, its scope
   extends to the end of the *requirement-body* of the
-  requires-expression.
 - If P is associated with a *deduction-guide*, its scope extends to the
   end of the *deduction-guide*.
 ### Lambda scope <a id="basic.scope.lambda">[[basic.scope.lambda]]</a>
@@ -472,13 +514,13 @@ Any declaration of an enumeration E introduces an *enumeration scope*
 that includes the *enumerator-list* of the *enum-specifier* for E (if
 any).
 ### Template parameter scope <a id="basic.scope.temp">[[basic.scope.temp]]</a>
-Each template *template-parameter* introduces a
-*template parameter scope* that includes the *template-head* of the
-*template-parameter*.
 Each *template-declaration* D introduces a template parameter scope that
 extends from the beginning of its *template-parameter-list* to the end
 of the *template-declaration*. Any declaration outside the
 *template-parameter-list* that would inhabit that scope instead inhabits
@@ -488,5 +530,21 @@ not a template parameter scope.
 [*Note 1*: Therefore, only template parameters belong to a template
 parameter scope, and only template parameter scopes have a template
 parameter scope as a parent scope. — *end note*]

 ### General <a id="basic.scope.scope">[[basic.scope.scope]]</a>
 The declarations in a program appear in a number of *scopes* that are in
 general discontiguous. The *global scope* contains the entire program;
 every other scope S is introduced by a declaration,
+*parameter-declaration-clause*, *statement*, *handler*, or contract
+assertion (as described in the following subclauses of [[basic.scope]])
+appearing in another scope, which thereby contains S. An
+*enclosing scope* at a program point is any scope that contains it; the
+smallest such scope is said to be the *immediate scope* at that point. A
+scope *intervenes* between a program point P and a scope S (that does
+not contain P) if it is or contains S but does not contain P.
 Unless otherwise specified:
 - The smallest scope that contains a scope S is the *parent scope* of S.
 - No two declarations (re)introduce the same entity.
   [[basic.scope.pdecl]].
 - A declaration’s *target scope* is the scope it inhabits.
 - Any names (re)introduced by a declaration are *bound* to it in its
   target scope.
+The *host scope* of a declaration is the inhabited scope if that scope
+is a block scope and the target scope otherwise. An entity *belongs* to
+a scope S if S is the target scope of a declaration of the entity.
 [*Note 1*:
 Special cases include that:
   scopes [[basic.scope.temp]].
 - Corresponding declarations with appropriate linkage declare the same
   entity [[basic.link]].
 - The declaration in a *template-declaration* inhabits the same scope as
   the *template-declaration*.
+- Friend declarations and declarations of template specializations do
+  not bind names [[dcl.meaning]]; those with qualified names target a
+  specified scope, and other friend declarations and certain
+  *elaborated-type-specifier*s [[dcl.type.elab]] target a larger
+  enclosing scope.
+- Block-scope extern or function declarations target a larger enclosing
+ scope but bind a name in their immediate scope
+  [[dcl.meaning.general]].
 - The names of unscoped enumerators are bound in the two innermost
   enclosing scopes [[dcl.enum]].
 - A class’s name is also bound in its own scope [[class.pre]].
 - The names of the members of an anonymous union are bound in the
   union’s parent scope [[class.union.anon]].
 — *end note*]
 Two non-static member functions have *corresponding object parameters*
+if
 - exactly one is an implicit object member function with no
   *ref-qualifier* and the types of their object parameters [[dcl.fct]],
+  after removing references, are the same, or
 - their object parameters have the same type.
 Two non-static member function templates have *corresponding object
+parameters* if
 - exactly one is an implicit object member function with no
   *ref-qualifier* and the types of their object parameters, after
   removing any references, are equivalent, or
 - the types of their object parameters are equivalent.
 Two declarations *correspond* if they (re)introduce the same name, both
 declare constructors, or both declare destructors, unless
 - either is a *using-declarator*, or
+- one declares a type (not a type alias) and the other declares a
   variable, non-static data member other than of an anonymous union
   [[class.union.anon]], enumerator, function, or function template, or
+- each declares a function or function template and they do not declare
+  corresponding overloads.
+Two function or function template declarations declare *corresponding
+overloads* if
 - both declare functions with the same
   non-object-parameter-type-list,[^3] equivalent [[temp.over.link]]
   trailing *requires-clause*s (if any, except as specified in
   [[temp.friend]]), and, if both are non-static members, they have
   corresponding object parameters, or
 - both declare function templates with corresponding signatures and
+ equivalent *template-head*s and trailing *requires-clause*s (if any).
 [*Note 2*:
 Declarations can correspond even if neither binds a name.
 };
 ```
 — *end example*]
+A declaration is *name-independent* if its name is `_`
+(U+005f (low line)) and it declares
+- a variable with automatic storage duration,
+- a structured binding with no *storage-class-specifier* and not
+  inhabiting a namespace scope,
+- a result binding [[dcl.contract.res]],
+- the variable introduced by an *init-capture*, or
+- a non-static data member of other than an anonymous union.
+*Recommended practice:* Implementations should not emit a warning that a
+name-independent declaration is used or unused.
 Two declarations *potentially conflict* if they correspond and cause
 their shared name to denote different entities [[basic.link]]. The
 program is ill-formed if, in any scope, a name is bound to two
+declarations A and B that potentially conflict and A precedes B
+[[basic.lookup]], unless B is name-independent.
+[*Note 3*: An *id-expression* that names a unique name-independent
+declaration is usable until an additional declaration of the same name
+is introduced in the same scope [[basic.lookup.general]]. — *end note*]
+[*Note 4*: Overload resolution can consider potentially conflicting
 declarations found in multiple scopes (e.g., via *using-directive*s or
 for operator functions), in which case it is often
 ambiguous. — *end note*]
 [*Example 3*:
 namespace B = A;
 namespace B = A;        // OK, no effect
 namespace B = B;        // OK, no effect
 namespace A = B;        // OK, no effect
 namespace B {}          // error: different entity for B
+void g() {
+  int _;
+  _ = 0;                // OK
+  int _;                // OK, name-independent declaration
+  _ = 0;                // error: two non-function declarations in the lookup set
+}
+void h () {
+  int _;                // #1
+  _ ++;                 // OK
+  static int _;         // error: conflicts with #1 because static variables are not name-independent
+}
 ```
 — *end example*]
 A declaration is *nominable* in a class, class template, or namespace E
 The locus of the declaration of a structured binding [[dcl.struct.bind]]
 is immediately after the *identifier-list* of the structured binding
 declaration.
 The locus of a *for-range-declaration* of a range-based `for` statement
+[[stmt.ranged]] is immediately after the *for-range-initializer*. The
+locus of a *for-range-declaration* of an *expansion-statement*
+[[stmt.expand]] is immediately after the *expansion-initializer*.
 The locus of a *template-parameter* is immediately after it.
 [*Example 5*:
     N = 0> struct A { };
 ```
 — *end example*]
+The locus of a *result-name-introducer* [[dcl.contract.res]] is
+immediately after it.
 The locus of a *concept-definition* is immediately after its
+*concept-name* [[temp.concept]].
 [*Note 3*: The *constraint-expression* cannot use the
 *concept-name*. — *end note*]
 The locus of a *namespace-definition* with an *identifier* is
 ### Block scope <a id="basic.scope.block">[[basic.scope.block]]</a>
 Each
+- selection, iteration, or expansion statement
+  [[stmt.select]], [[stmt.iter]], [[stmt.expand]],
 - substatement of such a statement,
 - *handler* [[except.pre]], or
 - compound statement [[stmt.block]] that is not the *compound-statement*
   of a *handler*
 int j = i;          // j = 42
 ```
 — *end example*]
+If a declaration that is not a name-independent declaration and that
+binds a name in the block scope S of a
 - *compound-statement* of a *lambda-expression*, *function-body*, or
   *function-try-block*,
 - substatement of a selection or iteration statement that is not itself
   a selection or iteration statement, or
   parameter scope is nested within its class’s scope. — *end note*]
 - If P is associated with a *lambda-declarator*, its scope extends to
   the end of the *compound-statement* in the *lambda-expression*.
 - If P is associated with a *requirement-parameter-list*, its scope
   extends to the end of the *requirement-body* of the
+ *requires-expression*.
 - If P is associated with a *deduction-guide*, its scope extends to the
   end of the *deduction-guide*.
 ### Lambda scope <a id="basic.scope.lambda">[[basic.scope.lambda]]</a>
 that includes the *enumerator-list* of the *enum-specifier* for E (if
 any).
 ### Template parameter scope <a id="basic.scope.temp">[[basic.scope.temp]]</a>
+Each *type-tt-parameter*, *variable-tt-parameter*, and
+*concept-tt-parameter* introduces a *template parameter scope* that
+includes the *template-head* of the *template-parameter*.
 Each *template-declaration* D introduces a template parameter scope that
 extends from the beginning of its *template-parameter-list* to the end
 of the *template-declaration*. Any declaration outside the
 *template-parameter-list* that would inhabit that scope instead inhabits
 [*Note 1*: Therefore, only template parameters belong to a template
 parameter scope, and only template parameter scopes have a template
 parameter scope as a parent scope. — *end note*]
+### Contract-assertion scope <a id="basic.scope.contract">[[basic.scope.contract]]</a>
+Each contract assertion [[basic.contract]] C introduces a
+*contract-assertion scope* that includes C.
+If a *result-name-introducer* [[dcl.contract.res]] that is not
+name-independent [[basic.scope.scope]] and whose enclosing postcondition
+assertion is associated with a function `F` potentially conflicts with a
+declaration whose target scope is
+- the function parameter scope of `F` or
+- if associated with a *lambda-declarator*, the nearest enclosing lambda
+  scope of the precondition assertion [[expr.prim.lambda]],
+the program is ill-formed.

Diff to HTML by rtfpessoa