[Ada] Enforce matching of extra formals

This patch enforces matching of extra formals in overridden subprograms,
subprogram renamings, and subprograms to which attributes 'Access,
'Unchecked_Access, or 'Unrestricted_Access is applied (for these access
cases the subprogram is checked against its corresponding subprogram
type).

gcc/ada/

	* debug.adb
	(Debug_Flag_Underscore_X): Switch added temporarily to allow
	disabling extra formal checks.

	* exp_attr.adb
	(Expand_N_Attribute_Reference [access types]): Add extra formals
	to the subprogram referenced in the prefix of 'Unchecked_Access,
	'Unrestricted_Access or 'Access; required to check that its extra
	formals match the extra formals of the corresponding subprogram
	type.

	* exp_ch3.adb
	(Stream_Operation_OK): Declaration moved to the public part of the
	package.
	(Validate_Tagged_Type_Extra_Formals): New subprogram.
	(Expand_Freeze_Record_Type): Improve the code that takes care of
	adding the extra formals of dispatching primitives; extended to
	add also the extra formals to renamings of dispatching primitives.

	* exp_ch3.ads
	(Stream_Operation_OK): Declaration moved from the package body.

	* exp_ch6.adb
	(Has_BIP_Extra_Formal): Subprogram declaration moved to the public
	part of the package. In addition, a parameter has been added to
	disable an assertion that requires its use with frozen entities.
	(Expand_Call_Helper): Enforce assertion checking extra formals on
	thunks.
	(Is_Build_In_Place_Function): Return False for entities with
	foreign convention.
	(Make_Build_In_Place_Call_In_Object_Declaration): Occurrences of
	Is_Return_Object replaced by the local variable
	Is_OK_Return_Object that evaluates to False for scopes with
	foreign convention.
	(Might_Have_Tasks): Fix check of class-wide limited record types.
	(Needs_BIP_Task_Actuals): Remove assertion to allow calling this
	function in more contexts; in addition it returns False for
	functions returning objects with foreign convention.
	(Needs_BIP_Finalization_Master): Likewise.
	(Needs_BIP_Alloc_Form): Likewise.

	* exp_ch6.ads
	(Stream_Operation_OK): Declaration moved from the package body. In
	addition, a parameter has been added to disable assertion that
	requires its use with frozen entities.

	* freeze.adb
	(Check_Itype): Add extra formals to anonymous access subprogram
	itypes.
	(Freeze_Expression): Improve code that disables the addition of
	extra formals to functions with foreign convention.
	(Check_Extra_Formals): Moved to package Sem_Ch6 as
	Extra_Formals_OK.
	(Freeze_Subprogram): Add extra formals to non-dispatching
	subprograms.

	* sem_ch3.adb
	(Access_Subprogram_Declaration): Defer the addition of extra
	formals to the freezing point so that we know the convention.
	(Check_Anonymous_Access_Component): Likewise.
	(Derive_Subprogram): Fix documentation.

	* sem_ch6.adb
	(Check_Anonymous_Return): Fix check of access to class-wide
	limited record types.
	(Check_Untagged_Equality): Placed in alphabetical order.
	(Extra_Formals_OK): Subprogram moved from freeze.adb.
	(Extra_Formals_Match_OK): New subprogram.
	(Has_BIP_Formals): New subprogram.
	(Has_Extra_Formals): New subprograms.
	(Needs_Accessibility_Check_Extra): New subprogram.
	(Needs_Constrained_Extra): New subprogram.
	(Parent_Subprogram): New subprogram.
	(Add_Extra_Formal): Minor code cleanup.
	(Create_Extra_Formals): Enforce matching extra formals on
	overridden and aliased entities.
	(Has_Reliable_Extra_Formals): New subprogram.

	* sem_ch6.ads
	(Extra_Formals_OK): Subprogram moved from freeze.adb.
	(Extra_Formals_Match_OK): New subprogram.

	* sem_eval.adb
	(Compile_Time_Known_Value): Improve predicate to avoid assertion
	failure; found working on this ticket; this change does not affect
	the behavior of the compiler because this subprogram has an
	exception handler that returns False when the assertion fails.

	* sem_util.adb
	(Needs_Result_Accessibility_Level): Do not return False for
	dispatching operations compiled with Ada_Version < 2012 since they
	they may be overridden by primitives compiled with Ada_Version >=
	Ada_2012.

1 files changed, 11 insertions, 12 deletions

diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb
index 00c2e67..99e188d 100644
--- a/gcc/ada/sem_ch3.adb
+++ b/gcc/ada/sem_ch3.adb
@@ -1318,7 +1318,8 @@ package body Sem_Ch3 is
 
       Check_Restriction (No_Access_Subprograms, T_Def);
 
-      Create_Extra_Formals (Desig_Type);
+      --  Addition of extra formals must be delayed till the freeze point so
+      --  that we know the convention.
    end Access_Subprogram_Declaration;
 
    ----------------------------
@@ -11768,11 +11769,9 @@ package body Sem_Ch3 is
          Insert_Before (Typ_Decl, Decl);
          Analyze (Decl);
 
-         --  If an access to subprogram, create the extra formals
-
-         if Present (Acc_Def) then
-            Create_Extra_Formals (Designated_Type (Anon_Access));
-         end if;
+         --  At first sight we could add here the extra formals of an access to
+         --  subprogram; however, it must delayed till the freeze point so that
+         --  we know the convention.
 
          if Nkind (Comp_Def) = N_Component_Definition then
             Rewrite (Comp_Def,
@@ -16033,12 +16032,12 @@ package body Sem_Ch3 is
          Next_Formal (Formal);
       end loop;
 
-      --  Extra formals are shared between the parent subprogram and the
-      --  derived subprogram (implicit in the above copy of formals), unless
-      --  the parent type is a limited interface type; hence we must inherit
-      --  also the reference to the first extra formal. When the parent type is
-      --  an interface the extra formals will be added when the subprogram is
-      --  frozen (see Freeze.Freeze_Subprogram).
+      --  Extra formals are shared between the parent subprogram and this
+      --  internal entity built by Derive_Subprogram (implicit in the above
+      --  copy of formals), unless the parent type is a limited interface type;
+      --  hence we must inherit also the reference to the first extra formal.
+      --  When the parent type is an interface, the extra formals will be added
+      --  when the tagged type is frozen (see Expand_Freeze_Record_Type).
 
       if not Is_Limited_Interface (Parent_Type) then
          Set_Extra_Formals (New_Subp, Extra_Formals (Parent_Subp));