[Ada] Ada2020 AI12-0282: Shared variable control aspects in generics

Message ID 20200609081007.GA73938@adacore.com
State New
Headers show
Series
  • [Ada] Ada2020 AI12-0282: Shared variable control aspects in generics
Related show

Commit Message

Pierre-Marie de Rodat June 9, 2020, 8:10 a.m.
This patch further refines the checks and the corresponding error
messsages on the legality of instantiations where some formal types and
their corresponding actuals may carry Atomic,  Volatile, etc.  aspect
specifications. The legality rules stated in RN 6.1 (12/5) are in fact
backward-incompatible because they violate a basic language design rule,
namely that limited private formal types impose no constraint on the
corresponding formals. Pending further ARG discussions the current code
reverts the checking for an exact match between specified aspects to
fornal derived types only.

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

2020-06-09  Ed Schonberg  <schonberg@adacore.com>

gcc/ada/

	* sem_ch12.adb (Check_Shared_Variable_Control_Aspects): Require
	exact match between formal and actual for aspects Atomic and
	Volatile only for formal derived types.

Patch

--- gcc/ada/sem_ch12.adb
+++ gcc/ada/sem_ch12.adb
@@ -12394,19 +12394,38 @@  package body Sem_Ch12 is
 
       --  Ada 2020: Verify that shared variable control aspects (RM C.6)
       --  that may be specified for the formal are obeyed by the actual.
+      --  If the fornal is a derived type the aspect specifications must match.
+      --  NOTE: AI12-0282 implies that matching of aspects is required between
+      --  formal and actual in all cases, but this is too restrictive.
+      --  In particular it violates a language design rule: a limited private
+      --  indefinite formal can be matched by any actual. The current code
+      --  reflects an older and more permissve version of RM C.6 (12/5).
 
       procedure Check_Shared_Variable_Control_Aspects is
       begin
          if Ada_Version >= Ada_2020 then
-            if Is_Atomic (A_Gen_T) /= Is_Atomic (Act_T) then
+            if Is_Atomic (A_Gen_T) and then not Is_Atomic (Act_T) then
+               Error_Msg_NE
+                  ("actual for& must have Atomic aspect", Actual, A_Gen_T);
+
+            elsif Is_Derived_Type (A_Gen_T)
+              and then Is_Atomic (A_Gen_T) /= Is_Atomic (Act_T)
+            then
                Error_Msg_NE
                   ("actual for& has different Atomic aspect", Actual, A_Gen_T);
             end if;
 
-            if Is_Volatile (A_Gen_T) /= Is_Volatile (Act_T) then
+            if Is_Volatile (A_Gen_T) and then not Is_Volatile (Act_T) then
                Error_Msg_NE
                   ("actual for& has different Volatile aspect",
                     Actual, A_Gen_T);
+
+            elsif Is_Derived_Type (A_Gen_T)
+              and then Is_Volatile (A_Gen_T) /= Is_Volatile (Act_T)
+            then
+               Error_Msg_NE
+                  ("actual for& has different Volatile aspect",
+                     Actual, A_Gen_T);
             end if;
 
             --  We assume that an array type whose atomic component type