[basic.scope] - C++17 → C++20

Files changed (1) hide show

tmp/tmpkudtzdeb/{from.md → to.md} +162 -96

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

@@ -2,11 +2,11 @@
 ### Declarative regions and scopes <a id="basic.scope.declarative">[[basic.scope.declarative]]</a>
 Every name is introduced in some portion of program text called a
 *declarative region*, which is the largest part of the program in which
-that name is *valid*, that is, in which that name may be used as an
 unqualified name to refer to the same entity. In general, each
 particular name is valid only within some possibly discontiguous portion
 of program text called its *scope*. To determine the scope of a
 declaration, it is sometimes convenient to refer to the *potential
 scope* of a declaration. The scope of a declaration is the same as its
@@ -39,62 +39,68 @@ same as its potential scope.
 — *end example*]
 The names declared by a declaration are introduced into the scope in
 which the declaration occurs, except that the presence of a `friend`
-specifier ([[class.friend]]), certain uses of the
-*elaborated-type-specifier* ([[dcl.type.elab]]), and
-*using-directive*s ([[namespace.udir]]) alter this general behavior.
 Given a set of declarations in a single declarative region, each of
 which specifies the same unqualified name,
 - they shall all refer to the same entity, or all refer to functions and
   function templates; or
 - exactly one declaration shall declare a class name or enumeration name
   that is not a typedef name and the other declarations shall all refer
   to the same variable, non-static data member, or enumerator, or all
   refer to functions and function templates; in this case the class name
-  or enumeration name is hidden ([[basic.scope.hiding]]). \[*Note 1*: A
- namespace name or a class template name must be unique in its
- declarative region ([[namespace.alias]], Clause
- [[temp]]). — *end note*]
 [*Note 2*: These restrictions apply to the declarative region into
 which a name is introduced, which is not necessarily the same as the
 region in which the declaration occurs. In particular,
-*elaborated-type-specifier*s ([[dcl.type.elab]]) and friend
-declarations ([[class.friend]]) may introduce a (possibly not visible)
-name into an enclosing namespace; these restrictions apply to that
-region. Local extern declarations ([[basic.link]]) may introduce a name
-into the declarative region where the declaration appears and also
-introduce a (possibly not visible) name into an enclosing namespace;
-these restrictions apply to both regions. — *end note*]
 [*Note 3*: The name lookup rules are summarized in
 [[basic.lookup]]. — *end note*]
 ### Point of declaration <a id="basic.scope.pdecl">[[basic.scope.pdecl]]</a>
 The *point of declaration* for a name is immediately after its complete
