From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1914) id D05363857835; Fri, 18 Jun 2021 08:37:33 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org D05363857835 MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Pierre-Marie de Rodat To: gcc-cvs@gcc.gnu.org Subject: [gcc r12-1610] [Ada] Ada2020: Special handling of types derived from runtime X-Act-Checkin: gcc X-Git-Author: Javier Miranda X-Git-Refname: refs/heads/master X-Git-Oldrev: 64b5da8f97122de895af1b13c5f5e103717858c6 X-Git-Newrev: 07537fe632cd6e2fcf83954fb85455d118d80c06 Message-Id: <20210618083733.D05363857835@sourceware.org> Date: Fri, 18 Jun 2021 08:37:33 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 18 Jun 2021 08:37:33 -0000 https://gcc.gnu.org/g:07537fe632cd6e2fcf83954fb85455d118d80c06 commit r12-1610-g07537fe632cd6e2fcf83954fb85455d118d80c06 Author: Javier Miranda Date: Sat Mar 13 14:47:59 2021 -0500 [Ada] Ada2020: Special handling of types derived from runtime gcc/ada/ * einfo.ads (Is_Ada_2022_Only): Adding documentation. * gen_il-fields.ads (Is_Ada_2022_Only): New flag. * gen_il-gen-gen_entities.adb (Is_Ada_2022_Only): New flag. * itypes.adb (Create_Null_Excluding_Itype): Inherit Is_Ada_2022_Only. * sem_ch3.adb (Check_Abstract_Overriding): Skip reporting error on Ada 2022 only subprograms that require overriding if we are not in Ada 2022 mode. (Derive_Subprogram): Inherit Is_Ada_2022_Only. * sem_ch6.adb (Check_Overriding_Indicator): Inherit Is_Ada_2022_Only. (New_Overloaded_Entity): Inherit Is_Ada_2022_Only. * sem_ch7.adb (Declare_Inherited_Private_Subprograms): Inherit Is_Ada_2022_Only. (Preserve_Full_Attributes): Inherit Is_Ada_2022_Only. * sem_disp.adb (Find_Hidden_Overridden_Primitive): Inherit Is_Ada_2022_Only. (Override_Dispatching_Operation): Inherit Is_Ada_2022_Only. * sem_prag.adb (Analyze_Pragma): Allow form with argument for Ada 2022. * sem_type.adb: (Disambiguate): Deal with Is_Ada_2022_Only * lib-xref.adb (Generate_Reference): Error on static and dispatching calls to Ada 2022 subprograms that require overriding if we are not in Ada 2022 mode; warn on other references to Ada 2022 entities when not in Ada 2022 mode. * sem_ch13.adb (Inherit_Aspects_At_Freeze_Point): Inherit Ada_2020_Only. * libgnat/a-cdlili.ads (Empty): Adding pragma Ada_2022. * libgnat/a-cidlli.ads (Empty): Adding pragma Ada_2022. * libgnat/a-ciorma.ads (Empty): Adding pragma Ada_2022. * libgnat/a-cobove.ads (Empty): Adding pragma Ada_2022. * libgnat/a-coorma.ads (Empty): Adding pragma Ada_2022. (New_Vector): Adding pragma Ada_2022. (Insert_Vector): Adding pragma Ada_2022. (Prepend_Vector): Adding pragma Ada_2022. (Append_Vector): Adding pragma Ada_2022. Diff: --- gcc/ada/einfo.ads | 8 ++++++ gcc/ada/gen_il-fields.ads | 1 + gcc/ada/gen_il-gen-gen_entities.adb | 1 + gcc/ada/itypes.adb | 1 + gcc/ada/lib-xref.adb | 31 ++++++++++++++++++++++ gcc/ada/libgnat/a-cdlili.ads | 2 ++ gcc/ada/libgnat/a-cidlli.ads | 2 ++ gcc/ada/libgnat/a-ciorma.ads | 1 + gcc/ada/libgnat/a-cobove.ads | 7 +++++ gcc/ada/libgnat/a-coorma.ads | 2 ++ gcc/ada/sem_ch13.adb | 10 ++++++++ gcc/ada/sem_ch3.adb | 11 ++++++++ gcc/ada/sem_ch6.adb | 12 +++++++++ gcc/ada/sem_ch7.adb | 3 +++ gcc/ada/sem_disp.adb | 3 +++ gcc/ada/sem_prag.adb | 51 ++++++++++++++++++++++++++++++++----- gcc/ada/sem_type.adb | 40 ++++++++++++++++++++--------- 17 files changed, 168 insertions(+), 18 deletions(-) diff --git a/gcc/ada/einfo.ads b/gcc/ada/einfo.ads index 55cf83d847e..471056c5441 100644 --- a/gcc/ada/einfo.ads +++ b/gcc/ada/einfo.ads @@ -2317,6 +2317,13 @@ package Einfo is -- the entity is part of a unit compiled with the normal no-argument form -- of pragma Ada_12 or Ada_2012. +-- Is_Ada_2022_Only +-- Defined in all entities, true if a valid pragma Ada_2022 applies to +-- the entity which specifically names the entity, indicating that the +-- entity is Ada 2022 only. Note that this flag is not set if the entity +-- is part of a unit compiled with the normal no-argument form of pragma +-- Ada_2022. + -- Is_Aliased -- Defined in all entities. Set for objects and types whose declarations -- carry the keyword aliased, and on record components that have the @@ -4871,6 +4878,7 @@ package Einfo is -- In_Private_Part -- Is_Ada_2005_Only -- Is_Ada_2012_Only + -- Is_Ada_2022_Only -- Is_Bit_Packed_Array (base type only) -- Is_Aliased -- Is_Character_Type diff --git a/gcc/ada/gen_il-fields.ads b/gcc/ada/gen_il-fields.ads index 4aac802819a..2f0df43c606 100644 --- a/gcc/ada/gen_il-fields.ads +++ b/gcc/ada/gen_il-fields.ads @@ -669,6 +669,7 @@ package Gen_IL.Fields is Is_Actual_Subtype, Is_Ada_2005_Only, Is_Ada_2012_Only, + Is_Ada_2022_Only, Is_Aliased, Is_Asynchronous, Is_Atomic, diff --git a/gcc/ada/gen_il-gen-gen_entities.adb b/gcc/ada/gen_il-gen-gen_entities.adb index afd3ec47696..2e745c2f939 100644 --- a/gcc/ada/gen_il-gen-gen_entities.adb +++ b/gcc/ada/gen_il-gen-gen_entities.adb @@ -119,6 +119,7 @@ begin -- Gen_IL.Gen.Gen_Entities Sm (In_Use, Flag), Sm (Is_Ada_2005_Only, Flag), Sm (Is_Ada_2012_Only, Flag), + Sm (Is_Ada_2022_Only, Flag), Sm (Is_Aliased, Flag), Sm (Is_Atomic, Flag), Sm (Is_Bit_Packed_Array, Flag, Impl_Base_Type_Only), diff --git a/gcc/ada/itypes.adb b/gcc/ada/itypes.adb index 3282d11375e..f51b44a4412 100644 --- a/gcc/ada/itypes.adb +++ b/gcc/ada/itypes.adb @@ -111,6 +111,7 @@ package body Itypes is Set_Is_Atomic (I_Typ, Is_Atomic (T)); Set_Is_Ada_2005_Only (I_Typ, Is_Ada_2005_Only (T)); Set_Is_Ada_2012_Only (I_Typ, Is_Ada_2012_Only (T)); + Set_Is_Ada_2022_Only (I_Typ, Is_Ada_2022_Only (T)); Set_Can_Never_Be_Null (I_Typ); return I_Typ; diff --git a/gcc/ada/lib-xref.adb b/gcc/ada/lib-xref.adb index a426745a0cd..17de8864bef 100644 --- a/gcc/ada/lib-xref.adb +++ b/gcc/ada/lib-xref.adb @@ -703,6 +703,37 @@ package body Lib.Xref is Error_Msg_NE ("& is only defined in Ada 2012?y?", N, E); end if; + -- Warn if reference to Ada 2022 entity not in Ada 2022 mode. We only + -- detect real explicit references (modifications and references). + + if Comes_From_Source (N) + and then Is_Ada_2022_Only (E) + and then not Is_Subprogram (E) + and then Ada_Version < Ada_2022 + and then Warn_On_Ada_2022_Compatibility + and then (Typ = 'm' or else Typ = 'r') + then + Error_Msg_NE ("& is only defined in Ada 2022?y?", N, E); + + -- Error on static and dispatching calls to Ada 2022 subprograms that + -- require overriding if we are not in Ada 2022 mode (since overriding + -- was skipped); warn if the subprogram does not require overriding. + + elsif Comes_From_Source (N) + and then Is_Ada_2022_Only (E) + and then Ada_Version < Ada_2022 + and then Is_Subprogram (E) + and then (Typ = 'r' or else Typ = 's' or else Typ = 'R') + then + if Requires_Overriding (E) then + Error_Msg_NE + ("& is only defined in Ada 2022 and requires overriding", N, E); + + elsif Warn_On_Ada_2022_Compatibility then + Error_Msg_NE ("& is only defined in Ada 2022?y?", N, E); + end if; + end if; + -- Do not generate references if we are within a postcondition sub- -- program, because the reference does not comes from source, and the -- preanalysis of the aspect has already created an entry for the ALI diff --git a/gcc/ada/libgnat/a-cdlili.ads b/gcc/ada/libgnat/a-cdlili.ads index aed02bc0e06..8d2d345b066 100644 --- a/gcc/ada/libgnat/a-cdlili.ads +++ b/gcc/ada/libgnat/a-cdlili.ads @@ -66,7 +66,9 @@ is pragma Preelaborable_Initialization (Cursor); Empty_List : constant List; + function Empty return List; + pragma Ada_2022 (Empty); No_Element : constant Cursor; diff --git a/gcc/ada/libgnat/a-cidlli.ads b/gcc/ada/libgnat/a-cidlli.ads index ee92e712391..d5c4e45e32b 100644 --- a/gcc/ada/libgnat/a-cidlli.ads +++ b/gcc/ada/libgnat/a-cidlli.ads @@ -65,7 +65,9 @@ is pragma Preelaborable_Initialization (Cursor); Empty_List : constant List; + function Empty return List; + pragma Ada_2022 (Empty); No_Element : constant Cursor; diff --git a/gcc/ada/libgnat/a-ciorma.ads b/gcc/ada/libgnat/a-ciorma.ads index 734fdb21bfa..68e9b93c035 100644 --- a/gcc/ada/libgnat/a-ciorma.ads +++ b/gcc/ada/libgnat/a-ciorma.ads @@ -70,6 +70,7 @@ is Empty_Map : constant Map; function Empty return Map; + pragma Ada_2022 (Empty); No_Element : constant Cursor; function Has_Element (Position : Cursor) return Boolean; diff --git a/gcc/ada/libgnat/a-cobove.ads b/gcc/ada/libgnat/a-cobove.ads index e808d85cd0f..eb8072d4018 100644 --- a/gcc/ada/libgnat/a-cobove.ads +++ b/gcc/ada/libgnat/a-cobove.ads @@ -80,12 +80,14 @@ package Ada.Containers.Bounded_Vectors is Ada.Iterator_Interfaces (Cursor, Has_Element); function Empty (Capacity : Count_Type := 10) return Vector; + pragma Ada_2022 (Empty); overriding function "=" (Left, Right : Vector) return Boolean; function New_Vector (First, Last : Index_Type) return Vector with Pre => First = Index_Type'First; -- Ada 2022 aggregate operation. + pragma Ada_2022 (New_Vector); function To_Vector (Length : Count_Type) return Vector; @@ -194,6 +196,7 @@ package Ada.Containers.Bounded_Vectors is (Container : in out Vector; Before : Extended_Index; New_Item : Vector); + pragma Ada_2022 (Insert_Vector); procedure Insert (Container : in out Vector; @@ -205,6 +208,7 @@ package Ada.Containers.Bounded_Vectors is (Container : in out Vector; Before : Cursor; New_Item : Vector); + pragma Ada_2022 (Insert_Vector); procedure Insert (Container : in out Vector; @@ -217,6 +221,7 @@ package Ada.Containers.Bounded_Vectors is Before : Cursor; New_Item : Vector; Position : out Cursor); + pragma Ada_2022 (Insert_Vector); procedure Insert (Container : in out Vector; @@ -258,6 +263,7 @@ package Ada.Containers.Bounded_Vectors is procedure Prepend_Vector (Container : in out Vector; New_Item : Vector); + pragma Ada_2022 (Prepend_Vector); procedure Prepend (Container : in out Vector; @@ -272,6 +278,7 @@ package Ada.Containers.Bounded_Vectors is procedure Append_Vector (Container : in out Vector; New_Item : Vector); + pragma Ada_2022 (Append_Vector); procedure Append (Container : in out Vector; diff --git a/gcc/ada/libgnat/a-coorma.ads b/gcc/ada/libgnat/a-coorma.ads index 735b0b18bc9..5740621c921 100644 --- a/gcc/ada/libgnat/a-coorma.ads +++ b/gcc/ada/libgnat/a-coorma.ads @@ -67,7 +67,9 @@ is pragma Preelaborable_Initialization (Cursor); Empty_Map : constant Map; + function Empty return Map; + pragma Ada_2022 (Empty); No_Element : constant Cursor; diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index 3c3e35150e9..35e0b9236ab 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -13399,6 +13399,16 @@ package body Sem_Ch13 is Set_Is_Ada_2012_Only (Typ); end if; + -- Ada_2022 + + if not Has_Rep_Item (Typ, Name_Ada_2022, False) + and then Has_Rep_Item (Typ, Name_Ada_2022) + and then Is_Pragma_Or_Corr_Pragma_Present_In_Rep_Item + (Get_Rep_Item (Typ, Name_Ada_2022)) + then + Set_Is_Ada_2022_Only (Typ); + end if; + -- Atomic/Shared if not Has_Rep_Item (Typ, Name_Atomic, Name_Shared, False) diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index d807b10c2f0..a762a6199f0 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -10967,6 +10967,15 @@ package body Sem_Ch3 is then null; + -- Skip reporting the error on Ada 2022 only subprograms + -- that require overriding if we are not in Ada 2022 mode. + + elsif Ada_Version < Ada_2022 + and then Requires_Overriding (Subp) + and then Is_Ada_2022_Only (Ultimate_Alias (Subp)) + then + null; + else Error_Msg_NE ("type must be declared abstract or & overridden", @@ -16061,6 +16070,8 @@ package body Sem_Ch3 is then Set_Has_Yield_Aspect (New_Subp, Has_Yield_Aspect (Alias (New_Subp))); end if; + + Set_Is_Ada_2022_Only (New_Subp, Is_Ada_2022_Only (Parent_Subp)); end Derive_Subprogram; ------------------------ diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index 68e10afc7cc..7bca9df7225 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -7271,10 +7271,14 @@ package body Sem_Ch6 is then Set_Overridden_Operation (Subp, Alias (Overridden_Subp)); Inherit_Subprogram_Contract (Subp, Alias (Overridden_Subp)); + Set_Is_Ada_2022_Only (Subp, + Is_Ada_2022_Only (Alias (Overridden_Subp))); else Set_Overridden_Operation (Subp, Overridden_Subp); Inherit_Subprogram_Contract (Subp, Overridden_Subp); + Set_Is_Ada_2022_Only (Subp, + Is_Ada_2022_Only (Overridden_Subp)); end if; end if; end if; @@ -11888,10 +11892,13 @@ package body Sem_Ch6 is if Present (Alias (S)) then Set_Overridden_Operation (E, Alias (S)); Inherit_Subprogram_Contract (E, Alias (S)); + Set_Is_Ada_2022_Only (E, + Is_Ada_2022_Only (Alias (S))); else Set_Overridden_Operation (E, S); Inherit_Subprogram_Contract (E, S); + Set_Is_Ada_2022_Only (E, Is_Ada_2022_Only (S)); end if; -- When a dispatching operation overrides an inherited @@ -12058,6 +12065,8 @@ package body Sem_Ch6 is then Set_Overridden_Operation (S, Alias (E)); Inherit_Subprogram_Contract (S, Alias (E)); + Set_Is_Ada_2022_Only (S, + Is_Ada_2022_Only (Alias (E))); -- Normal case of setting entity as overridden @@ -12071,6 +12080,7 @@ package body Sem_Ch6 is elsif not Is_Init_Proc (S) then Set_Overridden_Operation (S, E); Inherit_Subprogram_Contract (S, E); + Set_Is_Ada_2022_Only (S, Is_Ada_2022_Only (E)); end if; Check_Overriding_Indicator (S, E, Is_Primitive => True); @@ -12099,6 +12109,8 @@ package body Sem_Ch6 is if Present (Alias (E)) then Set_Overridden_Operation (S, Alias (E)); Inherit_Subprogram_Contract (S, Alias (E)); + Set_Is_Ada_2022_Only (S, + Is_Ada_2022_Only (Alias (E))); end if; end if; diff --git a/gcc/ada/sem_ch7.adb b/gcc/ada/sem_ch7.adb index 27927ebf840..69ad184948a 100644 --- a/gcc/ada/sem_ch7.adb +++ b/gcc/ada/sem_ch7.adb @@ -2061,6 +2061,8 @@ package body Sem_Ch7 is Replace_Elmt (Op_Elmt, New_Op); Remove_Elmt (Op_List, Op_Elmt_2); Set_Overridden_Operation (New_Op, Parent_Subp); + Set_Is_Ada_2022_Only (New_Op, + Is_Ada_2022_Only (Parent_Subp)); -- We don't need to inherit its dispatching slot. -- Set_All_DT_Position has previously ensured that @@ -2725,6 +2727,7 @@ package body Sem_Ch7 is Set_Is_Atomic (Priv, Is_Atomic (Full)); Set_Is_Ada_2005_Only (Priv, Is_Ada_2005_Only (Full)); Set_Is_Ada_2012_Only (Priv, Is_Ada_2012_Only (Full)); + Set_Is_Ada_2022_Only (Priv, Is_Ada_2022_Only (Full)); Set_Has_Pragma_Unmodified (Priv, Has_Pragma_Unmodified (Full)); Set_Has_Pragma_Unreferenced (Priv, Has_Pragma_Unreferenced (Full)); Set_Has_Pragma_Unreferenced_Objects diff --git a/gcc/ada/sem_disp.adb b/gcc/ada/sem_disp.adb index 20e3e93911a..903182664bf 100644 --- a/gcc/ada/sem_disp.adb +++ b/gcc/ada/sem_disp.adb @@ -2199,6 +2199,8 @@ package body Sem_Disp is while Present (Elmt) loop if Node (Elmt) = Orig_Prim then Set_Overridden_Operation (S, Prim); + Set_Is_Ada_2022_Only (S, + Is_Ada_2022_Only (Prim)); Set_Alias (Prim, Orig_Prim); return Prim; end if; @@ -2761,6 +2763,7 @@ package body Sem_Disp is Set_Alias (Prev_Op, New_Op); Set_DTC_Entity (Prev_Op, Empty); Set_Has_Controlling_Result (New_Op, Has_Controlling_Result (Prev_Op)); + Set_Is_Ada_2022_Only (New_Op, Is_Ada_2022_Only (Prev_Op)); end if; end Override_Dispatching_Operation; diff --git a/gcc/ada/sem_prag.adb b/gcc/ada/sem_prag.adb index 1a1fc74c572..a65864dfa83 100644 --- a/gcc/ada/sem_prag.adb +++ b/gcc/ada/sem_prag.adb @@ -12542,22 +12542,61 @@ package body Sem_Prag is -------------- -- pragma Ada_2022; + -- pragma Ada_2022 (LOCAL_NAME): -- Note: this pragma also has some specific processing in Par.Prag -- because we want to set the Ada 2022 version mode during parsing. + -- The one argument form is used for managing the transition from Ada + -- 2012 to Ada 2022 in the run-time library. If an entity is marked + -- as Ada_2022 only, then referencing the entity in any pre-Ada_2022 + -- mode will generate a warning;for calls to Ada_2022 only primitives + -- that require overriding an error will be reported. In addition, in + -- any pre-Ada_2022 mode, a preference rule is established which does + -- not choose such an entity unless it is unambiguously specified. + -- This avoids extra subprograms marked this way from generating + -- ambiguities in otherwise legal pre-Ada 2022 programs. The one + -- argument form is intended for exclusive use in the GNAT run-time + -- library. + when Pragma_Ada_2022 => + declare + E_Id : Node_Id; + + begin GNAT_Pragma; - Check_Arg_Count (0); + if Arg_Count = 1 then + Check_Arg_Is_Local_Name (Arg1); + E_Id := Get_Pragma_Arg (Arg1); - Check_Valid_Configuration_Pragma; + if Etype (E_Id) = Any_Type then + return; + end if; - -- Now set appropriate Ada mode + Set_Is_Ada_2022_Only (Entity (E_Id)); + Record_Rep_Item (Entity (E_Id), N); + + else + Check_Arg_Count (0); + + -- For Ada_2022 we unconditionally enforce the documented + -- configuration pragma placement, since we do not want to + -- tolerate mixed modes in a unit involving Ada 2022. That + -- would cause real difficulties for those cases where there + -- are incompatibilities between Ada 2012 and Ada 2022. We + -- could allow mixing of Ada 2012 and Ada 2022 but it's not + -- worth it. - Ada_Version := Ada_2022; - Ada_Version_Explicit := Ada_2022; - Ada_Version_Pragma := N; + Check_Valid_Configuration_Pragma; + + -- Now set appropriate Ada mode + + Ada_Version := Ada_2022; + Ada_Version_Explicit := Ada_2022; + Ada_Version_Pragma := N; + end if; + end; ------------------------------------- -- Aggregate_Individually_Assign -- diff --git a/gcc/ada/sem_type.adb b/gcc/ada/sem_type.adb index 2998d2f8eb1..396f616cbf1 100644 --- a/gcc/ada/sem_type.adb +++ b/gcc/ada/sem_type.adb @@ -1810,26 +1810,42 @@ package body Sem_Type is It2 := It; Nam2 := It.Nam; - -- Check whether one of the entities is an Ada 2005/2012 and we are - -- operating in an earlier mode, in which case we discard the Ada - -- 2005/2012 entity, so that we get proper Ada 95 overload resolution. + -- Check whether one of the entities is an Ada 2005/2012/2022 and we + -- are operating in an earlier mode, in which case we discard the Ada + -- 2005/2012/2022 entity, so that we get proper Ada 95 overload + -- resolution. if Ada_Version < Ada_2005 then - if Is_Ada_2005_Only (Nam1) or else Is_Ada_2012_Only (Nam1) then + if Is_Ada_2005_Only (Nam1) + or else Is_Ada_2012_Only (Nam1) + or else Is_Ada_2022_Only (Nam1) + then return It2; - elsif Is_Ada_2005_Only (Nam2) or else Is_Ada_2012_Only (Nam1) then + + elsif Is_Ada_2005_Only (Nam2) + or else Is_Ada_2012_Only (Nam2) + or else Is_Ada_2022_Only (Nam2) + then + return It1; + end if; + + -- Check whether one of the entities is an Ada 2012/2022 entity and we + -- are operating in Ada 2005 mode, in which case we discard the Ada 2012 + -- Ada 2022 entity, so that we get proper Ada 2005 overload resolution. + + elsif Ada_Version = Ada_2005 then + if Is_Ada_2012_Only (Nam1) or else Is_Ada_2022_Only (Nam1) then + return It2; + elsif Is_Ada_2012_Only (Nam2) or else Is_Ada_2022_Only (Nam2) then return It1; end if; - end if; - -- Check whether one of the entities is an Ada 2012 entity and we are - -- operating in Ada 2005 mode, in which case we discard the Ada 2012 - -- entity, so that we get proper Ada 2005 overload resolution. + -- Ditto for Ada 2012 vs Ada 2022. - if Ada_Version = Ada_2005 then - if Is_Ada_2012_Only (Nam1) then + elsif Ada_Version = Ada_2012 then + if Is_Ada_2022_Only (Nam1) then return It2; - elsif Is_Ada_2012_Only (Nam2) then + elsif Is_Ada_2022_Only (Nam2) then return It1; end if; end if;