ada: Add prototype for mutably tagged types

This patch implements mutably tagged types via the new Size'Class aspect.

gcc/ada/

	* doc/gnat_rm/gnat_language_extensions.rst: Add documentation for
	mutably tagged type feature.
	* aspects.ads: Add registration for 'Size'Class.
	* einfo.ads: Add documentation for new components
	Class_Wide_Equivalent_Type and Is_Mutably_Tagged_Type.
	* exp_aggr.adb (Gen_Assign): Assume associated mutably tagged type
	when class-wide equivalent type is encountered.
	(Contains_Mutably_Tagged_Type): New subprogram.
	(Convert_To_Positional): Assume associated mutably tagged type
	when class-wide equivalent type is encountered.
	(Is_Static_Element): Assume associated mutably tagged type when
	class-wide equivalent type is encountered.
	(Expand_Array_Aggregate): Assume associated mutably tagged type
	when class-wide equivalent type is encountered.
	(Expand_Record_Aggregate): Force mutably tagged records to be
	expanded into assignments.
	* exp_ch3.adb (Build_Array_Init_Proc): Assume associated mutably
	tagged type when class-wide equivalent type is encountered.
	(Simple_Initialization_OK): Disallow simple initialization for
	class-wide equivalent types.
	(Build_Init_Statements): Assume associated mutably tagged type
	when class-wide equivalent type is encountered.
	(Expand_Freeze_Array_Type): Ignore building of record init procs
	for mutably tagged types.
	(Expand_N_Full_Type_Declaration): Replace mutably tagged type
	declarations with their associated class-wide equivalent types.
	(Default_Initialize_Object): Add special handling for mutably
	tagged types.
	* exp_ch4.adb (Expand_N_Allocator): Add initialization for mutably
	tagged types.
	(Expand_Record_Equality): Generate mutably tagged unchecked
	conversions.
	* exp_ch5.adb (Expand_N_Assignment_Statement): Generate a special
	assignment case for class-wide equivalent types which does tag
	assignments and ignores certain checks.
	* exp_ch6.adb (Expand_Call_Helper): Propagate constrained extra
	formal actuals for mutably tagged types.
	* exp_ch7.adb (Make_Init_Call): Handle mutably tagged type
	initialization.
	* exp_util.adb (Make_CW_Equivalent_Type): Modify to handle mutably
	tagged objects which contain no initialization expression.
	(Make_Subtype_From_Expr): Modify call to Make_CW_Equivalent_Type.
	* exp_util.ads (Make_CW_Equivalent_Type): Move declaration from
	body to spec.
	* freeze.adb (Size_Known): No longer return false automatically
	when a class-wide type is encountered.
	(Freeze_Entity): Ignore error messages about size not being known
	for mutably tagged types.
	* gen_il-fields.ads: Register new fields
	Class_Wide_Equivalent_Type and Is_Mutably_Tagged_Type.
	* gen_il-gen-gen_entities.adb: Register new fields
	Class_Wide_Equivalent_Type and Is_Mutably_Tagged_Type for type
	entities.
	* mutably_tagged.adb, mutably_tagged.ads
	(Corresponding_Mutably_Tagged_Type): New subprogram.
	(Depends_On_Mutably_Tagged_Ext_Comp): New subprogram.
	(Get_Corresponding_Mutably_Tagged_Type_If_Present): New
	subprogram.
	(Get_Corresponding_Tagged_Type_If_Present): New subprogram.
	(Is_Mutably_Tagged_Conversion): New subprogram.
	(Is_Mutably_Tagged_CW_Equivalent_Type): New subprogram.
	(Make_Mutably_Tagged_Conversion): New subprogram.
	(Make_CW_Size_Compile_Check): New subprogram.
	(Make_Mutably_Tagged_CW_Check): New subprogram.
	* sem_aggr.adb (Resolve_Array_Aggregate): Skip tag checks for
	class-wide equivalent types.
	(Resolve_Aggr_Expr): Assume associated mutably tagged type when
	class-wide equivalent type is encountered.
	* sem_attr.adb (Analyze_Attribute): Allow 'Tag on mutably tagged
	types.
	(Resolve_Attribute): Detect errors for dependence of mutably
	tagged extension type component.
	* sem_ch12.adb (Instantiate_Object): Detect errors for dependence
	of mutably tagged extension type component.
	* sem_ch13.adb (Analyze_One_Aspect): Propagate 'Size'Class to
	class-wide type.
	(Analyze_Attribute_Definition_Clause): Add handling of 'Size'Class
	by generating class-wide equivalent types and checking for illegal
	uses.
	* sem_ch2.adb (Analyze_Identifier): Generate unchecked conversion
	for class-wide equivalent types.
	* sem_ch3.adb (Analyze_Component_Declaration): Avoid unconstrained
	errors on mutably tagged types.
	(Analyze_Object_Declaration): Rewrite declarations of mutably
	tagged types to use class-wide equivalent types.
	(Array_Type_Declaration): Modify arrays of mutably tagged types to
	use their corresponding class-wide equivalent types.
	(Derived_Type_Declaration): Add various checks for mutably tagged
	derived types.
	* sem_ch4.adb (Analyze_Allocator): Replace reference to mutably
	tagged type with cooresponding tagged type.
	(Process_Indexed_Component): Generate unchecked conversion for
	class-wide equivalent type.
	(Analyze_One_Call): Generate unchecked conversion for class-wide
	equivalent types.
	(Analyze_Selected_Component): Assume reference to class-wide
	equivalent type is associated mutably tagged type.
	(Analyze_Type_Conversion): Generate unchecked conversion for
	class-wide equivalent type.
	* sem_ch5.adb (Analyze_Assignment): Assume associated mutably
	tagged type when class-wide equivalent type is encountered.
	(Analyze_Iterator_Specification): Detect errors for dependence of
	mutably tagged extension type component.
	* sem_ch6.adb (Create_Extra_Formals): Add code to generate extra
	formal for mutably tagged types to signal if they are constrained.
	* sem_ch8.adb (Analyze_Object_Renaming): Detect error on renaming
	of mutably tagged extension type component.
	(Analyze_Renaming_Primitive_Operation): Detect error on renaming
	of mutably tagged extension type component.
	* sem_res.adb (Resolve_Actuals): Allow class-wide arguments on
	class-wide equivalent types.
	(Valid_Conversion): Assume associated mutably tagged type when
	class-wide equivalent type is encountered.
	* sem_util.adb (Is_Fully_Initialized_Type): Flag mutably tagged
	types as fully initialized.
	(Needs_Simple_Initalization): Flag class-wide equivalent types as
	needing initialization.
	* gnat_rm.texi: Regenerate.
	* gcc-interface/Make-lang.in: Add entry for mutably_tagged.o.