-declarator (Clause  [[dcl.decl]]) and before its *initializer* (if any),
-except as noted below.
 [*Example 1*:
 ``` cpp
 unsigned char x = 12;
 { unsigned char x = x; }
 ```
-Here the second `x` is initialized with its own (indeterminate) value.
 — *end example*]
 [*Note 1*:
-a name from an outer scope remains visible up to the point of
 declaration of the name that hides it.
 [*Example 2*:
 ``` cpp
@@ -108,20 +114,20 @@ declares a block-scope array of two integers.
 — *end note*]
 The point of declaration for a class or class template first declared by
 a *class-specifier* is immediately after the *identifier* or
-*simple-template-id* (if any) in its *class-head* (Clause  [[class]]).
-The point of declaration for an enumeration is immediately after the
-*identifier* (if any) in either its *enum-specifier* ([[dcl.enum]]) or
-its first *opaque-enum-declaration* ([[dcl.enum]]), whichever comes
-first. The point of declaration of an alias or alias template
-immediately follows the *type-id* to which the alias refers.
 The point of declaration of a *using-declarator* that does not name a
-constructor is immediately after the *using-declarator* (
-[[namespace.udecl]]).
 The point of declaration for an enumerator is immediately after its
 *enumerator-definition*.
 [*Example 3*:
@@ -176,17 +182,24 @@ The point of declaration of a class first declared in an
   \[*Note 3*: These rules also apply within templates. — *end note*]
   \[*Note 4*: Other forms of *elaborated-type-specifier* do not declare
   a new name, and therefore must refer to an existing *type-name*. See
   [[basic.lookup.elab]] and  [[dcl.type.elab]]. — *end note*]
-The point of declaration for an *injected-class-name* (Clause
-[[class]]) is immediately following the opening brace of the class
-definition.
-The point of declaration for a function-local predefined variable (
-[[dcl.fct.def]]) is immediately before the *function-body* of a function
-definition.
 The point of declaration for a template parameter is immediately after
 its complete *template-parameter*.
 [*Example 4*:
@@ -201,72 +214,81 @@ template<class T
 — *end example*]
 [*Note 5*: Friend declarations refer to functions or classes that are
 members of the nearest enclosing namespace, but they do not introduce
-new names into that namespace ([[namespace.memdef]]). Function
 declarations at block scope and variable declarations with the `extern`
 specifier at block scope refer to declarations that are members of an
 enclosing namespace, but they do not introduce new names into that
 scope. — *end note*]
 [*Note 6*: For point of instantiation of a template, see
 [[temp.point]]. — *end note*]
 ### Block scope <a id="basic.scope.block">[[basic.scope.block]]</a>
-A name declared in a block ([[stmt.block]]) is local to that block; it
-has *block scope*. Its potential scope begins at its point of
-declaration ([[basic.scope.pdecl]]) and ends at the end of its block. A
-variable declared at block scope is a *local variable*.
-The potential scope of a function parameter name (including one
-appearing in a *lambda-declarator*) or of a function-local predefined
-variable in a function definition ([[dcl.fct.def]]) begins at its point
-of declaration. If the function has a *function-try-block* the potential
-scope of a parameter or of a function-local predefined variable ends at
-the end of the last associated handler, otherwise it ends at the end of
-the outermost block of the function definition. A parameter name shall
-not be redeclared in the outermost block of the function definition nor
-in the outermost block of any handler associated with a
-*function-try-block*.
 The name declared in an *exception-declaration* is local to the
 *handler* and shall not be redeclared in the outermost block of the
 *handler*.
 Names declared in the *init-statement*, the *for-range-declaration*, and
 in the *condition* of `if`, `while`, `for`, and `switch` statements are
 local to the `if`, `while`, `for`, or `switch` statement (including the
 controlled statement), and shall not be redeclared in a subsequent
 condition of that statement nor in the outermost block (or, for the `if`
-statement, any of the outermost blocks) of the controlled statement;
-see  [[stmt.select]].
-### Function prototype scope <a id="basic.scope.proto">[[basic.scope.proto]]</a>
-In a function declaration, or in any function declarator except the
-declarator of a function definition ([[dcl.fct.def]]), names of
-parameters (if supplied) have function prototype scope, which terminates
-at the end of the nearest enclosing function declarator.
 ### Function scope <a id="basic.funscope">[[basic.funscope]]</a>
-Labels ([[stmt.label]]) have *function scope* and may be used anywhere
-in the function in which they are declared. Only labels have function
 scope.
 ### Namespace scope <a id="basic.scope.namespace">[[basic.scope.namespace]]</a>
 The declarative region of a *namespace-definition* is its
 *namespace-body*. Entities declared in a *namespace-body* are said to be
 *members* of the namespace, and names introduced by these declarations
 into the declarative region of the namespace are said to be *member
 names* of the namespace. A namespace member name has namespace scope.
 Its potential scope includes its namespace from the name’s point of
-declaration ([[basic.scope.pdecl]]) onwards; and for each
-*using-directive* ([[namespace.udir]]) that nominates the member’s
 namespace, the member’s potential scope includes that portion of the
 potential scope of the *using-directive* that follows the member’s point
 of declaration.
 [*Example 1*:
@@ -296,47 +318,90 @@ namespace N {
 }
 ```
 — *end example*]
 A namespace member can also be referred to after the `::` scope
-resolution operator ([[expr.prim]]) applied to the name of its
 namespace or the name of a namespace which nominates the member’s
 namespace in a *using-directive*; see  [[namespace.qual]].
 The outermost declarative region of a translation unit is also a
 namespace, called the *global namespace*. A name declared in the global
 namespace has *global namespace scope* (also called *global scope*). The
-potential scope of such a name begins at its point of declaration (
-[[basic.scope.pdecl]]) and ends at the end of the translation unit that
 is its declarative region. A name with global namespace scope is said to
 be a *global name*.
 ### Class scope <a id="basic.scope.class">[[basic.scope.class]]</a>
 The potential scope of a name declared in a class consists not only of
 the declarative region following the name’s point of declaration, but
-also of all function bodies, default arguments, *noexcept-specifier*s,
-and *brace-or-equal-initializer*s of non-static data members in that
-class (including such things in nested classes).
 A name `N` used in a class `S` shall refer to the same declaration in
 its context and when re-evaluated in the completed scope of `S`. No
 diagnostic is required for a violation of this rule.
 A name declared within a member function hides a declaration of the same
 name whose scope extends to or past the end of the member function’s
 class.
-The potential scope of a declaration that extends to or past the end of
-a class definition also extends to the regions defined by its member
-definitions, even if the members are defined lexically outside the class
-(this includes static data member definitions, nested class definitions,
-and member function definitions, including the member function body and
-any portion of the declarator part of such definitions which follows the
-*declarator-id*, including a *parameter-declaration-clause* and any
-default arguments ([[dcl.fct.default]])).
 [*Example 1*:
 ``` cpp
 typedef int  c;
@@ -365,21 +430,21 @@ class D {
 — *end example*]
 The name of a class member shall only be used as follows:
 - in the scope of its class (as described above) or a class derived
- (Clause  [[class.derived]]) from its class,
 - after the `.` operator applied to an expression of the type of its
-  class ([[expr.ref]]) or a class derived from its class,
-- after the `->` operator applied to a pointer to an object of its
- class ([[expr.ref]]) or a class derived from its class,
-- after the `::` scope resolution operator ([[expr.prim]]) applied to
-  the name of its class or a class derived from its class.
 ### Enumeration scope <a id="basic.scope.enum">[[basic.scope.enum]]</a>
-The name of a scoped enumerator ([[dcl.enum]]) has *enumeration scope*.
 Its potential scope begins at its point of declaration and terminates at
 the end of the *enum-specifier*.
 ### Template parameter scope <a id="basic.scope.temp">[[basic.scope.temp]]</a>
@@ -415,12 +480,12 @@ to belong to this declarative region in spite of its being hidden during
 qualified and unqualified name lookup.)
 — *end example*]
 The potential scope of a template parameter name begins at its point of
-declaration ([[basic.scope.pdecl]]) and ends at the end of its
-declarative region.
 [*Note 1*:
 This implies that a *template-parameter* can be used in the declaration
 of subsequent *template-parameter*s and their default arguments but
@@ -450,11 +515,11 @@ The declarative region of the name of a template parameter is nested
 within the immediately-enclosing declarative region.
 [*Note 2*:
 As a result, a *template-parameter* hides any entity with the same name
-in an enclosing scope ([[basic.scope.hiding]]).
 [*Example 2*:
 ``` cpp
 typedef int N;
@@ -468,33 +533,34 @@ parameter of `A`.
 — *end example*]
 — *end note*]
 [*Note 3*: Because the name of a template parameter cannot be
-redeclared within its potential scope ([[temp.local]]), a template
 parameter’s scope is often its potential scope. However, it is still
 possible for a template parameter name to be hidden; see
 [[temp.local]]. — *end note*]
 ### Name hiding <a id="basic.scope.hiding">[[basic.scope.hiding]]</a>
