Raise expressions from AARM.

Raise expressions from AARM.

[Blady]

Hello,

AARM Ada 2022 section 11.3 presents some uses of raise expressions 
including this one:
(http://www.ada-auth.org/standards/22aarm/html/AA-11-3.html)

2.a.10/4        ...

                 B : Some_Array := (1, 2, 3, others => raise 
Not_Valid_Error);

What could be the use cases?

My guess: whatever the size of Some_Array (greater than 3), B is 
elaborated but raises Not_Valid_Error when accessing component beyond 
position 3:

type Some_Array is array (Positive range 1..10) of Natural;
...
B : Some_Array := (1, 2, 3, others => raise Not_Valid_Error);
...
begin
X := B (2); -- OK
X := B (6); -- raises Not_Valid_Error
end;

Is it correct?

NB: GNAT 13.2 issues a compilation error:
         >>> error: "others" choice not allowed here
see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113862

Thanks, Pascal.

Re: Raise expressions from AARM.

[Jeffrey R.Carter]

On 2024-02-24 10:50, Blady wrote:
> 
> My guess: whatever the size of Some_Array (greater than 3), B is elaborated but 
> raises Not_Valid_Error when accessing component beyond position 3:
> 
> type Some_Array is array (Positive range 1..10) of Natural;
> ...
> B : Some_Array := (1, 2, 3, others => raise Not_Valid_Error);
> ...
> begin
> X := B (2); -- OK
> X := B (6); -- raises Not_Valid_Error
> end;
> 
> Is it correct?

No. This will raise the exception upon the elaboration of B.

The only use of this that I can imagine is if the length of Some_Array is 3. 
Then the others choice is null, so the raise expression is never evaluated. But 
if someone changes the definition of Some_Array to be longer, then the exception 
will be raised.

> NB: GNAT 13.2 issues a compilation error:
>          >>> error: "others" choice not allowed here
> see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113862

The example in the error report has Some_Array unconstrained, in which case an 
others choice is not allowed. With the constrained definition given above, the 
aggregate is valid.

-- 
Jeff Carter
"Gentlemen, you can't fight in here. This is the War Room!"
Dr. Strangelove
30

Re: Raise expressions from AARM.

[Blady]

Le 24/02/2024 à 11:39, Jeffrey R.Carter a écrit :
> On 2024-02-24 10:50, Blady wrote:
>>
>> My guess: whatever the size of Some_Array (greater than 3), B is 
>> elaborated but raises Not_Valid_Error when accessing component beyond 
>> position 3:
>>
>> type Some_Array is array (Positive range 1..10) of Natural;
>> ...
>> B : Some_Array := (1, 2, 3, others => raise Not_Valid_Error);
>> ...
>> begin
>> X := B (2); -- OK
>> X := B (6); -- raises Not_Valid_Error
>> end;
>>
>> Is it correct?
> 
> No. This will raise the exception upon the elaboration of B.
> 
> The only use of this that I can imagine is if the length of Some_Array 
> is 3. Then the others choice is null, so the raise expression is never 
> evaluated. But if someone changes the definition of Some_Array to be 
> longer, then the exception will be raised.

If I understand well, no compiler error nor warning at compilation time 
but Not_Valid_Error raised at run time elaboration.
To be compared with:
    B1 : Some_Array := (1, 2, 3);
No compiler error, one compiler warning "Constraint_Error will be raised 
at run time" and Constraint_Error range check failed raised at run time 
elaboration.

>> NB: GNAT 13.2 issues a compilation error:
>>          >>> error: "others" choice not allowed here
>> see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113862
> 
> The example in the error report has Some_Array unconstrained, in which 
> case an others choice is not allowed. With the constrained definition 
> given above, the aggregate is valid.

Thanks to point out, I've corrected the GNAT report.

Pascal.

Re: Raise expressions from AARM.

[Niklas Holsti]

On 2024-02-24 11:50, Blady wrote:
> Hello,
> 
> AARM Ada 2022 section 11.3 presents some uses of raise expressions 
> including this one:
> (http://www.ada-auth.org/standards/22aarm/html/AA-11-3.html)
> 
> 2.a.10/4        ...
> 
>                  B : Some_Array := (1, 2, 3, others => raise 
> Not_Valid_Error);
> 
> What could be the use cases?


The point of these examples (which are only in the discussion 
annotation, not in the normative standard) is to discuss what is 
syntactically legal and why. The examples need not make practical sense.


> My guess: whatever the size of Some_Array (greater than 3), B is 
> elaborated but raises Not_Valid_Error when accessing component beyond 
> position 3:


No. A raise-expression is not a value that can be stored in an array or 
passed around; its evaluation raises an exception /instead/ of yielding 
a value.

In this example, if the evaluation of the array aggregate that 
initializes B evaluates the expression supplied for the "others" choice, 
this evaluation will raise Not_Valid_Error and disrupt the 
initialization of B.

It is not clear to me if the RM requires the evaluation of the "others" 
expression if there are no "other" indices. Experimenting with GNAT 
(Community 2019) shows that if the Some_Array type has 'Length = 3, the 
exception is not raised (so the "others" value is not evaluated), while 
if the 'Length is greater than 3 the exception is raised.


> type Some_Array is array (Positive range 1..10) of Natural;
> ...
> B : Some_Array := (1, 2, 3, others => raise Not_Valid_Error);


That should raise Not_Valid_Error during the initialization of B.


> ...
> begin
> X := B (2); -- OK
> X := B (6); -- raises Not_Valid_Error
> end;
> 
> Is it correct?


No.

> 
> NB: GNAT 13.2 issues a compilation error:
>          >>> error: "others" choice not allowed here
> see: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=113862


Interesting. GNAT Community 2019 accepted it.

Re: Raise expressions from AARM.

[Blady]

Le 24/02/2024 à 11:39, Niklas Holsti a écrit :
> The point of these examples (which are only in the discussion 
> annotation, not in the normative standard) is to discuss what is 
> syntactically legal and why. The examples need not make practical sense.

Well, despite I knew that, I wanted to draw some use cases from them.
For instance:
   A : A_Tagged   := (Some_Tagged'(raise TBD_Error) with Comp => 'A');
It will raise TBD_Error if Some_Tagged is not a null record, good to 
know, isn't it?

Pascal.

Re: Raise expressions from AARM.

[Niklas Holsti]

On 2024-02-25 13:23, Blady wrote:
> Le 24/02/2024 à 11:39, Niklas Holsti a écrit :
>> The point of these examples (which are only in the discussion 
>> annotation, not in the normative standard) is to discuss what is 
>> syntactically legal and why. The examples need not make practical sense.
> 
> Well, despite I knew that, I wanted to draw some use cases from them.
> For instance:
>    A : A_Tagged   := (Some_Tagged'(raise TBD_Error) with Comp => 'A');
> It will raise TBD_Error if Some_Tagged is not a null record, good to 
> know, isn't it?


Hm, not raising the exception for a null record seems weird to me, and I 
cannot deduce it from the RM. Moreover, for a plain qualified expression

    Some_Tagged'(raise TBD_Error)

not in an extension aggregate GNAT raises the exception even if the type 
is a null record. I suspect that not raising the exception for an 
extension aggregate where the ancestor type is a null record is a bug in 
GNAT.