"Yannick Duch�ne (Hibou57)" <yannick_duchene@yahoo.fr> wrote in message 
news:op.wnhvol1wule2fv@cardamome...

>     procedure Ex  is
>
>        -- ========================================
>
>        package P1 is
>
>           type R is interface;
>           type T is interface;
>
>          not overriding
>           function F
>             (E : T)
>              return R'Class
>              is abstract;
>        end;
>
>        -- ========================================
>
>        package P2 is
>
>           type R is interface and P1.R;
>           type T is interface and P1.T;
>
>           overriding
>           function F
>             (E : T)
>              return R'Class -- Not overriding :-(
>              is abstract;
>        end;
>
>        -- ========================================

I'd strongly suggest to use different names for different types in examples, 
otherwise you'll confuse everyone (and yourself). Just because you can use 
the same name in the real code (and might want to in unusual circumstances) 
is no good reason to make examples that confuse the heck out of everyone.

In any case, overriding requires subtype conformance. And if you properly 
named the types, the problem would be obvious.

        package P2 is

           type R2 is interface and P1.R;
           type T2 is interface and P1.T;

           overriding
           function F
             (E : T2)
              return R2'Class -- Not overriding :-(
              is abstract;
        end;

Since overriding requires subtype conformance (among other things, requiring 
the same subtype on all non-controlling parameters and results), and 
R2'Class /= R'Class (and this isn't a controlling result), no overriding is 
possible. There are good reasons for these restrictions (mostly 
implementation-oriented).

I'm sure there exist (very limited) cases where it might make sense to relax 
subtype conformance, but there would need to be a strong justification for 
the significant added complication in the language rules and implementation. 
I'm pretty certain that an example using types T and R isn't it.

In any case, Ada 2012 is finished (with possibility of some editorial 
corrections in the final edition, but nothing substansive). If we were going 
to fix anything in it, it would be the handful of bad bugs that have been 
identified, surely nothing involving features that are unchanged in Ada 2012 
(which is the case with overriding, modulo wording bugs).

                                                       Randy.