Re: ObjectAda vs Gnat -- bugs

[dewar@merv.cs.nyu.edu (Robert Dewar)]

<<When so many are wrong, including at least one compiler writer, it's
probably a problem with the language, not with all those people.  The
problem here, I think, is that enumeration literals are functions, in
Ada, which is completely weird, given that string_literals and
numeric_literals and null literals are just values.
>>

I agree with Bob here. The trouble is that although it makes moderately
consistent semantic sense to declare that enumeration literals are
functions, it does not make much sense from a programmer's point of view,
and it does not make much sense from an implementation point of view.
In GNAT, we find that we need special handling for enumeration literals
all over the place as a result of this rule. For example, look at the
code for handling object renamings:

      elsif not Is_Object_Reference (Nam)
        and then Nkind (Nam) /= N_Function_Call
        and then (Nkind (Nam) /= N_Type_Conversion
                    or else not Is_Tagged_Type (Entity (Subtype_Mark (Nam))))
      then
         if Nkind (Nam) = N_Type_Conversion then
            Error_Msg_N
              ("renaming of conversion only allowed for tagged types", Nam);
         else
            Error_Msg_N ("expect object name in renaming", Nam);
         end if;

The fix is clear, we just need to add an explicit check for
E_Enumeration_Literal, and it got forgotten (because it is easy
to forget, and of course because out of the thousands of people using
GNAT, no one noticed it yet :-)

Now we could have made all enumeration literal references look like
real function calls, but they we would have another set of special
casing.

Oh well, this is by no means the oddest corner in the language :-)