maintenance of overriding subprograms

[Stephen Leake <Stephen.Leake@gsfc.nasa.gov>]

The discussion of maintaining separate spec and implementation reminded
me of a potential maintenance problem with overriding subprograms of
derived types. Suppose we have:

   package Root is
      type Root_Type is tagged private;

      procedure Create (Item : in out Root_Type);
   private
      type Root_Type is tagged record
         Count : Integer;
      end record;
   end Root;

   package body Root is
      procedure Create (Item : in out Root_Type)
      is begin
         Item.Count := 0;
      end Create;
   end Root;

   package Derived is
      type Derived_Type is new Root.Root_Type with private;

      -- override Create (Root_Type)
      procedure Create (Item : in out Derived_Type);
   private
      type Derived_Type is new Root.Root_Type with record
         Leaves : Integer;
      end record;
   end Derived;

   package body Derived is
      procedure Create (Item : in out Derived_Type)
      is begin
         Root.Create (Root.Root_Type (Item));
         Item.Leaves := 0;
      end Create;
   end Derived;

Now suppose that in maintenance we add a parameter to Root.Create:

  procedure Create (Item : in out Root_Type; Max : in Integer := 0);

When we compile, the compiler tells us that the package body of Root
does not have a corresponding body for Create. However, it does not tell
us that Derived.Create no longer overrides Root.Create; Derived.Create
silently changes from an overriding subprogram to a "normal" subprogram.

To solve this, perhaps we could add a pragma:

pragma Confirm_Override ({subprogram_name});

which would generate a compile-time error if {subprogram_name} does not
override a root type subprogram. In Ada 200x, we could use the keyword
"new" for this:

new procedure Create (...);

which would have the same effect.

Any comments?
-- 
- Stephe