Go to the first, previous, next, last section, table of contents.

3.10.1 Incomplete Type Declarations

  1. There are no particular limitations on the designated type of an access type. In particular, the type of a component of the designated type can be another access type, or even the same access type. This permits mutually dependent and recursive access types. An incomplete_type_declaration can be used to introduce a type to be used as a designated type, while deferring its full definition to a subsequent full_type_declaration.


  2. incomplete_type_declaration ::=
       type defining_identifier [discriminant_part];

    Legality Rules

  3. An incomplete_type_declaration requires a completion, which shall be a full_type_declaration. If the incomplete_type_declaration occurs immediately within either the visible part of a package_specification or a declarative_part, then the full_type_declaration shall occur later and immediately within this visible part or declarative_part. If the incomplete_type_declaration occurs immediately within the private part of a given package_specification, then the full_type_declaration shall occur later and immediately within either the private part itself, or the declarative_part of the corresponding package_body.
  4. If an incomplete_type_declaration has a known_discriminant_part, then a full_type_declaration that completes it shall have a fully conforming (explicit) known_discriminant_part, See section 6.3.1 Conformance Rules. If an incomplete_type_declaration has no discriminant_part (or an unknown_discriminant_part), then a corresponding full_type_declaration is nevertheless allowed to have discriminants, either explicitly, or inherited via derivation.
  5. The only allowed uses of a name that denotes an incomplete_type_declaration are as follows:
    1. as the subtype_mark in the subtype_indication of an access_to_object_definition; the only form of constraint allowed in this subtype_indication is a discriminant_constraint;
    2. as the subtype_mark defining the subtype of a parameter or result of an access_to_subprogram_definition;
    3. as the subtype_mark in an access_definition;
    4. as the prefix of an attribute_reference whose attribute_designator is Class; such an attribute_reference is similarly restricted to the uses allowed here; when used in this way, the corresponding full_type_declaration shall declare a tagged type, and the attribute_reference shall occur in the same library unit as the incomplete_type_declaration.

  1. A dereference (whether implicit or explicit -- See section 4.1 Names.) shall not be of an incomplete type.

    Static Semantics

  2. An incomplete_type_declaration declares an incomplete type and its first subtype; the first subtype is unconstrained if a known_discriminant_part appears.

    Dynamic Semantics

  3. The elaboration of an incomplete_type_declaration has no effect.


  4. (80) Within a declarative_part, an incomplete_type_declaration and a corresponding full_type_declaration cannot be separated by an intervening body. This is because a type has to be completely defined before it is frozen, and a body freezes all types declared prior to it in the same declarative_part, See section 13.14 Freezing Rules.


  5. Example of a recursive type:
  6. type Cell;  --  incomplete type declaration
    type Link is access Cell;
  7. type Cell is
          Value  : Integer;
          Succ   : Link;
          Pred   : Link;
       end record;
  8. Head   : Link  := new Cell'(0, null, null);
    Next   : Link  := Head.Succ;
  9. Examples of mutually dependent access types:
  10. type Person(<>);    -- incomplete type declaration
    type Car;           -- incomplete type declaration
  11. type Person_Name is access Person;
    type Car_Name    is access all Car;
  12. type Car is
          Number  : Integer;
          Owner   : Person_Name;
       end record;
  13. type Person(Sex : Gender) is
          Name     : String(1 .. 20);
          Birth    : Date;
          Age      : Integer range 0 .. 130;
          Vehicle  : Car_Name;
          case Sex is
             when M => Wife    : Person_Name(Sex => F);
             when F => Husband : Person_Name(Sex => M);
          end case;
       end record;
  14. My_Car, Your_Car, Next_Car : Car_Name := new Car;
    -- See section 4.8 Allocators
    George : Person_Name := new Person(M);
    George.Vehicle := Your_Car;

Go to the first, previous, next, last section, table of contents.