!standard 1.1.3                                    09-01-19  SI99-0039-1/03
!standard 3.8
!standard 3.9.1
!standard 3.9.22
!standard 3.9.23
!standard 13.28
!standard 13.38
!standard 15.4
!standard 15.17
!standard 15.21
!standard 15.31
!standard 15.33
!standard 15.36
!standard 16.4
!standard 16.30
!standard 16.36
!standard 16.37
!standard 18.15
!standard 19.2
!standard 19.3
!standard 19.4
!standard 19.5
!standard 22
!class binding interpretation 08-10-21
!status ARG Approved  9-0-0  08-10-31
!status work item 08-10-21
!status received 08-10-21
!priority High
!difficulty Easy
!qualifier Omission
!subject Change representation clauses to aspect clauses

!summary

The name of all elements that included the term
"representation_clause" is changed to include "aspect_clause" for
consistency with the new terminology. Appropriate renamings are
provided in the Obsolescent Features section for compatibility.

!question

The corrigendum changed the term "representation clause" to
"aspect_clause". Should this change be reflected in the standard?
(Yes.)

!recommendation

(See summary.)

!wording

* Introduction
change:
   child package Asis.Clauses - Defines queries dealing with context
   clauses and representation clauses.

to:
   child package Asis.Clauses - Defines queries dealing with context
   clauses and aspect clauses.

* 1.1.3.1
change: 
   Adding "with" clauses, pragmas, representation specifications,
   comments, and allowable pragmas. Allowable pragmas are those which
   do not change the semantics of the interface (e.g., List, Optimize,
   Page).

to:
   Adding "with" clauses, pragmas, representation and operational items,
   comments, and allowable pragmas. Allowable pragmas are those which
   do not change the semantics of the interface (e.g., List, Optimize,
   Page).

(note: this change also removes the extra ';' in "with")

* 3.8
remove:
   subtype Representation_Clause           is Element;
   subtype Representation_Clause_List      is Element_List;

add after Access_Type_Definition:
   subtype Aspect_Clause                   is Element;
   subtype Aspect_Clause_List              is Element_List;

* 3.9.1
change:
                                 -> Representation_Clause_Kinds

to
                                 -> Aspect_Clause_Kinds

* 3.9.22
change:
   A_Representation_Clause, -- 13.1 -> Representation_Clause_Kinds

to:
   An_Aspect_Clause, -- 13.1 -> Aspect_Clause_Kinds

* 3.9.23
Replace 3.9.23 with:

3.9.23 type Aspect_Clause_Kinds

Type Aspect_Clause_Kinds describes varieties of aspect clauses.

type Aspect_Clause_Kinds is (
   Not_An_Aspect_Clause,                   -- An unexpected element
   An_Attribute_Definition_Clause,         -- 13.3
   An_Enumeration_Representation_Clause,   -- 13.4
   A_Record_Representation_Clause,         -- 13.5.1
   An_At_Clause);                          -- J.7

The comments list a reference to the definition in the Ada Standard
for each aspect clause. 

* 13.28
Replace 13.28 with:

13.28 function Aspect_Clause_Kind

function Aspect_Clause_Kind
               (Clause : in Asis.Aspect_Clause)
                return Asis.Aspect_Clause_Kinds;

Clause specifies the element to query.

Returns the Aspect_Clause_Kinds value of the Clause.

Returns Not_An_Aspect_Clause for any unexpected element such as
a Nil_Element, A_Definition, or A_Declaration.

Clause expects an element of Appropriate Clause_Kinds: 
   An_Aspect_Clause

* 13.38
Change:
   or an element of Representation_Clause_Kinds:

to:
   or an element of Aspect_Clause_Kinds:

* 15.4
change:
   If a representation_clause is defined for the enumeration type 

to:
   If an aspect_clause is defined for the enumeration type 

* 15.17
(see SI99-0021)

* 15.21
change:
   Returns a list of all basic declarations, representation
   specifications, use clauses, and pragmas in the declarative part of
   the body, in their order of appearance.

to:
   Returns a list of all basic declarations, representation and
   operational items, use clauses, and pragmas in the declarative part
   of the body, in their order of appearance.

* 15.31
change:
   Returns a list of all basic declarations, representation
   specifications, use clauses, and pragmas in the visible part of a
   package, in their order of appearance.

to:
   Returns a list of all basic declarations, representation and
   operational items, use clauses, and pragmas in the visible part of a
   package, in their order of appearance.

* 15.33
change:
   Returns a list of all basic declarations, representation
   specifications, use clauses, and pragmas in the private part of a
   package, in their order of appearance.

to:
   Returns a list of all basic declarations, representation and
   operational items, use clauses, and pragmas in the private part of a
   package, in their order of appearance.

* 15.36
Change:
   A_Representation_Clause

to:
   An_Aspect_Clause

16.4
(AARM - Usage note)
Change representation clauses to aspect clauses

16.30
change:
   A_Clause that has one of Definition_Kinds:

to:
   A_Clause that has one of Aspect_Clause_Kinds:

* 16.36
change:
   Returns a list of declarations, representation clauses and pragmas
   in the visible part of the task or protected
   definition, in their order of appearance. The list does not include
   discriminant_specification elements of the known_discriminant_part,
   if any, of the protected type or task type declaration.

