CVS difference for ai12s/ai12-0191-1.txt

Differences between 1.7 and version 1.8
Log of other versions for file ai12s/ai12-0191-1.txt

--- ai12s/ai12-0191-1.txt	2019/02/23 02:13:57	1.7
+++ ai12s/ai12-0191-1.txt	2019/02/23 02:17:47	1.8
@@ -1,4 +1,4 @@
-!standard 3.9.1(4.1/2)                                      19-02-20  AI12-0191-1/04
+!standard 3.9.1(4.1/2)                                      19-02-21  AI12-0191-1/05
 !standard 7.3.2(10.1/4)
 !standard 7.3.2(15/5)
 !class binding interpretation 16-06-06
@@ -31,11 +31,9 @@
   components that are not visible. On the other hand, a reference
   to the components of an object in a dynamic semantics rule would
   apply to all components of the object, visible or not, including
-  (for tagged objects) components which are not components of the
-  the view of the object (this can occur when the tag of the
-  object does not match the tag of the type of the view of the object).
-  Other terms, such as "subcomponent" and "part", are interpreted
-  analogously.
+  (for tagged objects) components which are hidden by the nominal
+  tag of the object (see 3.9.1). Other terms, such as "subcomponent"
+  and "part", are interpreted analogously.
 
 Add after 3.9.1(4.1/2):
 
@@ -43,15 +41,12 @@
   tagged type T1 or T1'Class and the (runtime) tag of X is T2'Tag,
   the components (if any) of X which are not components of T1
   (and which are not discriminants which correspond to a discriminant
-  of T1) are said to not be "components of the view of the object".
+  of T1) are said to be "hidden by the nominal tag" of the object.
   For example, if T2 is an
   undiscriminated extension of T1 which declares a component named Comp,
-  then X.Comp would not be a component of the view of X.
-  Similarly, a part of an object might or might not be a part of the
-  view of the object. [Redundant: A component of an untagged object, or
-  of a tagged object whose tag matches that of the type of the view of
-  the object, is always a component of the view of the object, even if
-  (for example) the view of the type of the object is a partial view.]
+  then X.Comp would be hidden by the nominal tag of X.
+  Similarly, a part or a subcomponent of an object might or might not be
+  hidden by the nominal tag of the object.
 
   AARM note: For example, there is a dynamic semantics rule that
   finalization of an object includes finalization of its components
@@ -62,34 +57,36 @@
      function Func return T1'Class is (T2'(others => <>));
      X : T1'Class := Func;
   the rule that "every component of the object is finalized" (as opposed to
-  something like "every component of the view of the object is finalized")
+  something like "every component of the object except those hidden by
+  the nominal tag of the object is finalized")
   means that the finalization of X will include finalization of X.Comp.
   For another example, see the rule about accessibility checking of
   access discriminants of parts of function results in 6.5.
   In contrast, the rules in 7.3.2 explicitly state that type invariant
   checks are only performed for parts which are of the type-invariant bearing
-  type and which are parts of the view of the object (as opposed to for all
-  parts, whether part of the view of the object or not, which are of that
-  type). Similarly, the rule in 13.13.2 governing
+  type and which not hidden by the nominal tag of the object (as opposed to
+  for all parts, whether hidden by the nominal tag or not, which are of
+  that type). Similarly, the rule in 13.13.2 governing
   which components of a composite value are read and written by the
   default implementations of Read and Write for a composite type states that
-  only the components of the view of the object are read or written.
+  only the components of the object which are not hidden by the nominal
+  tag of the object are read or written.
 
 Modify 7.3.2(10.1/4):
 
    After successful explicit initialization of the completion of a deferred 
-   constant with a part of type T {that is a part of the view
-   of the object}, if the completion is inside the immediate scope of the 
+   constant with a part of type T {that is not hidden by the nominal tag of 
+   the object}, if the completion is inside the immediate scope of the 
    full view of T, and the deferred constant is visible outside the immediate 
    scope of T, the check is performed on the part(s) of type T{ that are
-   parts of the view of the object};
+   not hidden by the nominal tag of the object};
 
 Modify 7.3.2(15/5):
 
    Upon a successful return from a call on any subprogram or entry which is 
    type-invariant preserving for T, an invariant check is performed on each
-   part of type T{ that is a part of the view of the object} which is subject 
-   to an invariant check for T.
+   part of type T{ that is not hidden by the nominal tag of the object} which 
+   is subject to an invariant check for T.
    In the case of a call to a protected operation, the check is performed 
    before the end of the protected action. In the case of a call to a task
    entry, the check is performed before the end of the rendezvous;
@@ -101,17 +98,17 @@
      some future extension component might have type T (contrast this to
      finalization, where we do intend that overhead). 
 with:
-     Reason: The various rules requiring type invariant checks only for
-     parts of type T which are parts of the view of the object, as opposed
-     to all parts of type T (whether part of the view of the object or not),
+     Reason: The various rules requiring type invariant checks only for parts of
+     type T which are not hidden by the nominal tag of the object, as opposed
+     to all parts of type T (whether hidden by the nominal tag or not),
      are motivated by a desire to avoid overhead associated with the
      possibility that there *might* exist an extension of the tagged type
      in question that has a part of type T.
 
 
 Modify in 13.13.2(9/3):
-   ... the Write or Read attribute for each component of the view
-   of the object is called ...
+   ... the Write or Read attribute for each component (excluding those,
+   if any, that are hidden by the nominal tag of the object) is called ...
 
 !discussion
 

Questions? Ask the ACAA Technical Agent