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

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

--- ai12s/ai12-0027-1.txt	2013/01/01 00:55:35	1.7
+++ ai12s/ai12-0027-1.txt	2013/01/01 02:59:14	1.8
@@ -1,8 +1,11 @@
-!standard 4.6(8/2)                                   12-12-08    AI12-0027-1/04
-!standard 4.6(24.8/2)
+!standard 4.6(24.17/3)                                   12-12-31    AI12-0027-1/05
+!standard 4.6(24.21/2)
+!standard 4.6(58)
 !standard 6.2(10/3)
 !standard 3.10.2(10/3)
 !class binding interpretation 12-06-04
+!status Amendment 202x 12-12-31
+!status ARG Approved 8-0-2  12-12-08
 !status work item 12-06-04
 !status received 12-04-09
 !priority Medium
@@ -57,21 +60,24 @@
    (see 12.3), these rules apply also in the private part of an
    instance of a generic unit.
 
+Remove the existing occurrences of the above wording from 4.6(24.17/3)
+and 4.6(24.21/2) as the above covers them.
+
 Append at the end of Dynamic Semantics section of 4.6:
 
-    Evaluation of a value conversion of a composite type will either
-    create a new anonymous object [(similar to the object
+    Evaluation of a value conversion of a composite type either
+    creates a new anonymous object [Redundant:(similar to the object
     created by the evaluation of an aggregate or a function call)] or
     yield a new view of the operand object without creating
     a new object:
 
       - If the target type is a by-reference type and there is a
         type that is an ancestor of both the target type and the
-        operand type then a new object shall not be created.
+        operand type then no new object is created;
 
       - If the target type is an array type having aliased components and
         the operand type is an array type having unaliased components,
-        then a new object shall be created.
+        then a new object is created;
 
       - Otherwise, it is unspecified whether a new object is created.
 
@@ -82,10 +88,9 @@
    an array type with unaliased components to one with aliased components
    if the element type has a controlled part.
 
-Append after 3.10.2(10/3):
+Append to the end of 3.10.2(10/3):
 
-   The accessibility of a value conversion (see 4.6) is defined as for an
-   aggregate.
+   Corresponding rules apply to a value conversion (see 4.6).
 
 In 6.2(10/3), replace
 
@@ -119,9 +124,103 @@
 take 'Access of them will fail an accessibility check. As most such
 checks are made statically, this will not add much overhead.
 
+!corrigendum 3.10.2(10/3)
+
+@drepl
+@xbullet<The accessibility level of an @fa<aggregate> that is used (in its
+entirety) to directly initialize part of an object is that of the object
+being initialized. In other contexts, the accessibility level of an
+@fa<aggregate> is that of the innermost master that evaluates the
+@fa<aggregate>.>
+@dby
+@xbullet<The accessibility level of an @fa<aggregate> that is used (in its
+entirety) to directly initialize part of an object is that of the object
+being initialized. In other contexts, the accessibility level of an
+@fa<aggregate> is that of the innermost master that evaluates the
+@fa<aggregate>. Corresponding rules apply to a value conversion
+(see 4.6).>
+
+!corrigenumd 4.6(24.17/3)
+
+@drepl
+@xinbull<The accessibility level of the operand type shall not be statically
+deeper than that of the target type, unless the target type is an anonymous access
+type of a stand-alone object. If the target type is that of such a stand-alone
+object, the accessibility level of the operand type
+shall not be statically deeper than that of the declaration of the
+stand-alone object. In addition to the places where Legality Rules
+normally apply (see 12.3), this rule applies also in the private part
+of an instance of a generic unit.>
+@dby
+@xinbull<The accessibility level of the operand type shall not be statically
+deeper than that of the target type, unless the target type is an anonymous access
+type of a stand-alone object. If the target type is that of such a stand-alone
+object, the accessibility level of the operand type
+shall not be statically deeper than that of the declaration of the
+stand-alone object.>
+
+!corrigendum 4.6(24.21/2)
+
+@drepl
+@xinbull<The accessibility level of the operand type shall not be statically
+deeper than that of the target type. In addition to the places where Legality Rules
+normally apply (see 12.3), this rule applies also in the private part of an
+instance of a generic unit. If the operand type is declared within a generic body,
+the target type shall be declared within the generic body.>
+@dby
+@xinbull<The accessibility level of the operand type shall not be statically
+deeper than that of the target type. If the operand type is declared within a generic body,
+the target type shall be declared within the generic body.>
+
+In addition to the places where Legality Rules normally apply (see 12.3), these
+rules apply also in the private part of an instance of a generic unit. 
+
+!corrigendum 4.6(58)
+
+@dinsa
+Conversion to a type is the same as conversion to an unconstrained subtype of the type. 
+@dinss
+Evaluation of a value conversion of a composite type either
+creates a new anonymous object (similar to the object
+created by the evaluation of an @fa<aggregate> or a function call) or
+yield a new view of the operand object without creating
+a new object:
+
+@xbullet<If the target type is a by-reference type and there is a
+type that is an ancestor of both the target type and the
+operand type then no new object is created;>
+
+@xbullet<If the target type is an array type having aliased components and
+the operand type is an array type having unaliased components,
+then a new object is created;>
+
+@xbullet<Otherwise, it is unspecified whether a new object is created.>
+
+If a new object is created, then the initialization of that object is
+an assignment operation.
+
+!corrigendum 6.2(10/3)
+
+@drepl
+A parameter of a by-reference type is passed by reference, as is an explicitly
+aliased parameter of any type. Each value of a by-reference type has an associated
+object. For a parenthesized expression, @fa<qualified_expression>,
+or @fa<type_conversion>, this object is the one associated with the
+operand. For a @fa<conditional_expression>, this object is the one associated
+with the evaluated @i<dependent_>@fa<expression>.
+@dby
+A parameter of a by-reference type is passed by reference, as is an explicitly
+aliased parameter of any type. Each value of a by-reference type has an associated
+object. For a parenthesized expression, @fa<qualified_expression>,
+or view conversion, this object is the one associated with the
+operand. For a value conversion, the associated object is the anonymous result
+object if such an object is created (see 4.6); otherwise it is the
+associated object of the operand. For a @fa<conditional_expression>, this object
+is the one associated with the evaluated @i<dependent_>@fa<expression>.
+
 !ACATS test
 
-An ACATS B-Test should be created to test these rules.
+An ACATS B-Test (using static accessibility) should be created to test these rules.
 
 !appendix
 

Questions? Ask the ACAA Technical Agent