Go to the first, previous, next, last section, table of contents.
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.
A declaration is defined to be directly visible at places where a name
consisting of only an identifier or operator_symbol is sufficient 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. A 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) can denote the
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,
There are two kinds of direct visibility: immediate visibility and
use-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, See section 8.4 Use Clauses. 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). Where hidden from direct visibility, only direct
visibility is lost; visibility using a selector_name is still possible.
Two or more declarations are overloaded 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, meaning 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.
Two homographs are not generally allowed immediately within the same
declarative region unless one overrides the other (see Legality Rules
below). A declaration overrides another homograph that occurs
immediately within the same declarative region in the following cases:
An explicit declaration overrides an implicit declaration of a primitive
subprogram, regardless of which declaration occurs first;
The implicit declaration of an inherited operator overrides that of a
An implicit declaration of an inherited subprogram overrides a previous
implicit declaration of an inherited subprogram.
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
A 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.
A declaration is hidden from all visibility until the end of the
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
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
A declaration with a defining_identifier or defining_operator_symbol is
immediately 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 region;
A declaration is also hidden from direct visibility where hidden from
Name Resolution Rules
A direct_name shall resolve to denote a directly visible declaration
whose defining name is the same as the direct_name. A selector_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, a parent_unit_name, or a pragma that appears at the
place of a compilation_unit. For those contexts, see the rules in
See section 10.1.6 Environment-Level Visibility Rules.
An explicit 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
explicit declaration. 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 region. 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 conformant.
(5) Visibility for compilation units follows from the definition of the
environment in See section 10.1.4 The Compilation Process, except that it is necessary to apply a
with_clause to obtain visibility to a library_unit_declaration or
(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 section 8.6 The Context of Overload Resolution.
(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 or selector_name.
Go to the first, previous, next, last section, table of contents.