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_clauses 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
use_package_clause ::= use package_name {, package_name};
use_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_clauses 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_clauses 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_clauses and 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_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
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 character_literals. 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_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
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.