1 files changed, 17 insertions, 0 deletions

diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb
index d2eca7c..a0dd1f7 100644
--- a/gcc/ada/sem_res.adb
+++ b/gcc/ada/sem_res.adb
@@ -47,6 +47,7 @@ with Itypes;         use Itypes;
 with Lib;            use Lib;
 with Lib.Xref;       use Lib.Xref;
 with Local_Restrict;
+with Mutably_Tagged; use Mutably_Tagged;
 with Namet;          use Namet;
 with Nmake;          use Nmake;
 with Nlists;         use Nlists;
@@ -5034,12 +5035,21 @@ package body Sem_Res is
             --  Skip this check on helpers and indirect-call wrappers built to
             --  support class-wide preconditions.
 
+            --  We make special exception here for mutably tagged types and
+            --  related calls to their initialization procedures.
+
             if (Is_Class_Wide_Type (A_Typ) or else Is_Dynamically_Tagged (A))
               and then not Is_Class_Wide_Type (F_Typ)
               and then not Is_Controlling_Formal (F)
               and then not In_Instance
               and then (not Is_Subprogram (Nam)
                          or else No (Class_Preconditions_Subprogram (Nam)))
+
+              --  Ignore mutably tagged types and their use in calls to init
+              --  procs.
+
+              and then not Is_Mutably_Tagged_CW_Equivalent_Type (A_Typ)
+              and then not Is_Init_Proc (Nam)
             then
                Error_Msg_N ("class-wide argument not allowed here!", A);
 
@@ -14069,6 +14079,13 @@ package body Sem_Res is
          end;
       end if;
 
+      --  When we encounter a class-wide equivalent type used to represent
+      --  a fully sized mutably tagged type, pretend we are actually looking
+      --  at the class-wide mutably tagged type instead.
+
+      Opnd_Type :=
+        Get_Corresponding_Mutably_Tagged_Type_If_Present (Opnd_Type);
+
       --  Deal with conversion of integer type to address if the pragma
       --  Allow_Integer_Address is in effect. We convert the conversion to
       --  an unchecked conversion in this case and we are all done.