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

--- ai12s/ai12-0075-1.txt	2018/03/02 07:23:28	1.10
+++ ai12s/ai12-0075-1.txt	2018/03/06 04:31:37	1.11
@@ -1,5 +1,14 @@
-!standard 4.9(6)                                  18-03-01    AI12-0075-1/07
-!standard 4.9(18)
+!standard 4.9(21)                                  18-03-05    AI12-0075-1/08
+!standard 6.8(3/4)
+!standard 6.8(5/4)
+!standard 6.8(6/4)
+!standard 7.3.2(8.2/5)
+!standard 7.3.2(15/4)
+!standard 7.3.2(16/4)
+!standard 7.3.2(17/4)
+!standard 7.3.2(18/4)
+!standard 7.3.2(19/4)
+!standard 7.3.2(20/5)
 !class Amendment 13-06-09
 !status work item 13-06-09
 !status received 13-05-07
@@ -66,7 +75,7 @@
 	      static expression.
 
               The Static value for an inherited function is True if some
-              corresponding primitive function of the parent or 
+              corresponding primitive function of the parent or
               progenitor type is a static expression function; otherwise,
               if not directly specified, the aspect is False.
 
@@ -76,17 +85,17 @@
 two Static Semantics sections in this clause.
 
 Add after 6.8(5/4): [In the Legality Rules section].
-  
-  Aspect Static shall only be specified to have the value True if the
+
+  Aspect Static shall be specified to have the value True only if the
   associated expression function:
-    - whose expression is a potentially static expression; and
-    - which contains no calls to itself; and
-    - each of whose parameters (if any) is of mode IN and is of a
-      static subtype; and
-    - whose result subtype is a static subtype; and
-    - to which no precondition or postcondition expression applies; and
-    - which is not type invariant enforcing for any type (see 7.3.2); and
-    - which is not a completion.
+    - is not a completion;
+    - has an expression that is a potentially static expression;
+    - contains no calls to itself;
+    - each parameter (if any) is of mode IN and is of a
+      static subtype;
+    - has a result subtype that is a static subtype;
+    - has no applicable precondition or postcondition expression; and
+    - is not type-invariant enforcing for any type (see 7.3.2).
 
 AARM Ramification: Since a string subtype can be static, this allows an
 expression function of a string type to be static.
@@ -94,21 +103,12 @@
 Add after 7.3.2(8.2/5) [as added by AI12-0199-1]
 
 If one or more invariant expressions apply to a nonabstract type T, then
-a subprogram or entry is said to be "type invariant enforcing" for T if
+a subprogram or entry is said to be "type-invariant enforcing" for T if
     - it is declared within the immediate scope of T (or by an instance
       of a generic unit, and the generic is declared within the immediate
       scope of type T), or is the Read or Input stream-oriented attribute
       of type T, and either:
 
-       * has a result with a part of type T; or
-       * has one or more *out* or *in out* parameters with a part of type T; or
-       * has an access-to-object parameter or result whose designated type has
-         a part of type T; or
-       * is a procedure or entry that has an *in* parameter with a part of type
-         T.
-
-    - and either:
-
        * T is a private type or a private extension and the subprogram or
          entry is visible outside the immediate scope of type T or overrides
          an inherited operation that is visible outside the immediate scope
@@ -118,13 +118,22 @@
          an inherited operation that is visible outside the immediate scope
          of T.
 
+    - and at least one of the following applies to the callable entity:
+
+       * has a result with a part of type T;
+       * has one or more *out* or *in out* parameters with a part of type T;
+       * has an access-to-object parameter or result whose designated type has
+         a part of type T; or
+       * is a procedure or entry that has an *in* parameter with a part of type
+         T.
+
      Each such part of type T is said to be "subject to an invariant check"
      for T.
 
 Replace 7.3.2(15/4-20/5) with: [as modified by AI12-0193-1]
 
    An invariant check is checked upon successful return from a call on any
-   subprogram or entry which is type invariant enforcing for T. The check is
+   subprogram or entry which is type-invariant enforcing for T. The check is
    performed on each part of type T 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
@@ -134,11 +143,10 @@
 !discussion
 
 The stuff in 7.3.2 (type invariants) is all intended to be semantics-preserving.
-The only goal of this rearrangement is to define the term "type invariant
+The only goal of this rearrangement is to define the term "type-invariant
 enforcing" so that we can say that an expression function which is
-"type invariant enforcing" for some type T is not a potentially static
-expression function. And, of course, the term itself is subject to
-discussion - we might choose a different term.
+"type-invariant enforcing" for some type T is not a potentially static
+expression function.
 
 This version incorporates feedback from the Vienna and Lexington meetings
 (#57 & 58) so that