to:
   Returns a list of declarations, representation and operational
   items, and pragmas in the visible part of the task or
   protected definition, in their order of appearance. The list does
   not include discriminant_specification elements of the
   known_discriminant_part, if any, of the protected type or task type
   declaration.

* 16.37
change:
   Returns a list of declarations, representation clauses, and pragmas
   in the private part of the task or protected definition, in their
   order of appearance.

to:
   Returns a list of declarations, representation and operational
   items, and pragmas in the private part of the task or protected
   definition, in their order of appearance.

* 18.15
change:
   Returns a list of the declarations, representation_clause elements,
   pragmas, and use_clause elements in the declarative_part of the
   block_statement, in their order of appearance.

to:
   Returns a list of the declarations, aspect_clause elements,
   pragmas, and use_clause elements in the declarative_part of the
   block_statement, in their order of appearance.

* 19.2
Replace 19.2 with:

19.2 function Aspect_Clause_Name
function Aspect_Clause_Name (Clause : in Asis.Clause)
                             return Asis.Name;

Clause specifies the aspect_clause or component_clause to query.

Returns the direct_name expression following the reserved word for.

Clause expects an element of one of Clause_Kinds: 
   An_Aspect_Clause
   A_Component_Clause

Raises ASIS_Inappropriate_Element with a Status of Value_Error for any
element that does not have one of these expected kinds.

Returns an element with one of Expression_Kinds: 
   An_Identifier
   An_Attribute_Reference

* 19.3
Replace 19.3 with:

19.3 function Aspect_Clause_Expression
   function Aspect_Clause_Expression
            (Clause : in Asis.Aspect_Clause)
             return Asis.Expression;

Clause specifies the aspect_clause to query.

Returns the expression following the reserved word use or the reserved
words use at.

Clause expects an element of Aspect_Clause_Kinds: 
   An_Attribute_Definition_Clause
   An_Enumeration_Representation_Clause
   An_At_Clause

Raises ASIS_Inappropriate_Element with a Status of Value_Error for any
element that does not have one of these expected kinds.

Returns an element with one of Element_Kinds: 
   An_Expression

* 19.4
change:
   function Mod_Clause_Expression (Clause : in Asis.Representation_Clause)
                             return Asis.Expression;

to:
   function Mod_Clause_Expression (Clause : in Asis.Aspect_Clause)
                             return Asis.Expression;

change:
   Clause expects an element of Representation_Clause_Kinds: 

to:
   Clause expects an element of Aspect_Clause_Kinds: 

* 19.5
change:
   function Component_Clauses (Clause : in Asis.Representation_Clause;
                            Include_Pragmas : in Boolean := False)
                            return Asis.Component_Clause_List;

to:
   function Component_Clauses (Clause : in Asis.Aspect_Clause;
                            Include_Pragmas : in Boolean := False)
                            return Asis.Component_Clause_List;

change:
   Clause expects an element of Appropriate Representation_Clause_Kinds: 

to:
   Clause expects an element of Appropriate Aspect_Clause_Kinds: 

* 22
change:
c) Records, array components, enumerations, and scalar types may have
   representation and length clauses applied to them. This includes
   scalar types used as record discriminants and array indices.

to:
c) Records, array components, enumerations, and scalar types may have
   aspect and length clauses applied to them. This includes scalar
   types used as record discriminants and array indices.

* F
Create a section with title:  "Obsolescent Features in package Asis"

In this section, add a clause with title "subtypes
Representation_Clause and Representation_Clause_List"

Content: 
This subtype is provided for compatibility with previous editions of this
standard.

   subtype Representation_Clause           is Aspect_Clause;
   subtype Representation_Clause_List      is Aspect_Clause_List;

Add a clause with title "function A_Representation_Clause"

Content:
This function is provided for compatibility with previous editions of this
standard.

   function A_Representation_Clause return Clause_Kinds renames An_Aspect_Clause;


Add a clause with title "type Representation_Clause_Kinds"

Content:
These elements are provided for compatibility with previous editions of this
standard.
   subtype Representation_Clause_Kinds is Aspect_Clause_Kinds;
   function Not_A_Representation_Clause return Aspect_Clause_Kinds renames Not_An_Aspect_Clause;



Create a section with title:  "Obsolescent Features in package Asis.Elements"

In this section, add a clause with title "function Representation_Clause_Kind"

Content:
This function is provided for compatibility with previous editions of this
standard.

   function Representation_Clause_Kind
               (Clause : in Asis.Aspect_Clause)
                return Asis.Aspect_Clause_Kinds renames Aspect_Clause_Kind;




Create a section with title:  "Obsolescent Features in package Asis.Clauses"

In this section, add a clause with title "function Representation_Clause_Name"

Content:
This function is provided for compatibility with previous editions of this
standard.

   function Representation_Clause_Name (Clause : in Asis.Clause)
                                        return Asis.Name renames Aspect_Clause_Name;


Add a clause with title "function Representation_Clause_Expression"

Content:
This function is provided for compatibility with previous editions of this
standard.

   function Representation_Clause_Expression
            (Clause : in Asis.Aspect_Clause)
             return Asis.Expression renames Aspect_Clause_Expression;

!discussion

If we did not make these changes, these routines would not appear to be usable
for operational aspects, while the intent is that all aspects are included.

!appendix

****************************************************************