Re: Recommendation of safe subset of Ada to use?

[gorgelo@hotmail.com]

G.B. wrote in the other thread the following on this topic:

> 1.  Dangling references:  Keeping a reference to an object past its lifetime 
> 
> Ada: 
> *********************************************** 
> with Ada.Text_IO; use Ada.Text_IO; 
> 
> procedure jdoodle is 
>      type Integer_Access is access all Integer; 
>       
>      function Inner(Value : aliased in out Integer) return Integer_Access is 
>      begin 
>          return Value'Access; 
>      end Inner; 
>       
>      function Outer return Integer_Access is 
>          Value : aliased Integer := 0; 
>      begin 
>          return Inner(Value); 
>      end Outer; 
>       
>      Ptr : Integer_Access := Outer;  -- !!! Dangling reference 
> begin 
>      Put_Line("Hello World"); 
> end jdoodle; 

Anything that can be done to prevent the above effect 
should be welcome, if it is representative of what the 
2012 RM allows. Or is this new *aliased* parameter thing 
some I-know-what-I-am-doing Ada? 

So, do explicitly *aliased* parameters indeed break all accessiblity 
rules of Ada?  I noticed that it is mentioned in the RM alongside 
parameters that are passed by reference already because their 
type is a by-reference type. I'd expect then, that one 
would drop *aliased* for those kinds of type, thus 


     27. with Ada.Text_IO; use Ada.Text_IO; 
     28. 
     29. procedure jdoodle2 is 
     30.     type T is tagged 
     31.        record 
     32.            Data :  Integer; 
     33.        end record; 
     34. 
     35.     type T_Access is access all T; 
     36. 
     37.     function Inner(Value : in out T) return T_Access is 
     38.     begin 
     39.         return Value'Access; 
                        | 
         >>> non-local pointer cannot point to local object 

     40.     end Inner; 
     41. 
     42.     function Outer return T_Access is 
     43.         Value : aliased T := T'(Data => 0); 
     44.     begin 
     45.         return Inner(Value); 
     46.     end Outer; 
     47. 
     48.     Ptr : T_Access := Outer; 
     49. begin 
     50.     Put_Line("Hello World"); 
     51. end jdoodle2; 


The same dangling pointer effect reappears, however, when I put 
*aliased* back, for no apparent reason: 

     function Inner(Value : aliased in out T) return T_Access is 
     begin 
         return Value'Access; 
     end Inner;