[Ada] Itype references for anonymous access return type.

[Arnaud Charlet]

In general itypes are elaborated by the back-end at the point of use. In some
cases the point of use may appear in a scope nested within the scope of
definition, and in that case we must inssrt an itype_reference node to force
gigi to elaborate the type earlier. Postconditions are another context in
which the first reference may appear nested within the defining context; for
the postcondition procedure we create an internal _Result variable to capture
the value of the function before return. The declaration for _result will force
the elaboration of the anonymous return type out of scope unless there is a
previous reference in the proper scope.

The following must compile quietly:

   gcc -c -gnata -gnat05 instance_singleton.ads

---
with Singleton;
pragma elaborate_all (singleton);
package instance_singleton is
   type t_item is tagged null record;

   procedure initialize (item : in out t_item'class) is null;

   package mon_singleton is new singleton (t_item, initialize);
end instance_singleton;
---
generic
   type T_Item is tagged limited private;
   with procedure Initialize (Item : in out T_Item'Class);
package Singleton is
   pragma Elaborate_Body;
   function Instance_Of return access T_Item;
private
   Instance : access T_Item;
end Singleton;
---
package body Singleton is

   function Instance_Of return access T_Item is
      pragma Postcondition (Instance /= null);
   begin
      return Instance;
   end Instance_Of;

begin
   Instance := new T_Item;
   Initialize (Instance.all);
end Singleton;

Tested on i686-pc-linux-gnu, committed on trunk

2008-08-04  Ed Schonberg  <schonberg@adacore.com>

	* sem_ch3.adb (Access_Definition): Create an itype reference for an
	anonymous access return type of a regular function that is not a
	compilation unit.

-------------- next part --------------
Index: sem_ch3.adb
===================================================================
--- sem_ch3.adb	(revision 138518)
+++ sem_ch3.adb	(working copy)
@@ -935,13 +935,25 @@ package body Sem_Ch3 is
          Build_Itype_Reference (Anon_Type, Parent (Parent (Related_Nod)));
 
       --  Similarly, if the access definition is the return result of a
-      --  protected function, create an itype reference for it because it
-      --  will be used within the function body.
+      --  function, create an itype reference for it because it
+      --  will be used within the function body. For a regular function that
+      --  is not a compilation unit, insert reference after the declaration.
+      --  For a protected operation, insert it after the enclosing protected
+      --  type declaration. In either case, do not create a reference for a
+      --  type obtained through a limited_with clause, because this would
+      --  introduce semantic dependencies.
 
       elsif Nkind (Related_Nod) = N_Function_Specification
-        and then  Ekind (Current_Scope) = E_Protected_Type
+        and then not From_With_Type (Anon_Type)
       then
-         Build_Itype_Reference (Anon_Type, Parent (Current_Scope));
+         if Ekind (Current_Scope) = E_Protected_Type then
+            Build_Itype_Reference (Anon_Type, Parent (Current_Scope));
+
+         elsif Is_List_Member (Parent (Related_Nod))
+           and then Nkind (Parent (N)) /= N_Parameter_Specification
+         then
+            Build_Itype_Reference (Anon_Type, Parent (Related_Nod));
+         end if;
 
       --  Finally, create an itype reference for an object declaration of
       --  an anonymous access type. This is strictly necessary only for