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
Language Design Principles
formal_package_actual_partis (<>), should be made visible by a
use_clausefor the appropriate package.
::=use [all] type
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_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
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.
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.
selected_components”. Thus, child library units and generic formal parameters of a formal package are potentially use-visible when their enclosing package is use'd.
use_clauseto 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
identifierare not use-visible unless each of them is an overloadable declaration.
default_expressions, any use will be ambiguous. We only mention
identifiers here, because declarations named by
operator_symbols are always overloadable, and hence never cancel each other. Direct visibility is irrelevant for
The elaboration of a
use_clause has no effect.
Example 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_clausethat makes it potentially use-visible has no effect. Therefore, a
use_type_clausefor 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_declarationfor "+" 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_declarations, the case where the rule should apply only to some subset of the declarations with the same defining name, and the case of
subtype_declarations (since they are claimed to be sufficient for renaming of subtypes).
Extensions to Ada 83
Wording Changes from Ada 83
Wording Changes from Ada 95
Extensions to Ada 2005
use_type_clauseis new to Ada 2012. It works similarly to prefixed views.