13.14 Freezing Rules
This clause defines a place in the program text where
each declared entity becomes “frozen.” A use of an entity,
such as a reference to it by name, or (for a type) an expression of the
type, causes freezing of the entity in some contexts, as described below.
The Legality Rules forbid certain kinds of uses of an entity in the region
of text where it is frozen.
of an entity occurs at one or more places (freezing points
the program text where the representation for the entity has to be fully
determined. Each entity is frozen from its first freezing point to the
end of the program text (given the ordering of compilation units defined
The end of a declarative_part
or a declaration of a library package or generic library package, causes
of each entity declared within it, except for incomplete
A noninstance body other than a renames-as-body
causes freezing of each entity declared before it within the same declarative_part
construct that (explicitly or implicitly) references an entity can cause
of the entity, as defined by subsequent paragraphs.
At the place where a construct causes freezing, each
the construct causes freezing:
occurrence of an object_declaration
that has no corresponding completion causes freezing.
- The declaration
of a record extension causes freezing of the parent subtype.
- The declaration of a record extension,
interface type, task unit, or protected unit causes freezing of any progenitor
types specified in the declaration.
A static expression causes freezing
where it occurs.
An object name or nonstatic expression
causes freezing where it occurs, unless the name or expression is part
of a default_expression
or a per-object expression of a component's constraint
in which case, the freezing occurs later as part of another construct.
An implicit call freezes the
same entities that would be frozen by an explicit call. This is true
even if the implicit call is removed via implementation permissions.
If an expression is implicitly
converted to a type or subtype T
, then at the place where the
expression causes freezing, T
The following rules
define which entities are frozen at the place where a construct causes
the place where a name
causes freezing, the entity denoted by the name
is frozen, unless the name
is a prefix
of an expanded name; at the place where an object
freezing, the nominal subtype associated with the name
the place where a range
causes freezing, the type of the range
the place where an allocator
causes freezing, the designated subtype of its type is frozen. If the
type of the allocator
is a derived type, then all ancestor types are also frozen.
the place where a callable entity is frozen, each subtype of its profile
is frozen. If the callable entity is a member of an entry family, the
index subtype of the family is frozen. At the place
where a function call causes freezing, if a parameter of the call is
defaulted, the default_expression
for that parameter causes freezing.
the place where a subtype is frozen, its type is frozen. At
the place where a type is frozen, any expressions or names
within the full type definition cause freezing; the first subtype, and
any component subtypes, index subtypes, and parent subtype of the type
are frozen as well. For a specific
tagged type, the corresponding class-wide type is frozen as well. For
a class-wide type, the corresponding specific type is frozen as well.
- At the
place where a specific tagged type is frozen, the primitive subprograms
of the type are frozen.
The explicit declaration
of a primitive subprogram of a tagged type shall occur before the type
is frozen (see 3.9.2
A type shall be completely
defined before it is frozen (see 3.11.1
The completion of a
deferred constant declaration shall occur before the constant is frozen
An operational or
representation item that directly specifies an aspect of an entity shall
appear before the entity is frozen (see 13.1
The tag (see 3.9
) of a
tagged type T is created at the point where T is frozen.