-A name can be hidden by an explicit declaration of that same name in a
-nested declarative region or derived class ([[class.member.lookup]]).
-A class name ([[class.name]]) or enumeration name ([[dcl.enum]]) can
-be hidden by the name of a variable, data member, function, or
-enumerator declared in the same scope. If a class or enumeration name
-and a variable, data member, function, or enumerator are declared in the
-same scope (in any order) with the same name, the class or enumeration
-name is hidden wherever the variable, data member, function, or
-enumerator name is visible.
 In a member function definition, the declaration of a name at block
 scope hides the declaration of a member of the class with the same name;
 see  [[basic.scope.class]]. The declaration of a member in a derived
-class (Clause  [[class.derived]]) hides the declaration of a member of a
-base class of the same name; see  [[class.member.lookup]].
 During the lookup of a name qualified by a namespace name, declarations
 that would otherwise be made visible by a *using-directive* can be
 hidden by declarations with the same name in the namespace containing
 the *using-directive*; see  [[namespace.qual]].

 ### Declarative regions and scopes <a id="basic.scope.declarative">[[basic.scope.declarative]]</a>
 Every name is introduced in some portion of program text called a
 *declarative region*, which is the largest part of the program in which
+that name is valid, that is, in which that name may be used as an
 unqualified name to refer to the same entity. In general, each
 particular name is valid only within some possibly discontiguous portion
 of program text called its *scope*. To determine the scope of a
 declaration, it is sometimes convenient to refer to the *potential
 scope* of a declaration. The scope of a declaration is the same as its
 — *end example*]
 The names declared by a declaration are introduced into the scope in
 which the declaration occurs, except that the presence of a `friend`
