Re: Refactoring and Ada

["Pat Rogers" <progers@classwide.com>]

"Dr. Michael Paus" <paus@ib-paus.com> wrote in message
news:3C623E98.646B7C0E@ib-paus.com...
> Robert Dewar wrote:
>
> > By the way, I talked to a never-ever-use-use user of Ada
> > the other day who was appalled to discover that even if
> > you don't use USE clauses, you can have a case where you
> > write
> >
> >        a := f (x);
> >
> > where there were no other occurrences of f in the same
> > source file, no USE clauses, and the textual declaration
> > of f was in another unit.
> >
> > This is of course standard in both Ada 83 and Ada 95 (if
> > you don't know how it arises, and always assumed that avoiding use
> > clauses guaranteed that this could not happen,
> > you have always been fooling yourself :-)
> >
> > I often find that people think that avoiding use clauses
> > avoids this, and requires full qualification. In fact in
> > the above example, suppose the only other occurrence of
> > f is in package p, then it is the case that trying to
> > qualify by writing
> >
> >        a := p.f (x);
> >
> > is not just unnecessary, but in fact illegal.
>
> If I understand your example correctly, it reflects a problem
> which I recently had to fix in program written by someone else.
> We had the requirement not to use use and so the call of f had
> to be qualified as in your example above.

That's a good example of the effect of blindly following bad rules, since the
"don't use use-clauses rule" doesn't even apply here.

> The compiler complained
> about this of course and can you imagine what the programmer did
> in order to fix the problem?  The type of x (B_Type) was derived from
> some other type (let's say A_Type). So the programmer wrote:
>
>        a := p.f (p.A_Type(x));
>
> The compiler was happy and in this particular case the program
> even did what it was assumed to do. The hidden bug in this
> statement is a maintenance time-bomb which would not have occurred
> if use had been used.

No, it is not a matter of use clauses, in terms of *language rules* they are not
at play here.  That is explicitly a call to the parent operation, and it should
not have passed the code review.    It did not do what it was assumed to do, for
that matter -- it called the parent operation, which must have not been
overridden since it seemed to do the right thing.

They should have written it something like this, to satisfy whomever:

package P is
   type T is range 1 .. 10;
   procedure Q( This : out T );
end P;


with P;
procedure R is
   type T2 is new P.T;
   X : T2;
begin
   R.Q( X );    -- note the name of the unit enclosing the derivation
end R;


---
Patrick Rogers                       Consulting and Training in:
http://www.classwide.com          Real-Time/OO Languages
progers@classwide.com               Hard Deadline Schedulability Analysis
(281)648-3165                                 Software Fault Tolerance