[Ada] AI12-0207 Convention of anonymous access types

Message ID 20200605122338.GA56651@adacore.com
State New
Headers show
Series
  • [Ada] AI12-0207 Convention of anonymous access types
Related show

Commit Message

Pierre-Marie de Rodat June 5, 2020, 12:23 p.m.
This AI was already implemented except for the case of array components
which is done here.

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

2020-06-05  Arnaud Charlet  <charlet@adacore.com>

gcc/ada/

	* sem_prag.adb (Set_Convention_From_Pragma): Set the convention
	of anonymous access array components.

Patch

--- gcc/ada/sem_prag.adb
+++ gcc/ada/sem_prag.adb
@@ -8020,26 +8020,38 @@  package body Sem_Prag is
             --  For the case of a record base type, also set the convention of
             --  any anonymous access types declared in the record which do not
             --  currently have a specified convention.
+            --  Similarly for an array base type and anonymous access types
+            --  components.
 
-            if Is_Record_Type (E) and then Is_Base_Type (E) then
-               declare
-                  Comp : Node_Id;
+            if Is_Base_Type (E) then
+               if Is_Record_Type (E) then
+                  declare
+                     Comp : Node_Id;
 
-               begin
-                  Comp := First_Component (E);
-                  while Present (Comp) loop
-                     if Present (Etype (Comp))
-                       and then Ekind_In (Etype (Comp),
-                                          E_Anonymous_Access_Type,
-                                          E_Anonymous_Access_Subprogram_Type)
-                       and then not Has_Convention_Pragma (Comp)
-                     then
-                        Set_Convention (Comp, C);
-                     end if;
+                  begin
+                     Comp := First_Component (E);
+                     while Present (Comp) loop
+                        if Present (Etype (Comp))
+                          and then
+                            Ekind_In (Etype (Comp),
+                                      E_Anonymous_Access_Type,
+                                      E_Anonymous_Access_Subprogram_Type)
+                          and then not Has_Convention_Pragma (Comp)
+                        then
+                           Set_Convention (Comp, C);
+                        end if;
 
-                     Next_Component (Comp);
-                  end loop;
-               end;
+                        Next_Component (Comp);
+                     end loop;
+                  end;
+
+               elsif Is_Array_Type (E)
+                 and then Ekind_In (Component_Type (E),
+                                    E_Anonymous_Access_Type,
+                                    E_Anonymous_Access_Subprogram_Type)
+               then
+                  Set_Convention (Designated_Type (Component_Type (E)), C);
+               end if;
             end if;
 
             --  Deal with incomplete/private type case, where underlying type