+specifier [[class.friend]], certain uses of the
+*elaborated-type-specifier* [[dcl.type.elab]], and *using-directive*s
+[[namespace.udir]] alter this general behavior.
 Given a set of declarations in a single declarative region, each of
 which specifies the same unqualified name,
 - they shall all refer to the same entity, or all refer to functions and
   function templates; or
 - exactly one declaration shall declare a class name or enumeration name
   that is not a typedef name and the other declarations shall all refer
   to the same variable, non-static data member, or enumerator, or all
   refer to functions and function templates; in this case the class name
+  or enumeration name is hidden [[basic.scope.hiding]]. \[*Note 1*: A
+ structured binding [[dcl.struct.bind]], namespace name
+  [[basic.namespace]], or class template name [[temp.pre]] must be
+ unique in its declarative region. — *end note*]
 [*Note 2*: These restrictions apply to the declarative region into
 which a name is introduced, which is not necessarily the same as the
 region in which the declaration occurs. In particular,
+*elaborated-type-specifier*s [[dcl.type.elab]] and friend declarations
+[[class.friend]] may introduce a (possibly not visible) name into an
+enclosing namespace; these restrictions apply to that region. Local
+extern declarations [[basic.link]] may introduce a name into the
+declarative region where the declaration appears and also introduce a
+(possibly not visible) name into an enclosing namespace; these
+restrictions apply to both regions. — *end note*]
+For a given declarative region *R* and a point *P* outside *R*, the set
+of *intervening* declarative regions between *P* and *R* comprises all
+declarative regions that are or enclose *R* and do not enclose *P*.
 [*Note 3*: The name lookup rules are summarized in
 [[basic.lookup]]. — *end note*]
 ### Point of declaration <a id="basic.scope.pdecl">[[basic.scope.pdecl]]</a>
 The *point of declaration* for a name is immediately after its complete
