Re: next "big" language?? (disagree)

[adam@irvine.com (Adam Beneschan)]

In article <dewar.835306677@schonberg> dewar@cs.nyu.edu (Robert Dewar) writes:
 >Jon said
 >
 >"I have to agree with Jon's point here.  I don't see any reason why the
 >definition of the language would have to prevent the compiler from
 >using the information for optimization.  If the customer didn't want
 >that to happen, the vendor could add a command-line option or pragma
 >to tell the compiler not to.  Don't Ada compilers already have
 >command-line options and/or pragmas to control how much optimization
 >takes place, anyway?"
 
The above words were mine, not Jon's.

 >This is really quite a tricky and subtle issue. If you do not see any
 >problem, then it is likely you don't see the issues fully yet. The basic
 >problem is that the notion of assertion can mean many things, and at the
 >level of discussing the precise semantics of assertions, there are
 >fundamental disagreements. There is certainly a school of thought that
 >is insistent that it is crucial that assertions NOT affect the semantics
 >or even the behavior of the program. 
 >
 >You can declare this silly if you like, but it is more helpful if everyone
 >makes the effort to understand the issues.
 >
 >In GNAT, 
 >
 >   pragma Assert (X);
 >
 >means EXACTLY
 >
 >   if not X then
 >	raise Assert_Error;
 >   end if;
 >
 >which is well defined, but not at all in the category of assertions that
 >the compiler can take advantage of, which can behave in a completely
 >differrent (and possibly suprising manner).

I'm losing you here.  What do you mean that the compiler can't take
advantage of the assertion?  If you mean simply that this is how GNAT
has been taught to behave, OK--you know a lot more about GNAT than I
do. 

If you mean that logically or semantically, the compiler can't take
advantage of the information--why not?  If I wrote code that looked
like this:

      if X not in Some_Subtype'range then
          raise Some_User_Defined_Error;
      end if;
      
  {    . . . More code that doesn't modify X . . .
  {    if X < Some_Subtype'first then
  {        blahblahblah
  {    end if;

I would expect a good optimizer to assume, throughout the bracketed
section of code, that X was in Some_Subtype'range, because control
could never get to that part of the code if it weren't.  (Assuming, of
course, X is not volatile.)  Therefore, the second "if" statement
could be deleted, and any other checks that made sure X was in
Some_Subtype'range could be suppressed.  

And if I'd expect this behavior if an exception I defined were raised,
why would I not expect this if the "raise" statement were changed to
raise Assert_Error?

(I could be missing the whole point of this thread--it's gone on for a
while and I've forgotten how it started.)

                                -- Adam