Contents Index Search Previous Next
The visibility rules
given below, determine which declarations are visible and directly visible
at each place within a program. The visibility rules apply to both explicit
and implicit declarations.
declaration is defined to be directly visible
at places where
consisting of only an identifier
to denote the declaration; that is, no selected_component
notation or special context (such as preceding => in a named association)
is necessary to denote the declaration.
is defined to be visible
wherever it is directly visible, as well
as at other places where some name
(such as a selected_component
denote the declaration.
The syntactic category direct_name
is used to indicate contexts where direct visibility is required. The
syntactic category selector_name
is used to indicate contexts where visibility, but not direct visibility,
are two kinds of direct visibility: immediate visibility
A declaration is immediately visible at a place if
it is directly visible because the place is within its immediate scope.
A declaration is use-visible if it is directly visible
because of a use_clause
Both conditions can apply.
A declaration can be hidden
either from direct visibility, or from all visibility, within certain
parts of its scope.
Where hidden from all visibility
it is not visible at all (neither using a direct_name
nor a selector_name
hidden from direct visibility
, only direct visibility is lost;
visibility using a selector_name
is still possible.
Two or more declarations are
if they all have the same defining name and there is
a place where they are all directly visible.
The declarations of callable
entities (including enumeration literals) are overloadable
that overloading is allowed for them.
Two declarations are homographs
if they have the same defining name, and, if both are overloadable, their
profiles are type conformant.
An inner declaration
hides any outer homograph from direct visibility.
are not generally allowed immediately within the same declarative region
unless one overrides
the other (see Legality Rules below).
only declarations that are overridable
the implicit declarations for predefined operators and inherited primitive
subprograms. A declaration overrides another homograph that occurs immediately
within the same declarative region in the following cases:
- A declaration that is not overridable
overrides one that is overridable, regardless of which declaration occurs
- The implicit declaration of an inherited
operator overrides that of a predefined operator;
- An implicit declaration of an inherited
subprogram overrides a previous implicit declaration of an inherited
- For an implicit declaration of a primitive
subprogram in a generic unit, there is a copy of this declaration in
an instance. However, a whole new set of primitive subprograms is implicitly
declared for each type declared within the visible part of the instance.
These new declarations occur immediately after the type declaration,
and override the copied ones. The copied ones can be called only from
within the instance; the new ones can be called only from outside the
instance, although for tagged types, the body of a new one can be executed
by a call to an old one.
declaration is visible within its scope, except where hidden from all
visibility, as follows:
- An overridden
declaration is hidden from all visibility within the scope of the overriding
declaration is hidden from all visibility until the end of the declaration,
- For a record type or record
extension, the declaration is hidden from all visibility only until the
reserved word record;
- For a package_declaration,
task declaration, protected declaration, generic_package_declaration,
or subprogram_body, the declaration
is hidden from all visibility only until the reserved word is
of the declaration.
- If the completion
of a declaration is a declaration, then within the scope of the completion,
the first declaration is hidden from all visibility. Similarly, a discriminant_specification
or parameter_specification is hidden
within the scope of a corresponding discriminant_specification
or parameter_specification of a
corresponding completion, or of a corresponding accept_statement.
- The declaration
of a library unit (including a library_unit_renaming_declaration)
is hidden from all visibility except at places that are within its declarative
region or within the scope of a with_clause
that mentions it. For each declaration or renaming of a generic unit
as a child of some parent generic package, there is a corresponding declaration
nested immediately within each instance of the parent. Such a nested
declaration is hidden from all visibility except at places that are within
the scope of a with_clause that
mentions the child.
declaration with a defining_identifier
visible (and hence directly visible) within its immediate scope
except where hidden from direct visibility, as follows:
- A declaration
is hidden from direct visibility within the immediate scope of a homograph
of the declaration, if the homograph occurs within an inner declarative
- A declaration
is also hidden from direct visibility where hidden from all visibility.
Name Resolution Rules
shall resolve to denote a directly visible declaration whose defining
name is the same as the direct_name
shall resolve to denote a visible declaration whose defining name is
the same as the selector_name
These rules on visibility and direct visibility
do not apply in a context_clause
, or a pragma
that appears at the place of a compilation_unit
For those contexts, see the rules in 10.1.6
``Environment-Level Visibility Rules
A non-overridable declaration is illegal if
there is a homograph occurring immediately within the same declarative
region that is visible at the place of the declaration, and is not hidden
from all visibility by the non-overridable declaration. In addition,
a type extension is illegal if somewhere within its immediate scope it
has two visible components with the same name. Similarly, the context_clause
for a subunit
is illegal if it mentions
(in a with_clause
) some library
unit, and there is a homograph of the library unit that is visible at
the place of the corresponding stub, and the homograph and the mentioned
library unit are both declared immediately within the same declarative
These rules also apply to dispatching operations
declared in the visible part of an instance of a generic unit. However,
they do not apply to other overloadable declarations in an instance;
such declarations may have type conformant profiles in the instance,
so long as the corresponding declarations in the generic were not type
5 Visibility for compilation
units follows from the definition of the environment in 10.1.4,
except that it is necessary to apply a with_clause
to obtain visibility to a library_unit_declaration
6 In addition to the visibility
rules given above, the meaning of the occurrence of a direct_name
or selector_name at a given place
in the text can depend on the overloading rules (see 8.6).
7 Not all contexts where
an identifier, character_literal,
or operator_symbol are allowed require
visibility of a corresponding declaration. Contexts where visibility
is not required are identified by using one of these three syntactic
categories directly in a syntax rule, rather than using direct_name
Contents Index Search Previous Next Legal