Contents   Index   Search   Previous   Next

8.5.4 Subprogram Renaming Declarations

   A subprogram_renaming_declaration can serve as the completion of a subprogram_declaration; {renaming-as-body} such a renaming_declaration is called a renaming-as-body. {renaming-as-declaration} A subprogram_renaming_declaration that is not a completion is called a renaming-as-declaration[, and is used to rename a subprogram (possibly an enumeration literal) or an entry].
Ramification: A renaming-as-body is a declaration, as defined in Section 3.


subprogram_renaming_declaration ::= subprogram_specification renames callable_entity_name;

Name Resolution Rules

   {expected profile (subprogram_renaming_declaration) [partial]} The expected profile for the callable_entity_name is the profile given in the subprogram_specification.

Legality Rules

   The profile of a renaming-as-declaration shall be mode-conformant with that of the renamed callable entity. {mode conformance (required)}
     {8652/0027} {8652/0028} The profile of a renaming-as-body shall be subtype-conformant with that of the renamed callable entity, and shall conform fully to that of the declaration it completes. {full conformance (required)} If the renaming-as-body completes that declaration before the subprogram it declares is frozen, the profile shall be mode-conformant {mode conformance (required)} with that of the renamed callable entity and the subprogram it declares takes its convention from the renamed subprogram; otherwise, the profile shall be subtype-conformant with that of the renamed callable entity and the convention of the renamed subprogram shall not be Intrinsic. {subtype conformance (required)} A renaming-as-body is illegal if the declaration occurs before the subprogram whose declaration it completes is frozen, and the renaming renames the subprogram itself, through one or more subprogram renaming declarations, none of whose subprograms has been frozen.
Reason: The otherwise part of the second sentence first part of the first sentence is to allow an implementation of a renaming-as-body as a single jump instruction to the target subprogram. Among other things, this prevents a subprogram from being completed with a renaming of an entry. (In most cases, the target of the jump can be filled in at link time. In some cases, such as a renaming of a name like "A(I).all", an indirect jump is needed. Note that the name is evaluated at renaming time, not at call time.)
{8652/0028} The first part of the second sentence is intended to allow renaming-as-body of predefined operators before the subprogram_declaration is frozen. For some types (such as integer types), the parameter type for operators is the base type, and it would be very strange for
   function Equal (A, B : in T) return Boolean;
   function Equal (A, B : in T) return Boolean renames "=";
to be illegal. (Note that predefined operators cannot be renamed this way after the subprogram_declaration is frozen, as they have convention Intrinsic.)
The second part of the first sentence is the normal rule for completions of subprogram_declarations.
Ramification: An entry_declaration, unlike a subprogram_declaration, cannot be completed with a renaming_declaration. Nor can a generic_subprogram_declaration.
The syntax rules prevent a protected subprogram declaration from being completed by a renaming. This is fortunate, because it allows us to avoid worrying about whether the implicit protected object parameter of a protected operation is involved in the conformance rules.
Reason: {8652/0027} Circular renames before freezing is illegal, as the compiler would not be able to determine the convention of the subprogram. Other circular renames are handled below; see Bounded (Run-Time) Errors.
   A name that denotes a formal parameter of the subprogram_specification is not allowed within the callable_entity_name.
Reason: This is to prevent things like this:
function F(X : Integer) return Integer renames Table(X).all;
A similar rule in 6.1 forbids things like this:
function F(X : Integer; Y : Integer := X) return Integer;

Static Semantics

   A renaming-as-declaration declares a new view of the renamed entity. The profile of this new view takes its subtypes, parameter modes, and calling convention from the original profile of the callable entity, while taking the formal parameter names and default_expressions from the profile given in the subprogram_renaming_declaration. The new view is a function or procedure, never an entry.
To be honest: When renaming an entry as a procedure, the compile-time rules apply as if the new view is a procedure, but the run-time semantics of a call are that of an entry call.
Ramification: For example, it is illegal for the entry_call_statement of a timed_entry_call to call the new view. But what looks like a procedure call will do things like barrier waiting.
{8652/0105} All properties of the renamed entity are inherited by the new view unless otherwise stated by this International Standard. In particular, if the renamed entity is abstract or requires overridding (see 3.9.3), the new view also is abstract or requires overridding. (The renaming will often be illegal in these cases, as a renaming cannot be overridden.)

