Teamers:

I posted this on CLA, but I think there is a problem with the
news server where I work.

Language lawyers and philosophers:

Two Ada 95 compilers treat the code below differently, and
I am unsure which one (if either) is correct.

From the partial view, type Basic is unconstrained.  The full
view of Basic is constrained.  The spec of Pack2.Child derives
a new type from Basic in the partial view (visible part) and
adds a discriminant.  This seems like it should be illegal
according to RM95 3.7(13) -- and that is the interpretation
of the compiler I am calling COMPILER A.  COMPILER B has a
different interpretation; see the comments in the spec of
package Pack2.Child.

So, I have three questions: which compiler is correct?  If
COMPILER B is correct, which rules make it so?  And if
COMPILER B is correct, doesn't this represent a language
anomoly, because the 'clients' of package heirarchy Pack2
'see' a violation of RM95 3.7(13)?

Stanley Allen
mailto:[log in to unmask]

------------------------------------------------------------
package Pack2 is

    type Basic (<>) is abstract tagged limited private;

    procedure Increment (B : in out Basic'Class);

    procedure Operation (B : in out Basic) is abstract;

private

    type Basic is abstract tagged limited
        record
            Item : Integer;
        end record;

end Pack2;

package body Pack2 is

    procedure Increment (B : in out Basic'Class) is
    begin
        B.Item := B.Item + 1;
    end Increment;

end Pack2;

package Pack2.Child is

    type Fancy (N : access Integer) is new Basic with private;
-------------------------------------------^
--  Fancy is derived from an unconstrained type, in this view
--
--  COMPILER A complains, referencing RM95 3.7(13)
--  COMPILER B accepts, here is a comment from vendor B:
--
--  "COMPILER B is correct here, the declaration of derived
--  type Fancy in your example is legal.  The full type is
--  derived from a constrained view of the parent type and
--  doesn't violate the stated rule."
--
--  COMPILER B reports an error if Fancy is not a private type,
--  but is declared instead as this:
--
--  type Fancy (N : access Integer) is new Basic with null record;
--

    type Fancy_Ptr is access all Fancy'Class;

    function New_Fancy (Init : access Integer) return Fancy_Ptr;

    procedure Operation (F : in out Fancy);   -- override

private

    type Fancy (N : access Integer) is new Basic with null record;
-------------------------------------------^
--  Fancy is derived from a constrained type, in this view
--

end Pack2.Child;

package body Pack2.Child is

    function New_Fancy (Init : access Integer) return Fancy_Ptr is
        Temp : Fancy_Ptr;
    begin
        Temp := new Fancy (N => Init);
        Basic (Temp.all).Item := Init.all;
        return Temp;
    end New_Fancy;

    procedure Operation (F : in out Fancy) is
    begin
        null;
    end Operation;

end Pack2.Child;
---------------------------------------------------------------