+declarator [[dcl.decl]] and before its *initializer* (if any), except as
+noted below.
 [*Example 1*:
 ``` cpp
 unsigned char x = 12;
 { unsigned char x = x; }
 ```
+Here, the initialization of the second `x` has undefined behavior,
+because the initializer accesses the second `x` outside its lifetime
+[[basic.life]].
 — *end example*]
 [*Note 1*:
+A name from an outer scope remains visible up to the point of
 declaration of the name that hides it.
 [*Example 2*:
 ``` cpp
 — *end note*]
 The point of declaration for a class or class template first declared by
 a *class-specifier* is immediately after the *identifier* or
+*simple-template-id* (if any) in its *class-head* [[class.pre]]. The
+point of declaration for an enumeration is immediately after the
+*identifier* (if any) in either its *enum-specifier* [[dcl.enum]] or its
+first *opaque-enum-declaration* [[dcl.enum]], whichever comes first. The
+point of declaration of an alias or alias template immediately follows
+the *defining-type-id* to which the alias refers.
 The point of declaration of a *using-declarator* that does not name a
+constructor is immediately after the *using-declarator*
+[[namespace.udecl]].
 The point of declaration for an enumerator is immediately after its
 *enumerator-definition*.
 [*Example 3*:
   \[*Note 3*: These rules also apply within templates. — *end note*]
   \[*Note 4*: Other forms of *elaborated-type-specifier* do not declare
   a new name, and therefore must refer to an existing *type-name*. See
   [[basic.lookup.elab]] and  [[dcl.type.elab]]. — *end note*]
+The point of declaration for an injected-class-name [[class.pre]] is
+immediately following the opening brace of the class definition.
+The point of declaration for a function-local predefined variable
+[[dcl.fct.def.general]] is immediately before the *function-body* of a
+function definition.
+The point of declaration of a structured binding [[dcl.struct.bind]] is
+immediately after the *identifier-list* of the structured binding
+declaration.
+The point of declaration for the variable or the structured bindings
+declared in the *for-range-declaration* of a range-based `for` statement
+[[stmt.ranged]] is immediately after the *for-range-initializer*.
 The point of declaration for a template parameter is immediately after
 its complete *template-parameter*.
 [*Example 4*:
 — *end example*]
 [*Note 5*: Friend declarations refer to functions or classes that are
 members of the nearest enclosing namespace, but they do not introduce
+new names into that namespace [[namespace.memdef]]. Function
 declarations at block scope and variable declarations with the `extern`
 specifier at block scope refer to declarations that are members of an
 enclosing namespace, but they do not introduce new names into that
 scope. — *end note*]
 [*Note 6*: For point of instantiation of a template, see
 [[temp.point]]. — *end note*]
 ### Block scope <a id="basic.scope.block">[[basic.scope.block]]</a>
+A name declared in a block [[stmt.block]] is local to that block; it has
+*block scope*. Its potential scope begins at its point of declaration
+[[basic.scope.pdecl]] and ends at the end of its block. A variable
+declared at block scope is a *local variable*.
 The name declared in an *exception-declaration* is local to the
 *handler* and shall not be redeclared in the outermost block of the
 *handler*.
 Names declared in the *init-statement*, the *for-range-declaration*, and
 in the *condition* of `if`, `while`, `for`, and `switch` statements are
 local to the `if`, `while`, `for`, or `switch` statement (including the
 controlled statement), and shall not be redeclared in a subsequent
 condition of that statement nor in the outermost block (or, for the `if`
+statement, any of the outermost blocks) of the controlled statement.
+[*Example 1*:
+``` cpp
+if (int x = f()) {
+  int x;            // error: redeclaration of x
+}
+else {
+  int x;            // error: redeclaration of x
+}
+```
+— *end example*]
+### Function parameter scope <a id="basic.scope.param">[[basic.scope.param]]</a>
+A function parameter (including one appearing in a *lambda-declarator*)
+or function-local predefined variable [[dcl.fct.def]] has *function
+parameter scope*. The potential scope of a parameter or function-local
+predefined variable begins at its point of declaration. If the nearest
+enclosing function declarator is not the declarator of a function
+definition, the potential scope ends at the end of that function
+declarator. Otherwise, if the function has a *function-try-block* the
+potential scope ends at the end of the last associated handler.
+Otherwise the potential scope ends at the end of the outermost block of
+the function definition. A parameter name shall not be redeclared in the
+outermost block of the function definition nor in the outermost block of
+any handler associated with a *function-try-block*.
 ### Function scope <a id="basic.funscope">[[basic.funscope]]</a>
+Labels [[stmt.label]] have *function scope* and may be used anywhere in
+the function in which they are declared. Only labels have function
 scope.
 ### Namespace scope <a id="basic.scope.namespace">[[basic.scope.namespace]]</a>
 The declarative region of a *namespace-definition* is its
 *namespace-body*. Entities declared in a *namespace-body* are said to be
 *members* of the namespace, and names introduced by these declarations
 into the declarative region of the namespace are said to be *member
 names* of the namespace. A namespace member name has namespace scope.
 Its potential scope includes its namespace from the name’s point of
+declaration [[basic.scope.pdecl]] onwards; and for each
+*using-directive* [[namespace.udir]] that nominates the member’s
 namespace, the member’s potential scope includes that portion of the
 potential scope of the *using-directive* that follows the member’s point
 of declaration.
 [*Example 1*:
 }
 ```
 — *end example*]
+If a translation unit Q is imported into a translation unit R
+[[module.import]], the potential scope of a name X declared with
+namespace scope in Q is extended to include the portion of the
+corresponding namespace scope in R following the first
+*module-import-declaration* or *module-declaration* in R that imports Q
+(directly or indirectly) if
+- X does not have internal linkage, and
+- X is declared after the *module-declaration* in Q (if any), and
+- either X is exported or Q and R are part of the same module.
+[*Note 1*:
+A *module-import-declaration* imports both the named translation unit(s)
+and any modules named by exported *module-import-declaration*s within
+them, recursively.
+[*Example 2*:
+Translation unit #1
+``` cpp
+export module Q;
+export int sq(int i) { return i*i; }
+```
+Translation unit #2
+``` cpp
+export module R;
+export import Q;
+```
+Translation unit #3
+``` cpp
+import R;
+int main() { return sq(9); }    // OK: sq from module Q
+```
+— *end example*]
+— *end note*]
 A namespace member can also be referred to after the `::` scope
+resolution operator [[expr.prim.id.qual]] applied to the name of its
 namespace or the name of a namespace which nominates the member’s
 namespace in a *using-directive*; see  [[namespace.qual]].
 The outermost declarative region of a translation unit is also a
 namespace, called the *global namespace*. A name declared in the global
 namespace has *global namespace scope* (also called *global scope*). The
+potential scope of such a name begins at its point of declaration
+[[basic.scope.pdecl]] and ends at the end of the translation unit that
 is its declarative region. A name with global namespace scope is said to
 be a *global name*.
 ### Class scope <a id="basic.scope.class">[[basic.scope.class]]</a>
 The potential scope of a name declared in a class consists not only of
 the declarative region following the name’s point of declaration, but
+also of all complete-class contexts [[class.mem]] of that class.
 A name `N` used in a class `S` shall refer to the same declaration in
 its context and when re-evaluated in the completed scope of `S`. No
 diagnostic is required for a violation of this rule.
 A name declared within a member function hides a declaration of the same
 name whose scope extends to or past the end of the member function’s
 class.
+The potential scope of a declaration in a class that extends to or past
+the end of a class definition also extends to the regions defined by its
+member definitions, even if the members are defined lexically outside
+the class (this includes static data member definitions, nested class
+definitions, and member function definitions, including the member
+function body and any portion of the declarator part of such definitions
+which follows the *declarator-id*, including a
+*parameter-declaration-clause* and any default arguments
+[[dcl.fct.default]]).
 [*Example 1*:
 ``` cpp
 typedef int  c;
 — *end example*]
 The name of a class member shall only be used as follows:
 - in the scope of its class (as described above) or a class derived
+  [[class.derived]] from its class,
 - after the `.` operator applied to an expression of the type of its
+  class [[expr.ref]] or a class derived from its class,
+- after the `->` operator applied to a pointer to an object of its class
+  [[expr.ref]] or a class derived from its class,
+- after the `::` scope resolution operator [[expr.prim.id.qual]] applied
+ to the name of its class or a class derived from its class.
 ### Enumeration scope <a id="basic.scope.enum">[[basic.scope.enum]]</a>
+The name of a scoped enumerator [[dcl.enum]] has *enumeration scope*.
 Its potential scope begins at its point of declaration and terminates at
 the end of the *enum-specifier*.
 ### Template parameter scope <a id="basic.scope.temp">[[basic.scope.temp]]</a>
 qualified and unqualified name lookup.)
 — *end example*]
 The potential scope of a template parameter name begins at its point of
+declaration [[basic.scope.pdecl]] and ends at the end of its declarative
+region.
 [*Note 1*:
 This implies that a *template-parameter* can be used in the declaration
 of subsequent *template-parameter*s and their default arguments but
 within the immediately-enclosing declarative region.
 [*Note 2*:
 As a result, a *template-parameter* hides any entity with the same name
+in an enclosing scope [[basic.scope.hiding]].
 [*Example 2*:
 ``` cpp
 typedef int N;
 — *end example*]
 — *end note*]
 [*Note 3*: Because the name of a template parameter cannot be
+redeclared within its potential scope [[temp.local]], a template
 parameter’s scope is often its potential scope. However, it is still
 possible for a template parameter name to be hidden; see
 [[temp.local]]. — *end note*]
 ### Name hiding <a id="basic.scope.hiding">[[basic.scope.hiding]]</a>
+A declaration of a name in a nested declarative region hides a
+declaration of the same name in an enclosing declarative region; see
+[[basic.scope.declarative]] and [[basic.lookup.unqual]].
+If a class name [[class.name]] or enumeration name [[dcl.enum]] and a
+variable, data member, function, or enumerator are declared in the same
+declarative region (in any order) with the same name (excluding
+declarations made visible via *using-directive*s
+[[basic.lookup.unqual]]), the class or enumeration name is hidden
+wherever the variable, data member, function, or enumerator name is
+visible.
 In a member function definition, the declaration of a name at block
 scope hides the declaration of a member of the class with the same name;
 see  [[basic.scope.class]]. The declaration of a member in a derived
+class [[class.derived]] hides the declaration of a member of a base
+class of the same name; see  [[class.member.lookup]].
 During the lookup of a name qualified by a namespace name, declarations
 that would otherwise be made visible by a *using-directive* can be
 hidden by declarations with the same name in the namespace containing
 the *using-directive*; see  [[namespace.qual]].

Diff to HTML by rtfpessoa