Dynamic Semantics

       {8652/0014} For a call to a subprogram whose body is given as a renaming-as-body, the execution of the renaming-as-body is equivalent to the execution of a subprogram_body that simply calls the renamed subprogram with its formal parameters as the actual parameters and, if it is a function, returns the value of the call.
Ramification: This implies that the subprogram completed by the renames-as-body has its own elaboration check.
   For a call on a renaming of a dispatching subprogram that is overridden, if the overriding occurred before the renaming, then the body executed is that of the overriding declaration, even if the overriding declaration is not visible at the place of the renaming; otherwise, the inherited or predefined subprogram is called.
Discussion: Note that whether or not the renaming is itself primitive has nothing to do with the renamed subprogram.
Note that the above rule is only for tagged types.
Consider the following example:
package P is
    type T is tagged null record;
    function Predefined_Equal(X, Y : T) return Boolean renames "=";
    function "="(X, Y : T) return Boolean; -- Override predefined "=".
end P;
with P; use P;
package Q is
    function User_Defined_Equal(X, Y : T) return Boolean renames P."=";
end Q;
A call on Predefined_Equal will execute the predefined equality operator of T, whereas a call on User_Defined_Equal will execute the body of the overriding declaration in the private part of P.
Thus a renaming allows one to squirrel away a copy of an inherited or predefined subprogram before later overriding it.

Bounded (Run-Time) Errors

       {8652/0027} {Program_Error (raised by failure of run-time check)} {Storage_Error (raised by failure of run-time check)} If a subprogram directly or indirectly renames itself, then it is a bounded error to call that subprogram. Possible consequences are that Program_Error or Storage_Error is raised, or that the call results in infinite recursion.
Reason: {8652/0027} This has to be a bounded error, as it is possible for a renames-as-body appearing in a package body to cause this problem. Thus it is not possible in general to detect this problem at compile time.
11  A procedure can only be renamed as a procedure. A function whose defining_designator is either an identifier or an operator_symbol can be renamed with either an identifier or an operator_symbol; for renaming as an operator, the subprogram specification given in the renaming_declaration is subject to the rules given in 6.6 for operator declarations. Enumeration literals can be renamed as functions; similarly, attribute_references that denote functions (such as references to Succ and Pred) can be renamed as functions. An entry can only be renamed as a procedure; the new name is only allowed to appear in contexts that allow a procedure name. An entry of a family can be renamed, but an entry family cannot be renamed as a whole.
12  The operators of the root numeric types cannot be renamed because the types in the profile are anonymous, so the corresponding specifications cannot be written; the same holds for certain attributes, such as Pos.
13  Calls with the new name of a renamed entry are procedure_call_statements and are not allowed at places where the syntax requires an entry_call_statement in conditional_ and timed_entry_calls, nor in an asynchronous_select; similarly, the Count attribute is not available for the new name.
14  The primitiveness of a renaming-as-declaration is determined by its profile, and by where it occurs, as for any declaration of (a view of) a subprogram; primitiveness is not determined by the renamed view. In order to perform a dispatching call, the subprogram name has to denote a primitive subprogram, not a non-primitive renaming of a primitive subprogram.
Reason: A subprogram_renaming_declaration could more properly be called renaming_as_subprogram_declaration, since you're renaming something as a subprogram, but you're not necessarily renaming a subprogram. But that's too much of a mouthful. Or, alternatively, we could call it a callable_entity_renaming_declaration, but that's even worse. Not only is it a mouthful, it emphasizes the entity being renamed, rather than the new view, which we think is a bad idea. We'll live with the oddity.


    Examples of subprogram renaming declarations:
procedure My_Write(C : in Character) renames Pool(K).Write; --  see 4.1.3
function Real_Plus(Left, Right : Real   ) return Real    renames "+";
function Int_Plus (Left, Right : Integer) return Integer renames "+";
function Rouge return Color renames Red;  --  see 3.5.1
function Rot   return Color renames Red;
function Rosso return Color renames Rouge;
function Next(X : Color) return Color renames Color'Succ; -- see 3.5.1
    Example of a subprogram renaming declaration with new parameter names:
function "*" (X,Y : Vector) return Real renames Dot_Product; -- see 6.1
    Example of a subprogram renaming declaration with a new default expression:
function Minimum(L : Link := Head) return Cell renames Min_Cell; -- see 6.1

Contents   Index   Search   Previous   Next   Legal