8.4 Use Clauses
This Reference Manual output has not been verified, and may contain omissions or errors. Report any problems on the tracking issue
[A use_package_clause
achieves direct visibility of declarations that appear in the visible part of a package; a use_type_clause
achieves direct visibility of the primitive operators of a type.]
Language Design Principles
formal_package_actual_part
is (<>), should be made visible by a use_clause
for the appropriate package.use_clause
s were carefully constructed to avoid so-called Beaujolais effects, where the addition or removal of a single use_clause
, or a single declaration in a "use"d package, would change the meaning of a program from one legal interpretation to another. Syntax
2use_clause
::=
use_package_clause
| use_type_clause
3use_package_clause
::=
use package_name
{, package_name
};
4/3use_type_clause
::=
use [all] type subtype_mark
{, subtype_mark
};
Legality Rules
5/2A package_name
of a use_package_clause
shall denote a nonlimited view of a package.
Static Semantics
6For each use_clause
, there is a certain region of text called the scope of the use_clause
. For a use_clause
within a context_clause
of a library_unit_declaration
or library_unit_renaming_declaration
, the scope is the entire declarative region of the declaration. For a use_clause
within a context_clause
of a body, the scope is the entire body [and any subunits (including multiply nested subunits). The scope does not include context_clause
s themselves.]
For a use_clause
immediately within a declarative region, the scope is the portion of the declarative region starting just after the use_clause
and extending to the end of the declarative region. However, the scope of a use_clause
in the private part of a library unit does not include the visible part of any public descendant of that library unit.
use_clause
s work like this: package P is
type T is range 1..10;
end P;
7.cwith P;
package Parent is
private
use P;
X : T;
end Parent;
7.dpackage Parent.Child is
Y : T; -- Illegal!
Z : P.T;
private
W : T;
end Parent.Child;
A package is named in a use_package_clause
if it is denoted by a package_name
of that clause. A type is named in a use_type_clause
if it is determined by a subtype_mark
of that clause.
For each package named in a use_package_clause
whose scope encloses a place, each declaration that occurs immediately within the declarative region of the package is potentially use-visible at this place if the declaration is visible at this place. For each type T or T'Class named in a use_type_clause
whose scope encloses a place, the declaration of each primitive operator of type T is potentially use-visible at this place if its declaration is visible at this place. If a use_type_clause
whose scope encloses a place includes the reserved word all, then the following entities are also potentially use-visible at this place if the declaration of the entity is visible at this place:
- Each primitive subprogram of T including each enumeration literal (if any);
- Each subprogram that is declared immediately within the declarative region in which an ancestor type of T is declared and that operates on a class-wide type that covers T.
identifier
are not made potentially visible by a use_type_clause
unless reserved word all is included. A use_type_clause
without all is only for operators.use_clause
s and selected_component
s”. Thus, child library units and generic formal parameters of a formal package are potentially use-visible when their enclosing package is use'd.use_clause
to a parent unit does not make all of its children use-visible — only those that have been made visible by a with_clause
. It also implies that we don't have to worry about hiding in the definition of "directly visible" — a declaration cannot be use-visible unless it is visible.Certain implicit declarations may become potentially use-visible in certain contexts as described in 12.6.
A declaration is use-visible if it is potentially use-visible, except in these naming-conflict cases:
- A potentially use-visible declaration is not use-visible if the place considered is within the immediate scope of a homograph of the declaration.
- Potentially use-visible declarations that have the same
identifier
are not use-visible unless each of them is an overloadable declaration.
default_expression
s, any use will be ambiguous. We only mention identifier
s here, because declarations named by operator_symbol
s are always overloadable, and hence never cancel each other. Direct visibility is irrelevant for character_literal
s. Dynamic Semantics
12The elaboration of a use_clause
has no effect.
Examples
13Example of a use clause in a context clause:
with Ada.Calendar; use Ada;
Example of a use type clause:
use type Rational_Numbers.Rational; -- see 7.1
Two_Thirds: Rational_Numbers.Rational := 2/3;
use_clause
that makes it potentially use-visible has no effect. Therefore, a use_type_clause
for a type whose declaration appears in a place other than the visible part of a package has no effect; it cannot make a declaration use-visible unless that declaration is already immediately visible.subprogram_declaration
for "+" is potentially use-visible, and a fully conformant renaming of it is also potentially use-visible, then they (annoyingly) cancel each other out; neither one is use-visible. The considered rule would have made just one of them use-visible. We gave up on this idea due to the complexity of the rule. It would have had to account for both overloadable and nonoverloadable renaming_declaration
s, the case where the rule should apply only to some subset of the declarations with the same defining name, and the case of subtype_declaration
s (since they are claimed to be sufficient for renaming of subtypes). Extensions to Ada 83
use_type_clause
is new to Ada 95. Wording Changes from Ada 83
Wording Changes from Ada 95
Extensions to Ada 2005
use_type_clause
is new to Ada 2012. It works similarly to prefixed views.