[Ada] Implementation of AI05-0073

This AI fixes some gaps in the handling of functions with abstract results and
with controlling access results. A series of new legality checks apply to such
functions, and make illegal some constructs that were legal but useless in
Ada2005.
Compiling the program below in Ada2012  mode must yield:

pack.ads:7:04: function whose access result designates abstract type must be abstract
pack.ads:11:04: generic function cannot have abstract result type
pack.ads:15:04: generic function cannot have an access result that designates an abstract type
pack.ads:20:06: function that returns abstract type must be abstract
pack.ads:25:07: function whose access result designates abstract type must be abstract
pack.ads:30:13: private function with controlling access result must override visible-part function
pack.ads:30:13: move subprogram to the visible part (RM 3.9.3(10))

---
--  AI05-0073 : verify that generic functions cannot return an abstract
--  type or an access to an abstract type.
package Pack is

   type Real is tagged null record;
   type Abstr is abstract tagged null record;
   function Wrong  (X : integer) return access Abstr;  -- ERROR

   generic
      type T (<>) is abstract tagged private;
   function Gft (X : T) return T;            --  ERROR

   generic
      type T (<>) is abstract tagged private;
   function Gft2 (X : T) return access T;    --  ERROR

   generic
      type T (<>) is abstract tagged private;
   package GP is
     function Ft (X : T) return T;           --  ERROR
   end GP;

   package Pkg is
      type T (<>) is abstract tagged private;
      function Ft (X : in T) return access T;   -- ERROR
   private
       type T (D : Integer) is tagged null record;
   end Pkg;
private
   function Create (X : Integer) return access Real;  --  ERROR
end Pack;
---
In addition, there is now a dynamic check that the return value of a function
with a controlling access result has the same tag as the designated type of
the return specification.  The following must compile and execute quietly in
Ada2012 mode:

--  Ada05-0073: rules on controlling results. If a function has a controlling
--  access result, verify that the return value designates an object with the
--  same tag as that of the designated return type,
pragma Ada_2012;
with ada.Tags; use Ada.Tags;
procedure Tag_Test is
   package Pack is
      type T is tagged null record;
      function Func (X : Integer) return Access T; 

      type T1 is new T with null record;
      function Func (X : Integer) return Access T1; 
      Obj1 :  aliased T1;
  end Pack;
  use Pack;

  Obj : aliased T;
  Obj1 : aliased T1;
  function Get return T'Class is
  begin
     return T'Class (Obj1);
  end;
  It : aliased T'class := Get;
  package body Pack is
      function Func (X : Integer) return Access T is
      begin
         if X < 10 then        
            return Obj : access T := It'Access do
               null;
            end return;
         else
            return It'Access;
         end if;
      end Func;

      function Func (X : Integer) return access T1 is
      begin
         return Obj1'access;
      end;
   end Pack;
   Ptr : access T;
begin
   begin
      Ptr := Func (0);
      raise Program_Error;   --  should not get here
   exception
      when Constraint_Error => null;
   end;
   begin
      Ptr := Func (100);
      raise Program_Error;   --  should not get here
   exception
      when Constraint_Error => null;
   end;
end Tag_Test;

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

2010-10-07  Ed Schonberg  <schonberg@adacore.com>

	* sem_ch6.adb (Analyze_Subprogram_Specification): Implement Ada2012
	checks on functions that return an abstract type or have a controlling
	result whose designated type is an abstract type.
	(Check_Private_Overriding): Implement Ada2012 checks on functions
	declared in the private part, if an abstract type is involved.
	* sem_ch12.adb (Analyze_Generic_Subprogram_Declaration): In Ada2012,
	reject a generic function that returns an abstract type.
	* exp_ch5.adb (Expand_Simple_Function_Return): in Ada2012, if a
	function has a controlling access result, check that the tag of the
	return value matches the designated type of the return expression.

[Ada] Implementation of AI05-0073

Details

Commit Message

Patch hide | download patch | download mbox